mems_disksim.c

来自「disksim是一个非常优秀的磁盘仿真工具」· C语言 代码 · 共 1,418 行 · 第 1/3 页

  /* Per-device statistics */

  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);

    if (dev->stat.num_buffer_accesses) {
      hit_ratio = (double)dev->stat.num_buffer_hits / 
	(double)dev->stat.num_buffer_accesses;
    fprintf(outputfile, "%sNumber of buffer accesses for device %d: %d\n",
	    prefix, i, dev->stat.num_buffer_accesses);
    fprintf(outputfile, "%sNumber of buffer hits for device %d:     %d\n",
	    prefix, i, dev->stat.num_buffer_hits);
    fprintf(outputfile, "%sBuffer hit ratio for device %d:          %f\n",
	    prefix, i, hit_ratio);
    fprintf(outputfile, "%sBuffer miss ratio for device %d:         %f\n",
	    prefix, i, 1.0 - hit_ratio);
    fprintf(outputfile, "\n");
    } else {
      fprintf(outputfile, "%sNo buffer accesses for device %d\n",
	      prefix, i);
    }
  }
}


static void
mems_inactive_printstats (int *set, int setsize, char *prefix)
{
  int i;
  int j;
  statgen *statset[MAXDEVICES];
  mems_t *dev;

  /************************************************************************
   * num_spinups
   ************************************************************************/

  {
    int total_spinups = 0;
    for (i=0; i < setsize; i++) {
      dev = getmems(set[i]);
      total_spinups += dev->stat.num_spinups;
    }
    fprintf(outputfile, "%sNumber of spinups: %d\n\n", 
	    prefix, total_spinups);
  }

  /* Spinups for each device and sled */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    fprintf(outputfile, "%sNumber of spinups for device %d: %d\n",
	    prefix, set[i], dev->stat.num_spinups);
    for (j=0; j < dev->num_sleds; j++) {
      fprintf(outputfile, "%sNumber of spinups for device %d sled %d: %d\n",
	      prefix, set[i], j, dev->sled[j].stat.num_spinups);
    }
    fprintf(outputfile, "\n");
  }

  /************************************************************************
   * num_spindowns
   ************************************************************************/

  {
    int total_spindowns = 0;
    for (i=0; i < setsize; i++) {
      dev = getmems(set[i]);
      total_spindowns += dev->stat.num_spindowns;
    }
    fprintf(outputfile, "%sNumber of spindowns: %d\n\n", 
	    prefix, total_spindowns);
  }

  /* Spindowns for each device and sled */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    fprintf(outputfile, "%sNumber of spindowns for device %d: %d\n",
	    prefix, set[i], dev->stat.num_spindowns);
    for (j=0; j < dev->num_sleds; j++) {
      fprintf(outputfile, "%sNumber of spindowns for device %d sled %d: %d\n",
	      prefix, set[i], j, dev->sled[j].stat.num_spindowns);
    }
    fprintf(outputfile, "\n");
  }

  /************************************************************************
   * inactive_time
   ************************************************************************/
  
  /* Overall statistics */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    statset[i] = &dev->stat.inactive_time;
  }
  stat_print_set(statset, setsize, prefix);

  /* Per-device and per-sled statistics */
  for (i=0; i < setsize; i++) {
    char newprefix[80];
    dev = getmems(set[i]);

    sprintf(newprefix, "%sdevice %d ", prefix, i);
    statset[0] = &dev->stat.inactive_time;
    stat_print_set(statset, 1, newprefix);

    for (j=0; j < dev->num_sleds; j++) {
      sprintf(newprefix, "%sdevice %d sled %d ", prefix, i, j);
      statset[0] = &dev->sled[j].stat.inactive_time;
      stat_print_set(statset, 1, newprefix);
    }
  }
}


static void
mems_other_printstats (int *set, int setsize, char *prefix)
{
  int i;
  int j;
  statgen *statset[MAXDEVICES];
  mems_t *dev;

  /************************************************************************
   * subtrack_accesses
   ************************************************************************/
  
  /* Overall statistics */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    statset[i] = &dev->stat.subtrack_accesses;
  }
  stat_print_set(statset, setsize, prefix);

  /* Per-device and per-sled statistics */
  for (i=0; i < setsize; i++) {
    char newprefix[80];
    dev = getmems(set[i]);

    sprintf(newprefix, "%sdevice %d ", prefix, i);
    statset[0] = &dev->stat.subtrack_accesses;
    stat_print_set(statset, 1, newprefix);

    for (j=0; j < dev->num_sleds; j++) {
      sprintf(newprefix, "%sdevice %d sled %d ", prefix, i, j);
      statset[0] = &dev->sled[j].stat.subtrack_accesses;
      stat_print_set(statset, 1, newprefix);
    }
  }

  /************************************************************************
   * tips_per_access
   ************************************************************************/
  
  /* Overall statistics */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    statset[i] = &dev->stat.tips_per_access;
  }
  stat_print_set(statset, setsize, prefix);

  /* Per-device and per-sled statistics */
  for (i=0; i < setsize; i++) {
    char newprefix[80];
    dev = getmems(set[i]);

    sprintf(newprefix, "%sdevice %d ", prefix, i);
    statset[0] = &dev->stat.tips_per_access;
    stat_print_set(statset, 1, newprefix);

    for (j=0; j < dev->num_sleds; j++) {
      sprintf(newprefix, "%sdevice %d sled %d ", prefix, i, j);
      statset[0] = &dev->sled[j].stat.tips_per_access;
      stat_print_set(statset, 1, newprefix);
    }
  }
}


