disksim_disk.c

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

  assert (diskcnt == numdisks);

  disk_seek_printstats(set, numdisks, prefix);
  disk_latency_printstats(set, numdisks, prefix);
  disk_transfer_printstats(set, numdisks, prefix);
  disk_acctime_printstats(set, numdisks, prefix);
  disk_interfere_printstats(set, numdisks, prefix);
  disk_buffer_printstats(set, numdisks, prefix);
  fprintf (outputfile, "\n\n");

  if (numdisks <= 1) {
    return;
  }

  for (i=0; i<numdisks; i++) {
    disk *currdisk = getdisk (set[i]); 
    if (currdisk->printstats == FALSE) {
      continue;
    }
    if (ioqueue_get_number_of_requests(currdisk->queue) == 0) {
      fprintf(outputfile, "No requests for disk #%d\n\n\n", set[i]);
      continue;
    }
    fprintf(outputfile, "Disk #%d:\n\n", set[i]);
    fprintf(outputfile, "Disk #%d highest block number requested: %d\n", set[i], currdisk->stat.highblkno);
    sprintf(prefix, "Disk #%d ", set[i]);
    ioqueue_printstats(&currdisk->queue, 1, prefix);
    disk_seek_printstats(&set[i], 1, prefix);
    disk_latency_printstats(&set[i], 1, prefix);
    disk_transfer_printstats(&set[i], 1, prefix);
    disk_acctime_printstats(&set[i], 1, prefix);
    disk_interfere_printstats(&set[i], 1, prefix);
    disk_buffer_printstats(&set[i], 1, prefix);
    fprintf (outputfile, "\n\n");
  }
}



//
// Create a disk from a param parse tree.  Install it into the 
// global diskinfo table, etc.
//
disk *disksim_disk_loadparams(struct lp_block *b,
			      int *num)
{
  int c;
  disk *result;
  int num2;

  device_initialize_deviceinfo();

  if(!disksim->diskinfo) disk_initialize_diskinfo();
  
  disk_setcallbacks();
  disk_postpass();
  disk_syncset_init();

  result = malloc(sizeof(disk));
  if(!result) return 0;
  memset(result, 0, sizeof(struct disk));

  result->hdr = disk_hdr_initializer;
  result->hdr.device_name = strdup(b->name);
  num2 = disk_add(result);
  if(num) *num = num2;

  ((struct device_header *)result)->device_type = DEVICETYPE_DISK;
    
   #include "modules/disksim_disk_param.c"


  device_add((struct device_header *)result, num2);
  return result;
}




struct device_header *disk_copy(struct device_header *orig) {

  struct disk *result = malloc(sizeof(disk));
  memcpy((struct disk *)result, orig, sizeof(disk));
  
  //  bandcopy(&result->bands, orig->bands, orig->numbands);

  
  result->queue = ioqueue_copy(((struct disk *)orig)->queue);
  return (struct device_header *)result;
}


int disk_load_syncsets(struct lp_block *b) {
  int c, d;
  int type, devnum;
  struct lp_list *l;
  disk *currdisk;

  ++numsyncsets;

  for(c = 0; c < b->params_len; c++) {
    if(!b->params[c]) continue;
    else if(strcmp(b->params[c]->name, "devices")) continue;
    l = LVAL(b->params[c]);
    for(d = 0; d < l->values_len; d++) {
      if(!l->values[c]) continue;
      currdisk = (disk*)getdevbyname(l->values[c]->v.s, 0, &devnum, &type);
      if(!currdisk || (type != DEVICETYPE_DISK)) {
	fprintf(stderr, "*** error: bad syncset spec: no such device %s or %s is of the wrong type.\n", l->values[c]->v.s, l->values[c]->v.s);
	return 0;
      }

      currdisk->syncset = numsyncsets;

    }
    break;
  }


  return 1;
}




