disksim_pfsim.c

目前最精确的磁盘模拟器的第3版

   ASSERT1(curr->type == CPU_EVENT, "curr->type", curr->type);
   pf_handle_cpu_event((cpu_event *) curr);
}


static void pf_cpu_resetstats()
{
   int i;

   for (i=0; i<numcpus; i++) {
      cpus[i].idletime = 0.0;
      cpus[i].falseidletime = 0.0;
      cpus[i].idleworktime = 0.0;
      cpus[i].idlestart = simtime;
      cpus[i].intrs = 0;
      cpus[i].iointrs = 0;
      cpus[i].clockintrs = 0;
      cpus[i].runintrtime = 0.0;
      cpus[i].runiointrtime = 0.0;
      cpus[i].runclockintrtime = 0.0;
      cpus[i].cswitches = 0;
      cpus[i].runswitchtime = 0.0;
   }
}


static void pf_cpu_initialize()
{
   int i;

   for (i=0; i<numcpus; i++) {
      cpus[i].scale = pfscale;
      cpus[i].idleevents = NULL;
      cpus[i].current = (cpu_event *) getfromextraq();
      cpus[i].current->type = CPU_EVENT;
      cpus[i].current->cpunum = i;
      cpus[i].current->procp = NULL;
      cpus[i].current->intrp = NULL;
   }
   pf_cpu_resetstats();
}


void pf_resetstats()
{
   pf_cpu_resetstats();
}


void pf_setcallbacks()
{
}


void pf_initialize (int seedvalue)
{
   int i = 0;
   process *procp = NULL;
   intr_event *intrp;
/*
fprintf (outputfile, "Entered pf_initialize - numcpus %d, pfscale %f, pfinit %d\n", numcpus, pfscale, (pfinitfile != NULL));
*/
   StaticAssert (sizeof(cpu_event) <= DISKSIM_EVENT_SIZE);
   StaticAssert (sizeof(intend_event) <= DISKSIM_EVENT_SIZE);
   StaticAssert (sizeof(cswitch_event) <= DISKSIM_EVENT_SIZE);
   StaticAssert (sizeof(idleloop_event) <= DISKSIM_EVENT_SIZE);
   StaticAssert (sizeof(sleep_event) <= DISKSIM_EVENT_SIZE);
   StaticAssert (sizeof(wakeup_event) <= DISKSIM_EVENT_SIZE);

   stat_initialize(statdeffile, "Response time", &timecritrespstats);
   stat_initialize(statdeffile, "Response time", &timelimitrespstats);
   stat_initialize(statdeffile, "Response time", &timenoncritrespstats);
   pf_cpu_initialize();

   intrp = (intr_event *) getfromextraq();
   intrp->type = INTR_EVENT;
   intrp->time = PF_INTER_CLOCK_TIME;
   intrp->vector = CLOCK_INTERRUPT;
   intrp->eventlist = NULL;
   addtointq((event *) intrp);

   DISKSIM_srand48(seedvalue);
   procp = synthlist;
   while(procp) {
     if(procp->space) {
       synthio_initialize_generator(procp);
     }
     procp = procp->next;
   }
 
   // initial distribution of processes to cpus
   pf_dispatcher_init(synthlist);
   synthlist = NULL;

   for (i = 0; i < numcpus; i++) {
     fprintf (outputfile, "Kicking off cpu #%d\n", i);

     if(cpus[i].current->procp) {
       cpus[i].current->procp->active = 1;
       cpus[i].current->time = cpus[i].scale * 
	 pf_get_time_to_next_process_event(cpus[i].current->procp);

       addtointq((event *)cpus[i].current);
         cpus[i].state = CPU_PROCESS;
	 fprintf (outputfile, "First event occurs at time %f\n", 
		  cpus[i].current->time);
     } 
     else {
       cpus[i].state = CPU_IDLE;
     }
   }
}



int disksim_pf_loadparams(struct lp_block *b) {
  pf_info_t *pf_info;

  if(!disksim->pf_info) {
    pf_info = DISKSIM_malloc (sizeof(pf_info_t));
    if(!pf_info) return 0;
    bzero ((char *)pf_info, sizeof(pf_info_t));
    disksim->pf_info = pf_info;
  }

/*    unparse_block(b, outputfile); */

#include "modules/disksim_pf_param.c"

  return 1;
}


int disksim_pf_stats_loadparams(struct lp_block *b) {
  pf_info_t *pf_info;

  if(!disksim->pf_info) {
    pf_info = DISKSIM_malloc (sizeof(pf_info_t));
    if(!pf_info) return 0;
    bzero ((char *)pf_info, sizeof(pf_info_t));
    disksim->pf_info = pf_info;
  }


#include "modules/disksim_pf_stats_param.c"


  return 1;
}