/* Print set statistics */
void
mems_printsetstats (int *set, int setsize, char *sourcestr)
{
  int i;
  struct ioq *queueset[MAXDEVICES];
  int reqcnt = 0;
  char prefix[80];

  sprintf(prefix, "%smems ", sourcestr);
  for (i=0; i<setsize; i++) {
    mems_t *dev = getmems(set[i]);
    queueset[i] = dev->queue;
    reqcnt += ioqueue_get_number_of_requests(dev->queue);
  }
  if (reqcnt == 0) {
    fprintf(outputfile, "\nNo mems requests for members of this set\n\n");
    return;
  }
  ioqueue_printstats(queueset, setsize, prefix);

  mems_prefetch_printstats(set, setsize, prefix);
  mems_seektime_printstats(set, setsize, prefix);
  mems_other_printstats(set, setsize, prefix);
  mems_inactive_printstats(set, setsize, prefix);
  mems_buffer_printstats(set, setsize, prefix);
  mems_energy_printstats(set, setsize, prefix);
}


/* Print statistics */
void
mems_printstats (void)
{
  struct ioq *queueset[MAXDEVICES];
  int set[MAXDEVICES];
  int i;
  int reqcnt = 0;
  char prefix[80];
  int devcnt;

  mems_t *dev;

  fprintf(outputfile, "\nMEMS STATISTICS\n----------------\n\n");
  sprintf(prefix, "Mems ");

  if (!disksim->memsinfo) {
    fprintf(outputfile, "No mems requests encountered (1)\n");
    return;
  }    

  devcnt = 0;
  for (i = 0; i < disksim->memsinfo->devices_len; i++) {
    dev = getmems(i);
    if (dev) {
      // SCHLOS - this has been hard-coded to the first sled since
      //  mems_event doesn't use the device queues anymore.
      queueset[devcnt] = dev->sled[0].queue;
      reqcnt += ioqueue_get_number_of_requests(dev->queue);
      devcnt++;
    }
  }
  assert(devcnt == disksim->memsinfo->numdevices);

  /*
  if (reqcnt == 0) {
    fprintf(outputfile, "No mems requests encountered (2)\n");
    return;
  }
  */

  ioqueue_printstats(queueset, devcnt, prefix);

  devcnt = 0;
  for (i=0; i < disksim->memsinfo->devices_len; i++) {
    dev = getmems(i);
    if (dev) {
      set[devcnt] = i;
      devcnt++;
    }
  }
  assert(devcnt == disksim->memsinfo->numdevices);

  mems_prefetch_printstats(set, devcnt, prefix);
  mems_seektime_printstats(set, devcnt, prefix);
  mems_other_printstats(set, devcnt, prefix);
  mems_inactive_printstats(set, devcnt, prefix);
  mems_buffer_printstats(set, devcnt, prefix);
  mems_energy_printstats(set, devcnt, prefix);
  fprintf(outputfile, "\n\n");
}


/************************************************************************
 * Initialization foo
 ************************************************************************/