void disk_initialize (void)
{
   int i, j;
   diskreq *tmpdiskreq;
   segment *tmpseg;




   // fprintf (outputfile, "Entered disk_initialize - numdisks %d\n", numdisks);

   StaticAssert (sizeof(segment) <= DISKSIM_EVENT_SIZE);
   StaticAssert (sizeof(diskreq) <= DISKSIM_EVENT_SIZE);

   if (disksim->diskinfo == NULL) {
      disk_initialize_diskinfo();
   }

   disk_setcallbacks();
   disk_postpass();
   disk_syncset_init();

   for (i = 0; i < MAXDEVICES; i++) {
     disk *currdisk = getdisk (i); if(!currdisk) continue;
     /*        if (currdisk->inited != 0) { */
     /*           continue; */
     /*        } */
     ioqueue_initialize(currdisk->queue, i);
     ioqueue_set_enablement_function (currdisk->queue, &disksim->enablement_disk);
     addlisttoextraq((event **) &currdisk->outwait);
     addlisttoextraq((event **) &currdisk->buswait);
     
     if (currdisk->currentbus) {
       if (currdisk->currentbus == currdisk->effectivebus) {
	 currdisk->effectivebus = NULL;
       }
       tmpdiskreq = currdisk->currentbus;
       if (tmpdiskreq->seg) {
	 disk_buffer_remove_from_seg(tmpdiskreq);
       }
       addlisttoextraq((event **) &tmpdiskreq->ioreqlist);
       currdisk->currentbus = NULL;
       addtoextraq((event *) tmpdiskreq);
     }

     if (currdisk->effectivebus) {
       tmpdiskreq = currdisk->effectivebus;
       if (tmpdiskreq->seg) {
	 disk_buffer_remove_from_seg(tmpdiskreq);
       }
       addlisttoextraq((event **) &tmpdiskreq->ioreqlist);
       currdisk->effectivebus = NULL;
       addtoextraq((event *) tmpdiskreq);
     }

     if (currdisk->currenthda) {
       if (currdisk->currenthda == currdisk->effectivehda) {
	 currdisk->effectivehda = NULL;
       }
       tmpdiskreq = currdisk->currenthda;
       if (tmpdiskreq->seg) {
	 disk_buffer_remove_from_seg(tmpdiskreq);
       }
       addlisttoextraq((event **) &tmpdiskreq->ioreqlist);
       currdisk->currenthda = NULL;
       addtoextraq((event *) tmpdiskreq);
     }

     if (currdisk->effectivehda != NULL) {
       tmpdiskreq = currdisk->effectivehda;
       if (tmpdiskreq->seg) {
	 disk_buffer_remove_from_seg(tmpdiskreq);
       }
       addlisttoextraq((event **) &tmpdiskreq->ioreqlist);
       currdisk->effectivehda = NULL;
       addtoextraq((event *) tmpdiskreq);
     }

     while (currdisk->pendxfer) {
       tmpdiskreq = currdisk->pendxfer;
       if (tmpdiskreq->seg) {
	 disk_buffer_remove_from_seg(tmpdiskreq);
       }
       addlisttoextraq((event **) &tmpdiskreq->ioreqlist);
       currdisk->pendxfer = tmpdiskreq->bus_next;
       addtoextraq((event *) tmpdiskreq);
     }

     currdisk->outstate = DISK_IDLE;
     currdisk->busy = FALSE;
     currdisk->prev_readahead_min = -1;
     currdisk->extradisc_diskreq = NULL;

     currdisk->currtime = 0.0;
     currdisk->lastflags = READ;

     currdisk->lastgen = -1;
     currdisk->busowned = -1;
     currdisk->numdirty = 0;
     if (currdisk->seglist == NULL) {
       currdisk->seglist = (segment *) DISKSIM_malloc(sizeof(segment));
       currdisk->seglist->next = NULL;
       currdisk->seglist->prev = NULL;
       currdisk->seglist->diskreqlist = NULL;
       currdisk->seglist->recyclereq = NULL;
       currdisk->seglist->access = NULL;
       for (j = 1; j < currdisk->numsegs; j++) {
	 tmpseg = (segment *) DISKSIM_malloc(sizeof(segment));
	 tmpseg->next = currdisk->seglist;
	 currdisk->seglist = tmpseg;
	 tmpseg->next->prev = tmpseg;
	 tmpseg->prev = NULL;
	 tmpseg->diskreqlist = NULL;
	 tmpseg->recyclereq = NULL;
	 tmpseg->access = NULL;
       }
       if (currdisk->dedicatedwriteseg) {
	 currdisk->dedicatedwriteseg = currdisk->seglist;
       }
     }
     tmpseg = currdisk->seglist;

      // initialize cache buffers
     for (j = 0; j < currdisk->numsegs; j++) {
       tmpseg->outstate = BUFFER_IDLE;
       tmpseg->state = BUFFER_EMPTY;
       tmpseg->size = currdisk->segsize;
       while (tmpseg->diskreqlist) {
	 addlisttoextraq((event **) &tmpseg->diskreqlist->ioreqlist);
	 tmpdiskreq = tmpseg->diskreqlist;
	 tmpseg->diskreqlist = tmpdiskreq->seg_next;
	 addtoextraq((event *) tmpdiskreq);
       }
       /* recyclereq should have already been "recycled" :) by the
	  effectivehda or currenthda recycling above */
       tmpseg->recyclereq = NULL;
       addlisttoextraq((event **) &tmpseg->access);
       tmpseg = tmpseg->next;
     }


     diskstatinit(i, TRUE);
   }
}



