simdisk_file.cpp

Go to the documentation of this file.

/***************************************************************************
 * lib/io/simdisk_file.cpp
 *
 * Part of the STXXL. See http://stxxl.sourceforge.net
 *
 * Copyright (C) 2002-2003 Roman Dementiev <[email protected]>
 * Copyright (C) 2008 Andreas Beckmann <[email protected]>
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 **************************************************************************/

#include <stxxl/bits/io/simdisk_file.h>

#if STXXL_HAVE_SIMDISK_FILE

#include <stxxl/bits/io/iostats.h>
#include <stxxl/bits/common/error_handling.h>
#include "ufs_platform.h"
#include <sys/mman.h>

STXXL_BEGIN_NAMESPACE


void simdisk_geometry::add_zone(int& first_cyl, int last_cyl,
 int sec_per_track, int& first_sect)
{
 double rate =
 nsurfaces * sec_per_track * bytes_per_sector /
 ((nsurfaces - 1) * head_switch_time +
 cyl_switch_time +
 nsurfaces * revolution_time);
 int sectors =
 (last_cyl - first_cyl +
 1) * nsurfaces * sec_per_track;
 zones.insert(Zone(first_sect, sectors, rate));
 first_sect += sectors;
 first_cyl = last_cyl + 1;
}

// returns delay in s
double simdisk_geometry::get_delay(file::offset_type offset, file::size_type size)
{
#if 0
 int first_sect = offset / bytes_per_sector;
 int last_sect = (offset + size) / bytes_per_sector;
 int sectors = size / bytes_per_sector;
 double delay =
 cmd_ovh + seek_time + rot_latency +
 double(bytes_per_sector) /
 double(interface_speed);

 std::set<Zone, ZoneCmp>::iterator zone = zones.lower_bound(first_sect);
 //std::cout << __PRETTY_FUNCTION__ << " " << (*zone).first_sector << std::endl;
 while (1)
 {
 int from_this_zone =
 last_sect - ((*zone).first_sector +
 (*zone).sectors);
 if (from_this_zone <= 0)
 {
 delay += sectors * bytes_per_sector /
 ((*zone).sustained_data_rate);
 break;
 }
 else
 {
 delay += from_this_zone *
 bytes_per_sector /
 ((*zone).sustained_data_rate);
 zone++;
 stxxl_nassert(zone == zones.end());
 sectors -= from_this_zone;
 }
 }

 return delay;
#else
 STXXL_UNUSED(offset);
 return double(size) / double(AVERAGE_SPEED);
#endif
}


