disksim_logorg.c

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

      }
   } 

   logorg_resetstats(logorgs, numlogorgs);
}


void logorg_cleanstats (logorg **logorgs, int numlogorgs)
{
   int i;
   double tpass;

   for (i=0; i<numlogorgs; i++) {
      logorg_streakstat(logorgs[i], logorgs[i]->actualnumdisks);
      if (logorgs[i]->stat.outstanding > 0) {
         logorgs[i]->stat.nonzeroouttime += simtime - logorgs[i]->stat.outtime;
      } else {
         tpass = simtime - logorgs[i]->stat.idlestart;
         stat_update(&logorgs[i]->stat.idlestats, tpass);
      }
      logorgs[i]->stat.idlestart = simtime;
      logorgs[i]->stat.runouttime += (double) logorgs[i]->stat.outstanding * (simtime - logorgs[i]->stat.outtime);
      logorgs[i]->stat.outtime = simtime;
   }
}


static void logorg_printreqtimestats (logorg *currlogorg, char *prefix)
{
   int tmp1, tmp2;

   tmp1 = stat_get_count(&currlogorg->stat.intarrstats);
   fprintf(outputfile, "%sNumber of requests:       %d\n", prefix, tmp1);
   tmp2 = stat_get_count(&currlogorg->stat.readintarrstats);

   fprintf(outputfile, "%sNumber of read requests:  %d  \t%f\n", prefix, tmp2, ((double) tmp2 / (double) max(1,tmp1)));

   tmp1 = stat_get_count(&currlogorg->stat.resptimestats) + currlogorg->stat.outstanding;
   fprintf(outputfile, "%sNumber of accesses:       %d\n", prefix, tmp1);
   tmp2 = currlogorg->stat.reads + currlogorg->stat.readoutstanding;
   fprintf(outputfile, "%sNumber of read accesses:  %d  \t%f\n", prefix, tmp2, ((double) tmp2 / (double) max(1,tmp1)));

   fprintf(outputfile, "%sAverage outstanding:      %f\n", prefix, (currlogorg->stat.runouttime / (simtime - warmuptime)));
   fprintf(outputfile, "%sMaximum outstanding:      %d\n", prefix, currlogorg->stat.maxoutstanding);
   if (currlogorg->stat.nonzeroouttime == 0.0) {
      fprintf(outputfile, "%sAvg nonzero outstanding:  none\n", prefix);
   } else {
      fprintf(outputfile, "%sAvg nonzero outstanding:  %f\n", prefix, (currlogorg->stat.runouttime / currlogorg->stat.nonzeroouttime));
   }
   fprintf(outputfile, "%sCompletely idle time:     %f\n", prefix, (simtime - warmuptime - currlogorg->stat.nonzeroouttime));
   stat_print(&currlogorg->stat.resptimestats, prefix);
}


static void logorg_printlocalitystats (logorg *currlogorg, char *prefix)
{
   int i;
   int seqreads = 0;
   int seqwrites = 0;
   int intreads = 0;
   int intwrites = 0;
   int numreqs;
   int numreads;
   int numwrites;
   statgen * statset[MAXDEVICES];

   if (currlogorg->printlocalitystats) {
      for (i=0; i<currlogorg->actualnumdisks; i++) {
	 seqreads += currlogorg->devs[i].seqreads;
	 seqwrites += currlogorg->devs[i].seqwrites;
	 intreads += currlogorg->devs[i].intreads;
	 intwrites += currlogorg->devs[i].intwrites;
	 statset[i] = &currlogorg->devs[i].localitystats;
      }
      numreqs = stat_get_count(&currlogorg->stat.intarrstats);
      numreads = stat_get_count(&currlogorg->stat.readintarrstats);
      numwrites = stat_get_count(&currlogorg->stat.writeintarrstats);

      stat_print_set(statset, currlogorg->actualnumdisks, prefix);
      fprintf(outputfile, "%sSequential reads:           %4d\t%f\t%f\n", prefix, seqreads, ((double) seqreads / (double) max(numreqs,1)), ((double) seqreads / (double) max(numreads,1)));
      fprintf(outputfile, "%sSequential writes:          %4d\t%f\t%f\n", prefix, seqwrites, ((double) seqwrites / (double) max(numreqs,1)), ((double) seqwrites / (double) max(numwrites,1)));
      fprintf(outputfile, "%sInterleaved reads:          %4d\t%f\t%f\n", prefix, intreads, ((double) intreads / (double) max(numreqs,1)), ((double) intreads / (double) max(numreads,1)));
      fprintf(outputfile, "%sInterleaved writes:         %4d\t%f\t%f\n", prefix, intwrites, ((double) intwrites / (double) max(numreqs,1)), ((double) intwrites / (double) max(numwrites,1)));

      fprintf(outputfile, "%sLogical sequential reads:   %4d\t%f\t%f\n", prefix, currlogorg->stat.seqreads, ((double) currlogorg->stat.seqreads / (double) max(numreqs,1)), ((double) currlogorg->stat.seqreads / (double) max(numreads,1)));
      fprintf(outputfile, "%sLogical sequential writes:  %4d\t%f\t%f\n", prefix, currlogorg->stat.seqwrites, ((double) currlogorg->stat.seqwrites / (double) max(numreqs,1)), ((double) currlogorg->stat.seqwrites / (double) max(numwrites,1)));
      seqreads = currlogorg->stat.seqreads + currlogorg->stat.seqwrites;
      fprintf(outputfile, "%sSequential disk switches:   %4d\t%f\n", prefix, currlogorg->stat.seqdiskswitches, ((double) currlogorg->stat.seqdiskswitches / (double) max(seqreads,1)));
      fprintf(outputfile, "%sLogical local accesses:     %4d\t%f\n", prefix, currlogorg->stat.numlocal, ((double) currlogorg->stat.numlocal / (double) max(numreqs,1)));
      fprintf(outputfile, "%sLocal disk swicthes:        %4d\t%f\n", prefix, currlogorg->stat.locdiskswitches, ((double) currlogorg->stat.locdiskswitches / (double) max(currlogorg->stat.numlocal,1)));
   }
}


