disksim_disk.c

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

  }

  if ((currdisk->numsegs <= 1) && (currdisk->dedicatedwriteseg)) {
    fprintf(stderr, "Must have more segments than dedicated write segments\n");
    ddbg_assert(0);;
  }
  if (((int)currdisk->dedicatedwriteseg != 0) &&
      ((int)currdisk->dedicatedwriteseg != 1)) {
    fprintf(stderr, "Invalid value for dedicatedwriteseg in disk_postpass_perdisk: %d\n", (int)currdisk->dedicatedwriteseg);
    ddbg_assert(0);;
  }

  if ((currdisk->fastwrites != 0) && (currdisk->fastwrites != 1) &&
      (currdisk->fastwrites != 2)) {
    fprintf(stderr, "Invalid value for fastwrites in disk_postpass_perdisk: %d\n", currdisk->fastwrites);
    ddbg_assert(0);;
  }
  if ((currdisk->fastwrites != 0) && (currdisk->enablecache == FALSE)) {
    fprintf(stderr, "disk_postpass_perdisk:  Can't use fast write if not employing caching\n");
    ddbg_assert(0);;
  }

  if (currdisk->model->dm_surfaces < 1) {
    fprintf(stderr, "Invalid value for numsurfaces in disk_postpass_perdisk: %d\n", currdisk->model->dm_surfaces);
    ddbg_assert(0);;
  }

  /* This is probably too difficult to be worthwhile  -rcohen
     if (currdisk->model->dm_cyls < 1) {
     fprintf(stderr, "Invalid value for numcyls in disk_postpass_perdisk: %d\n", currdisk->model->dm_cyls);
     ddbg_assert(0);;
     }
  */
}


static void disk_postpass (void)
{
  int i;

  if (numdisks == 0) {
    return;
  }

  if (reading_buffer_whole_servtime < 0.0) {
    fprintf(stderr, "Invalid value for reading_buffer_whole_servtime in disk_postpass: %f\n", reading_buffer_whole_servtime);
    ddbg_assert(0);;
  }


  ddbg_assert3(buffer_whole_servtime >= 0.0, ("Invalid value for buffer_whole_servtime in disk_postpass: %f\n", buffer_whole_servtime));


  if (reading_buffer_partial_servtime < 0.0) {
    fprintf(stderr, "Invalid value for reading_buffer_partial_servtime in disk_postpass: %f\n", reading_buffer_partial_servtime);
    ddbg_assert(0);;
  }

  if (buffer_partial_servtime < 0.0) {
    fprintf(stderr, "Invalid value for buffer_partial_servtime in disk_postpass: %f\n", buffer_partial_servtime);
    ddbg_assert(0);
  }

  for (i = 0; i < MAXDEVICES; i++) {
    disk *currdisk = getdisk (i);
    if (currdisk) {
      disk_postpass_perdisk(currdisk);
    }
  }

  /* syncset stuff, perhaps should be in its own function */
  /* unnecessary for now anyway */

  /*
    for (i = 0; i < MAXDEVICES; i++) {
    disk *currdisk = getdisk (i);
    if (currdisk) {
    currdisk->syncset = 0;
    }
    }
  */

}


void disk_setcallbacks ()
{
  disksim->enablement_disk = disk_enablement_function;
  ioqueue_setcallbacks();
}


static void disk_initialize_diskinfo ()
{
  disksim->diskinfo = malloc (sizeof(disk_info_t));
  bzero ((char *)disksim->diskinfo, sizeof(disk_info_t));

  disksim->diskinfo->disks = (struct disk**) malloc(MAXDEVICES * sizeof(disk));
  disksim->diskinfo->disks_len = MAXDEVICES;
  bzero ((char *)disksim->diskinfo->disks, (MAXDEVICES * sizeof(disk)));

  /* important initialization of stuff that gets remapped into diskinfo */
  disk_printhacktime = 0.0;
  //  global_currtime = 0.0;
  //  global_currangle = 0.0;
  swap_forward_only = 1;
  addtolatency = 0.0;
  disk_seek_stoptime = 0.0;
  disk_last_seektime = 0.0;
  disk_last_latency = 0.0;
  disk_last_xfertime = 0.0;
  disk_last_acctime = 0.0;
  buffer_partial_servtime = 0.000000001;
  reading_buffer_partial_servtime = 0.000000001;
  buffer_whole_servtime = 0.000000000;
  reading_buffer_whole_servtime = 0.000000000;
}


void disk_resetstats (void)
{
  int i;

  for (i=0; i<MAXDEVICES; i++) {
    disk *currdisk = getdisk (i);
    if (currdisk) {
      ioqueue_resetstats(currdisk->queue);
      diskstatinit(i, 0);
    }
  }
}



