disksim_pfsim.c

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

   process *procp = NULL;

   if (pf_printhack)
   fprintf (outputfile, "%.3f\tCONTEXT SWITCH cpu=%d pid=%d, newpid=%d\n", simtime, cpu_ev->cpunum, ((cpu_ev->procp) ? cpu_ev->procp->pid : 0), ((curr->newprocp) ? curr->newprocp->pid : 0));

   if (cpu_ev->procp) {
      if (cpu_ev->procp->idler == 0) {
         lastuser = simtime;
      }
      cpu_ev->procp->cswitches++;
   }

   /* Used to identify how long the system has been completely idle   */
   /* Simulation should stop rather than continuing to idle endlessly */
   if ((idlereset == 0) && 
       ((curr->newprocp == NULL) || 
	(curr->newprocp->idler != 0))) {
      idlein = simtime;
      idlereset = 1;
   } 
   else {
      idlereset = 0;
   }

   cpu_ev->procp = curr->newprocp;
   cpus[(cpu_ev->cpunum)].state = (curr->newprocp) ? CPU_PROCESS : CPU_IDLE;
   if (cpu_ev->procp) {
      cpu_ev->procp->pfflags &= ~PF_SLEEP_FLAG;
   }

   if ((cpu_ev->procp == NULL) && (pf_dispq)) {
      procp = pf_dispatch(cpu_ev->cpunum);
      if (procp != cpu_ev->procp) {
         pf_add_cswitch_event(cpu_ev->procp, procp, cpu_ev);
      }
   } else {
      addlisttoextraq((event **) &cpus[(cpu_ev->cpunum)].idleevents);
   }
}


static void pf_handle_idleloop_event (idleloop_event *curr, cpu_event *cpu_ev)
{
   process *procp;

   if (pf_printhack)
   fprintf (outputfile, "%f\tIDLELOOP cpu=%d\n", simtime, cpu_ev->cpunum);

   ASSERT(cpu_ev->procp == NULL);
   procp = pf_dispatch(cpu_ev->cpunum);
   if (procp != cpu_ev->procp) {
      pf_add_cswitch_event(cpu_ev->procp, procp, cpu_ev);
   }
}


static void pf_handle_sleep_event (sleep_event *curr, cpu_event *cpu_ev)
{
   process *procp = cpu_ev->procp;
   process *newprocp;

   if (pf_printhack)
   fprintf (outputfile, "%f\tSLEEP cpu=%d pid=%d chan=%p info=%d iosleep=%d\n", simtime, cpu_ev->cpunum, procp->pid, curr->chan, curr->info, curr->iosleep);

   if (pf_iowait(curr->chan, procp)) {
      ASSERT(curr->iosleep > 0);
      procp->iosleep = TRUE;
      procp->iosleeps++;
   } else if (curr->iosleep) {
      return;   /* to support synthetic TIME_LIMIT'd requests */
   } else {
      ASSERT (0);
   }
   procp->pfflags |= PF_SLEEP_FLAG;
   procp->chan = curr->chan;
   newprocp = pf_disp_sleep(procp);
   pf_add_cswitch_event(procp, newprocp, cpu_ev);
   procp->lastsleep = simtime;
   procp->sleeps++;
}


static void pf_handle_wakeup_event(wakeup_event *curr, cpu_event *cpu_ev)
{
   process *procp;

   if (pf_printhack) {
     fprintf (outputfile, "%f\tWAKEUP cpu=%d chan=%p info=%d\n", 
	      simtime, cpu_ev->cpunum, curr->chan, curr->info);
   }

   while ((procp = pf_disp_get_from_sleep_queue(curr->chan))) {

     if (pf_printhack) {
       fprintf (outputfile, "Waking up process %d\n", procp->pid);
     }

     procp->runsleep += simtime - procp->lastsleep;
     if (procp->iosleep == 1) {
       procp->runiosleep += simtime - procp->lastsleep;
     }
     pf_disp_wakeup(procp);
   }

   procp = cpu_ev->procp;
   if ((procp) 
       && ((procp->pfflags & PF_SLEEP_FLAG) 
	   && (procp->chan == curr->chan))) 
     {
       procp->pfflags |= PF_WAKED;
     }
}


