static void io_hpl_do_stats1 ()
{
int i;
if (tracestats == NULL) {
tracestats = (statgen *)DISKSIM_malloc(tracemappings * sizeof(statgen));
tracestats1 = (statgen *)DISKSIM_malloc(tracemappings * sizeof(statgen));
tracestats2 = (statgen *)DISKSIM_malloc(tracemappings * sizeof(statgen));
tracestats3 = (statgen *)DISKSIM_malloc(tracemappings * sizeof(statgen));
tracestats4 = (statgen *)DISKSIM_malloc(tracemappings * sizeof(statgen));
for (i=0; i<tracemappings; i++) {
stat_initialize(statdeffile, statdesc_tracequeuestats, &tracestats[i]);
stat_initialize(statdeffile, statdesc_tracerespstats, &tracestats1[i]);
stat_initialize(statdeffile, statdesc_traceaccstats, &tracestats2[i]);
stat_initialize(statdeffile, statdesc_traceqlenstats, &tracestats3[i]);
stat_initialize(statdeffile, statdesc_tracenoqstats, &tracestats4[i]);
}
}
}
//extern void intialize_device_physical_parameters();
static void ssd_statinit (int devno, int firsttime)
{
ssd_t *currdisk;
currdisk = getssd (devno);
if (firsttime) {
stat_initialize(statdeffile, statdesc_acctimestats, &currdisk->stat.acctimestats);
} else {
stat_reset(&currdisk->stat.acctimestats);
}
currdisk->stat.requestedbus = 0.0;
currdisk->stat.waitingforbus = 0.0;
currdisk->stat.numbuswaits = 0;
}
void io_validate_do_stats1 ()
{
int i;
if (tracestats2 == NULL) {
tracestats2 = (statgen *)DISKSIM_malloc(sizeof(statgen));
tracestats3 = (statgen *)DISKSIM_malloc(sizeof(statgen));
tracestats4 = (statgen *)DISKSIM_malloc(sizeof(statgen));
tracestats5 = (statgen *)DISKSIM_malloc(sizeof(statgen));
stat_initialize(statdeffile, statdesc_traceaccstats, tracestats2);
stat_initialize(statdeffile, statdesc_traceaccdiffstats, tracestats3);
stat_initialize(statdeffile, statdesc_traceaccwritestats, tracestats4);
stat_initialize(statdeffile, statdesc_traceaccdiffwritestats, tracestats5);
for (i=0; i<10; i++) {
validatebuf[i] = 0;
}
} else {
stat_update(tracestats3, (validate_lastserv - disksim->lastphystime));
if (!validate_lastread) {
stat_update(tracestats5, (validate_lastserv - disksim->lastphystime));
}
}
}
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
}
static void
mems_statinit (int devno, int firsttime)
{
mems_t *dev = getmems(devno);
int j;
/* First initialize device statistics */
if (firsttime) {
stat_initialize (statdeffile, statdesc_request_energy_uj,
&dev->stat.request_energy_uj);
stat_initialize (statdeffile, statdesc_seek_time,
&dev->stat.seek_time);
stat_initialize (statdeffile, statdesc_x_seek_time,
&dev->stat.x_seek_time);
stat_initialize (statdeffile, statdesc_y_seek_time,
&dev->stat.y_seek_time);
stat_initialize (statdeffile, statdesc_turnaround_time,
&dev->stat.turnaround_time);
stat_initialize (statdeffile, statdesc_turnaround_number,
&dev->stat.turnaround_number);
stat_initialize (statdeffile, statdesc_stream_turnaround_time,
&dev->stat.stream_turnaround_time);
stat_initialize (statdeffile, statdesc_stream_turnaround_number,
&dev->stat.stream_turnaround_number);
stat_initialize (statdeffile, statdesc_subtrack_accesses,
&dev->stat.subtrack_accesses);
stat_initialize (statdeffile, statdesc_tips_per_access,
&dev->stat.tips_per_access);
stat_initialize (statdeffile, statdesc_inactive_time,
&dev->stat.inactive_time);
stat_initialize (statdeffile, statdesc_prefetched_blocks,
&dev->stat.prefetched_blocks);
} else {
stat_reset (&dev->stat.request_energy_uj);
stat_reset (&dev->stat.seek_time);
stat_reset (&dev->stat.x_seek_time);
stat_reset (&dev->stat.y_seek_time);
stat_reset (&dev->stat.turnaround_time);
stat_reset (&dev->stat.turnaround_number);
stat_reset (&dev->stat.stream_turnaround_time);
stat_reset (&dev->stat.stream_turnaround_number);
stat_reset (&dev->stat.subtrack_accesses);
stat_reset (&dev->stat.tips_per_access);
stat_reset (&dev->stat.inactive_time);
stat_reset (&dev->stat.prefetched_blocks);
}
dev->stat.total_energy_j = 0.0;
dev->stat.servicing_energy_j = 0.0;
dev->stat.startup_energy_j = 0.0;
dev->stat.idle_energy_j = 0.0;
dev->stat.inactive_energy_j = 0.0;
dev->stat.num_spinups = 0;
dev->stat.num_spindowns = 0;
dev->stat.num_buffer_accesses = 0;
dev->stat.num_buffer_hits = 0;
dev->stat.num_initial_turnarounds = 0;
dev->stat.num_stream_turnarounds = 0;
/* Now initialize sled statistics */
for (j=0; j < dev->num_sleds; j++) {
if (firsttime) {
stat_initialize (statdeffile, statdesc_request_energy_uj,
&dev->sled[j].stat.request_energy_uj);
stat_initialize (statdeffile, statdesc_seek_time,
&dev->sled[j].stat.seek_time);
stat_initialize (statdeffile, statdesc_x_seek_time,
&dev->sled[j].stat.x_seek_time);
stat_initialize (statdeffile, statdesc_y_seek_time,
&dev->sled[j].stat.y_seek_time);
stat_initialize (statdeffile, statdesc_turnaround_time,
&dev->sled[j].stat.turnaround_time);
stat_initialize (statdeffile, statdesc_turnaround_number,
&dev->sled[j].stat.turnaround_number);
stat_initialize (statdeffile, statdesc_stream_turnaround_time,
&dev->sled[j].stat.stream_turnaround_time);
stat_initialize (statdeffile, statdesc_stream_turnaround_number,
&dev->sled[j].stat.stream_turnaround_number);
stat_initialize (statdeffile, statdesc_subtrack_accesses,
&dev->sled[j].stat.subtrack_accesses);
stat_initialize (statdeffile, statdesc_tips_per_access,
&dev->sled[j].stat.tips_per_access);
stat_initialize (statdeffile, statdesc_inactive_time,
&dev->sled[j].stat.inactive_time);
stat_initialize (statdeffile, statdesc_prefetched_blocks,
&dev->sled[j].stat.prefetched_blocks);
} else {
stat_reset (&dev->sled[j].stat.request_energy_uj);
stat_reset (&dev->sled[j].stat.seek_time);
stat_reset (&dev->sled[j].stat.x_seek_time);
stat_reset (&dev->sled[j].stat.y_seek_time);
stat_reset (&dev->sled[j].stat.turnaround_time);
stat_reset (&dev->sled[j].stat.turnaround_number);
stat_reset (&dev->sled[j].stat.stream_turnaround_time);
stat_reset (&dev->sled[j].stat.stream_turnaround_number);
stat_reset (&dev->sled[j].stat.subtrack_accesses);
stat_reset (&dev->sled[j].stat.tips_per_access);
stat_reset (&dev->sled[j].stat.inactive_time);
stat_reset (&dev->sled[j].stat.prefetched_blocks);
}
dev->sled[j].stat.total_energy_j = 0.0;
dev->sled[j].stat.servicing_energy_j = 0.0;
dev->sled[j].stat.startup_energy_j = 0.0;
dev->sled[j].stat.idle_energy_j = 0.0;
dev->sled[j].stat.inactive_energy_j = 0.0;
dev->sled[j].stat.num_spinups = 0;
dev->sled[j].stat.num_spindowns = 0;
dev->sled[j].stat.num_buffer_accesses = 0;
dev->sled[j].stat.num_buffer_hits = 0;
dev->sled[j].stat.num_initial_turnarounds = 0;
dev->sled[j].stat.num_stream_turnarounds = 0;
}
}
