disksim_simpledisk.c

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

         simpledisk_request_complete (curr);
      }

   } else {
      /* reconnect to controller */
      curr->type = IO_INTERRUPT_ARRIVE;
      curr->cause = RECONNECT;
      simpledisk_send_event_up_path (curr, currdisk->bus_transaction_latency);
      currdisk->reconnect_reason = DEVICE_ACCESS_COMPLETE;
   }
}


/* intermediate disconnect done */

static void simpledisk_disconnect_done (ioreq_event *curr)
{
   simpledisk_t *currdisk;

   currdisk = getsimpledisk (curr->devno);

   // fprintf (outputfile, "Entering simpledisk_disconnect for disk %d: %12.6f\n", currdisk->devno, simtime);

   addtoextraq((event *) curr);

   if (currdisk->busowned != -1) {
      bus_ownership_release(currdisk->busowned);
      currdisk->busowned = -1;
   }
}


/* completion disconnect done */

static void simpledisk_completion_done (ioreq_event *curr)
{
   simpledisk_t *currdisk = getsimpledisk (curr->devno);

   // fprintf (outputfile, "Entering simpledisk_completion for disk %d: %12.6f\n", currdisk->devno, simtime);

   addtoextraq((event *) curr);

   if (currdisk->busowned != -1) {
      bus_ownership_release(currdisk->busowned);
      currdisk->busowned = -1;
   }

   /* check for and start next queued request, if any */
   curr = ioqueue_get_next_request(currdisk->queue);
   if (curr != NULL) {
      ASSERT (currdisk->media_busy == FALSE);
      if (curr->flags & READ) {
         currdisk->media_busy = TRUE;
         stat_update (&currdisk->stat.acctimestats, currdisk->acctime);
         curr->time = simtime + currdisk->acctime;
         curr->type = DEVICE_ACCESS_COMPLETE;
         addtointq ((event *)curr);

      } else {
         curr->type = IO_INTERRUPT_ARRIVE;
         curr->cause = RECONNECT;
         simpledisk_send_event_up_path (curr, currdisk->bus_transaction_latency);
         currdisk->reconnect_reason = IO_INTERRUPT_ARRIVE;
      }
   }
}


static void simpledisk_interrupt_complete (ioreq_event *curr)
{
   // fprintf (outputfile, "Entered simpledisk_interrupt_complete - cause %d\n", curr->cause);

   switch (curr->cause) {

      case RECONNECT:
         simpledisk_reconnect_done(curr);
	 break;

      case DISCONNECT:
	 simpledisk_disconnect_done(curr);
	 break;

      case COMPLETION:
	 simpledisk_completion_done(curr);
	 break;

      default:
         ddbg_assert2(0, "bad event type");
   }
}


void simpledisk_event_arrive (ioreq_event *curr)
{
   simpledisk_t *currdisk;

   // fprintf (outputfile, "Entered simpledisk_event_arrive: time %f (simtime %f)\n", curr->time, simtime);
   // fprintf (outputfile, " - devno %d, blkno %d, type %d, cause %d, read = %d\n", curr->devno, curr->blkno, curr->type, curr->cause, curr->flags & READ);

   currdisk = getsimpledisk (curr->devno);

   switch (curr->type) {

      case IO_ACCESS_ARRIVE:
         curr->time = simtime + currdisk->overhead;
         curr->type = DEVICE_OVERHEAD_COMPLETE;
         addtointq((event *) curr);
         break;

      case DEVICE_OVERHEAD_COMPLETE:
         simpledisk_request_arrive(curr);
         break;

      case DEVICE_ACCESS_COMPLETE:
         simpledisk_access_complete (curr);
         break;

      case DEVICE_DATA_TRANSFER_COMPLETE:
         simpledisk_bustransfer_complete(curr);
         break;

      case IO_INTERRUPT_COMPLETE:
         simpledisk_interrupt_complete(curr);
         break;

      case IO_QLEN_MAXCHECK:
         /* Used only at initialization time to set up queue stuff */
         curr->tempint1 = -1;
         curr->tempint2 = simpledisk_get_maxoutstanding(curr->devno);
         curr->bcount = 0;
         break;

      default:
         fprintf(stderr, "Unrecognized event type at simpledisk_event_arrive\n");
         exit(1);
   }

   // fprintf (outputfile, "Exiting simpledisk_event_arrive\n");
}


