disksim_disk.c

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

/*
 * DiskSim Storage Subsystem Simulation Environment (Version 3.0)
 * Revision Authors: John Bucy, Greg Ganger
 * Contributors: John Griffin, Jiri Schindler, Steve Schlosser
 *
 * Copyright (c) of Carnegie Mellon University, 2001, 2002, 2003.
 *
 * This software is being provided by the copyright holders under the
 * following license. By obtaining, using and/or copying this software,
 * you agree that you have read, understood, and will comply with the
 * following terms and conditions:
 *
 * Permission to reproduce, use, and prepare derivative works of this
 * software is granted provided the copyright and "No Warranty" statements
 * are included with all reproductions and derivative works and associated
 * documentation. This software may also be redistributed without charge
 * provided that the copyright and "No Warranty" statements are included
 * in all redistributions.
 *
 * NO WARRANTY. THIS SOFTWARE IS FURNISHED ON AN "AS IS" BASIS.
 * CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY KIND, EITHER
 * EXPRESSED OR IMPLIED AS TO THE MATTER INCLUDING, BUT NOT LIMITED
 * TO: WARRANTY OF FITNESS FOR PURPOSE OR MERCHANTABILITY, EXCLUSIVITY
 * OF RESULTS OR RESULTS OBTAINED FROM USE OF THIS SOFTWARE. CARNEGIE
 * MELLON UNIVERSITY DOES NOT MAKE ANY WARRANTY OF ANY KIND WITH RESPECT
 * TO FREEDOM FROM PATENT, TRADEMARK, OR COPYRIGHT INFRINGEMENT.
 * COPYRIGHT HOLDERS WILL BEAR NO LIABILITY FOR ANY USE OF THIS SOFTWARE
 * OR DOCUMENTATION.
 *
 */



/*
 * DiskSim Storage Subsystem Simulation Environment (Version 2.0)
 * Revision Authors: Greg Ganger
 * Contributors: Ross Cohen, John Griffin, Steve Schlosser
 *
 * Copyright (c) of Carnegie Mellon University, 1999.
 *
 * Permission to reproduce, use, and prepare derivative works of
 * this software for internal use is granted provided the copyright
 * and "No Warranty" statements are included with all reproductions
 * and derivative works. This software may also be redistributed
 * without charge provided that the copyright and "No Warranty"
 * statements are included in all redistributions.
 *
 * NO WARRANTY. THIS SOFTWARE IS FURNISHED ON AN "AS IS" BASIS.
 * CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY KIND, EITHER
 * EXPRESSED OR IMPLIED AS TO THE MATTER INCLUDING, BUT NOT LIMITED
 * TO: WARRANTY OF FITNESS FOR PURPOSE OR MERCHANTABILITY, EXCLUSIVITY
 * OF RESULTS OR RESULTS OBTAINED FROM USE OF THIS SOFTWARE. CARNEGIE
 * MELLON UNIVERSITY DOES NOT MAKE ANY WARRANTY OF ANY KIND WITH RESPECT
 * TO FREEDOM FROM PATENT, TRADEMARK, OR COPYRIGHT INFRINGEMENT.
 */

/*
 * DiskSim Storage Subsystem Simulation Environment
 * Authors: Greg Ganger, Bruce Worthington, Yale Patt
 *
 * Copyright (C) 1993, 1995, 1997 The Regents of the University of Michigan 
 *
 * This software is being provided by the copyright holders under the
 * following license. By obtaining, using and/or copying this software,
 * you agree that you have read, understood, and will comply with the
 * following terms and conditions:
 *
 * Permission to use, copy, modify, distribute, and sell this software
 * and its documentation for any purpose and without fee or royalty is
 * hereby granted, provided that the full text of this NOTICE appears on
 * ALL copies of the software and documentation or portions thereof,
 * including modifications, that you make.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO
 * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE,
 * BUT NOT LIMITATION, COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR
 * WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR
 * THAT THE USE OF THE SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY
 * THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. COPYRIGHT
 * HOLDERS WILL BEAR NO LIABILITY FOR ANY USE OF THIS SOFTWARE OR
 * DOCUMENTATION.
 *
 *  This software is provided AS IS, WITHOUT REPRESENTATION FROM THE
 * UNIVERSITY OF MICHIGAN AS TO ITS FITNESS FOR ANY PURPOSE, AND
 * WITHOUT WARRANTY BY THE UNIVERSITY OF MICHIGAN OF ANY KIND, EITHER
 * EXPRESSED OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE REGENTS
 * OF THE UNIVERSITY OF MICHIGAN SHALL NOT BE LIABLE FOR ANY DAMAGES,
 * INCLUDING SPECIAL , INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
 * WITH RESPECT TO ANY CLAIM ARISING OUT OF OR IN CONNECTION WITH THE
 * USE OF OR IN CONNECTION WITH THE USE OF THE SOFTWARE, EVEN IF IT HAS
 * BEEN OR IS HEREAFTER ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
 *
 * The names and trademarks of copyright holders or authors may NOT be
 * used in advertising or publicity pertaining to the software without
 * specific, written prior permission. Title to copyright in this software
 * and any associated documentation will at all times remain with copyright
 * holders.
 */

