disksim_synthio.c

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

	     (tmp->bcount <= 0)) {

	tmp->blkno = (int) (DISKSIM_drand48() * (double)gen->blksperdisk);
	tmp->bcount = ((int) synthio_getrand(&gen->sizedist) + 
		       gen->blocksize - 1) / gen->blocksize;
      }

      if (DISKSIM_drand48() < gen->probread) {
	tmp->flags = READ;
      }
   }
   reqclass = DISKSIM_drand48() - gen->probtmcrit;

   if (reqclass < 0.0) {
     tmp->flags |= TIME_CRITICAL;
   } 
   else if (reqclass < gen->probtmlim) {
     tmp->flags |= TIME_LIMITED;
   }
   return 1;
}


void synthio_generate_io_activity (process *procp)
{
   synthio_generator *gen;

   gen = (synthio_generator *) procp->space;

   //   fprintf (stderr, "simtime %f, endtime %f, iocnt %d, endiocnt %d\n", simtime, synthio_endtime, synthio_iocnt, synthio_endiocnt);
   
   synthio_iocnt++;
   if (synthio_generatenextio(gen)) {
      synthio_appendio(procp, gen->pendio);
   } else {
      disksim_simstop();
   }
}




void synthio_resetstats()
{
}


void synthio_cleanstats()
{
}


void synthio_printstats()
{
}


static void synthio_read_uniform (FILE *parfile, synthio_distr *newdistr, double mult)
{
   newdistr->type = SYNTHIO_UNIFORM;
   if (fscanf(parfile, "Minimum value: %lf\n", &newdistr->base) != 1) {
      fprintf(stderr, "Error reading 'minimum value'\n");
      exit(1);
   }
   fprintf (outputfile, "Minimum value: %f\n", newdistr->base);
   newdistr->base *= mult;
   if (fscanf(parfile, "Maximum value: %lf\n", &newdistr->var) != 1) {
      fprintf(stderr, "Error reading 'maximum value'\n");
      exit(1);
   }
   fprintf (outputfile, "Maximum value: %f\n", newdistr->var);
   newdistr->var *= mult;
   if (newdistr->var <= newdistr->base) {
      fprintf(stderr, "'maximum value' is not greater than 'minimum value' - %f <= %f\n", newdistr->var, newdistr->base);
      exit(1);
   }
}


static void synthio_read_normal (FILE *parfile, synthio_distr *newdistr, double mult)
{
   newdistr->type = SYNTHIO_NORMAL;
   if (fscanf(parfile, "Mean: %lf\n", &newdistr->mean) != 1) {
      fprintf(stderr, "Error reading normal mean\n");
      exit(1);
   }
   fprintf (outputfile, "Mean: %f\n", newdistr->mean);
   newdistr->mean *= mult;
   if (fscanf(parfile, "Variance: %lf\n", &newdistr->var) != 1) {
      fprintf(stderr, "Error reading normal variance\n");
      exit(1);
   }
   fprintf (outputfile, "Variance: %f\n", newdistr->var);
   if (newdistr->var < 0) {
      fprintf(stderr, "Invalid value for 'variance' - %f\n", newdistr->var);
      exit(1);
   }
   newdistr->var = mult * sqrt(newdistr->var);
}


static void synthio_read_exponential (FILE *parfile, synthio_distr *newdistr, double mult)
{
   newdistr->type = SYNTHIO_EXPONENTIAL;
   if (fscanf(parfile, "Base value: %lf\n", &newdistr->base) != 1) {
      fprintf(stderr, "Error reading exponential base\n");
      exit(1);
   }
   fprintf (outputfile, "Base value: %f\n", newdistr->base);
   newdistr->base *= mult;
   if (fscanf(parfile, "Mean: %lf\n", &newdistr->mean) != 1) {
      fprintf(stderr, "Error reading exponential mean\n");
      exit(1);
   }
   fprintf (outputfile, "Mean: %f\n", newdistr->mean);
   newdistr->mean *= mult;
}


static void synthio_read_poisson (FILE *parfile, synthio_distr *newdistr, double mult)
{
   newdistr->type = SYNTHIO_POISSON;
   if (fscanf(parfile, "Base value: %lf\n", &newdistr->base) != 1) {
      fprintf(stderr, "Error reading 'base value'\n");
      exit(1);
   }
   fprintf (outputfile, "Base value: %f\n", newdistr->base);
   newdistr->base *= mult;
   if (fscanf(parfile, "Mean: %lf\n", &newdistr->mean) != 1) {
      fprintf(stderr, "Error reading poisson mean\n");
      exit(1);
   }
   fprintf (outputfile, "Mean: %f\n", newdistr->mean);
   newdistr->mean *= mult;
}


