mech_g1.c

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

  tmppbn.head = initial->head;
  tmppbn.sector = start_sect;
  sectors = d->layout->dm_get_sectors_pbn(d, &tmppbn);

  ddbg_assert(len <= sectors);

  skew = d->layout->dm_pbn_skew(d, &tmppbn);
  start = skew;

  if(!immed) {
    return start_sect;
  }
  else {
    dm_angle_t extra = 0;
    tmppbn.sector = (start_sect + len - 1); // % sectors;
        
    if(tmppbn.sector >= sectors) {
      tmppbn.sector = sectors - 1;
    }

    //    d->layout->dm_convert_ptoa(d, &tmppbn, &end, 0);
    end = d->layout->dm_pbn_skew(d, &tmppbn);
    
    // head is between 0 and the start of the access
    if(((theta <= start) && (start < end))
       || ( (end < theta) && (theta <= start) )
       || ( (start < end) && (end <= theta))
       || (tmppbn.sector == start_sect)) // corner case!
      {
	ddbg_assert(start_sect < sectors);
	return start_sect;
      }
    // head is in the middle of the access
    else {
      // dm_angle_t skewed;
      dm_angle_t track_skew;
      struct dm_pbn track_endpbn;
      struct dm_mech_state skewed;
      struct dm_pbn result_pbn;
      dm_angle_t sectWidth = 
	d->layout->dm_get_sector_width(d, &tmppbn, 1);

      track_endpbn.cyl = initial->cyl;
      track_endpbn.head = initial->head;

      track_endpbn.sector = 0;
      track_skew = d->layout->dm_pbn_skew(d, &track_endpbn);

      skewed.cyl = initial->cyl;      
      skewed.head = initial->head;
      skewed.theta = theta - track_skew;
      
      if((skewed.theta % sectWidth) != 0) {
	skewed.theta += (sectWidth - (skewed.theta % sectWidth));
      }

      d->layout->dm_convert_atop(d, &skewed, &result_pbn);

      ddbg_assert(result_pbn.sector < sectors);
      return result_pbn.sector;
    }
  }
  // UNREACHED
}

dm_time_t
dm_latency_g1_average(struct dm_disk_if *d,
		      struct dm_mech_state *begin,
		      int start,
		      int len,
		      int immed)
{
  dm_time_t result;
  struct dm_mech_g1 *m = (struct dm_mech_g1 *)d->mech;
  result = m->rotatetime >> 1;
  return result;
}


// compute how long it will take the disk to rotate from the angle
// in the first position to that in the second position

// use an average value of half the full-rotation time
static dm_time_t 
dm_rottime_g1_average(struct dm_disk_if *d,
		      dm_angle_t junk1,
		      dm_angle_t junk2)
{
  dm_time_t result;
  struct dm_mech_g1 *m = (struct dm_mech_g1 *)d->mech;
  result = m->rotatetime >> 1;
  return result;
}

static dm_time_t 
dm_rottime_g1(struct dm_disk_if *d,
	      dm_angle_t begin,
	      dm_angle_t end)
{
  struct dm_mech_g1 *m = (struct dm_mech_g1 *)d->mech;
  dm_angle_t diff;
  if(end == begin) {
    return 0;
  }
  else if(end > begin) {
    diff = end - begin;
  }
  else {
    // Ladies and Gentlemen, please disregard the man behind the curtain.
    diff = -(begin - end);
  }

  //printf("dm_rottime_g1: rotdistance = %f\n", dm_angle_itod(diff));



  // XXX this is immensly evil
  return ((((long long)diff << 20) >> DM_ANGLE_EXP) * m->rotatetime) >> 20;
}

