mems_disksim.c

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

		       &dev->sled[j].stat.stream_turnaround_number);

      stat_initialize (statdeffile, statdesc_subtrack_accesses,
		       &dev->sled[j].stat.subtrack_accesses);
      stat_initialize (statdeffile, statdesc_tips_per_access,
		       &dev->sled[j].stat.tips_per_access);
      stat_initialize (statdeffile, statdesc_inactive_time,
		       &dev->sled[j].stat.inactive_time);
      stat_initialize (statdeffile, statdesc_prefetched_blocks,
		       &dev->sled[j].stat.prefetched_blocks);
    } else {
      stat_reset (&dev->sled[j].stat.request_energy_uj);
      stat_reset (&dev->sled[j].stat.seek_time);
      stat_reset (&dev->sled[j].stat.x_seek_time);
      stat_reset (&dev->sled[j].stat.y_seek_time);
      stat_reset (&dev->sled[j].stat.turnaround_time);
      stat_reset (&dev->sled[j].stat.turnaround_number);

      stat_reset (&dev->sled[j].stat.stream_turnaround_time);
      stat_reset (&dev->sled[j].stat.stream_turnaround_number);

      stat_reset (&dev->sled[j].stat.subtrack_accesses);
      stat_reset (&dev->sled[j].stat.tips_per_access);
      stat_reset (&dev->sled[j].stat.inactive_time);
      stat_reset (&dev->sled[j].stat.prefetched_blocks);
    }
    dev->sled[j].stat.total_energy_j = 0.0;
    dev->sled[j].stat.servicing_energy_j = 0.0;
    dev->sled[j].stat.startup_energy_j   = 0.0;
    dev->sled[j].stat.idle_energy_j      = 0.0;
    dev->sled[j].stat.inactive_energy_j  = 0.0;
    dev->sled[j].stat.num_spinups    = 0;
    dev->sled[j].stat.num_spindowns  = 0;
    dev->sled[j].stat.num_buffer_accesses = 0;
    dev->sled[j].stat.num_buffer_hits     = 0;
    dev->sled[j].stat.num_initial_turnarounds = 0;
    dev->sled[j].stat.num_stream_turnarounds  = 0;
  }
}


/* Reset device and ioqueue statistics */
void 
mems_cleanstats (void)
{
  mems_t *dev;
  int i;		/* loop counter [which device] */
  int j;		/* loop counter [which sled on device] */

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

  /* FIXME: Should this be (i=0; i<disksim->memsinfo->nummdevices) ? */
  for (i = 0; i < disksim->memsinfo->devices_len; i++) {
    dev = getmems(i);
    if (dev) {
      ioqueue_cleanstats(dev->queue);
      /* FIXME: Should this be (j=0; j<dev->numsleds; j++) ? */
      for (j = 0; j < dev->num_sleds; j++) {
	ioqueue_cleanstats(dev->sled[j].queue);
	/* FIXME: Should we also clean mems stat structures? */
      }
    }
  }
  return;
}