static void synthio_read_twovalue (FILE *parfile, synthio_distr *newdistr, double mult)
{
   newdistr->type = SYNTHIO_TWOVALUE;
   if (fscanf(parfile, "Default value: %lf\n", &newdistr->base) != 1) {
      fprintf(stderr, "Error reading 'default value'\n");
      exit(1);
   }
   fprintf(outputfile, "Default value: %f\n", newdistr->base);
   newdistr->base *= mult;
   if (fscanf(parfile, "Second value: %lf\n", &newdistr->mean) != 1) {
      fprintf(stderr, "Error reading 'second value'\n");
      exit(1);
   }
   fprintf(outputfile, "Second value: %f\n", newdistr->mean);
   newdistr->mean *= mult;
   if (fscanf(parfile, "Probability of second value: %lf\n", &newdistr->var) != 1) {
      fprintf(stderr, "Error reading 'probability of second value'\n");
      exit(1);
   }
   if ((newdistr->var < 0) || (newdistr->var > 1)) {
      fprintf(stderr, "Invalid probability of second value - %f\n", newdistr->var);
      exit(1);
   }
   fprintf(outputfile, "Probability of second value: %f\n", newdistr->var);
}


static void synthio_read_distr (FILE *parfile, synthio_distr *newdistr, double mult)
{
   char type[80];

   if (fscanf(parfile, "Type of distribution: %s\n", type) != 1) {
      fprintf(stderr, "Error reading 'type of distribution'\n");
      exit(1);
   }
   fprintf (outputfile, "Type of distribution: %s\n", type);
   switch (type[0]) {
      case 'u':
		synthio_read_uniform(parfile, newdistr, mult);
		break;
      case 'n':
		synthio_read_normal(parfile, newdistr, mult);
		break;
      case 'e':
		synthio_read_exponential(parfile, newdistr, mult);
		break;
      case 'p':
		synthio_read_poisson(parfile, newdistr, mult);
		break;
      case 't':
		synthio_read_twovalue(parfile, newdistr, mult);
		break;
      default:
                fprintf(stderr, "Invalid value for 'type of distribution' - %s\n", type);
                exit(1);
   }

}


static void synthio_distrcopy (synthio_distr *distr1, synthio_distr *distr2)
{
   distr2->base = distr1->base;
   distr2->mean = distr1->mean;
   distr2->var = distr1->var;
   distr2->type = distr1->type;
}


static void synthio_gencopy (synthio_generator *gen1, synthio_generator *gen2)
{
   gen2->probseq = gen1->probseq;
   gen2->probloc = gen1->probloc;
   gen2->probread = gen1->probread;
   gen2->probtmcrit = gen1->probtmcrit;
   gen2->probtmlim = gen1->probtmlim;
   gen2->tracefile = NULL; /* No good way to copy the descriptor */
   gen2->pendio = NULL;
   gen2->limits = NULL;
   gen2->numdisks = gen1->numdisks;
   memcpy(gen2->devno, gen1->devno, gen1->numdisks * sizeof(int));
   gen2->numblocks = gen1->numblocks;
   gen2->sectsperdisk = gen1->sectsperdisk;
   gen2->blksperdisk = gen1->blksperdisk;
   gen2->blocksize = gen1->blocksize;
   synthio_distrcopy(&gen1->tmlimit, &gen2->tmlimit);
   synthio_distrcopy(&gen1->genintr, &gen2->genintr);
   synthio_distrcopy(&gen1->seqintr, &gen2->seqintr);
   synthio_distrcopy(&gen1->locintr, &gen2->locintr);
   synthio_distrcopy(&gen1->locdist, &gen2->locdist);
   synthio_distrcopy(&gen1->sizedist, &gen2->sizedist);
}





static int loadsynthgenerators(synthio_generator *result,
			       struct lp_list *l);


/*  static void add_gen(synthio_generator **a, int *len,  */
/*  		    synthio_generator *newgen) { */
/*    int c, newlen; */

/*    for(c = 0; c < (*len); c++) { */
/*      if(!a[c]) goto foundslot; */
/*    } */

/*    newlen = (*len) ? 2 *(*len) : 2; */
/*    a = realloc(a, newlen * sizeof(synthio_generator *)); */
/*    if(*len) */
/*      bzero(a + c, c * sizeof(synthio_generator *)); */
/*    else */
/*      bzero(a, 2 * sizeof(synthio_generator *)); */

/*   *l = newlen; */

/*   foundslot: */
/*   a[c] = newgen; */


/*  } */

int disksim_synthio_loadparams(struct lp_block *b) {

  if(!disksim->synthio_info) {
    disksim->synthio_info = DISKSIM_malloc (sizeof(synthio_info_t));
    bzero ((char *)disksim->synthio_info, sizeof(synthio_info_t));
  }

    
/*    unparse_block(b, outputfile); */

#include "modules/disksim_synthio_param.c"

  return 1;
}


static int loadgen(struct lp_block *b, synthio_generator **result);

static int loadsynthgenerators(synthio_generator *junk,
			       struct lp_list *l)
{
  int c;
  process *procp;
  int slot = 0;

  if(synthio_gens) {
    fprintf(stderr, "*** error: tried to redefine synth. I/O generators.\n");
    return -1;
  }