struct mems *memsmodel_mems_loadparams(struct lp_block *b,
				       int *numptr)
{
  int c;
  int num;
  struct mems *result;
  mems_sled_t tmpsled;

  device_initialize_deviceinfo();

  bzero(&tmpsled, sizeof(tmpsled));

  result = malloc(sizeof(mems_t));
  if(!result) return 0;
  bzero(result, sizeof(mems_t));

  ((struct device_header *)result)->device_type = DEVICETYPE_MEMS;

  /* Initialize disksim's memsinfo structures */
  if (disksim->memsinfo == NULL) {
    disksim->memsinfo = malloc(sizeof(struct mems_info));
    ASSERT(disksim->memsinfo != NULL);
    bzero((char *)disksim->memsinfo, sizeof(struct mems_info));

/*      disksim->memsinfo->devices = malloc(MAXDEVICES * sizeof(mems_t)); */
/*      ASSERT(disksim->memsinfo->devices != NULL); */

  }

  for(c = 0; c < disksim->memsinfo->devices_len; c++) {
    if(!disksim->memsinfo->devices[c]) {
      break;
    }
  }

  if(c == disksim->memsinfo->devices_len) {
    int newlen = disksim->memsinfo->devices_len ?
      disksim->memsinfo->devices_len * 2 : 2;
    int zerolen = newlen == 2 ? 2 : newlen / 2;
     
    disksim->memsinfo->devices = 
      realloc(disksim->memsinfo->devices, 
	      newlen * sizeof(mems_t *));

    bzero(disksim->memsinfo->devices + c, zerolen * sizeof(mems_t *));
    disksim->memsinfo->devices_len = newlen;
  }
  
  disksim->memsinfo->devices[c] = result;
  num = c;
  if(numptr) *numptr = num;
  result->hdr = mems_hdr_initializer;
  result->hdr.device_name = strdup(b->name);
  
  disksim->memsinfo->numdevices++;

    
  //#include "modules/disksim_mems_param.c"
  lp_loadparams(result, b, &memsmodel_mems_mod);

  for (c = 0; c < MAXINBUSES; c++) {
    result->inbuses[c] = -1;
    result->depth[c]   = -1;
    result->slotno[c]  = -1;
  }


  for(c = 0; c < result->num_sleds; c++) {
    memcpy(&result->sled[c], &result->sled[0], result->num_sleds * sizeof(mems_sled_t));
    result->sled[c].queue = ioqueue_copy(result->queue);
  }

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

mems_t *mems_copy(mems_t *src) {
  mems_t *result = malloc(sizeof(mems_t));
  bzero(result, sizeof(mems_t));
  memcpy(result, src, sizeof(mems_t));
  result->queue = ioqueue_copy(src->queue);
  memcpy(&result->sled, src->sled, src->num_sleds * sizeof(mems_sled_t));
  return result;
}




/* Initialize device structures */
void
mems_initialize (void)
{
  int i;
  int j;
  int k;
  mems_t *dev;

  if (disksim->memsinfo == NULL) return;

  ioqueue_setcallbacks();

  /* Initialize all devices that have been inited (huh?) */
  for (i = 0; i < disksim->memsinfo->devices_len; i++) {
    dev = getmems(i);
    if (dev) {
      dev->busowned = -1;
      addlisttoextraq((event **)&dev->buswait);
      ioqueue_initialize(dev->queue, i);
      dev->dataxfer_req = NULL;
      dev->dataxfer_queue = NULL;

      /* Segment initialization stuff taken in part from disksim_disk.c */
      if ((dev->numsegs > 0) && (dev->seglist == NULL)) {
	dev->seglist = (struct mems_segment *)DISKSIM_malloc(sizeof(struct mems_segment));
	dev->seglist->next = NULL;
	dev->seglist->prev = NULL;
	dev->seglist->time = 0.0;
	dev->seglist->startblkno = 0;
	dev->seglist->endblkno   = 0;
	for (k = 1; k < dev->numsegs; k++) {
	  struct mems_segment *tmpseg = (struct mems_segment *)DISKSIM_malloc(sizeof(struct mems_segment));
	  tmpseg->next = dev->seglist;
	  dev->seglist = tmpseg;
	  tmpseg->next->prev = tmpseg;
	  tmpseg->prev = NULL;
	  tmpseg->startblkno = 0;
	  tmpseg->endblkno   = 0;
	}
      }
      if (dev->numsegs == 0) addlisttoextraq((event **)&dev->seglist);

      mems_check_numblocks(dev);

      for (j = 0; j < dev->num_sleds; j++) {
	dev->sled[j].dev = dev;

	ioqueue_initialize(dev->sled[j].queue, i);

	dev->sled[j].active = MEMS_SLED_INACTIVE;
	dev->sled[j].active_request = NULL;
	dev->sled[j].prefetch_info  = NULL;
	dev->sled[j].lastreq_lbn = mems_centermost_lbn(&dev->sled[j]);
	dev->sled[j].lastreq_comptime = 0.0;

	/* Initialize sled position, velocity at centermost LBN */
	mems_lbn_to_position(dev->sled[j].lastreq_lbn, &dev->sled[j], &dev->sled[j].coordset_up, &dev->sled[j].coordset_dn, &dev->sled[j].tipset, NULL, NULL, NULL);
	mems_coord_t_copy(&dev->sled[j].coordset_up.servo_start, &dev->sled[j].pos);

      }
      mems_statinit(i, TRUE);
      if (dev->precompute_seek_count > 0) {
	mems_precompute_seek_curve(dev);
      }
    }
  }
}


void mems_unimplemented(void) {
  fprintf(stderr, "*** error: mems method unsupported\n");
  assert(0);
}


extern void mems_event_arrive (ioreq_event *curr);
extern void mems_bus_delay_complete (int devno, ioreq_event *curr, int sentbusno);
extern void mems_bus_ownership_grant (int devno, ioreq_event *curr, int busno, double arbdelay);


/* default mems dev header */
struct device_header mems_hdr_initializer = { 
  DEVICETYPE_MEMS,
  sizeof(struct mems),
  "unnamed mems",
  (void *)mems_copy,
  mems_set_depth,
  mems_get_depth,
  mems_get_inbus,
  mems_get_busno,
  mems_get_slotno,
  mems_get_number_of_blocks,
  mems_get_maxoutstanding,
  mems_get_numcyls,
  mems_get_blktranstime,
  mems_get_avg_sectpercyl,
  mems_get_mapping,
  mems_event_arrive,
  mems_get_distance,
  mems_get_servtime,
  mems_get_seektime,
  (void *)mems_unimplemented,
  mems_bus_delay_complete,
  mems_bus_ownership_grant
};