// Amount of time to read len sectors from the track designated by
// the 2nd argument.  This is a convience wrapper for 
// rottime.
static dm_time_t 
dm_xfertime_g1(struct dm_disk_if *d,
	       struct dm_mech_state *track,
	       int len)
{
  struct dm_pbn pbn;
  //  int sectors;
  dm_angle_t theta;
  //  struct dm_mech_state theta2;
  
  pbn.head = track->head;
  pbn.cyl = track->cyl;
  pbn.sector = len - 1;
  
  // actually *don't* want to use this interface; we just want
  // (len / blkspertrack) * period
  //  d->layout->dm_convert_ptoa(d, &pbn, &theta2.theta, 0);

  //  sectors = d->layout->dm_get_sectors_pbn(d, &pbn);

  // XXX have to go up to 64 bits wide to represent this 
  //  theta = ((long long)len << DM_ANGLE_EXP) / sectors;
  { 
    struct dm_pbn tmppbn; 
    tmppbn.head = track->head;
    tmppbn.cyl = track->cyl;
    theta = d->layout->dm_get_sector_width(d, &tmppbn, len);
  }

  return d->mech->dm_rottime(d, 0, theta);
}


// this is probably constant for now but might not be in the future
static dm_time_t 
dm_headswitch_time_g1(struct dm_disk_if *d, 
		      int h1, 
		      int h2)
{
  struct dm_mech_g1 *m = (struct dm_mech_g1 *)d->mech;
  if(h1 != h2) {
    return m->headswitch;
  }
  else {
    return 0;
  }
}


// how far will the media rotate in the given amount of time
// only the angle in the result is set
static dm_angle_t
dm_rotate_g1(struct dm_disk_if *d, 
	     dm_time_t *time)
{
  struct dm_mech_g1 *m = (struct dm_mech_g1 *)d->mech;
  if(*time == 0) {
    return 0;
  }
  else {
    // time / time/tics = tics
    uint64_t result1, result2;

    //    result1 = dm_angle_dtoi(dm_time_itod(*time) / dm_time_itod(m->rotatetime));

    // This is a little tricky; if we do time << DM_ANGLE_T, we may
    // run out of bits so we shift by a bit less, then divide and then

    // shift some more.  Consequently, this is somewhat lossy.
    // These shifts assume that DM_TIME_EXP > DM_ANGLE_EXP and that a
    // dm_time_t is 64 bits wide

    result2 =  ((*time << (64 - DM_TIME_EXP)) 
		/ m->rotatetime) 
		       << (DM_TIME_EXP - DM_ANGLE_EXP);


    return result2;
  }
}


// assuming no activity, what will the state of the disk be
// at some time in the future
static void 
dm_progress_g1(struct dm_disk_if *d, 
	       struct dm_pbn *cur_state,
	       dm_time_t time,
	       struct dm_pbn *result_state)
{
  ddbg_assert2(0, "unimplemented");
}

static dm_time_t
dm_period_g1(struct dm_disk_if *d) { 
  struct dm_mech_g1 *m = (struct dm_mech_g1 *)d->mech;
  return m->rotatetime;
}



int mech_g1_marshalled_len(struct dm_disk_if *d) {
  struct dm_mech_g1 *m = (struct dm_mech_g1 *)d->mech;
  int result = sizeof(struct dm_mech_g1);
  result += sizeof(struct dm_marshall_hdr);
  result += m->xseekcnt * (sizeof(int) + sizeof(dm_time_t));
  return result;
}



void dm_mech_g1_set_period(struct dm_disk_if *d) {
  //  fprintf(stderr, "*** warning: RPM randomization is disabled\n");
}


// random prototypes for the fns array
void *mech_g1_marshall(struct dm_disk_if *d, char *b);

dm_time_t seek_const(struct dm_disk_if *d,
		     struct dm_mech_state *begin,
		     struct dm_mech_state *end,
		     int rw);

dm_time_t seek_3pt_curve(struct dm_disk_if *d,
			 struct dm_mech_state *begin,
			 struct dm_mech_state *end,
			 int rw);

dm_time_t seek_3pt_line(struct dm_disk_if *d,
			struct dm_mech_state *begin,
			struct dm_mech_state *end,
			int rw);

dm_time_t seek_hpl(struct dm_disk_if *d,
		   struct dm_mech_state *begin,
		   struct dm_mech_state *end,
		   int rw);

dm_time_t seek_1st10_plus_hpl(struct dm_disk_if *d, 
			      struct dm_mech_state *begin,
			      struct dm_mech_state *end,
			      int rw);

dm_time_t seek_extracted(struct dm_disk_if *d,
			 struct dm_mech_state *begin,
			 struct dm_mech_state *end,
			 int rw);

