void simpledisk_initialize (void)
{
int i;
if (disksim->simplediskinfo == NULL) {
simpledisk_initialize_diskinfo ();
}
/*
fprintf (outputfile, "Entered simpledisk_initialize - numsimpledisks %d\n", numsimpledisks);
*/
simpledisk_setcallbacks();
simpledisk_postpass();
for (i=0; i<MAXDEVICES; i++) {
simpledisk_t *currdisk = getsimpledisk (i);
if(!currdisk) continue;
/* if (!currdisk->inited) { */
currdisk->media_busy = FALSE;
currdisk->reconnect_reason = -1;
addlisttoextraq ((event **) &currdisk->buswait);
currdisk->busowned = -1;
ioqueue_initialize (currdisk->queue, i);
simpledisk_statinit(i, TRUE);
/* } */
}
}
void ssd_initialize (void)
{
int i, j;
if (disksim->ssdinfo == NULL) {
ssd_initialize_diskinfo ();
}
initialize_device_physical_parameters(); //Initliaze the physical parameters of the device.
ssd_setcallbacks();
// fprintf(stdout, "MAXDEVICES = %d, numssds %d\n", MAXDEVICES, numssds);
// vp - changing the MAXDEVICES in the below 'for' loop to numssds
for (i=0; i<numssds; i++) {
int exp_size;
ssd_t *currdisk = getssd (i);
if (!currdisk) continue;
ssd_alloc_queues(currdisk); //also allocates the refresh queue
currdisk->params.refresh_interval*=1000; //in ms.
currdisk->next_refresh_time = currdisk->params.refresh_interval;
currdisk->params.refresh_service_time = currdisk->params.block_erase_latency +
( (currdisk->params.page_write_latency +
currdisk->params.page_read_latency) *
currdisk->params.pages_per_block);
if (currdisk->params.checkpoint_time == 0)
currdisk->params.checkpoint_time = 0.5;
currdisk->params.checkpoint_time *= (60* 60 *1000);//hours to milli seconds.
//vp - some verifications:
ssd_verify_parameters(currdisk);
//vp - this was not initialized and caused so many bugs
currdisk->devno = i;
currdisk->numblocks = currdisk->params.nelements *
currdisk->params.blocks_per_element *
currdisk->params.pages_per_block *
currdisk->params.page_size;
currdisk->reconnect_reason = -1;
addlisttoextraq ((event **) &currdisk->buswait);
currdisk->busowned = -1;
currdisk->completion_queue = NULL;
/* hack to init queue structure */
ioqueue_initialize (currdisk->queue, i);
ssd_statinit(i, TRUE);
currdisk->timing_t = ssd_new_timing_t(&currdisk->params);
// initialize the gang
exp_size = ssd_elem_export_size(currdisk);
for (j = 0; j < SSD_NUM_GANG(currdisk); j ++) {
int tot_pages = exp_size * currdisk->params.elements_per_gang;
currdisk->gang_meta[j].busy = 0;
currdisk->gang_meta[j].cleaning = 0;
currdisk->gang_meta[j].reqs_waiting = 0;
currdisk->gang_meta[j].oldest = 0;
currdisk->gang_meta[j].pg2elem = (ssd_elem_number*)malloc(sizeof(ssd_elem_number) * tot_pages);
memset(currdisk->gang_meta[j].pg2elem, 0, sizeof(ssd_elem_number) * tot_pages);
ioqueue_initialize (currdisk->gang_meta[j].queue, i);
}
for (j=0; j<currdisk->params.nelements; j++) {
ssd_element *elem = &currdisk->elements[j];
ioqueue_initialize (elem->queue, i);
/* hack to init queue structure */
elem->media_busy = FALSE;
// vp - pins are also free
elem->pin_busy = FALSE;
// vp - initialize the planes in the element
ssd_plane_init(elem, currdisk, i);
// vp - initialize the ssd element metadata
// FIXME: where to free these data?
if (currdisk->params.write_policy == DISKSIM_SSD_WRITE_POLICY_OSR) {
ssd_element_metadata_init(j, &(elem->metadata), currdisk);
}
//vp - initialize the stat structure
memset(&elem->stat, 0, sizeof(ssd_element_stat));
}
}
fprintf(stderr,"Finished loading state from snapshot\n");
}
void ssd_initialize (void)
{
// static print1 = 1;
int i, j;
if (disksim->ssdinfo == NULL) {
ssd_initialize_diskinfo ();
}
/*
fprintf (outputfile, "Entered ssd_initialize - numssds %d\n", numssds);
*/
ssd_setcallbacks();
// fprintf(stdout, "MAXDEVICES = %d, numssds %d\n", MAXDEVICES, numssds);
// vp - changing the MAXDEVICES in the below 'for' loop to numssds
for (i=0; i<numssds; i++) {
int exp_size;
ssd_t *currdisk = getssd (i);
ssd_alloc_queues(currdisk);
//vp - some verifications:
ssd_verify_parameters(currdisk);
//vp - this was not initialized and caused so many bugs
currdisk->devno = i;
if (!currdisk) continue;
/* if (!currdisk->inited) { */
currdisk->numblocks = currdisk->params.nelements *
currdisk->params.blocks_per_element *
currdisk->params.pages_per_block *
currdisk->params.page_size;
currdisk->reconnect_reason = -1;
addlisttoextraq ((event **) &currdisk->buswait);
currdisk->busowned = -1;
currdisk->completion_queue = NULL;
/* hack to init queue structure */
ioqueue_initialize (currdisk->queue, i);
ssd_statinit(i, TRUE);
currdisk->timing_t = ssd_new_timing_t(&currdisk->params);
// initialize the gang
exp_size = ssd_elem_export_size(currdisk);
for (j = 0; j < SSD_NUM_GANG(currdisk); j ++) {
int tot_pages = exp_size * currdisk->params.elements_per_gang;
currdisk->gang_meta[j].busy = 0;
currdisk->gang_meta[j].cleaning = 0;
currdisk->gang_meta[j].reqs_waiting = 0;
currdisk->gang_meta[j].oldest = 0;
currdisk->gang_meta[j].pg2elem = malloc(sizeof(ssd_elem_number) * tot_pages);
memset(currdisk->gang_meta[j].pg2elem, 0, sizeof(ssd_elem_number) * tot_pages);
ioqueue_initialize (currdisk->gang_meta[j].queue, i);
}
for (j=0; j<currdisk->params.nelements; j++) {
ssd_element *elem = &currdisk->elements[j];
ioqueue_initialize (elem->queue, i);
/* hack to init queue structure */
elem->media_busy = FALSE;
// vp - pins are also free
elem->pin_busy = FALSE;
// vp - initialize the planes in the element
ssd_plane_init(elem, currdisk, i);
// vp - initialize the ssd element metadata
// FIXME: where to free these data?
memset(&elem->stat, 0, sizeof(elem->stat));
if (currdisk->params.write_policy == DISKSIM_SSD_WRITE_POLICY_OSR) {
ssd_element_metadata_init(j, &(elem->metadata), currdisk);
}
//vp - initialize the stat structure
memset(&elem->stat, 0, sizeof(ssd_element_stat));
}
/* } */
}
}
/* Initialize device structures */
void
mems_initialize (void)
{
int i;
int j;
int k;
mems_t *dev;
if (disksim->memsinfo == NULL) return;
ioqueue_setcallbacks();
/* Initialize all devices that have been inited (huh?) */
for (i = 0; i < disksim->memsinfo->devices_len; i++) {
dev = getmems(i);
if (dev) {
dev->busowned = -1;
addlisttoextraq((event **)&dev->buswait);
ioqueue_initialize(dev->queue, i);
dev->dataxfer_req = NULL;
dev->dataxfer_queue = NULL;
/* Segment initialization stuff taken in part from disksim_disk.c */
if ((dev->numsegs > 0) && (dev->seglist == NULL)) {
dev->seglist = (struct mems_segment *)DISKSIM_malloc(sizeof(struct mems_segment));
dev->seglist->next = NULL;
dev->seglist->prev = NULL;
dev->seglist->time = 0.0;
dev->seglist->startblkno = 0;
dev->seglist->endblkno = 0;
for (k = 1; k < dev->numsegs; k++) {
struct mems_segment *tmpseg = (struct mems_segment *)DISKSIM_malloc(sizeof(struct mems_segment));
tmpseg->next = dev->seglist;
dev->seglist = tmpseg;
tmpseg->next->prev = tmpseg;
tmpseg->prev = NULL;
tmpseg->startblkno = 0;
tmpseg->endblkno = 0;
}
}
if (dev->numsegs == 0) addlisttoextraq((event **)&dev->seglist);
mems_check_numblocks(dev);
for (j = 0; j < dev->num_sleds; j++) {
dev->sled[j].dev = dev;
ioqueue_initialize(dev->sled[j].queue, i);
dev->sled[j].active = MEMS_SLED_INACTIVE;
dev->sled[j].active_request = NULL;
dev->sled[j].prefetch_info = NULL;
dev->sled[j].lastreq_lbn = mems_centermost_lbn(&dev->sled[j]);
dev->sled[j].lastreq_comptime = 0.0;
/* Initialize sled position, velocity at centermost LBN */
mems_lbn_to_position(dev->sled[j].lastreq_lbn, &dev->sled[j], &dev->sled[j].coordset_up, &dev->sled[j].coordset_dn, &dev->sled[j].tipset, NULL, NULL, NULL);
mems_coord_t_copy(&dev->sled[j].coordset_up.servo_start, &dev->sled[j].pos);
}
mems_statinit(i, TRUE);
if (dev->precompute_seek_count > 0) {
mems_precompute_seek_curve(dev);
}
}
}
}
