disksim_logorg.c

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

   stat_update(&currlogorg->stat.resptimestats, (simtime - req->arrtime));
   currlogorg->stat.nonzeroouttime += simtime - currlogorg->stat.outtime;
   currlogorg->stat.runouttime += currlogorg->stat.outstanding * (simtime - currlogorg->stat.outtime);
   currlogorg->stat.outstanding--;
   if (req->flags & READ) {
      currlogorg->stat.readoutstanding--;
   }
   currlogorg->stat.outtime = simtime;
}


void logorg_timestamp (ioreq_event *curr)
{
   logorg *currlogorg = (logorg *) curr->tempptr1;
   double avgqlen = 0.0;
   double avgdiff = 0.0;
   int maxqlen = 0;
   double maxdiff = 0.0;
   int i;
   double calc;

   curr->time += currlogorg->stampinterval;
   if (curr->time > currlogorg->stampstop) {
      addtoextraq((event *) curr);
   } else {
      addtointq((event *) curr);
   }
   calc = (double) currlogorg->actualnumdisks;
   for (i=0; i<currlogorg->actualnumdisks; i++) {
      logorg_numoutdist(currlogorg->devs[i].numout, currlogorg->devs[i].distnumout);
      if (currlogorg->stampfile) {
         fprintf(currlogorg->stampfile, "%d ", currlogorg->devs[i].numout);
      }
      avgqlen += (double) currlogorg->devs[i].numout;
      if (currlogorg->devs[i].numout > maxqlen) {
         maxqlen = currlogorg->devs[i].numout;
      }
   }
   if (currlogorg->stampfile) {
      fprintf(currlogorg->stampfile, "\n");
   }
   avgqlen = avgqlen / calc;
   for (i=0; i<currlogorg->actualnumdisks; i++) {
      if (avgqlen > (double) currlogorg->devs[i].numout) {
         avgdiff += (avgqlen - (double) currlogorg->devs[i].numout);
      } else {
         avgdiff += ((double) currlogorg->devs[i].numout - avgqlen);
      }
      maxdiff += (double) (maxqlen - currlogorg->devs[i].numout);
   }
   logorg_diffdist((avgdiff / calc), currlogorg->stat.distavgdiff);
   logorg_diffdist((maxdiff / calc), currlogorg->stat.distmaxdiff);
}


static void logorg_addnewtooutstandq (logorg *currlogorg, outstand *temp)
{
   outstand *run = NULL;

   temp->next = NULL;
   run = currlogorg->hashoutstand[(temp->opid % HASH_OUTSTAND)];
   if (run == NULL) {
      currlogorg->hashoutstand[(temp->opid % HASH_OUTSTAND)] = temp;
   } else {
      while (run->next != NULL)
         run = run->next;
      run->next = temp;
   }
   currlogorg->outstandqlen++;
}


static void logorg_addtooutstandq (logorg *currlogorg, outstand *temp)
{
   temp->next = currlogorg->hashoutstand[(temp->opid % HASH_OUTSTAND)];
   currlogorg->hashoutstand[(temp->opid % HASH_OUTSTAND)] = temp;
   currlogorg->outstandqlen++;
}


static outstand *logorg_show_buf_from_outstandq (logorg *currlogorg, void *buf, int opid)
{
   int i;
   outstand *tmp;

   for(i=0; i<HASH_OUTSTAND; i++) {
      tmp = currlogorg->hashoutstand[i];
      while ((tmp) && ((tmp->buf != buf) || ((opid != -1) && (tmp->reqopid != opid)))) {
         tmp = tmp->next;
      }
      if (tmp) {
         return(tmp);
      }
   }
   return(NULL);
}