static void logorg_printinterferestats (logorg *currlogorg, char *prefix)
{
   int i;
   double frac;
   double reqcnt;
   int *intdist;
   int localoff[INTDISTMAX];

   if (currlogorg->printinterferestats == FALSE) {
      return;
   }

   localoff[1] = -4;
   localoff[2] = -8;
   localoff[3] = -16;
   localoff[4] = -64;
   localoff[5] = 8;
   localoff[6] = 16;
   localoff[7] = 64;
   intdist = currlogorg->stat.intdist;
   reqcnt = (double) stat_get_count(&currlogorg->stat.intarrstats);
   for (i=0; i<(INTERFEREMAX*INTDISTMAX); i+=INTDISTMAX) {
      frac = (double) intdist[i] / reqcnt;
      if (frac >= 0.002) {
         fprintf (outputfile, "%sSequential step %2d:  %6d \t%f\n", prefix, (i/INTDISTMAX), intdist[i], frac);
      }
   }
   for (i=0; i<(INTERFEREMAX*INTDISTMAX); i++) {
      if (i % INTDISTMAX) {
	 frac = (double) intdist[i] / reqcnt;
	 if (frac >= 0.002) {
	    fprintf (outputfile, "%sLocal (%3d) step %2d:  %6d \t%f\n", prefix, localoff[(i % INTDISTMAX)], (i/INTDISTMAX), intdist[i], frac);
	 }
      }
   }
}


static void logorg_printblockingstats (logorg *currlogorg, char *prefix)
{
   int i;
   double frac;
   double reqcnt;

   if (currlogorg->printblockingstats == FALSE) {
      return;
   }

   reqcnt = (double) stat_get_count(&currlogorg->stat.intarrstats);
   fprintf(outputfile, "%sBlocking statistics\n", prefix);
   for (i=0; i<BLOCKINGMAX; i++) {
      frac = (double) currlogorg->stat.blocked[i] / reqcnt;
      if (frac >= (double) 0.01) {
	 fprintf(outputfile, "%sBlocking factor: %3d \t%6d \t%f\n", prefix, (i+1), currlogorg->stat.blocked[i], frac);
      }
   }
   fprintf(outputfile, "%sAlignment statistics\n", prefix);
   for (i=0; i<BLOCKINGMAX; i++) {
      frac = (double) currlogorg->stat.aligned[i] / reqcnt;
      if (frac >= (double) 0.1) {
	 fprintf(outputfile, "%sAlignment factor: %3d \t%6d \t%f\n", prefix, (i+1), currlogorg->stat.aligned[i], frac);
      }
   }
}