static void pf_handle_ioreq_event (ioreq_event *curr, cpu_event *cpu_ev)
{
   process *procp = cpu_ev->procp;
   ioreq_event *new;
   ioreq_event *tmp;

   io_map_trace_request(curr);
   curr->next = NULL;

   if (pf_printhack)
   fprintf (outputfile, "%f\tIOREQ cpu=%d opid=%d buf=%p blkno=%x flags=%x, bcount=%d\n", simtime, cpu_ev->cpunum, curr->opid, curr->buf, curr->blkno, curr->flags, curr->bcount);

   curr->flags &= ~(TIMED_OUT|HALF_OUT); /* hack to help out ioqueue.c */

   pf_add_to_pendiolist(procp, curr);

   if (cpu_ev->intrp == NULL) {
      procp->ios++;
      if (curr->flags & READ) {
         procp->ioreads++;
      }
   }
   curr->cause = 0;   /* To avoid a stupid problem in logorg.c --- TEMP  */
   new = (ioreq_event *) io_request(curr);
   if (new) {
      tmp = (ioreq_event *) procp->eventlist;
      procp->eventlist = (event *) new;
      while (new->next) {
         new = new->next;
      }
      new->next = tmp;
   }
}


static void pf_handle_ioacc_event (ioreq_event *curr, cpu_event *cpu_ev)
{
   if (pf_printhack)
   fprintf (outputfile, "%f\tIOACC cpu=%d opid=%d blkno=%x\n", simtime, cpu_ev->cpunum, curr->opid, curr->blkno);

   io_schedule(curr);
}


static void pf_handle_io_internal_event (ioreq_event *curr, cpu_event *cpu_ev)
{
   if (pf_printhack)
   fprintf (outputfile, "%f\tIO INTERNAL cpu=%d type %d opid=%d blkno=%x buf=%p\n", simtime, cpu_ev->cpunum, curr->type, curr->opid, curr->blkno, curr->buf);

   if (curr->type == IO_REQUEST_ARRIVE) {
      ioreq_event *new = (ioreq_event *) io_request (curr);
      if (new) {
         intr_event *intrp = cpu_ev->intrp;
         ioreq_event *tmp;
         ASSERT (intrp != NULL);

         tmp = (ioreq_event *) intrp->eventlist;
         intrp->eventlist = (event *) new;
         while (new->next) {
            new = new->next;
         }
         new->next = tmp;
      }
   } else {
      io_internal_event(curr);
   }
}


static void pf_clock_interrupt_complete (intr_event *intrp)
{
   addtoextraq((event *) intrp);
}


static void pf_handle_intend_event (intend_event *curr, cpu_event *cpu_ev)
{
   intr_event *intrp = cpu_ev->intrp;
   process *procp = cpu_ev->procp;
   cpu *currcpu = &cpus[(cpu_ev->cpunum)];

   if (pf_printhack)
   fprintf (outputfile, "%f\tINTEND cpu=%d\n", simtime, cpu_ev->cpunum);

   cpu_ev->intrp = (intr_event *) intrp->next;
   currcpu->state = intrp->oldstate;
   currcpu->intrs++;
   currcpu->runintrtime += intrp->runtime;
   if (intrp->vector == IO_INTERRUPT) {
      currcpu->iointrs++;
      currcpu->runiointrtime += intrp->runtime;
      io_interrupt_complete ((ioreq_event *) intrp);
   } else if (intrp->vector == CLOCK_INTERRUPT) {
      currcpu->clockintrs++;
      currcpu->runclockintrtime += intrp->runtime;
      pf_clock_interrupt_complete(intrp);
   } else {
      fprintf (stderr, "pf_handle_intend_event: unknown interrupt vector (%d)\n", intrp->vector);
      exit(1);
   }
   intrp = cpu_ev->intrp;
   if (intrp == NULL) {
      if ((procp == NULL) && (pf_dispq)) {
         procp = pf_dispatch(cpu_ev->cpunum);
         assert (procp != NULL);
         pf_add_cswitch_event (NULL, procp, cpu_ev);
      }
      if ((procp == NULL) || (procp->idler != 0)) {
         if ((idlereset) && ((simtime - idlein) > (double) 50000.0)) {
            fprintf (outputfile, "Idle process has been running for more than 50 seconds\n");
            disksim_simstop();
         }
      }
   }
}