static outstand * logorg_getfromoutstandq (logorg *currlogorg, int requestno)
{
   outstand *temp = NULL;
   outstand *hold = NULL;
   int i;

   if (requestno == -1) {
      for(i=0; i<HASH_OUTSTAND; i++) {
         if (currlogorg->hashoutstand[i] != NULL) {
            temp = currlogorg->hashoutstand[i];
            currlogorg->hashoutstand[i] = temp->next;
            currlogorg->outstandqlen--;
            return(temp);
         }
      }
   }

   temp = currlogorg->hashoutstand[(requestno % HASH_OUTSTAND)];
   if (temp == NULL)
      return(NULL);
   if (temp->opid == requestno) {
      currlogorg->outstandqlen--;
      currlogorg->hashoutstand[(requestno % HASH_OUTSTAND)] = temp->next;
   } else {
      while (temp->next != NULL) {
         if (temp->next->opid == requestno) {
            hold = temp->next;
            temp->next = temp->next->next;
            currlogorg->outstandqlen--;
            return(hold);
         }
         temp = temp->next;
      }
      temp = NULL;
   }
   return(temp);
}


static void logorg_mapideal (logorg *currlogorg, ioreq_event *curr)
{
   curr->devno = currlogorg->idealno;
   curr->blkno = -1;
   currlogorg->idealno = (currlogorg->idealno + 1) % currlogorg->numdisks;
   curr->next = curr;
}


static void logorg_maprandom (logorg *currlogorg, ioreq_event *curr)
{
   curr->devno = (int)((double)currlogorg->numdisks * DISKSIM_drand48());
   curr->blkno = -1;
   curr->next = curr;
}


static int logorg_mapinterleaved (logorg *currlogorg, ioreq_event *curr)
{
   int numdisks;
   int blkno;
   int i;
   ioreq_event *temp;

   numdisks = currlogorg->numdisks;
   blkno = curr->blkno / numdisks;
   curr->bcount += curr->blkno - (blkno * numdisks);
   curr->bcount = (curr->bcount + numdisks - 1) / numdisks;
   curr->blkno = blkno;
   curr->devno = 0;
   temp = curr;
   for (i = 1; i < numdisks; i++) {
      temp->next = ioreq_copy(curr);
      temp->next->devno = i;
      temp = temp->next;
   }
   temp->next = curr;
   return(numdisks);
}