static void logorg_printstampstats (logorg *currlogorg, char *prefix)
{
   int i, j;
   int distnumout[10];

   if (currlogorg->printstampstats == FALSE)
      return;

   for (i=0; i<10; i++) {
      distnumout[i] = 0;
   }
   for (i=0; i<currlogorg->actualnumdisks; i++) {
      for (j=0; j<10; j++) {
         distnumout[j] += currlogorg->devs[i].distnumout[j];
      }
   }
   fprintf(outputfile, "%sTimestamped # outstanding distribution (interval = %f)\n", prefix, currlogorg->stampinterval);
   fprintf(outputfile, "     0       1       2       3       4       5       6       7       8      9+\n");
   fprintf(outputfile, "%6d  %6d  %6d  %6d  %6d  %6d  %6d  %6d  %6d  %6d\n",
      distnumout[0], distnumout[1], distnumout[2], distnumout[3],
      distnumout[4], distnumout[5], distnumout[6], distnumout[7],
      distnumout[8], distnumout[9]);
   fprintf(outputfile, "%sTimestamped avg # outstanding difference distribution\n", prefix);
   fprintf(outputfile, "   <.5      <1    <1.5      <2    <2.5      <3      <4      <5      <6      6+\n");
   fprintf(outputfile, "%6d  %6d  %6d  %6d  %6d  %6d  %6d  %6d  %6d  %6d\n",
      currlogorg->stat.distavgdiff[0], currlogorg->stat.distavgdiff[1],
      currlogorg->stat.distavgdiff[2], currlogorg->stat.distavgdiff[3],
      currlogorg->stat.distavgdiff[4], currlogorg->stat.distavgdiff[5],
      currlogorg->stat.distavgdiff[6], currlogorg->stat.distavgdiff[7],
      currlogorg->stat.distavgdiff[8], currlogorg->stat.distavgdiff[9]);
   fprintf(outputfile, "%sTimestamped max # outstanding difference distribution\n", prefix);
   fprintf(outputfile, "   <.5      <1    <1.5      <2    <2.5      <3      <4      <5      <6      6+\n");
   fprintf(outputfile, "%6d  %6d  %6d  %6d  %6d  %6d  %6d  %6d  %6d  %6d\n",
      currlogorg->stat.distmaxdiff[0], currlogorg->stat.distmaxdiff[1],
      currlogorg->stat.distmaxdiff[2], currlogorg->stat.distmaxdiff[3],
      currlogorg->stat.distmaxdiff[4], currlogorg->stat.distmaxdiff[5],
      currlogorg->stat.distmaxdiff[6], currlogorg->stat.distmaxdiff[7],
      currlogorg->stat.distmaxdiff[8], currlogorg->stat.distmaxdiff[9]);
}


void logorg_printstats (logorg **logorgs, int numlogorgs, char *sourcestr)
{
   int i, j;
   int actualnumdisks;
   statgen * statset[MAXDEVICES];
   int set[MAXDEVICES];
   char prefix[80];

   for (i = 0; i < numlogorgs; i++) {
      fprintf (outputfile, "%sLogical Organization #%d\n", sourcestr, i);
      sprintf(prefix, "%slogorg #%d ", sourcestr, i);
      actualnumdisks = logorgs[i]->actualnumdisks;
      logorg_printreqtimestats(logorgs[i], prefix);
      fprintf (outputfile, "%sTime-critical reads:  %d\n", prefix, logorgs[i]->stat.critreads);
      fprintf (outputfile, "%sTime-critical writes: %d\n", prefix, logorgs[i]->stat.critwrites);
      logorg_printlocalitystats(logorgs[i], prefix);
      logorg_printinterferestats(logorgs[i], prefix);
      logorg_printblockingstats(logorgs[i], prefix);

      if (logorgs[i]->printintarrstats) {
	 stat_print(&logorgs[i]->stat.intarrstats, prefix);
	 stat_print(&logorgs[i]->stat.readintarrstats, prefix);
	 stat_print(&logorgs[i]->stat.writeintarrstats, prefix);
      }

      if (logorgs[i]->printstreakstats) {
         for (j = 0; j < actualnumdisks; j++) {
	    statset[j] = &logorgs[i]->devs[j].streakstats;
         }
         fprintf (outputfile, "%sNumber of streaks:\t\t%d\n", prefix, stat_get_count_set(statset, actualnumdisks));
	 stat_print_set(statset, actualnumdisks, prefix);
      }

      logorg_printstampstats(logorgs[i], prefix);

      if (logorgs[i]->printsizestats) {
	 stat_print(&logorgs[i]->stat.sizestats, prefix);
	 stat_print(&logorgs[i]->stat.readsizestats, prefix);
	 stat_print(&logorgs[i]->stat.writesizestats, prefix);
      }

      if (logorgs[i]->printidlestats) {
         fprintf (outputfile, "%sNumber of idle periods:	%d\n", prefix, stat_get_count(&logorgs[i]->stat.idlestats));
         stat_print(&logorgs[i]->stat.idlestats, prefix);
      }

      for (j = 0; j < actualnumdisks; j++) {
	 set[j] = logorgs[i]->devs[j].devno;
      }
      device_printsetstats(set, actualnumdisks, prefix);
      if ((i+1) < numlogorgs) {
         fprintf (outputfile, "\n");
      }
   }
}