void pf_cleanstats()
{
   int i;
   intr_event *intrp;
   process *procp;

   for (i=0; i<numcpus; i++) {
      intrp = cpus[i].current->intrp;
      procp = cpus[i].current->procp;
      switch (cpus[i].state) {
         case CPU_IDLE:
                      cpus[i].idletime += simtime - cpus[i].idlestart;
                      cpus[i].falseidletime += pf_add_false_idle_time(simtime - cpus[i].idlestart);
                      break;
         case CPU_IDLE_WORK:
                      cpus[i].idleworktime += simtime - cpus[i].idleevents->time;
                      break;
         case CPU_PROCESS:
                      if (procp->idler == 0) {
                         lastuser = simtime;
                      }
                      procp->runtime += simtime - procp->eventlist->time;
                      break;
         case CPU_INTR:
                      intrp->runtime += simtime - intrp->eventlist->time;
                      break;
         default:
                      fprintf(stderr, "Unknown CPU state at pf_cleanstats - %d\n", cpus[i].state);
                      exit(1);
      }
   }
   procp = process_livelist;
   while (procp) {
      if (procp->stat == PROC_SLEEP) {
         procp->runsleep += simtime - procp->lastsleep;
         if (procp->iosleep) {
            procp->runiosleep += simtime - procp->lastsleep;
         }
      }
      procp = procp->livelist;
   }
}


static void pf_print_interrupt_stats (int startcpu, int stopcpu)
{
   int i;
   int iointrs = 0;
   int clockintrs = 0;
   double runiointr = 0.0;
   double runclockintr = 0.0;
   char cpustr[81];

   if (startcpu == stopcpu) {
      sprintf(cpustr, "CPU #%d ", startcpu);
   } else {
      sprintf(cpustr, "CPU ");
   }

   if (pf_print_intrstats == FALSE) {
      return;
   }

   for (i=startcpu; i<=stopcpu; i++) {
      iointrs += cpus[i].iointrs;
      clockintrs += cpus[i].clockintrs;
      runiointr += cpus[i].runiointrtime;
      runclockintr += cpus[i].runclockintrtime;
   }
   fprintf (outputfile, "%sNumber of IO interrupts:            %d\n", cpustr, iointrs);
   fprintf (outputfile, "%sTime spent in I/O interrupts:       %f\n", cpustr, runiointr);
   fprintf (outputfile, "%sNumber of clock interrupts:         %d\n", cpustr, clockintrs);
   fprintf (outputfile, "%sTime spent in clock interrupts:     %f\n", cpustr, runclockintr);
}


static void pf_print_sleep_stats()
{
   int sleeps = 0;
   int iosleeps = 0;
   double runsleep = 0.0;
   double runiosleep = 0.0;
   process *procp = process_livelist;

   if (pf_print_sleepstats == FALSE) {
      return;
   }

   while (procp) {
      sleeps += procp->sleeps;
      iosleeps += procp->iosleeps;
      runsleep += procp->runsleep;
      runiosleep += procp->runiosleep;
      procp = procp->livelist;
   }
   fprintf (outputfile, "Number of sleep events:     %d\n", sleeps);
   fprintf (outputfile, "Number of I/O sleep events: %d\n", iosleeps);
   fprintf (outputfile, "Average sleep time:         %f\n", (runsleep / (double) max(sleeps,1)));
   fprintf (outputfile, "Average I/O sleep time:     %f\n", (runiosleep / (double) max(iosleeps,1)));
}