  synthio_gens = malloc(l->values_len * sizeof(synthio_generator));
  bzero(synthio_gens, l->values_len * sizeof(synthio_generator));
  disksim->synthio_info->synthio_gens_len = l->values_len;

  for(c = 0; c < l->values_len; c++) {
    if(!l->values[c]) continue;

    if(l->values[c]->t != BLOCK) {
      fprintf(stderr, "*** error: bad synthio io generator spec -- must be a block.\n");
      return -1;
    }

    if(loadgen(l->values[c]->v.b, &synthio_gens[slot]))
      return -1;

    slot++;
  }

  for(c = 0; c < slot; c++) {
    procp = pf_new_process(); 
    procp->space = synthio_gens[c];
    synthio_gens[c]->number = c;
  }

  synthio_gencnt = slot;
  return 0;
}


static char *distnames[] = {
  "uniform",
  "normal",
  "exponential",
  "poisson",
  "twovalue"
};

static int distname(char *name) {
  int c;
  for(c = SYNTHIO_UNIFORM; c <= SYNTHIO_TWOVALUE; c++) {
    if(!strcmp(name, distnames[c])) return c;
  }
  return -1;
}

static int loaddistn(struct lp_list *l, struct dist *result) {
  int d;
  char *type;

  if(!l->values[0]) {
    return -1;
  }
  else if(l->values[0]->t != S) {
    return -1;
  }
  type = l->values[0]->v.s;

  result->type = distname(type);
  switch(result->type) {

  case SYNTHIO_UNIFORM:
    if(l->values_len < 3) {

    }
    for(d = 1; d <= 3; d++) {
      if(!l->values[d]) { }
      else if(l->values[d]->t != D) { }
    }

    result->base = l->values[1]->v.d;
    result->var = l->values[2]->v.d;
    break;

  case SYNTHIO_NORMAL:
    if(l->values_len < 3) {

    }
    for(d = 1; d <= 3; d++) {
      if(!l->values[d]) { }
      else if(l->values[d]->t != D) { }
    }

/*      result->base = l->values[1]->v.d; */
    result->mean = l->values[1]->v.d; 
    result->var = l->values[2]->v.d;
    break;

  case SYNTHIO_EXPONENTIAL:
    if(l->values_len < 3) {

    }
    for(d = 1; d <= 3; d++) {
      if(!l->values[d]) { }
      else if(l->values[d]->t != D) { }
    }

    result->base = l->values[1]->v.d;
    result->mean = l->values[2]->v.d;
    break;

  case SYNTHIO_POISSON:
    if(l->values_len < 3) {

    }
    for(d = 1; d <= 3; d++) {
      if(!l->values[d]) { }
      else if(l->values[d]->t != D) { }
    }

    result->base = l->values[1]->v.d;
    result->mean = l->values[2]->v.d;
    break;

  case SYNTHIO_TWOVALUE:
    if(l->values_len < 4) {

    }
    for(d = 1; d <= 4; d++) {
      if(!l->values[d]) { }
      else if(l->values[d]->t != D) { }
    }

    result->base = l->values[1]->v.d;
    result->mean = l->values[2]->v.d;
    result->var = l->values[3]->v.d;
    if(!RANGE(result->var,0.0,1.0)) {

    }
    break;

  default:
    fprintf(stderr, "*** error: unknown distribution: %s\n", type);
    return -1;
    break;
  }


  return 0;
}

/* this is a dummy that should never be called */
int disksim_synthgen_loadparams(struct lp_block *b) { 
  ddbg_assert2(0, "this is a dummy that isn't supposed to be called");
  return 0;
}

static int loadsynthdevs(synthio_generator *result, struct lp_list *l);

static int loadgen(struct lp_block *b, synthio_generator **result) {

  (*result) = malloc(sizeof(synthio_generator));
  bzero((*result), sizeof(synthio_generator));

#include "modules/disksim_synthgen_param.c"


  (*result)->numblocks = (*result)->sectsperdisk * (*result)->numdisks; 
  (*result)->blksperdisk = (*result)->sectsperdisk / (*result)->blocksize;

  return 0;
}



static int loadsynthdevs(synthio_generator *result, struct lp_list *l)
{
  int c;
  int num, type;
  char *name;
  int slot = 0;

  result->devno = malloc(l->values_len * sizeof(int));
  bzero(result->devno, l->values_len * sizeof(int));
  
  for(c = 0; c < l->values_len; c++) {
    if(!l->values[c]) continue;
    if(l->values[c]->t != S) {
      /* error */
      return -1;
    }
    name = l->values[c]->v.s;
    
    if(!getdevbyname(name, &num, 0, &type)) {
      if(!getlogorgbyname(sysorgs, numsysorgs, name, &num)) {
	fprintf(stderr, "*** error: bad device %s in synthetic generator spec: no such device or logorg.\n", name);
	return -1;
      }
    }

    result->devno[slot++] = num;
  }


  result->numdisks = slot;

  return 0;
}