static int logorg_distn(logorg *result, char *s) {
  if(!strcmp(s, "Asis")) { 
    result->maptype = ASIS;
  } 
  else if(!strcmp(s, "Striped")) { 
    result->maptype = STRIPED;
  } 
  else if(!strcmp(s, "Random")) { 
    fprintf(stderr, "*** warning: Random logorg distribution is only "
	    "to be used with constant access-time disks "
	    "for load-balancing experiments \n");

    result->maptype = RANDOM;
  } 
  else if(!strcmp(s, "Ideal")) { 
    result->maptype = IDEAL;
  } 
  else { 
    fprintf(stderr, "*** error: %s is not a valid argument for logorg addressing mode\n", s); 
    return -1; 
  }
  return 0;
}

static int logorg_addr(logorg *result, char *s) {
  if(!strcmp(s, "Parts")) {
    result->addrbyparts = TRUE;
  }
  else if(!strcmp(s, "Array")) {
    result->addrbyparts = FALSE;
  }
  else {
    fprintf(stderr, "*** error: %s is not a valid argument for logorg distribution scheme\n", s);
    return -1;
  }
  return 0;
}

static int logorg_redun(logorg *result, char *s) {
  if(!strcmp(s, "Noredun")) {
    result->reduntype = NO_REDUN;
  }
  else if(!strcmp(s, "Shadowed")) {
    result->reduntype = SHADOWED;
  }
  else if(!strcmp(s, "Parity_disk")) {
    result->reduntype = PARITY_DISK;
  }
  else if(!strcmp(s, "Parity_rotated")) {
    result->reduntype = PARITY_ROTATED;
  }
  else {
    fprintf(stderr, "*** error: %s is not a valid argument for logorg redundancy scheme\n", s);
    return -1;
  }
  return 0;
}


static int getlogorgdevs(logorg *result, struct lp_list *l) {
  int c, j;
  int devno, devtype;
  int slot = 0;

  result->devs = malloc(l->values_len * sizeof(logorgdev));
  bzero(result->devs, l->values_len * sizeof(logorgdev));

  for(c = 0; c < l->values_len; c++) {
    if(!l->values[c]) continue;

    if(l->values[c]->t != S) {
      fprintf(stderr, "*** error: bad logorg member device spec.\n");
      return -1;
    }
    else if(!getdevbyname(l->values[c]->v.s, &devno, 0, &devtype)) {
      fprintf(stderr, "*** error: bad logorg member device spec: no such device.\n");
      return -1;
    }

/*      if(devtype != DEVICETYPE_DISK) { */
/*        fprintf(stderr, "*** error: bad logorg member device spec: members must be disks.\n"); */
/*        return -1; */
/*      } */

    /* from logorg_postpass_per() */
    result->devs[slot].devno = devno;
    result->devs[slot].startblkno = 0;

    result->devs[slot].seqreads = 0;
    result->devs[slot].seqwrites = 0;
    result->devs[slot].intreads = 0;
    result->devs[slot].intwrites = 0;
    for (j=0; j<10; j++) {
      result->devs[slot].distnumout[j] = 0;
    }
    stat_reset(&result->devs[slot].streakstats);
    stat_reset(&result->devs[slot].localitystats);

    slot++;
  }

  /* hmmmm .... this is what lorg_initialize() does */
  result->actualnumdisks = slot;

/*    result->numdisks = slot - 1; */
  result->numdisks = slot;


  return 0;
}




struct logorg *disksim_logorg_loadparams(struct lp_block *b) 
{
  int c;
  struct logorg *result;
  double rmwpoint = 0.0;


  result = malloc(sizeof(struct logorg));
  bzero(result, sizeof(struct logorg));

#include "modules/disksim_logorg_param.c"

  result->name = strdup(b->name);

  /* deal with rmwpoint here */
  result->rmwpoint = (int) (rmwpoint * (double) result->actualnumdisks);

  return result;
}





INLINE void logorg_set_arraydisk(struct logorg *l, int n) {
  l->arraydisk = n;
}


logorg *getlogorgbyname(logorg **logorgs, 
			int numlogorgs, 
			char *name, 
			int *n) 
{
  int c;

  for(c = 0; c < numlogorgs; c++) {
    if(logorgs[c] == 0) continue;

    if(!strcmp(logorgs[c]->name, name)) {
      if(n != 0) {
	*n = c;
      }

      return logorgs[c];
    }

  }

  return 0;
}