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 controller_smart_initialize (controller *currctlr) { int numdevs = device_get_numdevices(); device *currdev; int i; controller_smart_setcallbacks (); currctlr->numdevices = numdevs; currctlr->devices = (device *) DISKSIM_malloc(numdevs * sizeof(device)); ASSERT(currctlr->devices != NULL); for (i=0; i<numdevs; i++) { currdev = &currctlr->devices[i]; currdev->devno = i; currdev->busy = FALSE; currdev->flag = 0; currdev->queue = ioqueue_copy(currctlr->queue); ioqueue_initialize(currdev->queue, i); iosim_get_path_to_device (0, i, &currdev->buspath, &currdev->slotpath); currdev->maxoutstanding = currctlr->maxdiskqsize; } currctlr->cache->cache_initialize(currctlr->cache, &disksim->issuefunc_ctlrsmart, currctlr, &disksim->queuefind_ctlrsmart, currctlr, &disksim->wakeupfunc_ctlrsmart, currctlr, numdevs); }
void iodriver_initialize (int standalone) { int numdevs; struct ioq * queueset[MAXDEVICES]; int i, j; iodriver *curriodriver; i = numiodrivers; /* Code will be broken by multiple iodrivers */ ASSERT1(numiodrivers == 1, "numiodrivers", numiodrivers); ioqueue_initialize (OVERALLQUEUE, 0); for (i = 0; i < numiodrivers; i++) { curriodriver = iodrivers[i]; curriodriver->type = standalone; if (standalone != STANDALONE) { curriodriver->scale = 1.0; } numdevs = controller_get_numcontrollers(); curriodriver->numctlrs = numdevs; curriodriver->ctlrs = (ctlr*) DISKSIM_malloc(numdevs * (sizeof(ctlr))); ASSERT(curriodriver->ctlrs != NULL); for (j=0; j < numdevs; j++) { ctlr *currctlr = &curriodriver->ctlrs[j]; currctlr->ctlno = j; currctlr->flags = 0; if (controller_C700_based(j) == TRUE) { /* fprintf (outputfile, "This one is c700_based - %d\n", j); */ currctlr->flags |= DRIVER_C700; } currctlr->buspath.value = 0; currctlr->slotpath.value = 0; iosim_get_path_to_controller(i, currctlr->ctlno, &currctlr->buspath, &currctlr->slotpath); currctlr->numoutstanding = 0; currctlr->pendio = NULL; currctlr->oversized = NULL; } numdevs = device_get_numdevices(); curriodriver->numdevices = numdevs; curriodriver->devices = (device*) DISKSIM_malloc(numdevs * (sizeof(device))); ASSERT(curriodriver->devices != NULL); for (j = 0; j < numdevs; j++) { device *currdev = &curriodriver->devices[j]; currdev->devno = j; currdev->busy = FALSE; currdev->flag = 0; currdev->queue = ioqueue_copy(curriodriver->queue); ioqueue_initialize(currdev->queue, j); queueset[j] = currdev->queue; currdev->buspath.value = 0; currdev->slotpath.value = 0; iosim_get_path_to_device(i, currdev->devno, &currdev->buspath, &currdev->slotpath); iodriver_set_ctl_to_device(i, currdev); get_device_maxoutstanding(curriodriver, currdev); } logorg_initialize(sysorgs, numsysorgs, queueset, drv_printlocalitystats, drv_printblockingstats, drv_printinterferestats, drv_printstreakstats, drv_printstampstats, drv_printintarrstats, drv_printidlestats, drv_printsizestats); /* fprintf (outputfile, "Back from logorg_initialize\n"); */ } stat_initialize(statdeffile, statdesc_emptyqueue, &emptyqueuestats); stat_initialize(statdeffile, statdesc_initiatenext, &initiatenextstats); #if 0 print_paths_to_devices(); print_paths_to_ctlrs(); #endif }
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); } } } }