disksim_logorg.c

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

         if (curr->devno == logorgs[i]->devs[j].devno) {
            if (logorg_overlap(logorgs[i], j, curr, logorgs[i]->actualblksperpart) == TRUE) {
               logorgno = i;
               break;
            }
         }
      }
      if (logorgno != -1)
         break;
   }
   if (logorgno == -1) {
      fprintf(stderr, "logorg_mapcomplete entered for non-logorged request\n");
      exit(1);
   }

   if (curr->flags & READ) {
      logorgs[logorgno]->stat.reads++;
   }
   logorgs[logorgno]->stat.idlestart = simtime;
   logorgs[logorgno]->devs[curr->devno].numout--;
   req = logorg_getfromoutstandq(logorgs[logorgno], curr->opid);
   ASSERT(req != NULL);
   req->numreqs--;
   if (req->depend) {
      ret = logorg_check_dependencies(logorgs[logorgno], req, curr);
      temp = curr->next;
      for (i = 0; i < ret; i++) {
         temp->blkno += logorgs[logorgno]->devs[(temp->devno)].startblkno;
         temp->devno = logorgs[logorgno]->devs[(temp->devno)].devno;
         temp = temp->next;
      }
      if (ret == 0) {
	 ret = NOT_COMPLETE;
      }
   }

   curr->blkno += logorgs[logorgno]->devs[(curr->devno)].startblkno;
   curr->devno = logorgs[logorgno]->devs[(curr->devno)].devno;
   if (req->numreqs) {
      logorg_addtooutstandq(logorgs[logorgno], req);
      return(ret);
   } else {
/*
fprintf (outputfile, "Request completion:  %2d %7d %4d %c %f  (opid %d)\n", req->devno, req->blkno, req->bcount, ((req->flags & READ) ? 'R' : 'W'), (simtime - req->arrtime), req->opid);
*/

      logorg_mapcomplete_update_stats(logorgs[logorgno], curr, req);
      curr->bcount = req->bcount;
      curr->blkno = req->blkno;
      curr->flags = req->flags;
      curr->busno = req->busno;
      curr->devno = req->devno;
      curr->opid = req->reqopid;
      curr->buf = req->buf;
      addtoextraq((event *) req);
      return(COMPLETE);
   }
/*
fprintf (outputfile, "Leaving logorg_mapcomplete\n");
*/
}


void logorg_raise_priority (logorg **logorgs, int numlogorgs, int opid, int devno, int blkno, void *buf)
{
   int i, j;
   int logorgno = -1;
   int calc;
   outstand *tmp;
   int found = 0;
/*
fprintf (outputfile, "Entered logorg_raise_priority: numlogorgs %d, devno %d, blkno %d, buf %p\n", numlogorgs, devno, blkno, buf);
*/
   ASSERT((numlogorgs >= 1) && (numlogorgs < MAXLOGORGS));
   for (i = 0; i < numlogorgs; i++) {
      if (!logorgs[i]->addrbyparts) {
	 if (devno == logorgs[i]->arraydisk) {
	    logorgno = i;
	    break;
	 }
      } else {
/*           for (j = 0; j < logorgs[i]->numdisks; j++) { */
         for (j = 0; j < logorgs[i]->actualnumdisks; j++) {
	    if (devno == logorgs[i]->devs[j].devno) {
               calc = blkno - logorgs[i]->devs[devno].startblkno;
               if ((calc >= 0) && (calc < logorgs[i]->blksperpart)) {
	          logorgno = i;
	          break;
	       }
	    }
         }
	 if (logorgno != -1) {
	    break;
         }
      }
   }
   ASSERT(logorgno != -1);
   tmp = logorg_show_buf_from_outstandq(logorgs[logorgno], buf, opid);
   if (tmp) {
      for (i=0; i<logorgs[logorgno]->actualnumdisks; i++) {
         found = ioqueue_raise_priority(logorgs[logorgno]->devs[i].queue, tmp->opid);
      }
   }
/*
fprintf (outputfile, "Leaving logorg_raise_priority\n");
*/
}