static void pf_handle_synthio_event (event *curr, cpu_event *cpu_ev)
{
/*
fprintf (outputfile, "%f, SYNTHIO_EVENT\n", simtime);
*/
   curr->time = 0.0;
   curr->next = cpu_ev->procp->eventlist;
   cpu_ev->procp->eventlist = curr;
   synthio_generate_io_activity(cpu_ev->procp);
}


static void pf_handle_event (event *curr, cpu_event *cpu_ev)
{
  if (pf_printhack) {
    fprintf (outputfile, "%f, entered pf_handle_event with event type %d\n", simtime, curr->type);
    fflush(outputfile);
  }

  switch (curr->type) {
  case IDLELOOP_EVENT:
    pf_handle_idleloop_event((idleloop_event *)curr, cpu_ev);
    break;
  case CSWITCH_EVENT:
    pf_handle_cswitch_event((cswitch_event *)curr, cpu_ev);
    break;
  case SLEEP_EVENT:
    pf_handle_sleep_event((sleep_event *)curr, cpu_ev);
    break;
  case WAKEUP_EVENT:
    pf_handle_wakeup_event((wakeup_event *)curr, cpu_ev);
    break;
  case IOREQ_EVENT:
    pf_handle_ioreq_event((ioreq_event *)curr, cpu_ev);
    curr = NULL;
    break;
  case IOACC_EVENT:
    pf_handle_ioacc_event((ioreq_event *)curr, cpu_ev);
    curr = NULL;
    break;
  case INTEND_EVENT:
    pf_handle_intend_event((intend_event *)curr, cpu_ev);
    break;
  case SYNTHIO_EVENT:
    pf_handle_synthio_event(curr, cpu_ev);
    curr = NULL;
    break;
  default:
    if ((curr->type >= IO_MIN_EVENT) && (curr->type <= IO_MAX_EVENT)) {
      pf_handle_io_internal_event((ioreq_event *)curr, cpu_ev);
      curr = NULL;
      break;
    }
    fprintf(stderr, "Trying to handle unknown pf event - %d\n", curr->type);
    exit(1);
  }
  addtoextraq((event *) curr);
}


static void pf_handle_io_intr_arrive (intr_event *intrp, cpu_event *cpu_ev)
{
   if (pf_printhack) {
   ioreq_event *tmp = (ioreq_event *) intrp->infoptr;
fprintf (outputfile, "%f\tIO_INTERRUPT cpu %d  cause %d  buf %p\n", simtime, cpu_ev->cpunum, tmp->cause, tmp->buf);
   }

   io_interrupt_arrive ((ioreq_event *)intrp);
}