static int logorg_mapstriped (logorg *currlogorg, ioreq_event *curr)
{
   int numdisks;
   int stripeunit;
   int unitno;
   int stripeno;
   int reqsize;
   int numstripes = 2;
   int numreqs = 1;
   int startslop;
   int devno;
   int startdevno;
   ioreq_event *newreq;
   ioreq_event *temp;
   int blkno;
   int i;
   int last = FALSE;

   numdisks = currlogorg->numdisks;
   stripeunit = currlogorg->stripeunit;

   temp = curr;
   if (currlogorg->addrbyparts) {
      curr->blkno = (curr->devno * currlogorg->blksperpart) + curr->blkno;
   }
   if (stripeunit == 0) {
      return(logorg_mapinterleaved(currlogorg, curr));
   }
   unitno = curr->blkno / stripeunit;
   stripeno = unitno / numdisks;
   if (stripeno == currlogorg->numfull) {
      last = TRUE;
      stripeunit = currlogorg->blksperpart - (currlogorg->numfull * stripeunit);
      unitno = stripeno * numdisks;
      unitno += (curr->blkno - (unitno * currlogorg->stripeunit)) / stripeunit;
      curr->blkno -= stripeno * numdisks * currlogorg->stripeunit;
   }
   devno = unitno % numdisks;
   curr->devno = devno;
   curr->blkno = curr->blkno % stripeunit;
   startslop = stripeunit - curr->blkno;
   curr->blkno += stripeno * currlogorg->stripeunit;
   if (startslop < curr->bcount) {
      blkno = stripeno * currlogorg->stripeunit;
      for (i=0; i<numdisks; i++) {
         currlogorg->sizes[i] = 0;
      }
      currlogorg->sizes[devno] = startslop;
      reqsize = curr->bcount - startslop;
/*
fprintf (outputfile, "Have a multi-disk request - bcount %d, startslop %d, stripeno %d, numfull %d\n", curr->bcount, startslop, stripeno, currlogorg->numfull);
*/
      startdevno = devno;
      devno++;
      if (devno == numdisks) {
	 devno = 0;
	 stripeno++;
	 if (stripeno == currlogorg->numfull) {
	    stripeunit = currlogorg->blksperpart - (stripeno * stripeunit);
	 }
      }
      while (reqsize > stripeunit) {
	 currlogorg->sizes[devno] += stripeunit;
	 numstripes++;
	 devno++;
	 reqsize -= stripeunit;
	 if (devno == numdisks) {
	    devno = 0;
	    stripeno++;
	    if (stripeno == currlogorg->numfull) {
	       stripeunit = currlogorg->blksperpart - (stripeno * stripeunit);
	    }
	 }
      }
      currlogorg->sizes[devno] += reqsize;
      curr->bcount = currlogorg->sizes[startdevno];
      numreqs = min(numstripes, numdisks);
      for (i = (startdevno + 1); i < (startdevno + numreqs); i++) {
         newreq = (ioreq_event *) getfromextraq();
	 newreq->devno = i % numdisks;
         newreq->time = curr->time;
         newreq->blkno = blkno + (wrap(startdevno, newreq->devno) * currlogorg->stripeunit);
         newreq->busno = curr->busno & 0x0000FFFF;
         newreq->bcount = currlogorg->sizes[(i % numdisks)];
         newreq->flags = curr->flags;
	 newreq->next = NULL;
	 newreq->prev = NULL;
	 newreq->type = curr->type;
	 newreq->opid = curr->opid;
	 newreq->buf = curr->buf;
         temp->next = newreq;
	 temp = newreq;
      }
   }
   temp->next = curr;
   return(numreqs);
}


