disksim_redun.c

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

static void logorg_parity_read_old_sync (logorg *currlogorg, ioreq_event *curr, int numreqs)
{
   int i, j;
   depends *depend;
   depends *tmpdep;
   ioreq_event *temp;
   int devno = 1;

   depend = (depends *) getfromextraq();
   depend->blkno = curr->blkno;
   depend->devno = curr->devno;
   depend->deps[0] = ioreq_copy(curr);
   depend->deps[0]->opid = numreqs;
   curr->prev = (ioreq_event *) depend;
   depend->numdeps = numreqs;
   temp = curr->next;
   for (i=1; i<numreqs; i++) {
      if (devno == 0) {
	 depend->cont = (depends *) getfromextraq();
	 depend = depend->cont;
      }
      depend->deps[devno] = ioreq_copy(temp);
      depend->deps[devno]->opid = numreqs;
      devno = logorg_modulus_update(1, devno, 10);
      temp = temp->next;
   }
   temp = curr->next;
   curr->flags |= READ;
   for (i=1; i<numreqs; i++) {
      depend = (depends *) ioreq_copy(curr->prev);
      depend->next = (depends *) curr->prev;
      curr->prev = (ioreq_event *) depend;
      depend->blkno = temp->blkno;
      depend->devno = temp->devno;
      tmpdep = depend->cont;
      for (j=0; j<(numreqs/10); j++) {
	 depend->cont = (depends *) ioreq_copy((ioreq_event *) tmpdep);
	 tmpdep = tmpdep->cont;
	 depend = depend->cont;
      }
      temp->flags |= READ;
      temp = temp->next;
   }
}


static void logorg_parity_read_old_nosync (logorg *currlogorg, ioreq_event *curr, int numreqs)
{
   int i;
   depends *depend;
   depends *tmpdep;
   ioreq_event *temp;
   int devno = 1;

   depend = (depends *) getfromextraq();
   depend->blkno = curr->blkno;
   depend->devno = curr->devno;
   depend->numdeps = numreqs;
   depend->next = NULL;
   depend->deps[0] = ioreq_copy(curr);
   depend->deps[0]->opid = 1;
   curr->prev = (ioreq_event *) depend;
   curr->flags |= READ;
   temp = curr->next;
   for (i=1; i<numreqs; i++) {
      if (devno == 0) {
	 depend->cont = (depends *) getfromextraq();
	 depend = depend->cont;
      }
      tmpdep = (depends *) getfromextraq();
      tmpdep->blkno = temp->blkno;
      tmpdep->devno = temp->devno;
      tmpdep->numdeps = 1;
      tmpdep->next = (depends *) curr->prev;
      curr->prev = (ioreq_event *) tmpdep;
      tmpdep->deps[0] = ioreq_copy(temp);
      tmpdep->deps[0]->opid = 2;
      depend->deps[devno] = tmpdep->deps[0];
      temp->flags |= READ;
      devno = logorg_modulus_update(1, devno, 10);
      temp = temp->next;
   }
}


int logorg_parity_rotate (logorg *currlogorg, ioreq_event *curr, int numreqs)
{
   int reqs = 2;

   if (currlogorg->maptype == IDEAL) {
      logorg_parity_rotate_ideal(currlogorg, curr);
   } else if (currlogorg->maptype == RANDOM) {
      logorg_parity_rotate_random(currlogorg, curr);
   } else if (currlogorg->maptype == ASIS) {
      switch (currlogorg->rottype) {

	 case PARITY_LEFT_SYM:
	 case PARITY_LEFT_ASYM:
            reqs = logorg_parity_rotate_updates(currlogorg, curr, -1);
	    break;

	 case PARITY_RIGHT_SYM:
	 case PARITY_RIGHT_ASYM:
            reqs = logorg_parity_rotate_updates(currlogorg, curr, 1);
	    break;

	 default:
	    fprintf(stderr, "Unknown rottype at logorg_parity_rotate - %d\n", currlogorg->rottype);
	    exit(1);
      }
   } else {
      fprintf(stderr, "Unknown maptype at logorg_parity_rotate - %d\n", currlogorg->maptype);
      exit(1);
   }
   if (curr->flags & READ) {
      return(1);
   }

   if (currlogorg->writesync == TRUE) {
      logorg_parity_read_old_sync(currlogorg, curr, reqs);
   } else {
      logorg_parity_read_old_nosync(currlogorg, curr, reqs);
   }

   return(2*reqs);
}