void *mech_g1_fns[] = {
  dm_seek_time_g1,
  g1_access_block,
  dm_latency_g1,
  dm_pos_time_g1,
  dm_acctime_g1,
  dm_rottime_g1,
  dm_xfertime_g1,
  dm_headswitch_time_g1,
  dm_rotate_g1,
  dm_period_g1,

  dm_mech_g1_set_period,

  mech_g1_marshalled_len,
  mech_g1_marshall,

  seek_const,
  seek_3pt_line,
  seek_3pt_curve,
  seek_hpl,
  seek_1st10_plus_hpl,
  seek_extracted,
  dm_latency_seq_g1
};


void *mech_g1_marshall(struct dm_disk_if *d, char *b) {
  char *ptr = b;

  struct dm_marshall_hdr *h = (struct dm_marshall_hdr *)b;
  struct dm_mech_g1 *m = (struct dm_mech_g1 *)d->mech;

  h->type = DM_MECH_G1_TYP;
  h->len = mech_g1_marshalled_len(d);
  ptr += sizeof(*h);

  
  memcpy(ptr, (char *)m, sizeof(struct dm_mech_g1));
  marshall_fns((void **)&m->hdr, 
	       sizeof(struct dm_mech_if) / sizeof(void *),
	       ptr,
	       DM_MECH_G1_TYP);
  {
    int *seekfnoffset = (int *)ptr + sizeof(struct dm_mech_if);
    
    marshall_fn((void *)m->seekfn, DM_MECH_G1_TYP, 
		(struct marshalled_fn *)seekfnoffset);
  }

  ptr += sizeof(struct dm_mech_g1) + sizeof(void*);
  if(m->xseekcnt != 0) {
    int distsize = m->xseekcnt * sizeof(int);
    int timesize = m->xseekcnt * sizeof(dm_time_t);
    
    memcpy(ptr, (char *)m->xseekdists, distsize);
    ptr += distsize;
    memcpy(ptr, (char *)m->xseektimes, timesize);
    ptr += timesize;
  }
   
  return (void *)ptr;
}

char *
mech_g1_unmarshall(struct dm_marshall_hdr *h,
		   void **result,
		   void *parent) 
{
  char *ptr = (char *)h;
  struct dm_mech_g1 *m = malloc(sizeof(struct dm_mech_g1));

  ptr += sizeof(*h);
  memcpy((char *)m, ptr, sizeof(struct dm_mech_g1));
  unmarshall_fns((void **)&m->hdr, 
		 sizeof(struct dm_mech_if) / sizeof(void *),
		 ptr,
		 DM_MECH_G1_TYP);

  {
    int *seekfnoffset = (int *)ptr + sizeof(struct dm_mech_if);
    m->seekfn = unmarshall_fn(seekfnoffset,
			      DM_MECH_G1_TYP);
  }
  ptr += sizeof(struct dm_mech_g1) + sizeof(void*);

  if(m->xseekcnt != 0) {
    int distsize = m->xseekcnt * sizeof(int);
    int timesize = m->xseekcnt * sizeof(dm_time_t);
    
    m->xseekdists = malloc(distsize);
    m->xseektimes = malloc(timesize);
    memcpy((char *)m->xseekdists, ptr, distsize);
    ptr += distsize;
    memcpy((char *)m->xseektimes, ptr, timesize);
    ptr += timesize;
  }


  m->disk = parent;

  *result = m;
  return ptr;
}


struct dm_marshall_module dm_mech_g1_marshall_mod = 
{ mech_g1_unmarshall,
  mech_g1_fns,
  sizeof(mech_g1_fns) / sizeof(void *)
};


// this is an initializer; some of these functions may change
// e.g. seek_time
struct dm_mech_if dm_mech_g1 = {
  dm_seek_time_g1,
  g1_access_block,
  dm_latency_g1,
  dm_latency_seq_g1,
  dm_pos_time_g1,
  dm_acctime_g1,
  dm_rottime_g1,

  dm_xfertime_g1,
  dm_headswitch_time_g1,
  dm_rotate_g1,
  //  dm_progress_g1,
  dm_period_g1,

  dm_mech_g1_set_period,

  mech_g1_marshalled_len,
  mech_g1_marshall
};