#include "disksim_global.h"
#include "disksim_iosim.h"
#include "disksim_stat.h"
#include "disksim_disk.h"
#include "disksim_ioqueue.h"
#include "config.h"

#include "modules/disksim_disk_param.h"

static void disk_initialize_diskinfo ();

/* read-only globals used during readparams phase */
static char *statdesc_seekdiststats	=	"Seek distance";
static char *statdesc_seektimestats	=	"Seek time";
static char *statdesc_rotlatstats	=	"Rotational latency";
static char *statdesc_xfertimestats	=	"Transfer time";
static char *statdesc_postimestats	=	"Positioning time";
static char *statdesc_acctimestats	=	"Access time";


INLINE struct disk *getdisk (int diskno)
{
   disk *currdisk;
   ASSERT1((diskno >= 0) && (diskno < MAXDEVICES), "diskno", diskno);
   currdisk = disksim->diskinfo->disks[diskno];
   if (!currdisk) {
      //fprintf (stderr, "getdisk returning a non-initialized currdisk\n");
   }
   return (currdisk);
}


int disk_add(struct disk *d) {
  int c;

  if(!disksim->diskinfo) disk_initialize_diskinfo();
  
  for(c = 0; c < disksim->diskinfo->disks_len; c++) {
    if(!disksim->diskinfo->disks[c]) {
      disksim->diskinfo->disks[c] = d;
      numdisks++;
      return c;
    }
  }

  /* note that numdisks must be equal to diskinfo->disks_len */
  disksim->diskinfo->disks = realloc(disksim->diskinfo->disks, 
			   2*numdisks*sizeof(disk *));
  bzero(disksim->diskinfo->disks + numdisks, numdisks);
  disksim->diskinfo->disks[c] = d;
  numdisks++;
  disksim->diskinfo->disks_len *= 2;
  return c;
}


int disk_get_numdisks (void)
{
   return(numdisks);
}


void disk_cleanstats (void)
{
   int i;

   for (i=0; i<MAXDEVICES; i++) {
      disk *currdisk = getdisk (i);
      if (currdisk) {
         ioqueue_cleanstats(currdisk->queue);
      }
   }
}





static void diskstatinit (int diskno, int firsttime)
{
   disk *currdisk = getdisk (diskno);
   diskstat *stat = &currdisk->stat;

   if (firsttime) {
      stat_initialize(statdeffile, statdesc_seekdiststats, &stat->seekdiststats);
      stat_initialize(statdeffile, statdesc_seektimestats, &stat->seektimestats);
      stat_initialize(statdeffile, statdesc_rotlatstats, &stat->rotlatstats);
      stat_initialize(statdeffile, statdesc_xfertimestats, &stat->xfertimestats);
      stat_initialize(statdeffile, statdesc_postimestats, &stat->postimestats);
      stat_initialize(statdeffile, statdesc_acctimestats, &stat->acctimestats);
   } 
   else {
      stat_reset(&stat->seekdiststats);
      stat_reset(&stat->seektimestats);
      stat_reset(&stat->rotlatstats);
      stat_reset(&stat->xfertimestats);
      stat_reset(&stat->postimestats);
      stat_reset(&stat->acctimestats);
   }

   stat->highblkno = 0;
   stat->zeroseeks = 0;
   stat->zerolatency = 0;
   stat->writecombs = 0;
   stat->readmisses = 0;
   stat->writemisses = 0;
   stat->fullreadhits = 0;
   stat->appendhits = 0;
   stat->prependhits = 0;
   stat->readinghits = 0;
   stat->runreadingsize = 0.0;
   stat->remreadingsize = 0.0;
   stat->parthits = 0;
   stat->runpartsize = 0.0;
   stat->rempartsize = 0.0;
   stat->interfere[0] = 0;
   stat->interfere[1] = 0;
   stat->requestedbus = 0.0;
   stat->waitingforbus = 0.0;
   stat->numbuswaits = 0;
}