/* Uh, reset the statistics. */
void
mems_resetstats (void)
{
  mems_t *dev;
  int i;
  int j;

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

  for (i = 0; i < disksim->memsinfo->devices_len; i++) {
    dev = getmems(i);
    if (dev) {
      ioqueue_resetstats(dev->queue);
      for (j=0; j<MEMS_MAXSLEDS; j++) {
	ioqueue_resetstats(dev->sled[j].queue);
      }
      mems_statinit(i, FALSE);
    }
  }
}


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

  /************************************************************************
   * prefetched_blocks
   ************************************************************************/
  
  /* Overall statistics */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    statset[i] = &dev->stat.prefetched_blocks;
  }
  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.prefetched_blocks;
    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.prefetched_blocks;
      stat_print_set(statset, 1, newprefix);
    }
  }
}


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

  /************************************************************************
   * seek_time
   ************************************************************************/
  
  /* Overall statistics */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    statset[i] = &dev->stat.seek_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.seek_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.seek_time;
      stat_print_set(statset, 1, newprefix);
    }
  }

  /************************************************************************
   * x_seek_time
   ************************************************************************/
  
  /* Overall statistics */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    statset[i] = &dev->stat.x_seek_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.x_seek_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.x_seek_time;
      stat_print_set(statset, 1, newprefix);
    }
  }

  /************************************************************************
   * y_seek_time
   ************************************************************************/
  
  /* Overall statistics */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    statset[i] = &dev->stat.y_seek_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.y_seek_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.y_seek_time;
      stat_print_set(statset, 1, newprefix);
    }
  }

  /************************************************************************
   * turnaround_time
   ************************************************************************/
  
  /* Overall statistics */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    statset[i] = &dev->stat.turnaround_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.turnaround_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.turnaround_time;
      stat_print_set(statset, 1, newprefix);
    }
  }

  /************************************************************************
   * turnaround_number
   ************************************************************************/
  
  /* Overall statistics */

  fprintf(outputfile, "%sTotal initial turnarounds: %d\n",
	  prefix, dev->stat.num_initial_turnarounds);

  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    statset[i] = &dev->stat.turnaround_number;
  }
  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);

    fprintf(outputfile, "%sTotal initial turnarounds: %d\n",
	    newprefix, dev->stat.num_initial_turnarounds);

    statset[0] = &dev->stat.turnaround_number;
    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.turnaround_number;
      stat_print_set(statset, 1, newprefix);
    }
  }

  /************************************************************************
   * stream_turnaround_time
   ************************************************************************/
  
  /* Overall statistics */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    statset[i] = &dev->stat.stream_turnaround_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.stream_turnaround_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.stream_turnaround_time;
      stat_print_set(statset, 1, newprefix);
    }
  }

  /************************************************************************
   * stream_turnaround_number
   ************************************************************************/
  
  /* Overall statistics */
  fprintf(outputfile, "%sTotal streaming turnarounds: %d\n",
	  prefix, dev->stat.num_stream_turnarounds);

  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    statset[i] = &dev->stat.stream_turnaround_number;
  }
  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);

    fprintf(outputfile, "%sTotal streaming turnarounds: %d\n",
	    newprefix, dev->stat.num_stream_turnarounds);

    statset[0] = &dev->stat.stream_turnaround_number;
    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.stream_turnaround_number;
      stat_print_set(statset, 1, newprefix);
    }
  }
}


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

  /************************************************************************
   * Per-request energy (request_energy_uj)
   ************************************************************************/

  /* Overall statistics */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    statset[i] = &dev->stat.request_energy_uj;
  }
  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.request_energy_uj;
    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.request_energy_uj;
      stat_print_set(statset, 1, newprefix);
    }
  }

  /************************************************************************
   * Total energy dissipated
   ************************************************************************/

  {
    double total_energy = 0.0;
    double servicing_energy = 0.0;
    double startup_energy   = 0.0;
    double idle_energy      = 0.0;
    double inactive_energy  = 0.0;
    for (i=0; i < setsize; i++) {
      dev = getmems(set[i]);
      total_energy += dev->stat.total_energy_j;
      servicing_energy += dev->stat.servicing_energy_j;
      startup_energy   += dev->stat.startup_energy_j;
      idle_energy      += dev->stat.idle_energy_j;
      inactive_energy  += dev->stat.inactive_energy_j;
    }
    fprintf(outputfile, "%sTotal energy (J): %f\n", prefix, total_energy);
    fprintf(outputfile, 
	    "%sServicing energy (J): %f\n", prefix, servicing_energy);
    fprintf(outputfile, 
	    "%sStartup energy   (J): %f\n", prefix, startup_energy);
    fprintf(outputfile, 
	    "%sIdle energy      (J): %f\n", prefix, idle_energy);
    fprintf(outputfile, 
	    "%sInactive energy  (J): %f\n", prefix, inactive_energy);
    fprintf(outputfile, "\n");
  }

  /* Finally, total energy dissipated by each device and sled */
  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    fprintf(outputfile, "%sTotal energy (J) for device %d: %f\n", 
	    prefix, set[i], dev->stat.total_energy_j);
    fprintf(outputfile, "%sServicing energy (J) for device %d: %f\n", 
	    prefix, set[i], dev->stat.servicing_energy_j);
    fprintf(outputfile, "%sStartup energy   (J) for device %d: %f\n",
	    prefix, set[i], dev->stat.startup_energy_j);
    fprintf(outputfile, "%sIdle energy      (J) for device %d: %f\n", 
	    prefix, set[i], dev->stat.idle_energy_j);
    fprintf(outputfile, "%sInactive energy  (J) for device %d: %f\n", 
	    prefix, set[i], dev->stat.inactive_energy_j);

    for (j=0; j < dev->num_sleds; j++) {
      fprintf(outputfile, "%sTotal energy (J) for device %d sled %d: %f\n", 
	      prefix, set[i], j, dev->sled[j].stat.total_energy_j);
      fprintf(outputfile, 
	      "%sServicing energy (J) for device %d sled %d: %f\n", 
	      prefix, set[i], j, dev->sled[j].stat.servicing_energy_j);
      fprintf(outputfile,
	      "%sStartup energy   (J) for device %d sled %d: %f\n",
	      prefix, set[i], j, dev->sled[j].stat.startup_energy_j);
      fprintf(outputfile, 
	      "%sIdle energy      (J) for device %d sled %d: %f\n", 
	      prefix, set[i], j, dev->sled[j].stat.idle_energy_j);
      fprintf(outputfile, 
	      "%sInactive energy  (J) for device %d sled %d: %f\n", 
	      prefix, set[i], j, dev->sled[j].stat.inactive_energy_j);
    }
    fprintf(outputfile, "\n");
  }
}


static void
mems_buffer_printstats (int *set, int setsize, char *prefix)
{
  int i;
  mems_t *dev;
  int total_accesses = 0;
  int total_hits     = 0;
  double hit_ratio;

  /* Overall statistics */

  for (i=0; i < setsize; i++) {
    dev = getmems(set[i]);
    total_accesses += dev->stat.num_buffer_accesses;
    total_hits += dev->stat.num_buffer_hits;
  }
  hit_ratio = (double)total_hits / (double)total_accesses;

  fprintf(outputfile, "%sNumber of buffer accesses: %d\n",
	  prefix, total_accesses);
  fprintf(outputfile, "%sNumber of hits:            %d\n",
	  prefix, total_hits);
  fprintf(outputfile, "%sBuffer hit ratio:          %f\n",
	  prefix, hit_ratio);
  fprintf(outputfile, "%sBuffer miss ratio:         %f\n", 
	  prefix, 1.0 - hit_ratio);
  fprintf(outputfile, "\n");