static void pf_print_process_stats()
{
   int i = 0;
   process *procp = process_livelist;
   int proccnt = 0;
   double runtime = 0.0;
   double lasteventtime = 0.0;
   int ios = 0;
   int ioreads = 0;
   int cswitches = 0;
   int sleeps = 0;
   double runsleep = 0.0;
   int iosleeps = 0;
   double runiosleep = 0.0;
   double falseidletime = 0.0;
   statgen * readlimitstats[511];
   statgen * writelimitstats[511];
   statgen * readmissstats[511];
   statgen * writemissstats[511];
   char procstr[81];

   fprintf (outputfile, "\nPROCESS STATISTICS\n");
   while (procp) {
      if ((procp->runtime != 0.0) || (procp->cswitches)) {
         proccnt++;
      }
      procp = procp->livelist;
   }

   ASSERT(proccnt < 511);
   procp = process_livelist;
   i = 0;
   while (procp) {
      if ((procp->runtime != 0.0) || (procp->cswitches)) {
         runtime += procp->runtime;
         lasteventtime = max (procp->lasteventtime, lasteventtime);
         ios += procp->ios;
         ioreads += procp->ioreads;
         cswitches += procp->cswitches;
         sleeps += procp->sleeps;
         runsleep += procp->runsleep;
         iosleeps += procp->iosleeps;
         runiosleep += procp->runiosleep;
         falseidletime += procp->falseidletime;
         readlimitstats[i] = &procp->readtimelimitstats;
         writelimitstats[i] = &procp->writetimelimitstats;
         readmissstats[i] = &procp->readmisslimitstats;
         writemissstats[i] = &procp->writemisslimitstats;
         i++;
      }
      procp = procp->livelist;
   }

   fprintf(outputfile, "Process Total computation time:  %f\n", runtime);
   fprintf(outputfile, "Process Last event time:         %f\n", lasteventtime);
   fprintf(outputfile, "Process Number of I/O requests:  %d\n", ios);
   fprintf(outputfile, "Process Number of read requests: %d\n", ioreads);
   fprintf(outputfile, "Process Number of C-switches:    %d\n", cswitches);
   fprintf(outputfile, "Process Number of sleeps:        %d\n", sleeps);
   fprintf(outputfile, "Process Average sleep time:      %f\n", (runsleep / (double) max(sleeps,1)));
   fprintf(outputfile, "Process Number of I/O sleeps:    %d\n", iosleeps);
   fprintf(outputfile, "Process Average I/O sleep time:  %f\n", (runiosleep / (double) max(iosleeps,1)));
   fprintf(outputfile, "Process False idle time:         %f\n", falseidletime);
   fprintf(outputfile, "Process Read Time limits measured: %d\n", stat_get_count_set(readlimitstats, proccnt));
   stat_print_set(readlimitstats, proccnt, "Process Read ");
   fprintf(outputfile, "Process Write Time limits measured: %d\n", stat_get_count_set(writelimitstats, proccnt));
   stat_print_set(writelimitstats, proccnt, "Process Write ");
   fprintf(outputfile, "Process Read Time limits missed: %d\n", stat_get_count_set(readmissstats, proccnt));
   stat_print_set(readmissstats, proccnt, "Process Missed Read ");
   fprintf(outputfile, "Process Write Time limits missed: %d\n", stat_get_count_set(writemissstats, proccnt));
   stat_print_set(writemissstats, proccnt, "Process Missed Write ");

   if ((pf_print_perprocessstats == FALSE) || (proccnt <= 1)) {
      return;
   }

   procp = process_livelist;
   while (procp) {
      if ((procp->runtime == 0.0) && (procp->cswitches == 0)) {
         procp = procp->livelist;
         continue;
      }
      fprintf(outputfile, "\nProcess %d\n", procp->pid);
      fprintf(outputfile, "Process %d Total computation time:  %f\n", procp->pid, procp->runtime);
      fprintf(outputfile, "Process %d Last event time:         %f\n", procp->pid, procp->lasteventtime);
      fprintf(outputfile, "Process %d Number of I/O requests:  %d\n", procp->pid, procp->ios);
      fprintf(outputfile, "Process %d Number of read requests: %d\n", procp->pid, procp->ioreads);
      fprintf(outputfile, "Process %d Number of C-switches:    %d\n", procp->pid, procp->cswitches);
      fprintf(outputfile, "Process %d Number of sleeps:        %d\n", procp->pid, procp->sleeps);
      fprintf(outputfile, "Process %d Average sleep time:      %f\n", procp->pid, (procp->runsleep / (double) max(procp->sleeps,1)));
      fprintf(outputfile, "Process %d Number of I/O sleeps:    %d\n", procp->pid, procp->iosleeps);
      fprintf(outputfile, "Process %d Average I/O sleep time:  %f\n", procp->pid, (procp->runiosleep / (double) max(procp->iosleeps,1)));
      fprintf(outputfile, "Process %d False idle time:         %f\n", procp->pid, procp->falseidletime);
      fprintf(outputfile, "Process %d Read Time limits measured: %d\n", procp->pid, stat_get_count(&procp->readtimelimitstats));
      sprintf(procstr, "Process %d Read ", procp->pid);
      stat_print(&procp->readtimelimitstats, procstr);
      fprintf(outputfile, "Process %d Write Time limits measured: %d\n", procp->pid, stat_get_count(&procp->writetimelimitstats));
      sprintf(procstr, "Process %d Write ", procp->pid);
      stat_print(&procp->writetimelimitstats, procstr);
      fprintf(outputfile, "Process %d Read Time limits missed: %d\n", procp->pid, stat_get_count(&procp->readmisslimitstats));
      sprintf(procstr, "Process %d Missed Read ", procp->pid);
      stat_print(&procp->readmisslimitstats, procstr);
      fprintf(outputfile, "Process %d Write Time limits missed: %d\n", procp->pid, stat_get_count(&procp->writemisslimitstats));
      sprintf(procstr, "Process %d Missed Write ", procp->pid);
      stat_print(&procp->writemisslimitstats, procstr);
      procp = procp->livelist;
   }
   fprintf(outputfile, "\n");
}