static void pf_handle_clock_intr_arrive (intr_event *intrp, cpu_event *cpu_ev)
{
   intr_event *nextclock;
   intend_event *new;
   curlbolt++;

if (pf_printhack)
fprintf (outputfile, "%f,   CLOCK_INTERRUPT - new lbolt %d\n", simtime, curlbolt);

   ASSERT (intrp->eventlist == NULL);
   new = (intend_event *) getfromextraq();
   new->type = INTEND_EVENT;
   new->vector = intrp->type;
   if ((curlbolt % PF_INTER_LONG_CLOCKS) == 0) {
      io_tick();
      new->time = PF_LONG_CLOCK_TIME;
   } else {
      new->time = PF_SHORT_CLOCK_TIME;
   }
   pf_add_to_intrp_eventlist(intrp, (event *)new);

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


void pf_handle_intr_event (intr_event *intrp, int cpunum)
{
   cpu *currcpu = &cpus[cpunum];
   cpu_event *cpu_ev = currcpu->current;
   process *procp = cpu_ev->procp;

   if (pf_printhack)
   fprintf (outputfile, "%f\tINTR cpu=%d vector=%d cpustate=%d\n", simtime, cpunum, intrp->vector, currcpu->state);

   intrp->runtime = 0.0;
   intrp->flags = 0;
   intrp->next = cpu_ev->intrp;
   if (currcpu->state == CPU_IDLE) {
      currcpu->idletime += simtime - currcpu->idlestart;
      currcpu->falseidletime += pf_add_false_idle_time(simtime - currcpu->idlestart);
   } else {
      if (removefromintq((event *)cpu_ev) == 0) {
         fprintf(stderr, "Event from active CPU not pending on internal queue\n");
         exit(1);
      }
      if (intrp->next) {
         intrp->next->runtime += simtime - intrp->next->eventlist->time;
         intrp->next->eventlist->time = (cpu_ev->time - simtime) / currcpu->scale;
      } else if (procp == NULL) {
         currcpu->idleworktime += simtime - currcpu->idleevents->time;
         currcpu->idleevents->time = (cpu_ev->time - simtime) / currcpu->scale;
      } else {
         procp->runtime += simtime - procp->eventlist->time;
         procp->eventlist->time = (cpu_ev->time - simtime) / currcpu->scale;
      }
   }
   intrp->oldstate = currcpu->state;
   currcpu->state = CPU_INTR;
   cpu_ev->intrp = intrp;
   if (intrp->vector == IO_INTERRUPT) {
      pf_handle_io_intr_arrive(intrp, cpu_ev);
   } else if (intrp->vector == CLOCK_INTERRUPT) {
      pf_handle_clock_intr_arrive(intrp, cpu_ev);
   } else {
      fprintf(stderr, "Unknown interrupt vector: %d\n", intrp->vector);
      exit(1);
   }
   cpu_ev->time = currcpu->scale * pf_get_time_to_next_intr_event(intrp);
   cpu_ev->time += simtime;
   addtointq((event *) cpu_ev);
/*
fprintf (outputfile, "Exit pf_handle_intr_event\n");
*/
}


static void pf_handle_cpu_event (cpu_event *curr)
{
   event *tmp;
   cpu *currcpu = &cpus[(curr->cpunum)];

   /*
    * if (simtime > 29000.0) {
    *   pf_printhack = 1;
    * }
    */

   if(pf_printhack) {
     fprintf (outputfile, "Entered handle_cpu_event: %d\n", curr->type);
     fflush(outputfile);
   }

   if(curr->intrp) {
      tmp = curr->intrp->eventlist;
      curr->intrp->runtime += simtime - tmp->time;
      curr->intrp->eventlist = tmp->next;
   } 
   else if(curr->procp) {
      curr->procp->lasteventtime = simtime;
      tmp = curr->procp->eventlist;
      curr->procp->runtime += simtime - tmp->time;
      curr->procp->eventlist = tmp->next;
   } 
   else {
      tmp = currcpu->idleevents;
      currcpu->idleworktime += simtime - tmp->time;
      currcpu->idleevents = tmp->next;
   }

   ASSERT(tmp != NULL);
   tmp->next = NULL;
   pf_handle_event(tmp, curr);

   if(curr->intrp) {
      curr->time = pf_get_time_to_next_intr_event(curr->intrp);
   } 
   else if(curr->procp == NULL) {
     if (currcpu->idleevents == NULL) {
       currcpu->state = CPU_IDLE;
       currcpu->idlestart = simtime;
       return;
     }
     curr->time = currcpu->idleevents->time;
     currcpu->idleevents->time = simtime;
     currcpu->state = CPU_IDLE_WORK;
   } 
   else {
     curr->time = pf_get_time_to_next_process_event(curr->procp);
   }

   curr->time = simtime + (currcpu->scale * curr->time);
   addtointq((event *) curr);

   
   if(pf_printhack) {
     fprintf(outputfile, "Exited handle_cpu_event\n");
     fflush(outputfile);
   }
}


void pf_internal_event (event *curr)
{
   ASSERT(curr != NULL);
/*
fprintf (outputfile, "%f: pf_internal_event entered with event type %d\n", curr->time, curr->type);
*/