int logorg_maprequest (logorg **logorgs, int numlogorgs, ioreq_event *curr)
{
   int numreqs = 1;
   int maptype;
   int reduntype;
   int logorgno = -1;
   int i, j;
   outstand *req = NULL;
   ioreq_event *temp;
   int orgdevno;
/*
fprintf (outputfile, "Entered logorg_maprequest - numlogorgs %d, devno %d, blkno %d, time %f\n", numlogorgs, curr->devno, curr->blkno, simtime);
fprintf (outputfile, "flags %x, opid %d\n", curr->flags, curr->opid);
*/

   ASSERT1((numlogorgs >= 1) && (numlogorgs < MAXLOGORGS), "numlogorgs", numlogorgs);

   if (curr->flags & MAPPED) {
     curr->flags &= ~MAPPED;
     curr->next = NULL;
     return(1);
   }
   req = (outstand *) getfromextraq();
   ASSERT (req != NULL);
   req->arrtime = simtime;
   req->bcount = curr->bcount;
   req->blkno = curr->blkno;
   req->devno = curr->devno;
   req->flags = curr->flags;
   req->busno = curr->busno;
   req->buf = curr->buf;
   req->reqopid = curr->opid;
   req->depend = NULL;

   for (i = 0; i < numlogorgs; i++) {
     // i.e. array
     if (!logorgs[i]->addrbyparts) {
       if ((curr->devno == logorgs[i]->arraydisk) 
	   && ((curr->blkno + curr->bcount) < 
	       (logorgs[i]->blksperpart * logorgs[i]->numdisks)) 
	   && (curr->blkno >= 0)) 

	 {
	   logorgno = i;
	   break;
	 }
     }
     else {
       /* ???? */
       /*           for (j = 0; j < logorgs[i]->numdisks; j++) { */
       for(j = 0; j < logorgs[i]->actualnumdisks; j++) {
	 if (curr->devno == logorgs[i]->devs[j].devno) {
	   if(logorg_overlap(logorgs[i], j, curr, logorgs[i]->blksperpart)) {
	     logorgno = i;
	     break;
	   }
	 }
       }
       if (logorgno != -1) {
	 break;
       }
     }
   }

   /* Every request must be covered by a logorg */
   if (logorgno == -1) {
      fprintf (stderr, "unexpected request location: devno %x, blkno %d, bcount %d\n", curr->devno, curr->blkno, curr->bcount);
   }
   ASSERT(logorgno != -1);
   maptype = logorgs[logorgno]->maptype;
   reduntype = logorgs[logorgno]->reduntype;

   curr->opid = logorgs[logorgno]->opid;
   req->opid = logorgs[logorgno]->opid;
   curr->next = NULL;
   curr->prev = NULL;

   if (maptype == ASIS) {
      curr->next = curr;
   } else if (maptype == IDEAL) {
      logorg_mapideal(logorgs[logorgno], curr);
   } else if (maptype == RANDOM) {
      logorg_maprandom(logorgs[logorgno], curr);
   } else if (maptype == STRIPED) {
      numreqs = logorg_mapstriped(logorgs[logorgno], curr);
   } else {
      fprintf(stderr, "Unknown maptype in use at logorg_maprequest - %d\n", maptype);
      exit(1);
   }

   if (reduntype == NO_REDUN) {
   } else if (reduntype == SHADOWED) {
      numreqs = logorg_shadowed(logorgs[logorgno], curr, numreqs);
   } else if (reduntype == PARITY_DISK) {
      numreqs = logorg_parity_disk(logorgs[logorgno], curr, numreqs);
   } else if (reduntype == PARITY_ROTATED) {
      numreqs = logorg_parity_rotate(logorgs[logorgno], curr, numreqs);
   } else if (reduntype == PARITY_TABLE) {
      numreqs = logorg_parity_table(logorgs[logorgno], curr, numreqs);
   } else {
      fprintf(stderr, "Unknown reduntype in use at logorg_maprequest - %d\n", reduntype);
      exit(1);
   }
/*
fprintf (outputfile, "back from logorging: numreqs %d\n", numreqs);
*/
   orgdevno = curr->devno;
   req->depend = (depends *) curr->prev;
   curr->blkno += logorgs[logorgno]->devs[orgdevno].startblkno;
   curr->devno = logorgs[logorgno]->devs[orgdevno].devno;
   temp = curr->next;
   i = 1;
   while (temp != curr) {
      temp->blkno += logorgs[logorgno]->devs[(temp->devno)].startblkno;
      temp->devno = logorgs[logorgno]->devs[(temp->devno)].devno;
      temp->opid = curr->opid;
      temp = temp->next;
      i++;
   }
   req->numreqs = numreqs;
   logorg_addnewtooutstandq(logorgs[logorgno], req);
   logorgs[logorgno]->opid++;
   logorg_maprequest_update_stats(logorgs[logorgno], curr, req, i);
/*
fprintf (outputfile, "Leaving logorg_maprequest: cnt %d, devno %d, blkno %d, opid %d\n", i, curr->devno, curr->blkno, curr->opid);
*/
   return(i);
}


int logorg_mapcomplete (logorg **logorgs, int numlogorgs, ioreq_event *curr)
{
   outstand *req;
   int i, j;
   int logorgno = -1;
   int ret = NOT_COMPLETE;
   ioreq_event *temp;
/*
fprintf (outputfile, "Entered logorg_mapcomplete: %f, devno %d, blkno %d, opid %d\n", simtime, curr->devno, curr->blkno, curr->opid);
*/
   if ((numlogorgs < 1) || (numlogorgs >= MAXLOGORGS)) {
      fprintf(stderr, "Bad number of logorgs at logorg_mapcomplete: %d\n", numlogorgs);
      exit(1);
   }
   for (i = 0; i < numlogorgs; i++) {
      for (j = 0; j < logorgs[i]->actualnumdisks; j++) {