struct ssd *ssd_copy(struct ssd *orig) {
int i;
struct ssd *result = malloc(sizeof(struct ssd));
bzero(result, sizeof(struct ssd));
memcpy(result, orig, sizeof(struct ssd));
result->queue = ioqueue_copy(orig->queue);
for (i=0;i<orig->params.nelements;i++)
result->elements[i].queue = ioqueue_copy(orig->elements[i].queue);
return result;
}
struct device_header *simpledisk_copy(struct device_header *orig) {
struct simpledisk *result = (struct simpledisk *)calloc(1, sizeof(struct simpledisk));
memcpy(result, orig, sizeof(struct simpledisk));
result->queue = ioqueue_copy(((struct simpledisk *)orig)->queue);
return (struct device_header *)result;
}
static iodriver *driver_copy(iodriver *orig) {
iodriver *result = malloc(sizeof(iodriver));
bzero(result, sizeof(iodriver));
memcpy(result, orig, sizeof(iodriver));
result->queue = ioqueue_copy(orig->queue);
return result;
}
mems_t *mems_copy(mems_t *src) {
mems_t *result = (mems_t *)calloc(1, sizeof(mems_t));
memcpy(result, src, sizeof(mems_t));
result->queue = ioqueue_copy(src->queue);
memcpy(&result->sled, src->sled, src->num_sleds * sizeof(mems_sled_t));
return result;
}
struct simpledisk *simpledisk_copy(struct simpledisk *orig) {
struct simpledisk *result = malloc(sizeof(struct simpledisk));
bzero(result, sizeof(struct simpledisk));
memcpy(result, orig, sizeof(struct simpledisk));
result->queue = ioqueue_copy(orig->queue);
return result;
}
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
}
struct mems *memsmodel_mems_loadparams(struct lp_block *b,
int *numptr)
{
int c;
int num;
struct mems *result;
mems_sled_t tmpsled;
device_initialize_deviceinfo();
bzero(&tmpsled, sizeof(tmpsled));
result = (struct mems *)calloc(1, sizeof(mems_t));
if(!result) return 0;
((struct device_header *)result)->device_type = DEVICETYPE_MEMS;
/* Initialize disksim's memsinfo structures */
if (disksim->memsinfo == NULL) {
disksim->memsinfo = (struct mems_info *)calloc(1, sizeof(struct mems_info));
ASSERT(disksim->memsinfo != NULL);
/* disksim->memsinfo->devices = malloc(MAXDEVICES * sizeof(mems_t)); */
/* ASSERT(disksim->memsinfo->devices != NULL); */
}
for(c = 0; c < disksim->memsinfo->devices_len; c++) {
if(!disksim->memsinfo->devices[c]) {
break;
}
}
if(c == disksim->memsinfo->devices_len) {
int newlen = disksim->memsinfo->devices_len ?
disksim->memsinfo->devices_len * 2 : 2;
int zerolen = newlen == 2 ? 2 : newlen / 2;
disksim->memsinfo->devices =
(mems_t **)realloc(disksim->memsinfo->devices,
newlen * sizeof(mems_t *));
bzero(&(disksim->memsinfo->devices[c]), zerolen * sizeof(mems_t *));
disksim->memsinfo->devices_len = newlen;
}
disksim->memsinfo->devices[c] = result;
num = c;
if(numptr) *numptr = num;
result->hdr = mems_hdr_initializer;
result->hdr.device_name = strdup(b->name);
disksim->memsinfo->numdevices++;
//#include "modules/disksim_mems_param.c"
lp_loadparams(result, b, &memsmodel_mems_mod);
for (c = 0; c < MAXINBUSES; c++) {
result->inbuses[c] = -1;
result->depth[c] = -1;
result->slotno[c] = -1;
}
for(c = 0; c < result->num_sleds; c++) {
memcpy(&result->sled[c], &result->sled[0], result->num_sleds * sizeof(mems_sled_t));
result->sled[c].queue = ioqueue_copy(result->queue);
}
device_add((struct device_header *)result, num);
return result;
}