void disk_acctimestats (disk *currdisk, int distance, double seektime,
		        double latency, double xfertime, double acctime)
{
   int dist;

   /* Maybe remove me later */

   disk_last_angle = dm_angle_itod(currdisk->mech_state.theta);
   disk_last_latency = latency;
   disk_last_seektime = seektime;
   disk_last_cylno = currdisk->mech_state.cyl;

   //fprintf(stderr,"In DiskMech Seek = %f Lat = %f cylno = %d last =%d device = %d angle = %f xfer time = %f\n",seektime,latency,currdisk->currcylno,multi_disk_last[currdisk->devno],currdisk->devno,currdisk->currangle*360,xfertime);

   multi_disk_last_seektime[currdisk->devno][multi_disk_last[currdisk->devno]] = seektime;
   multi_disk_last_latency[currdisk->devno][multi_disk_last[currdisk->devno]] = latency;
   multi_disk_last_cylno[currdisk->devno][multi_disk_last[currdisk->devno]] = currdisk->mech_state.cyl;
   multi_disk_last_surface[currdisk->devno][multi_disk_last[currdisk->devno]] = currdisk->mech_state.head;
   multi_disk_last_angle[currdisk->devno][multi_disk_last[currdisk->devno]] = 
     dm_angle_itod(currdisk->mech_state.theta);
   multi_disk_last_xfertime[currdisk->devno][multi_disk_last[currdisk->devno]] = xfertime;
   if(do_free_blocks == 1)
     multi_disk_last[currdisk->devno]++;

   if(multi_disk_last[currdisk->devno] > 1){
     //     fprintf(stderr,"Hmmm badness %d\n",multi_disk_last[currdisk->devno]);
   }

   assert(multi_disk_last[currdisk->devno] < MAXSTATS);

   /* end Maybe Remove me later */

   disk_last_distance = distance;
   disk_last_seektime = seektime;
   disk_last_latency = latency;
   disk_last_xfertime = xfertime;
   disk_last_acctime = acctime;
   disk_last_cylno = currdisk->mech_state.cyl;
   disk_last_surface = currdisk->mech_state.head;
   if (device_printseekstats == TRUE) {
      dist = abs(distance);
      if (dist == 0) {
         currdisk->stat.zeroseeks++;
      }
      stat_update(&currdisk->stat.seekdiststats, (double) dist);
      stat_update(&currdisk->stat.seektimestats, seektime);
   }
   if (device_printlatencystats == TRUE) {
      if (latency == (double) 0.0) {
         currdisk->stat.zerolatency++;
      }
      stat_update(&currdisk->stat.rotlatstats, latency);
   }
   if (device_printxferstats == TRUE) {
      stat_update(&currdisk->stat.xfertimestats, xfertime);
   }
   if (device_printacctimestats == TRUE) {
      stat_update(&currdisk->stat.postimestats, (seektime+latency));
      stat_update(&currdisk->stat.acctimestats, acctime);
   }
}


static int disk_get_number_of_blocks(int n) {
  return disksim->diskinfo->disks[n]->model->dm_sectors;
}

static int disk_get_numcyls(int n) {
  return disksim->diskinfo->disks[n]->model->dm_cyls;
}

// this is an alias for dm_translate_ltop, basically
static void 
disk_get_mapping(int maptype, 
		 int n, 
		 int lbn, 
		 int *c, 
		 int *h, 
		 int *s)
{
  struct dm_pbn pbn;
  struct dm_disk_if *d = disksim->diskinfo->disks[n]->model;
  d->layout->dm_translate_ltop(d, maptype, lbn, &pbn, 0);
  
  if(c) {
    *c = pbn.cyl;
  }

  if(h) {
    *h = pbn.head;
  }

  if(s) {
    *s = pbn.sector;
  }
}

int disk_get_avg_sectpercyl(int devno)
{
  return disksim->diskinfo->disks[devno]->sectpercyl;
}


/* default disk dev header */
struct device_header disk_hdr_initializer = { 
  DEVICETYPE_DISK,
  sizeof(struct disk),
  "unnamed disk",
  disk_copy,

  disk_set_depth,
  disk_get_depth,
  disk_get_inbus,
  disk_get_busno,
  disk_get_slotno,

  disk_get_number_of_blocks,
  
  disk_get_maxoutstanding,
  disk_get_numcyls,
  
  disk_get_blktranstime,
  disk_get_avg_sectpercyl,

  disk_get_mapping,
  disk_event_arrive,
  disk_get_distance,
  disk_get_servtime,
  disk_get_seektime,
  disk_get_acctime,
  disk_bus_delay_complete,
  disk_bus_ownership_grant
};