static int logorg_join_seqreqs (ioreq_event *reqlist, ioreq_event *curr, int seqgive)
{
   ioreq_event *temp;
   ioreq_event *del;
   int numreqs = 0;
   int distance;

   temp = reqlist;
   if (temp) {
      while (temp->next) {
	 distance = temp->next->blkno - temp->blkno - temp->bcount;
/*
fprintf (outputfile, "In logorg_join_seqreqs, devno %d, blkno %d, bcount %d, read %d, distance %d\n", temp->devno, temp->blkno, temp->bcount, (temp->flags & READ), distance);
*/
         if (distance < 0) {
            fprintf(stderr, "Integrity check failure at logorg_join_seqreqs - blkno %d, bcount %d, blkno %d, read %d\n", temp->blkno, temp->bcount, temp->next->blkno, (temp->flags & READ));
            exit(1);
         }
         if (((temp->flags & READ) == (temp->next->flags & READ)) && (distance <= seqgive)) {
            del = temp->next;
            temp->next = del->next;
            temp->bcount += del->bcount + distance;
	    temp->opid |= del->opid;
            addtoextraq((event *) del);
         } else {
            del = temp;
            temp = del->next;
            del->next = curr->next;
            curr->next = del;
	    del->time = curr->time;
	    del->buf = curr->buf;
            numreqs++;
         }
      }
      numreqs++;
      temp->next = curr->next;
      curr->next = temp;
      temp->time = curr->time;
      temp->buf = curr->buf;
   }
   return(numreqs);
}


static void logorg_parity_table_insert (ioreq_event **head, ioreq_event *curr)
{
   ioreq_event *temp;

   if (((*head) == NULL) || (curr->blkno < (*head)->blkno)) {
      curr->next = (*head);
      (*head) = curr;
   } else {
      temp = (*head);
      while ((temp->next) && (curr->blkno >= temp->next->blkno)) {
         temp = temp->next;
      }
      curr->next = temp->next;
      temp->next = curr;
   }
}


static void logorg_parity_table_read_old (logorg *currlogorg, ioreq_event *rowhead, ioreq_event **reqlist, int opid)
{
   ioreq_event *temp;
   ioreq_event *newreq;
   ioreq_event *prev = NULL;

   temp = rowhead;
   while (temp) {
      newreq = (ioreq_event *) getfromextraq();
      newreq->blkno = temp->blkno;
      newreq->devno = temp->devno;
      newreq->bcount = temp->bcount;
      newreq->flags = temp->flags | READ;
      newreq->opid = opid;
      logorg_parity_table_insert(&reqlist[newreq->devno], newreq);
      newreq->prev = prev;
      prev = newreq;
	/* only the last write (the parity update) must depend on the reads */
      if (temp->prev == NULL) {
         temp->opid = opid;
      }
      temp = temp->prev;
   }
}


static void logorg_parity_table_recon (logorg *currlogorg, ioreq_event *rowhead, ioreq_event **reqlist, int stripeno, int unitno, int tableadd, int opid)
{
   ioreq_event *temp;
   ioreq_event *newreq;
   int entryno;
   int minblkno;
   int maxblkno;
   int lastentry;
   int i;
   int blkno;
   int offset;

   temp = rowhead;
   if (temp == NULL) {
      fprintf(stderr, "Can't have NULL rowhead at logorg_parity_table_recon\n");
      exit(1);
   }
   lastentry = (stripeno + 1) * currlogorg->partsperstripe + stripeno;
   while (temp->prev) {
      temp = temp->prev;
   }
   temp->opid = opid;
   minblkno = temp->blkno - currlogorg->table[lastentry].blkno - tableadd;
   maxblkno = minblkno + temp->bcount;
   entryno = stripeno * currlogorg->partsperstripe + stripeno;
   for (i = 0; i < unitno; i++) {
      newreq = (ioreq_event *) getfromextraq();
      newreq->devno = currlogorg->table[entryno].devno;
      newreq->blkno = tableadd + minblkno + currlogorg->table[entryno].blkno;
      newreq->bcount = maxblkno - minblkno;
      newreq->flags = rowhead->flags | READ;
      newreq->opid = opid;
      logorg_parity_table_insert(&reqlist[newreq->devno], newreq);
      entryno++;
   }
   temp = rowhead;
   while (temp->prev) {
      blkno = currlogorg->table[entryno].blkno;
      offset = temp->blkno - tableadd - blkno;
      if (offset > minblkno) {
         newreq = (ioreq_event *) getfromextraq();
         newreq->devno = temp->devno;
         newreq->blkno = tableadd + blkno + minblkno;
         newreq->bcount = offset - minblkno;
         newreq->flags = temp->flags | READ;
	 newreq->opid = opid;
         logorg_parity_table_insert(&reqlist[newreq->devno], newreq);
      }
      if ((offset + temp->bcount) < maxblkno) {
         newreq = (ioreq_event *) getfromextraq();
         newreq->devno = temp->devno;
         newreq->blkno = temp->blkno + temp->bcount;
         newreq->bcount = maxblkno - offset - temp->bcount;
         newreq->flags = temp->flags | READ;
	 newreq->opid = opid;
         logorg_parity_table_insert(&reqlist[newreq->devno], newreq);
      }
      entryno++;
      temp = temp->prev;
   }
   for (; entryno < lastentry; entryno++) {
      newreq = (ioreq_event *) getfromextraq();
      newreq->devno = currlogorg->table[entryno].devno;
      newreq->blkno = tableadd + minblkno + currlogorg->table[entryno].blkno;
      newreq->bcount = maxblkno - minblkno;
      newreq->flags = rowhead->flags | READ;
      newreq->opid = opid;
      logorg_parity_table_insert(&reqlist[newreq->devno], newreq);
   }
}