int simpledisk_get_number_of_blocks (int devno)
{
   simpledisk_t *currdisk = getsimpledisk (devno);
   return (currdisk->numblocks);
}


int simpledisk_get_numcyls (int devno)
{
   simpledisk_t *currdisk = getsimpledisk (devno);
   return (currdisk->numblocks);
}


void simpledisk_get_mapping (int maptype, int devno, int blkno, int *cylptr, int *surfaceptr, int *blkptr)
{
   simpledisk_t *currdisk = getsimpledisk (devno);

   if ((blkno < 0) || (blkno >= currdisk->numblocks)) {
      fprintf(stderr, "Invalid blkno at simpledisk_get_mapping: %d\n", blkno);
      exit(1);
   }

   if (cylptr) {
      *cylptr = blkno;
   }
   if (surfaceptr) {
      *surfaceptr = 0;
   }
   if (blkptr) {
      *blkptr = 0;
   }
}


int simpledisk_get_avg_sectpercyl (int devno)
{
   return (1);
}


int simpledisk_get_distance (int devno, ioreq_event *req, int exact, int direction)
{
   /* just return an arbitrary constant, since acctime is constant */
   return 1;
}


double  simpledisk_get_servtime (int devno, ioreq_event *req, int checkcache, double maxtime)
{
   simpledisk_t *currdisk = getsimpledisk (devno);
   return (currdisk->acctime);
}


double  simpledisk_get_acctime (int devno, ioreq_event *req, double maxtime)
{
   simpledisk_t *currdisk = getsimpledisk (devno);
   return (currdisk->acctime);
}


int simpledisk_get_numdisks (void)
{
   return(numsimpledisks);
}


void simpledisk_cleanstats (void)
{
   int i;

   for (i=0; i<MAXDEVICES; i++) {
      simpledisk_t *currdisk = getsimpledisk (i);
      if (currdisk) {
         ioqueue_cleanstats(currdisk->queue);
      }
   }
}