static void pf_print_pf_stats (int startcpu, int stopcpu)
{
   int i;
   double idletime = 0.0;
   double falseidletime = 0.0;
   double idleworktime = 0.0;
   int cswitches = 0;
   int numintrs = 0;
   double runintr = 0.0;
   double runswitchtime = 0.0;
   int cpucnt;
   char cpustr[81];
   char cpustr2[81];

   if (startcpu == stopcpu) {
      sprintf(cpustr, "CPU #%d ", startcpu);
   } else {
      sprintf(cpustr, "CPU ");
   }

   cpucnt = stopcpu - startcpu + 1;
   for (i=startcpu; i<=stopcpu; i++) {
      idletime += cpus[i].idletime;
      falseidletime += cpus[i].falseidletime;
      idleworktime += cpus[i].idleworktime;
      cswitches += cpus[i].cswitches;
      runswitchtime += cpus[i].runswitchtime;
      numintrs += cpus[i].intrs;
      runintr += cpus[i].runintrtime;
   }
   fprintf(outputfile, "%sTotal idle milliseconds:      %f\n", cpustr, idletime);
   fprintf(outputfile, "%sIdle time per processor:      %f\n", cpustr, (idletime / (double) cpucnt));
   fprintf(outputfile, "%sPercentage idle cycles:       %f\n", cpustr, ((double) 100.0 * idletime / ((simtime - warmuptime) * (double) cpucnt)));
   fprintf(outputfile, "%sTotal false idle ms:          %f\n", cpustr, falseidletime);
   fprintf(outputfile, "%sFalse idle time per CPU:      %f\n", cpustr, (falseidletime / (double) cpucnt));
   fprintf(outputfile, "%sPercentage false idle cycles: %f\n", cpustr, ((double) 100.0 * falseidletime / ((simtime - warmuptime) * (double) cpucnt)));
   fprintf(outputfile, "%sTotal idle work ms:           %f\n", cpustr, idleworktime);
   fprintf(outputfile, "%sContext Switches: %d\n", cpustr, cswitches);
   fprintf(outputfile, "%sTime spent context switching: %f\n", cpustr, runswitchtime);
   fprintf(outputfile, "%sPercentage switching cycles:  %f\n", cpustr, ((double) 100.0 * runswitchtime / ((simtime - warmuptime) * (double) cpucnt)));
   fprintf(outputfile, "%sNumber of interrupts: %d\n", cpustr, numintrs);
   fprintf(outputfile, "%sTotal time in interrupts: %.3f\n", cpustr, runintr);
   fprintf(outputfile, "%sPercentage interrupt cycles:  %f\n", cpustr, ((double) 100.0 * runintr / ((simtime - warmuptime) * (double) cpucnt)));
   fprintf(outputfile, "%sTime-Critical request count:      %d\n", cpustr, stat_get_count(&timecritrespstats));
   sprintf(cpustr2, "%sTime-Critical ", cpustr);
   stat_print(&timecritrespstats, cpustr2);
   fprintf(outputfile, "%sTime-Limited request count:       %d\n", cpustr, stat_get_count(&timelimitrespstats));
   sprintf(cpustr2, "%sTime-Limited ", cpustr);
   stat_print(&timelimitrespstats, cpustr2);
   fprintf(outputfile, "%sTime-Noncritical request count:   %d\n", cpustr, stat_get_count(&timenoncritrespstats));
   sprintf(cpustr2, "%sTime-Noncritical ", cpustr);
   stat_print(&timenoncritrespstats, cpustr2);
}


static void pf_print_percpu_stats()
{
   int i;

   if ((numcpus == 1) || (pf_print_percpustats == FALSE)) {
      return;
   }

   fprintf (outputfile, "\nPER-CPU STATISTICS\n");

   for (i=0; i<numcpus; i++) {
      fprintf (outputfile, "\nCPU #%d\n\n", i);
      pf_print_pf_stats(i, i);
      pf_print_interrupt_stats(i, i);
   }
}


void pf_printstats()
{
   fprintf (outputfile, "\nPROCESS FLOW STATISTICS\n");
   fprintf (outputfile, "-----------------------\n\n");

   pf_print_pf_stats(0, (numcpus - 1));
   pf_print_interrupt_stats(0, (numcpus - 1));
   pf_print_sleep_stats();
   pf_print_percpu_stats();
   pf_print_process_stats();
/*
   fprintf (outputfile, "Time since last user process:  %.3f\n", ((simtime - warmuptime) - lastuser));
*/
}