static void logorg_parity_table_dodeps_sync (logorg *currlogorg, ioreq_event *curr, ioreq_event **redunlist, ioreq_event **reqlist)
{
   int i, j;
   depends *depend;
   depends *tmpdep;
   int opid = 0;
   int numdeps = 0;
   ioreq_event *temp;
   ioreq_event *deplist = NULL;
   int devno = 1;

   for (i=0; i<currlogorg->actualnumdisks; i++) {
      temp = redunlist[i];
      while (temp) {
	 temp->opid = curr->opid;
	 opid++;
	 if (temp->next == NULL) {
	    temp->next = curr->next;
	    curr->next = redunlist[i];
	    break;
	 }
	 temp = temp->next;
      }
      temp = reqlist[i];
      while (temp) {
	 numdeps++;
	 if (temp->next == NULL) {
	    temp->next = deplist;
	    deplist = reqlist[i];
	    break;
	 }
	 temp = temp->next;
      }
   }
   if (numdeps <= 0) {
      fprintf(stderr, "Can't have zero requests at logorg_parity_table_dodeps_sync\n");
      exit(1);
   }
   if (opid == 0) {
      curr->prev = NULL;
      curr->next = deplist;
      return;
   }
   depend = (depends *) getfromextraq();
   depend->blkno = curr->next->blkno;
   depend->devno = curr->next->devno;
   depend->numdeps = numdeps;
   curr->prev = (ioreq_event *) depend;
   depend->deps[0] = deplist;
   deplist->opid = opid;
   temp = deplist->next;
   for (i=1; i<numdeps; i++) {
      if (devno == 0) {
	 depend->cont = (depends *) getfromextraq();
	 depend = depend->cont;
      }
      depend->deps[devno] = temp;
      temp->opid = opid;
      devno = logorg_modulus_update(1, devno, 10);
      temp = temp->next;
   }
   temp = curr->next->next;
   for (i=1; i<opid; i++) {
      depend = (depends *) ioreq_copy(curr->prev);
      depend->next = (depends *) curr->prev;
      curr->prev = (ioreq_event *) depend;
      depend->blkno = temp->blkno;
      depend->devno = temp->devno;
      tmpdep = depend->cont;
      for (j=0; j<(numdeps/10); j++) {
	 depend->cont = (depends *) ioreq_copy((ioreq_event *) tmpdep);
	 tmpdep = tmpdep->cont;
	 depend = depend->cont;
      }
      temp = temp->next;
   }
}


static void logorg_parity_table_dodeps_nosync (logorg *currlogorg, ioreq_event *curr, ioreq_event **redunlist, ioreq_event **reqlist)
{
   int i;
   depends *depend;
   depends *tmpdep;
   ioreq_event *temp;
   ioreq_event *del;
   ioreq_event *tmpread;
   ioreq_event *readlist = NULL;
   ioreq_event *deplist = NULL;
   int holddep;

   for (i=0; i<currlogorg->actualnumdisks; i++) {
      temp = redunlist[i];
      while (temp) {
         depend = (depends *) getfromextraq();
         depend->blkno = temp->blkno;
         depend->devno = temp->devno;
         depend->numdeps = 0;
	 depend->next = NULL;
	 temp->prev = (ioreq_event *) depend;
	 if (temp->next == NULL) {
	    temp->next = readlist;
	    readlist = redunlist[i];
	    break;
	 }
	 temp = temp->next;
      }
      temp = reqlist[i];
      while (temp) {
	 del = temp;
	 temp = temp->next;
	 if ((redunlist[i] == NULL) && (del->opid == 0)) {
	    del->next = curr->next;
	    curr->next = del;
	 } else {
	    del->next = deplist;
	    deplist = del;
	 }
      }
   }
   if (readlist == NULL) {
      if (deplist) {
         fprintf(stderr, "Unacceptable condition in logorg_parity_table_dodeps_nosync\n");
         exit(1);
      }
      curr->prev = NULL;
      return;
   }
   temp = deplist;
   while (temp) {
      holddep = temp->opid;
      temp->opid = 0;
      tmpread = readlist;
      while (tmpread) {
	 if ((tmpread->devno == temp->devno) | (holddep & tmpread->opid)) {
            tmpdep = (depends *) tmpread->prev;
            ASSERT (tmpdep != NULL);
            if (tmpdep->numdeps > 0) {
	       for (i=0; i<((tmpdep->numdeps-1)/10); i++) {
	          tmpdep = tmpdep->cont;
	       }
	       if ((tmpdep->numdeps % 10) == 0) {
	          tmpdep->cont = (depends *) getfromextraq();