void disk_set_syncset (int setstart, int setend)
{
  if ((setstart < 0) || (setend >= MAXDEVICES) || (setend < setstart)) {
    fprintf (stderr, "Bad range passed to disk_set_syncset (%d - %d)\n", setstart, setend);
    exit (0);
  }

  numsyncsets++;
  for (; setstart <= setend; setstart++) {
    disk *currdisk = getdisk (setstart);
    if (currdisk->syncset != 0) {
      fprintf (stderr, "Overlapping synchronized disk sets (%d and %d)\n", numsyncsets, currdisk->syncset);
      exit (0);
    }
    currdisk->syncset = numsyncsets;
  }
}


static void disk_interfere_printstats (int *set, int setsize, char *prefix)
{
  int seq = 0;
  int loc = 0;
  int i;

  if (device_printinterferestats == FALSE)
    return;

  for(i=0; i<setsize; i++) {
    disk *currdisk = getdisk (set[i]);
    seq += currdisk->stat.interfere[0];
    loc += currdisk->stat.interfere[1];
  }
  fprintf (outputfile, "%sSequential interference: %d\n", prefix, seq);
  fprintf (outputfile, "%sLocal interference:      %d\n", prefix, loc);
}


static void disk_buffer_printstats (int *set, int setsize, char *prefix)
{
  int writecombs = 0;
  int readmisses = 0;
  int writemisses = 0;
  int fullreadhits = 0;
  int prependhits = 0;
  int appendhits = 0;
  int readinghits = 0;
  double runreadingsize = 0.0;
  double remreadingsize = 0.0;
  int parthits = 0;
  double runpartsize = 0.0;
  double rempartsize = 0.0;
  double waitingforbus = 0.0;
  int numbuswaits = 0;
  int hits;
  int misses;
  int total;
  int reads;
  int writes;
  int i;

  if (device_printbufferstats == FALSE)
    return;

  for (i=0; i<setsize; i++) {
    disk *currdisk = getdisk (set[i]);
    writecombs += currdisk->stat.writecombs;
    readmisses += currdisk->stat.readmisses;
    writemisses += currdisk->stat.writemisses;
    fullreadhits += currdisk->stat.fullreadhits;
    prependhits += currdisk->stat.prependhits;
    appendhits += currdisk->stat.appendhits;
    readinghits += currdisk->stat.readinghits;
    runreadingsize += currdisk->stat.runreadingsize;
    remreadingsize += currdisk->stat.remreadingsize;
    parthits += currdisk->stat.parthits;
    runpartsize += currdisk->stat.runpartsize;
    rempartsize += currdisk->stat.rempartsize;
    waitingforbus += currdisk->stat.waitingforbus;
    numbuswaits += currdisk->stat.numbuswaits;
  }
  hits = fullreadhits + appendhits + prependhits + parthits + readinghits;
  misses = readmisses + writemisses;
  reads = fullreadhits + readmisses + readinghits + parthits;
  total = hits + misses;
  writes = total - reads;
  if (total == 0) {
    return;
  }
  fprintf(outputfile, "%sNumber of buffer accesses:    %d\n", prefix, total);
  fprintf(outputfile, "%sBuffer hit ratio:        %6d \t%f\n", prefix, hits, ((double) hits / (double) total));
  fprintf(outputfile, "%sBuffer miss ratio:            %6d \t%f\n", prefix, misses, ((double) misses / (double) total));
  fprintf(outputfile, "%sBuffer read hit ratio:        %6d \t%f \t%f\n", prefix, fullreadhits, ((double) fullreadhits / (double) max(1,reads)), ((double) fullreadhits / (double) total));
  fprintf(outputfile, "%sBuffer prepend hit ratio:       %6d \t%f\n", prefix, prependhits, ((double) prependhits / (double) max(1,writes)));
  fprintf(outputfile, "%sBuffer append hit ratio:       %6d \t%f\n", prefix, appendhits, ((double) appendhits / (double) max(1,writes)));
  fprintf(outputfile, "%sWrite combinations:           %6d \t%f\n", prefix, writecombs, ((double) writecombs / (double) max(1,writes)));
  fprintf(outputfile, "%sOngoing read-ahead hit ratio: %6d \t%f \t%f\n", prefix, readinghits, ((double) readinghits / (double) max(1,reads)), ((double) readinghits / (double) total));
  fprintf(outputfile, "%sAverage read-ahead hit size:  %f\n", prefix, (runreadingsize / (double) max(1,readinghits)));
  fprintf(outputfile, "%sAverage remaining read-ahead: %f\n", prefix, (remreadingsize / (double) max(1,readinghits)));
  fprintf(outputfile, "%sPartial read hit ratio: %6d \t%f \t%f\n", prefix, parthits, ((double) parthits / (double) max(1,reads)), ((double) parthits / (double) total));
  fprintf(outputfile, "%sAverage partial hit size:     %f\n", prefix, (runpartsize / (double) max(1,parthits)));
  fprintf(outputfile, "%sAverage remaining partial:    %f\n", prefix, (rempartsize / (double) max(1,parthits)));
  fprintf(outputfile, "%sTotal disk bus wait time: %f\n", prefix, waitingforbus);
  fprintf(outputfile, "%sNumber of disk bus waits: %d\n", prefix, numbuswaits);
}