IC35L080AVVA07::IC35L080AVVA07()
{
 std::cout << "Creating IBM 120GXP IC35L080AVVA07" <<
 std::endl;

 nsurfaces = 4;
 bytes_per_sector = 512;
 cmd_ovh = 0.0002; // in s
 seek_time = 0.0082; // in s
 rot_latency = 0.00417; // in s
 head_switch_time = 0.0015; // in s
 cyl_switch_time = 0.002; // in s
 revolution_time = 0.0083; // in s
 interface_speed = 100000000; // in byte/s

 int first_sect = 0;
 int last_cyl = 0;
 add_zone(last_cyl, 1938, 928, first_sect);
 add_zone(last_cyl, 3756, 921, first_sect);
 add_zone(last_cyl, 5564, 896, first_sect);
 add_zone(last_cyl, 7687, 896, first_sect);
 add_zone(last_cyl, 9526, 888, first_sect);
 add_zone(last_cyl, 11334, 883, first_sect);
 add_zone(last_cyl, 13331, 864, first_sect);
 add_zone(last_cyl, 15128, 850, first_sect);
 add_zone(last_cyl, 16925, 840, first_sect);
 add_zone(last_cyl, 18922, 822, first_sect);
 add_zone(last_cyl, 20709, 806, first_sect);
 add_zone(last_cyl, 22601, 792, first_sect);
 add_zone(last_cyl, 24138, 787, first_sect);
 add_zone(last_cyl, 26024, 768, first_sect);
 add_zone(last_cyl, 27652, 752, first_sect);
 add_zone(last_cyl, 29501, 740, first_sect);
 add_zone(last_cyl, 31234, 725, first_sect);
 add_zone(last_cyl, 33009, 698, first_sect);
 add_zone(last_cyl, 34784, 691, first_sect);
 add_zone(last_cyl, 36609, 672, first_sect);
 add_zone(last_cyl, 38374, 648, first_sect);
 add_zone(last_cyl, 40139, 630, first_sect);
 add_zone(last_cyl, 41904, 614, first_sect);
 add_zone(last_cyl, 43519, 595, first_sect);
 add_zone(last_cyl, 45250, 576, first_sect);
 add_zone(last_cyl, 47004, 552, first_sect);
 add_zone(last_cyl, 48758, 533, first_sect);
 add_zone(last_cyl, 50491, 512, first_sect);
 add_zone(last_cyl, 52256, 493, first_sect);
 add_zone(last_cyl, 54010, 471, first_sect);
 add_zone(last_cyl, 55571, 448, first_sect);

#if 0
 set<Zone, ZoneCmp>::iterator it = zones.begin();
 int i = 0;
 for ( ; it != zones.end(); it++, i++)
 {
 //const int block_size = 128*3*1024* 4; // one cylinder

 std::cout << "Zone " << i << " first sector: " << (*it).first_sector;
 std::cout << " sectors: " << (*it).sectors << " sustained rate: ";
 std::cout << (*it).sustained_data_rate / 1024 / 1024 << " MiB/s" << std::endl;
 }

 std::cout << "Last sector : " << first_sect << std::endl;
 std::cout << "Approx. capacity: " << (first_sect / 1024 / 1024) * bytes_per_sector << " MiB" << std::endl;
#endif

 std::cout << "Transfer 16 MiB from zone 0 : " <<
 get_delay(0, 16 * 1024 * 1024) << " s" << std::endl;
 std::cout << "Transfer 16 MiB from zone 30: " <<
 get_delay(file::offset_type(158204036) * file::offset_type(bytes_per_sector), 16 * 1024 * 1024) << " s" << std::endl;
}

////////////////////////////////////////////////////////////////////////////

void sim_disk_file::serve(const request* req) throw (io_error)
{
 scoped_mutex_lock fd_lock(fd_mutex);
 assert(req->get_file() == this);
 offset_type offset = req->get_offset();
 void* buffer = req->get_buffer();
 size_type bytes = req->get_size();
 request::request_type type = req->get_type();
 double op_start = timestamp();

 stats::scoped_read_write_timer read_write_timer(bytes, type == request::WRITE);

 void* mem = mmap(NULL, bytes, PROT_READ | PROT_WRITE, MAP_SHARED, file_des, offset);
 if (mem == MAP_FAILED)
 {
 STXXL_THROW_ERRNO
 (io_error,
 " mmap() failed." <<
 " Page size: " << sysconf(_SC_PAGESIZE) <<
 " offset modulo page size " << (offset % sysconf(_SC_PAGESIZE)));
 }
 else if (mem == 0)
 {
 STXXL_THROW_ERRNO(io_error, "mmap() returned NULL");
 }
 else
 {
 if (type == request::READ)
 {
 memcpy(buffer, mem, bytes);
 }
 else
 {
 memcpy(mem, buffer, bytes);
 }
 STXXL_THROW_ERRNO_NE_0(munmap(mem, bytes), io_error,
 "munmap() failed");
 }

 double delay = get_delay(offset, bytes);

 delay = delay - timestamp() + op_start;

 assert(delay > 0.0);

 int seconds_to_wait = static_cast<int>(floor(delay));
 if (seconds_to_wait)
 sleep(seconds_to_wait);

 usleep((unsigned long)((delay - seconds_to_wait) * 1000000.));
}

const char* sim_disk_file::io_type() const
{
 return "simdisk";
}

////////////////////////////////////////////////////////////////////////////

void sim_disk_file::set_size(offset_type newsize)
{
 scoped_mutex_lock fd_lock(fd_mutex);
 if (newsize > _size())
 {
 STXXL_THROW_ERRNO_LT_0(::lseek(file_des, newsize - 1, SEEK_SET), io_error,
 "lseek() fd=" << file_des << " pos=" << newsize - 1);
 STXXL_THROW_ERRNO_LT_0(::write(file_des, "", 1), io_error,
 "write() fd=" << file_des << " size=1");
 }
}

STXXL_END_NAMESPACE

#endif // #if STXXL_HAVE_SIMDISK_FILE
// vim: et:ts=4:sw=4