static void disk_syncset_init (void)
{
  int i, j;
  int synced[128];

  for(i = 1; i <= numsyncsets; i++) {
    synced[i] = 0;
  }

  for(i = 0; i < MAXDEVICES; i++) {
    disk *currdisk = getdisk (i);
    if(!currdisk) {
      continue;
    }

    currdisk->model->mech->dm_randomize_rpm(currdisk->model); 
    //    currdisk->mech_state.theta = dm_angle_dtoi(DISKSIM_drand48()); 

    if(currdisk->syncset == 0) {

    } 
    else if((currdisk->syncset > 0) && 
	    (synced[(currdisk->syncset)] == 0)) 
      {
	for (j = i; j < MAXDEVICES; j++) {
	  disk *currdisk2 = getdisk(j); 
	  if(!currdisk2) continue;

  	  if (currdisk2->syncset == currdisk->syncset) { 
	    currdisk2->mech_state.theta = currdisk->mech_state.theta;
  	  } 
	}
	synced[(currdisk->syncset)] = 1;
      }
  }
}


static void disk_postpass_perdisk (disk *currdisk)
{
  if ((currdisk->contread) && (currdisk->enablecache == FALSE)) {
    fprintf(stderr, "Makes no sense to use read-ahead but not use caching\n");
    ddbg_assert(0);;
  }

  if ((currdisk->contread == BUFFER_NO_READ_AHEAD) &&
      (currdisk->minreadahead > 0)) {
    // fprintf(stderr, "'Minimum read-ahead (blks)' forced to zero due to 'Buffer continuous read' value\n");
    currdisk->minreadahead = 0;
  }

  if ((currdisk->maxreadahead < currdisk->minreadahead) ||
      ((currdisk->contread == BUFFER_NO_READ_AHEAD) &&
       (currdisk->maxreadahead > 0))) {
    // fprintf(stderr, "'Maximum read-ahead (blks)' forced to zero due to 'Buffer continuous read' value\n");
    currdisk->maxreadahead = currdisk->minreadahead;
  }

  if (currdisk->keeprequestdata >= 0) {
    currdisk->keeprequestdata = abs(currdisk->keeprequestdata - 1);
  }

  if ((currdisk->readanyfreeblocks != FALSE) &&
      (currdisk->enablecache == FALSE)) {
    fprintf(stderr, "Makes no sense to read blocks with caching disabled\n");
    ddbg_assert(0);;
  }

  if ((currdisk->fastwrites) && (currdisk->enablecache == FALSE)) {
    fprintf(stderr, "Can't use fast write if not employing caching\n");
    ddbg_assert(0);;
  }

  /* ripped from the override function */

  if ((currdisk->readaheadifidle != 0) && (currdisk->readaheadifidle != 1)) {
    fprintf(stderr, "Invalid value for readaheadifidle in disk_postpass_perdisk: %d\n", currdisk->readaheadifidle);
    ddbg_assert(0);;
  }

  if ((currdisk->writecomb != 0) && (currdisk->writecomb != 1)) {
    fprintf(stderr, "Invalid value for writecomb in disk_postpass_perdisk: %d\n", currdisk->writecomb);
    ddbg_assert(0);;
  }

  if (currdisk->maxqlen < 0) {
    fprintf(stderr, "Invalid value for maxqlen in disk_postpass_perdisk: %d\n", currdisk->maxqlen);
    ddbg_assert(0);;
  }

  if ((currdisk->hold_bus_for_whole_read_xfer != 0) &&
      (currdisk->hold_bus_for_whole_read_xfer != 1)) {
    fprintf(stderr, "Invalid value for hold_bus_for_whole_read_xfer in disk_postpass_perdisk: %d\n", currdisk->hold_bus_for_whole_read_xfer);
    ddbg_assert(0);;
  }

  if ((currdisk->hold_bus_for_whole_write_xfer != 0) &&
      (currdisk->hold_bus_for_whole_write_xfer != 1)) {
    fprintf(stderr, "Invalid value for hold_bus_for_whole_write_xfer in disk_postpass_perdisk: %d\n", currdisk->hold_bus_for_whole_write_xfer);
    ddbg_assert(0);;
  }
  if ((currdisk->hold_bus_for_whole_read_xfer == 1) &&
      ((currdisk->sneakyfullreadhits == 1) ||
       (currdisk->sneakypartialreadhits == 1) ||
       (currdisk->sneakyintermediatereadhits == 1))) {
    fprintf(stderr, "hold_bus_for_whole_read_xfer and one or more sneakyreadhits detected disk_postpass_perdisk\n");
    ddbg_assert(0);;
  }

  if ((currdisk->almostreadhits != 0) && (currdisk->almostreadhits != 1)) {
    fprintf(stderr, "Invalid value for almostreadhits in disk_postpass_perdisk: %d\n", currdisk->almostreadhits);
    ddbg_assert(0);;
  }

  if ((currdisk->sneakyfullreadhits != 0) &&
      (currdisk->sneakyfullreadhits != 1)) {
    fprintf(stderr, "Invalid value for sneakyfullreadhits in disk_postpass_perdisk: %d\n", currdisk->sneakyfullreadhits);
    ddbg_assert(0);;
  }
  if ((currdisk->sneakyfullreadhits == 1) &&
      (currdisk->hold_bus_for_whole_read_xfer == 1)) {
    fprintf(stderr, "hold_bus_for_whole_read_xfer and sneakyfullreadhits detected disk_postpass_perdisk\n");
    ddbg_assert(0);;
  }

  if ((currdisk->sneakypartialreadhits != 0) &&
      (currdisk->sneakypartialreadhits != 1)) {
    fprintf(stderr, "Invalid value for sneakypartialreadhits in disk_postpass_perdisk: %d\n", currdisk->sneakypartialreadhits);
    ddbg_assert(0);;
  }
  if ((currdisk->sneakypartialreadhits == 1) &&
      (currdisk->hold_bus_for_whole_read_xfer == 1)) {
    fprintf(stderr, "hold_bus_for_whole_read_xfer and sneakypartialreadhits detected disk_postpass_perdisk\n");
    ddbg_assert(0);;
  }

  if ((currdisk->sneakyintermediatereadhits != 0) &&
      (currdisk->sneakyintermediatereadhits != 1)) {
    fprintf(stderr, "Invalid value for sneakyintermediatereadhits in disk_postpass_perdisk: %d\n", currdisk->sneakyintermediatereadhits);
    ddbg_assert(0);;
  }
  if ((currdisk->sneakyintermediatereadhits == 1) &&
      (currdisk->hold_bus_for_whole_read_xfer == 1)) {
    fprintf(stderr, "hold_bus_for_whole_read_xfer and sneakyintermediatereadhits detected disk_postpass_perdisk\n");
    ddbg_assert(0);;
  }

  if ((currdisk->readhitsonwritedata != 0) &&
      (currdisk->readhitsonwritedata != 1)) {
    fprintf(stderr, "Invalid value for readhitsonwritedata in disk_postpass_perdisk: %d\n", currdisk->readhitsonwritedata);
    ddbg_assert(0);;
  }

  if ((currdisk->writeprebuffering != 0) &&
      (currdisk->writeprebuffering != 1)) {
    fprintf(stderr, "Invalid value for writeprebuffering in disk_postpass_perdisk: %d\n", currdisk->writeprebuffering);
    ddbg_assert(0);;
  }

  if ((currdisk->preseeking != 0) && (currdisk->preseeking != 1) &&
      (currdisk->preseeking != 2)) {
    fprintf(stderr, "Invalid value for preseeking in disk_postpass_perdisk: %d\n", currdisk->preseeking);
    ddbg_assert(0);;
  }

  if ((currdisk->neverdisconnect != 0) && (currdisk->neverdisconnect != 1)) {
    fprintf(stderr, "Invalid value for neverdisconnect in disk_postpass_perdisk: %d\n", currdisk->neverdisconnect);
    ddbg_assert(0);;
  }

  if (currdisk->numsegs < 1) {
    fprintf(stderr, "Invalid value for numsegs in disk_postpass_perdisk: %d\n", currdisk->numsegs);
    ddbg_assert(0);;
  }

  if ((currdisk->segsize < 1) ||
      (currdisk->segsize > currdisk->model->dm_sectors)) {
    fprintf(stderr, "Invalid value for segsize in disk_postpass_perdisk: %d\n", currdisk->model->dm_sectors);
    ddbg_assert(0);;
  }

  if ((currdisk->numwritesegs > currdisk->numsegs) ||
      (currdisk->numwritesegs < 1)) {
    fprintf(stderr, "Invalid value for numwritesegs in disk_postpass_perdisk: %d\n", currdisk->numwritesegs);
    ddbg_assert(0);;