static void disk_seek_printstats (int *set, int setsize, char *prefix)
{
  int i;
  int zeros = 0;
  statgen * statset[MAXDEVICES];
  double zerofrac;

  if (device_printseekstats == FALSE) {
    return;
  }

  for (i=0; i<setsize; i++) {
    disk *currdisk = getdisk (set[i]);
    zeros += currdisk->stat.zeroseeks;
    statset[i] = &currdisk->stat.seekdiststats;
  }
  if (stat_get_count_set(statset,setsize) > 0) {
    zerofrac = (double) zeros / (double) stat_get_count_set(statset, setsize);
  } else {
    zerofrac = 0.0;
  }
  fprintf (outputfile, "%sSeeks of zero distance:\t%d\t%f\n", prefix, zeros, zerofrac);
  stat_print_set(statset, setsize, prefix);

  for (i=0; i<setsize; i++) {
    disk *currdisk = getdisk (set[i]);
    statset[i] = &currdisk->stat.seektimestats;
  }
  stat_print_set(statset, setsize, prefix);
}


static void disk_latency_printstats (int *set, int setsize, char *prefix)
{
  int i;
  int zeros = 0;
  statgen * statset[MAXDEVICES];
  double zerofrac;
  disk *currdisk = NULL;

  if (device_printlatencystats == FALSE) {
    return;
  }

  for (i=0; i<setsize; i++) {
    currdisk = getdisk (set[i]);
    zeros += currdisk->stat.zerolatency;
    statset[i] = &currdisk->stat.rotlatstats;
  }
  if (setsize == 1) {
    fprintf (outputfile, "%sFull rotation time:      %lld\n", prefix, dm_time_itod(currdisk->model->mech->dm_period(currdisk->model)));
  }
  if (stat_get_count_set(statset,setsize) > 0) {
    zerofrac = (double) zeros / (double) stat_get_count_set(statset, setsize);
  } else {
    zerofrac = 0.0;
  }
  fprintf (outputfile, "%sZero rotate latency:\t%d\t%f\n", prefix, zeros, zerofrac);
  stat_print_set(statset, setsize, prefix);
}


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

  if (device_printxferstats) {
    for (i=0; i<setsize; i++) {
      disk *currdisk = getdisk (set[i]);
      statset[i] = &currdisk->stat.xfertimestats;
    }
    stat_print_set(statset, setsize, prefix);
  }
}


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

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


void disk_printsetstats (int *set, int setsize, char *sourcestr)
{
  int i;
  struct ioq * queueset[MAXDEVICES];
  int reqcnt = 0;
  char prefix[80];

  sprintf(prefix, "%sdisk ", sourcestr);
  for (i=0; i<setsize; i++) {
    disk *currdisk = getdisk (set[i]);
    queueset[i] = currdisk->queue;
    reqcnt += ioqueue_get_number_of_requests(currdisk->queue);
  }
  if (reqcnt == 0) {
    fprintf (outputfile, "\nNo disk requests for members of this set\n\n");
    return;
  }
  ioqueue_printstats(queueset, setsize, prefix);

  disk_seek_printstats(set, setsize, prefix);
  disk_latency_printstats(set, setsize, prefix);
  disk_transfer_printstats(set, setsize, prefix);
  disk_acctime_printstats(set, setsize, prefix);
  disk_interfere_printstats(set, setsize, prefix);
  disk_buffer_printstats(set, setsize, prefix);
}


void disk_printstats (void)
{
  struct ioq * queueset[MAXDEVICES];
  int set[MAXDEVICES];
  int i;
  int reqcnt = 0;
  char prefix[80];
  int diskcnt;

  fprintf(outputfile, "\nDISK STATISTICS\n");
  fprintf(outputfile, "---------------\n\n");

  sprintf(prefix, "Disk ");

  diskcnt = 0;
  for (i=0; i<MAXDEVICES; i++) {
    disk *currdisk = getdisk (i);
    if (currdisk) {
      queueset[diskcnt] = currdisk->queue;
      reqcnt += ioqueue_get_number_of_requests(currdisk->queue);
      diskcnt++;
    }
  }
  assert (diskcnt == numdisks);

  if (reqcnt == 0) {
    fprintf(outputfile, "No disk requests encountered\n");
    return;
  }
  /*
    fprintf(outputfile, "Number of extra write disconnects:   %5d  \t%f\n", extra_write_disconnects, ((double) extra_write_disconnects / (double) reqcnt));
  */
  ioqueue_printstats(queueset, numdisks, prefix);

  diskcnt = 0;
  for (i=0; i<MAXDEVICES; i++) {
    disk *currdisk = getdisk (i);
    if (currdisk) {
      set[diskcnt] = i;
      diskcnt++;
    }
  }