mech_g1.c

disksim是一个非常优秀的磁盘仿真工具

    }

    result = d->mech->dm_rottime(d, theta, start);

    if(addtolatency && extra) {
      *addtolatency = d->mech->dm_rottime(d, 0, extra);
    }

    return result;
  }

  // UNREACHED
  return 0;
}

static dm_time_t 
dm_latency_seq_g1(struct dm_disk_if *d,
		  struct dm_mech_state *begin,
		  int start_sect,
		  int len,
		  int immed,
		  dm_time_t *addtolatency)
{
  ddbg_assert(0);
  return 0;
}


// initial->theta may be in unmapped space.  For the time being,
// we assume a whole-track layout and return start_sect in that case.
static int
g1_access_block(struct dm_disk_if *d,
		struct dm_mech_state *initial,
		int start_sect,
		int len,
		int immed)
{
  int sectors;
  dm_ptol_result_t rv;
  dm_angle_t start, end, skew;
  struct dm_pbn tmppbn;
  dm_angle_t theta = initial->theta;


  tmppbn.cyl = initial->cyl;
  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);
      
      if(sectWidth == 0) {
	goto out_nx;
      }

      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));
      }


      rv = d->layout->dm_convert_atop(d, &skewed, &result_pbn);
      if(rv < 0) {
	goto out_nx;
      }

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


 out_nx:
  return start_sect;

}

static 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;
    tmppbn.sector = 0; // XXX XXX
    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
    uint64_t 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_marshaled_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_marshal_hdr);
  result += m->xseekcnt * (sizeof(int) + sizeof(dm_time_t));
  return result;
}



static 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
static void *mech_g1_marshal(struct dm_disk_if *d, char *b);

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_marshaled_len,
  mech_g1_marshal,

  dm_mech_g1_seek_const,
  dm_mech_g1_seek_3pt_line,
  dm_mech_g1_seek_3pt_curve,
  dm_mech_g1_seek_hpl,
  dm_mech_g1_seek_1st10_plus_hpl,
  dm_mech_g1_seek_extracted,

  dm_latency_seq_g1
};


static void *
mech_g1_marshal(struct dm_disk_if *d, char *b) {
  void **fns;
  int i, fns_len, seekfns_len;
  char *ptr = b;

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


//    fns = malloc(sizeof(mech_g1_fns) + sizeof(DM_MECH_G1_MAX_SEEK * sizeof(void*)));
//    fns_len = (sizeof(mech_g1_fns) / sizeof(void *));
//    seekfns_len = DM_MECH_G1_MAX_SEEK+1;

//    for(i = 0; i < fns_len; i++) {
//      fns[i] = mech_g1_fns[i];
//    }
//    for(i = fns_len; i < fns_len + seekfns_len; i++) {
//      fns[i] = dm_mech_g1_seekfns[i];
//    }


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

  
  memcpy(ptr, (char *)m, sizeof(struct dm_mech_g1));
  marshal_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);
    
    marshal_fn((void *)m->seekfn, DM_MECH_G1_TYP, 
		(struct marshaled_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_unmarshal(struct dm_marshal_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));
  unmarshal_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 = unmarshal_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_marshal_module dm_mech_g1_marshal_mod = 
{ mech_g1_unmarshal,
  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_marshaled_len,
  mech_g1_marshal
};