static void simpledisk_statinit (int devno, int firsttime)
{
   simpledisk_t *currdisk;

   currdisk = getsimpledisk (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;
}


static void simpledisk_postpass (void)
{
}


void simpledisk_setcallbacks ()
{
   ioqueue_setcallbacks();
}


static void simpledisk_initialize_diskinfo ()
{
   disksim->simplediskinfo = malloc (sizeof(simplediskinfo_t));
   bzero ((char *)disksim->simplediskinfo, sizeof(simplediskinfo_t));
   disksim->simplediskinfo->simpledisks = malloc(MAXDEVICES * (sizeof(simpledisk_t)));
   disksim->simplediskinfo->simpledisks_len = MAXDEVICES;
   bzero ((char *)disksim->simplediskinfo->simpledisks, (MAXDEVICES * (sizeof(simpledisk_t))));
}


void simpledisk_initialize (void)
{
   int i;

   if (disksim->simplediskinfo == NULL) {
      simpledisk_initialize_diskinfo ();
   }
/*
fprintf (outputfile, "Entered simpledisk_initialize - numsimpledisks %d\n", numsimpledisks);
*/
   simpledisk_setcallbacks();
   simpledisk_postpass();

   for (i=0; i<MAXDEVICES; i++) {
      simpledisk_t *currdisk = getsimpledisk (i);
      if(!currdisk) continue;
/*        if (!currdisk->inited) { */
         currdisk->media_busy = FALSE;
         currdisk->reconnect_reason = -1;
         addlisttoextraq ((event **) &currdisk->buswait);
         currdisk->busowned = -1;
         ioqueue_initialize (currdisk->queue, i);
         simpledisk_statinit(i, TRUE);
/*        } */
   }
}


void simpledisk_resetstats (void)
{
   int i;

   for (i=0; i<MAXDEVICES; i++) {
      simpledisk_t *currdisk = getsimpledisk (i);
      if (currdisk) {
         ioqueue_resetstats(currdisk->queue);
         simpledisk_statinit(i, 0);
      }
   }
}



int simpledisk_add(struct simpledisk *d) {
  int c;

  if(!disksim->simplediskinfo) simpledisk_initialize_diskinfo();
  
  for(c = 0; c < disksim->simplediskinfo->simpledisks_len; c++) {
    if(!disksim->simplediskinfo->simpledisks[c]) {
      disksim->simplediskinfo->simpledisks[c] = d;
      numsimpledisks++;
      return c;
    }
  }

  /* note that numdisks must be equal to diskinfo->disks_len */
  disksim->simplediskinfo->simpledisks = 
    realloc(disksim->simplediskinfo->simpledisks, 
	    2 * c * sizeof(struct simpledisk *));

  bzero(disksim->simplediskinfo->simpledisks + numsimpledisks, 
	numsimpledisks);

  disksim->simplediskinfo->simpledisks[c] = d;
  numsimpledisks++;
  disksim->simplediskinfo->simpledisks_len *= 2;
  return c;
}


struct simpledisk *disksim_simpledisk_loadparams(struct lp_block *b)
{
  /* temp vars for parameters */
  struct simpledisk *result;
  int num;

  if(!disksim->simplediskinfo) simpledisk_initialize_diskinfo();

  result = malloc(sizeof(struct simpledisk));
  if(!result) return 0;
  bzero(result, sizeof(struct simpledisk));
  
  num = simpledisk_add(result);

  result->hdr = simpledisk_hdr_initializer; 
  if(b->name)
    result->hdr.device_name = strdup(b->name);

#include "modules/disksim_simpledisk_param.c"



  device_add((struct device_header *)result, num);
  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 simpledisk_set_syncset (int setstart, int setend)
{
}


static void simpledisk_acctime_printstats (int *set, int setsize, char *prefix)
{
   int i;
   statgen * statset[MAXDEVICES];

   if (device_printacctimestats) {
      for (i=0; i<setsize; i++) {
         simpledisk_t *currdisk = getsimpledisk (set[i]);
         statset[i] = &currdisk->stat.acctimestats;
      }
      stat_print_set(statset, setsize, prefix);
   }
}


static void simpledisk_other_printstats (int *set, int setsize, char *prefix)
{
   int i;
   int numbuswaits = 0;
   double waitingforbus = 0.0;

   for (i=0; i<setsize; i++) {
      simpledisk_t *currdisk = getsimpledisk (set[i]);
      numbuswaits += currdisk->stat.numbuswaits;
      waitingforbus += currdisk->stat.waitingforbus;
   }

   fprintf(outputfile, "%sTotal bus wait time: %f\n", prefix, waitingforbus);
   fprintf(outputfile, "%sNumber of bus waits: %d\n", prefix, numbuswaits);
}


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");
   }
}


double simpledisk_get_seektime (int devno, 
				ioreq_event *req, 
				int checkcache, 
				double maxtime)
{
  fprintf(stderr, "device_get_seektime not supported for simpledisk devno %d\n",  devno);
  assert(0);
}

/* default simpledisk dev header */
struct device_header simpledisk_hdr_initializer = { 
  DEVICETYPE_SIMPLEDISK,
  sizeof(struct simpledisk),
  "unnamed simpledisk",
  (void *)simpledisk_copy,
  simpledisk_set_depth,
  simpledisk_get_depth,
  simpledisk_get_inbus,
  simpledisk_get_busno,
  simpledisk_get_slotno,
  simpledisk_get_number_of_blocks,
  simpledisk_get_maxoutstanding,
  simpledisk_get_numcyls,
  simpledisk_get_blktranstime,
  simpledisk_get_avg_sectpercyl,
  simpledisk_get_mapping,
  simpledisk_event_arrive,
  simpledisk_get_distance,
  simpledisk_get_servtime,
  simpledisk_get_seektime,
  simpledisk_get_acctime,
  simpledisk_bus_delay_complete,
  simpledisk_bus_ownership_grant
};