void controller_smart_printstats (controller *currctlr, char *prefix)
{
ctlrinfo_t *ctlrinfo = disksim->ctlrinfo;
int devno;
char devprefix[181];
struct ioq **queueset = DISKSIM_malloc (currctlr->numdevices * sizeof(void *));
if (ctlrinfo->ctl_printcachestats) {
currctlr->cache->cache_printstats(currctlr->cache, prefix);
}
for (devno=0; devno<currctlr->numdevices; devno++) {
queueset[devno] = currctlr->devices[devno].queue;
}
sprintf (devprefix, "%sdevices ", prefix);
ioqueue_printstats (queueset, currctlr->numdevices, devprefix);
if ((ctlrinfo->ctl_printperdiskstats) && (currctlr->numdevices > 1)) {
for (devno=0; devno<currctlr->numdevices; devno++) {
struct ioq *queue = currctlr->devices[devno].queue;
if (ioqueue_get_number_of_requests(queue)) {
sprintf(devprefix, "%sdevice #%d ", prefix, devno);
ioqueue_printstats(&queue, 1, devprefix);
}
}
}
}
void iodriver_printstats()
{
int i;
int j;
struct ioq **queueset;
int setsize = 0;
char prefix[80];
fprintf (outputfile, "\nOVERALL I/O SYSTEM STATISTICS\n");
fprintf (outputfile, "-----------------------------\n\n");
sprintf (prefix, "Overall I/O System ");
ioqueue_printstats (&OVERALLQUEUE, 1, prefix);
fprintf (outputfile, "\nSYSTEM-LEVEL LOGORG STATISTICS\n");
fprintf (outputfile, "------------------------------\n\n");
sprintf(prefix, "System ");
logorg_printstats(sysorgs, numsysorgs, prefix);
fprintf (outputfile, "\nIODRIVER STATISTICS\n");
fprintf (outputfile, "-------------------\n\n");
for (i = 0; i < numiodrivers; i++) {
setsize += iodrivers[i]->numdevices;
}
queueset = (struct ioq **)DISKSIM_malloc(setsize*sizeof(struct ioq *));
setsize = 0;
for (i = 0; i < numiodrivers; i++) {
for (j = 0; j < iodrivers[i]->numdevices; j++) {
queueset[setsize] = iodrivers[i]->devices[j].queue;
setsize++;
}
}
sprintf(prefix, "IOdriver ");
if (stat_get_count(&emptyqueuestats) > 0) {
stat_print(&emptyqueuestats, prefix);
}
if (stat_get_count(&initiatenextstats) > 0) {
stat_print(&initiatenextstats, prefix);
}
ioqueue_printstats(queueset, setsize, prefix);
if ((drv_printperdiskstats == TRUE) && ((numiodrivers > 1) || (iodrivers[0]->numdevices > 1))) {
for (i = 0; i < numiodrivers; i++) {
for (j = 0; j < iodrivers[i]->numdevices; j++) {
fprintf (outputfile, "\nI/O Driver #%d - Device #%d\n", i, j);
sprintf(prefix, "IOdriver #%d device #%d ", i, j);
ioqueue_printstats(&iodrivers[i]->devices[j].queue, 1, prefix);
}
}
}
free(queueset);
queueset = NULL;
}
void ssd_printsetstats (int *set, int setsize, char *sourcestr)
{
int i;
struct ioq * queueset[MAXDEVICES*SSD_MAX_ELEMENTS];
int queuecnt = 0;
int reqcnt = 0;
char prefix[80];
//using more secure functions
sprintf_s4(prefix, 80, "%sssd ", sourcestr);
for (i=0; i<setsize; i++) {
ssd_t *currdisk = getssd (set[i]);
struct ioq *q = currdisk->queue;
queueset[queuecnt] = q;
queuecnt++;
reqcnt += ioqueue_get_number_of_requests(q);
}
if (reqcnt == 0) {
fprintf (outputfile, "\nNo ssd requests for members of this set\n\n");
return;
}
ioqueue_printstats(queueset, queuecnt, prefix);
ssd_acctime_printstats(set, setsize, prefix);
ssd_other_printstats(set, setsize, prefix);
}
/* Print statistics */
void
mems_printstats (void)
{
struct ioq *queueset[MAXDEVICES];
int set[MAXDEVICES];
int i;
int reqcnt = 0;
char prefix[80];
int devcnt;
mems_t *dev;
fprintf(outputfile, "\nMEMS STATISTICS\n----------------\n\n");
sprintf(prefix, "Mems ");
if (!disksim->memsinfo) {
fprintf(outputfile, "No mems requests encountered (1)\n");
return;
}
devcnt = 0;
for (i = 0; i < disksim->memsinfo->devices_len; i++) {
dev = getmems(i);
if (dev) {
// SCHLOS - this has been hard-coded to the first sled since
// mems_event doesn't use the device queues anymore.
queueset[devcnt] = dev->sled[0].queue;
reqcnt += ioqueue_get_number_of_requests(dev->queue);
devcnt++;
}
}
assert(devcnt == disksim->memsinfo->numdevices);
/*
if (reqcnt == 0) {
fprintf(outputfile, "No mems requests encountered (2)\n");
return;
}
*/
ioqueue_printstats(queueset, devcnt, prefix);
devcnt = 0;
for (i=0; i < disksim->memsinfo->devices_len; i++) {
dev = getmems(i);
if (dev) {
set[devcnt] = i;
devcnt++;
}
}
assert(devcnt == disksim->memsinfo->numdevices);
mems_prefetch_printstats(set, devcnt, prefix);
mems_seektime_printstats(set, devcnt, prefix);
mems_other_printstats(set, devcnt, prefix);
mems_inactive_printstats(set, devcnt, prefix);
mems_buffer_printstats(set, devcnt, prefix);
mems_energy_printstats(set, devcnt, prefix);
fprintf(outputfile, "\n\n");
}
/* Print set statistics */
void
mems_printsetstats (int *set, int setsize, char *sourcestr)
{
int i;
struct ioq *queueset[MAXDEVICES];
int reqcnt = 0;
char prefix[80];
sprintf(prefix, "%smems ", sourcestr);
for (i=0; i<setsize; i++) {
mems_t *dev = getmems(set[i]);
queueset[i] = dev->queue;
reqcnt += ioqueue_get_number_of_requests(dev->queue);
}
if (reqcnt == 0) {
fprintf(outputfile, "\nNo mems requests for members of this set\n\n");
return;
}
ioqueue_printstats(queueset, setsize, prefix);
mems_prefetch_printstats(set, setsize, prefix);
mems_seektime_printstats(set, setsize, prefix);
mems_other_printstats(set, setsize, prefix);
mems_inactive_printstats(set, setsize, prefix);
mems_buffer_printstats(set, setsize, prefix);
mems_energy_printstats(set, setsize, prefix);
}
void simpledisk_printsetstats (int *set, int setsize, char *sourcestr)
{
int i;
struct ioq * queueset[MAXDEVICES];
int reqcnt = 0;
char prefix[80];
sprintf(prefix, "%ssimpledisk ", sourcestr);
for (i=0; i<setsize; i++) {
simpledisk_t *currdisk = getsimpledisk (set[i]);
queueset[i] = currdisk->queue;
reqcnt += ioqueue_get_number_of_requests(currdisk->queue);
}
if (reqcnt == 0) {
fprintf (outputfile, "\nNo simpledisk requests for members of this set\n\n");
return;
}
ioqueue_printstats(queueset, setsize, prefix);
simpledisk_acctime_printstats(set, setsize, prefix);
simpledisk_other_printstats(set, setsize, prefix);
}
void simpledisk_printstats (void)
{
struct ioq * queueset[MAXDEVICES];
int set[MAXDEVICES];
int i;
int reqcnt = 0;
char prefix[80];
int diskcnt;
fprintf(outputfile, "\nSIMPLEDISK STATISTICS\n");
fprintf(outputfile, "---------------------\n\n");
sprintf(prefix, "Simpledisk ");
diskcnt = 0;
for (i=0; i<MAXDEVICES; i++) {
simpledisk_t *currdisk = getsimpledisk (i);
if (currdisk) {
queueset[diskcnt] = currdisk->queue;
reqcnt += ioqueue_get_number_of_requests(currdisk->queue);
diskcnt++;
}
}
assert (diskcnt == numsimpledisks);
if (reqcnt == 0) {
fprintf(outputfile, "No simpledisk requests encountered\n");
return;
}
ioqueue_printstats(queueset, numsimpledisks, prefix);
diskcnt = 0;
for (i=0; i<MAXDEVICES; i++) {
simpledisk_t *currdisk = getsimpledisk (i);
if (currdisk) {
set[diskcnt] = i;
diskcnt++;
}
}
assert (diskcnt == numsimpledisks);
simpledisk_acctime_printstats(set, numsimpledisks, prefix);
simpledisk_other_printstats(set, numsimpledisks, prefix);
fprintf (outputfile, "\n\n");
if (numsimpledisks <= 1) {
return;
}
for (i=0; i<numsimpledisks; i++) {
simpledisk_t *currdisk = getsimpledisk (set[i]);
if (currdisk->printstats == FALSE) {
continue;
}
if (ioqueue_get_number_of_requests(currdisk->queue) == 0) {
fprintf(outputfile, "No requests for simpledisk #%d\n\n\n", set[i]);
continue;
}
fprintf(outputfile, "Simpledisk #%d:\n\n", set[i]);
sprintf(prefix, "Simpledisk #%d ", set[i]);
ioqueue_printstats(&currdisk->queue, 1, prefix);
simpledisk_acctime_printstats(&set[i], 1, prefix);
simpledisk_other_printstats(&set[i], 1, prefix);
fprintf (outputfile, "\n\n");
}
}
void ssd_printstats (void)
{
struct ioq * queueset[MAXDEVICES*SSD_MAX_ELEMENTS];
int set[MAXDEVICES];
int i,j;
int reqcnt = 0;
char prefix[80];
int diskcnt;
int queuecnt;
fprintf(outputfile, "\nSSD STATISTICS\n");
fprintf(outputfile, "---------------------\n\n");
sprintf_s3(prefix, 80, "ssd ");
diskcnt = 0;
queuecnt = 0;
for (i=0; i<MAXDEVICES; i++) {
ssd_t *currdisk = getssd (i);
if (currdisk) {
struct ioq *q = currdisk->queue;
queueset[queuecnt] = q;
queuecnt++;
reqcnt += ioqueue_get_number_of_requests(q);
diskcnt++;
}
}
assert (diskcnt == numssds);
if (reqcnt == 0) {
fprintf(outputfile, "No ssd requests encountered\n");
return;
}
ioqueue_printstats(queueset, queuecnt, prefix);
diskcnt = 0;
for (i=0; i<MAXDEVICES; i++) {
ssd_t *currdisk = getssd (i);
if (currdisk) {
set[diskcnt] = i;
diskcnt++;
}
}
assert (diskcnt == numssds);
ssd_acctime_printstats(set, numssds, prefix);
ssd_other_printstats(set, numssds, prefix);
ssd_printcleanstats(set, numssds, prefix);
fprintf (outputfile, "\n\n");
for (i=0; i<numssds; i++) {
ssd_t *currdisk = getssd (set[i]);
if (currdisk->printstats == FALSE) {
continue;
}
reqcnt = 0;
{
struct ioq *q = currdisk->queue;
reqcnt += ioqueue_get_number_of_requests(q);
}
if (reqcnt == 0) {
fprintf(outputfile, "No requests for ssd #%d\n\n\n", set[i]);
continue;
}
fprintf(outputfile, "ssd #%d:\n\n", set[i]);
sprintf_s4(prefix, 80, "ssd #%d ", set[i]);
{
struct ioq *q;
q = currdisk->queue;
ioqueue_printstats(&q, 1, prefix);
}
for (j=0;j<currdisk->params.nelements;j++) {
char pprefix[100];
struct ioq *q;
sprintf_s5(pprefix, 100, "%s elem #%d ", prefix, j);
q = currdisk->elements[j].queue;
ioqueue_printstats(&q, 1, pprefix);
}
ssd_acctime_printstats(&set[i], 1, prefix);
ssd_other_printstats(&set[i], 1, prefix);
fprintf (outputfile, "\n\n");
}
}