static void logorg_postpass_per(logorg *currlogorg, int orgno)
{
/*     logorgdev *devs; */
   int i, j;


/*     if (currlogorg->orgno != (orgno + 1)) { */
/*        fprintf(stderr, "Logical organizations appear out of order\n"); */
/*        exit(1); */
/*     } */


   currlogorg->blksperpart = device_get_number_of_blocks(currlogorg->devs[0].devno);
   currlogorg->actualblksperpart = currlogorg->blksperpart;

   /* no longer necessary -- taken care of in the paramload function */
/*     devs = DISKSIM_malloc(currlogorg->numdisks * (sizeof(logorgdev))); */
/*     for (j=0; j<currlogorg->numdisks; j++) { */
/*        devs[j].devno = j + currlogorg->startdev - 1; */
/*        devs[j].startblkno = 0; */
/*     } */
/*     currlogorg->devs = &devs[0]; */

   if ((currlogorg->stripeunit < 0) ||
       (currlogorg->stripeunit > currlogorg->blksperpart)) {
      fprintf(stderr, "Invalid value for 'Stripe unit (in sectors)': %d (<0 || >%d)", currlogorg->stripeunit, currlogorg->blksperpart);
   }

   if ((currlogorg->parityunit < 0) ||
       (currlogorg->parityunit > currlogorg->blksperpart)) {
      fprintf(stderr, "Invalid value for 'Parity stripe unit': %d", currlogorg->stripeunit);
   }

   if (currlogorg->maptype == ASIS) {
      if (!currlogorg->addrbyparts) {
	 fprintf(stderr, "Can't have ASIS organization with array addressing\n");
	 exit(1);
      }
   }

   /* look out for rmwpoint, it's dependant on actualnumdisks */

   currlogorg->sizes = NULL;
   currlogorg->redunsizes = NULL;
   currlogorg->stat.blocked = NULL;
   currlogorg->stat.aligned = NULL;
   currlogorg->stat.lastreq = NULL;
   currlogorg->stat.intdist = NULL;

   if ((currlogorg->stripeunit < 0) ||
       (currlogorg->stripeunit > currlogorg->blksperpart)) {
      fprintf(stderr, "Invalid value for stripeunit at logorg_postpass_per: %d\n", currlogorg->stripeunit);
      exit(1);
   }

   if ((currlogorg->parityunit < 1) ||
       (currlogorg->parityunit > currlogorg->blksperpart)) {
      fprintf(stderr, "Invalid value for parity stripe unit - %d\n", currlogorg->parityunit);
      exit(1);
   }

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


static void logorg_postpass(struct logorg **logorgs, int numlogorgs)
{
   int i;

   for (i = 0; i < numlogorgs; i++) {
     if(logorgs[i]) logorg_postpass_per(logorgs[i], i);
   }
}





void logorg_resetstats (logorg **logorgs, int numlogorgs)
{
   int i, j;

   for (i=0; i<numlogorgs; i++) {
      logorgs[i]->stat.maxoutstanding = 0;
      logorgs[i]->stat.nonzeroouttime = 0.0;
      logorgs[i]->stat.runouttime = 0.0;
      logorgs[i]->stat.outtime = simtime;
      logorgs[i]->stat.reads = 0;
      logorgs[i]->stat.idlestart = simtime;
      for (j=0; j<10; j++) {
         logorgs[i]->stat.distavgdiff[j] = 0;
         logorgs[i]->stat.distmaxdiff[j] = 0;
      }
      logorgs[i]->stat.critreads = 0;
      logorgs[i]->stat.critwrites = 0;
      logorgs[i]->stat.seqreads = 0;
      logorgs[i]->stat.seqwrites = 0;
      logorgs[i]->stat.numlocal = 0;
      logorgs[i]->stat.seqdiskswitches = 0;
      logorgs[i]->stat.locdiskswitches = 0;
      if (logorgs[i]->stat.intdist) {
         for (j=0; j<(INTERFEREMAX*INTDISTMAX); j++) {
            logorgs[i]->stat.intdist[j] = 0;
         }
      }
      if (logorgs[i]->stat.blocked) {
         for (j=0; j<BLOCKINGMAX; j++) {
            logorgs[i]->stat.blocked[j] = 0;
            logorgs[i]->stat.aligned[j] = 0;
         }
      }
      /*
      for (j=0; j<logorgs[i]->actualnumdisks; j++) {
         logorgs[i]->devs[j].seqreads = 0;
         logorgs[i]->devs[j].seqwrites = 0;
         logorgs[i]->devs[j].intreads = 0;
         logorgs[i]->devs[j].intwrites = 0;
	 for (k=0; k<10; k++) {
            logorgs[i]->devs[j].distnumout[k] = 0;
         }
         stat_reset(&logorgs[i]->devs[j].streakstats);
         stat_reset(&logorgs[i]->devs[j].localitystats);
      }
      */
      stat_reset(&logorgs[i]->stat.intarrstats);
      stat_reset(&logorgs[i]->stat.readintarrstats);
      stat_reset(&logorgs[i]->stat.writeintarrstats);
      stat_reset(&logorgs[i]->stat.sizestats);
      stat_reset(&logorgs[i]->stat.readsizestats);
      stat_reset(&logorgs[i]->stat.writesizestats);
      stat_reset(&logorgs[i]->stat.idlestats);
      stat_reset(&logorgs[i]->stat.resptimestats);
   }
}


void logorg_initialize (logorg **logorgs, 
			int numlogorgs, 
			struct ioq **queueset,
			int printlocalitystats,
			int printblockingstats, 
			int printinterferestats, 
			int printstreakstats, 
			int printstampstats, 
			int printintarrstats, 
			int printidlestats, 
			int printsizestats)
{
   int i, j, k;



   StaticAssert (sizeof(depends) <= DISKSIM_EVENT_SIZE);
   StaticAssert (sizeof(outstand) <= DISKSIM_EVENT_SIZE);

   logorg_postpass (logorgs, numlogorgs);

   for (i = 0; i < numlogorgs; i++) {

     logorgs[i]->printlocalitystats = printlocalitystats;
     logorgs[i]->printblockingstats = printblockingstats;
     logorgs[i]->printinterferestats = printinterferestats;
     logorgs[i]->printidlestats = printidlestats;
     logorgs[i]->printintarrstats = printintarrstats;
     logorgs[i]->printstreakstats = printstreakstats;
     logorgs[i]->printstampstats = printstampstats;
     logorgs[i]->printsizestats = printsizestats;

      if (logorgs[i]->reduntype == SHADOWED) {
         if ((logorgs[i]->numdisks % logorgs[i]->copies) != 0) {
	   fprintf(stderr, "Number of devices not multiple of number of copies\n");
	   exit(1);
         }
	 logorgs[i]->numdisks = logorgs[i]->numdisks / logorgs[i]->copies;
      }
      else if (logorgs[i]->reduntype == PARITY_DISK) {
	if ((logorgs[i]->maptype == STRIPED) && 
	    (logorgs[i]->stripeunit != 0)) 
	  {
	    logorgs[i]->maptype = ASIS;
	    logorg_create_table(logorgs[i]);
	    logorgs[i]->reduntype = PARITY_TABLE;
	  }
	logorgs[i]->numdisks--;
      }
      else if ((logorgs[i]->reduntype == PARITY_ROTATED) && 
	       (logorg_tabular_rottype(logorgs[i]->maptype, 
				       logorgs[i]->reduntype, 
				       logorgs[i]->rottype, 
				       logorgs[i]->stripeunit))) 
	{
	  logorg_create_table(logorgs[i]);
	  logorgs[i]->maptype = ASIS;
	  logorgs[i]->reduntype = PARITY_TABLE;
	  logorgs[i]->blksperpart = 
	    (int) ((double) 
		   logorgs[i]->blksperpart * 
		   (double) (logorgs[i]->numdisks - 1) / 
		   (double) logorgs[i]->numdisks);
	  
	} 
      else if (logorgs[i]->reduntype == PARITY_ROTATED) {
	logorgs[i]->blksperpart = 
	  (int) 
	  ((double) 
	   logorgs[i]->blksperpart * 
	   (double) (logorgs[i]->numdisks - 1) / 
	   (double) logorgs[i]->numdisks) 
	  - logorgs[i]->parityunit;
      }

      logorgs[i]->opid = 0;
      logorgs[i]->idealno = 0;
      logorgs[i]->reduntoggle = 0;
      logorgs[i]->lastdiskaccessed = logorgs[i]->actualnumdisks;

      while (logorgs[i]->outstandqlen != 0) {
         addtoextraq((event *) logorg_getfromoutstandq(logorgs[i], -1));
      }

      if ((logorgs[i]->maptype == STRIPED) && (logorgs[i]->stripeunit)) {
         logorgs[i]->numfull = logorgs[i]->blksperpart / 
	   logorgs[i]->stripeunit;
      } 
      else if (logorgs[i]->reduntype == PARITY_ROTATED) {
         logorgs[i]->numfull = logorgs[i]->actualblksperpart / 
	   logorgs[i]->parityunit;
      }
      else if (logorgs[i]->reduntype == PARITY_TABLE) {
         logorgs[i]->numfull = logorgs[i]->actualblksperpart / 
	   logorgs[i]->stripeunit;
	 logorgs[i]->numfull *= logorgs[i]->stripeunit;
      } 
      else {
	 logorgs[i]->numfull = 0;
      }

      logorgs[i]->sizes = 
	DISKSIM_malloc(logorgs[i]->actualnumdisks * sizeof(int));

      logorgs[i]->redunsizes = 
	DISKSIM_malloc(logorgs[i]->actualnumdisks * sizeof(int));

      if (logorgs[i]->printinterferestats) {
         logorgs[i]->stat.lastreq = 
	   DISKSIM_malloc(2 * INTERFEREMAX*sizeof(int));

         for (j=0; j<(2*INTERFEREMAX); j++) {
            logorgs[i]->stat.lastreq[j] = 0;
         }

         logorgs[i]->stat.intdist = 
	   DISKSIM_malloc(INTERFEREMAX*INTDISTMAX*sizeof(int));
      }
      if (logorgs[i]->printblockingstats) {
         logorgs[i]->stat.blocked = DISKSIM_malloc(BLOCKINGMAX*sizeof(int));
         logorgs[i]->stat.aligned = DISKSIM_malloc(BLOCKINGMAX*sizeof(int));
      }
      logorgs[i]->stat.outstanding = 0;
      logorgs[i]->stat.readoutstanding = 0;

      stat_initialize(statdeffile, statdesc_intarr, 
		      &logorgs[i]->stat.intarrstats);
      stat_initialize(statdeffile, statdesc_readintarr, 
		      &logorgs[i]->stat.readintarrstats);
      stat_initialize(statdeffile, statdesc_writeintarr, 
		      &logorgs[i]->stat.writeintarrstats);
      stat_initialize(statdeffile, statdesc_reqsize, 
		      &logorgs[i]->stat.sizestats);
      stat_initialize(statdeffile, statdesc_readsize, 
		      &logorgs[i]->stat.readsizestats);
      stat_initialize(statdeffile, statdesc_writesize, 
		      &logorgs[i]->stat.writesizestats);
      stat_initialize(statdeffile, statdesc_idles, 
		      &logorgs[i]->stat.idlestats);
      stat_initialize(statdeffile, statdesc_resptime, 
		      &logorgs[i]->stat.resptimestats);

      logorgs[i]->stat.lastarr = 0.0;
      logorgs[i]->stat.lastread = 0.0;
      logorgs[i]->stat.lastwrite = 0.0;

      for (j=0; j<NUMGENS; j++) {
         logorgs[i]->stat.gens[j] = -1;
      }

      for (k=0; k<logorgs[i]->actualnumdisks; k++) {
         logorgs[i]->devs[k].queue = queueset[logorgs[i]->devs[k].devno];
         logorgs[i]->devs[k].lastblkno = -1;
         logorgs[i]->devs[k].lastblkno2 = -1;
         logorgs[i]->devs[k].numout = 0;
         logorgs[i]->devs[k].curstreak = 0;
         stat_initialize(statdeffile, statdesc_streak, 
			 &logorgs[i]->devs[k].streakstats);
         stat_initialize(statdeffile, statdesc_locality, 
			 &logorgs[i]->devs[k].localitystats);
      }

      if (logorgs[i]->stampinterval != 0.0) {
         ioreq_event *tmp = (ioreq_event *) getfromextraq();
         tmp->time = logorgs[i]->stampstart;
         tmp->type = TIMESTAMP_LOGORG;
         tmp->tempptr1 = logorgs[i];
         addtointq((event *) tmp);