rf_demo.c

RAIDFrame是个非常好的磁盘阵列RAID仿真工具

      rf_UpdateMeter(recon_pctg_meter, recon_pctg);
    }
   
    switch (rf_demo_op_mode){
       case RF_DEMO_FAULT_FREE:  
         resptime = (user_ios_so_far != 0) ? user_resp_time_sum_ms / user_ios_so_far : 0;
         if (resptime && (ff_avg_resp_time_meter >=0)) 
		rf_UpdateMeter(ff_avg_resp_time_meter, resptime);
         user_ios_ff += user_ios_so_far;
	 user_resp_time_sum_ff += user_resp_time_sum_ms;
	 break;
       case RF_DEMO_DEGRADED:
         resptime = (user_ios_so_far != 0) ? user_resp_time_sum_ms / user_ios_so_far : 0;
         if (resptime &&(deg_avg_resp_time_meter >=0)) 
		rf_UpdateMeter(deg_avg_resp_time_meter, resptime);
	 user_ios_deg += user_ios_so_far;
	 user_resp_time_sum_deg += user_resp_time_sum_ms;
       case RF_DEMO_RECON:
         resptime = (user_ios_so_far != 0) ? user_resp_time_sum_ms / user_ios_so_far : 0;
         if (resptime && (recon_avg_resp_time_meter >= 0)) 
		rf_UpdateMeter(recon_avg_resp_time_meter, resptime);
	 user_ios_recon += user_ios_so_far;
	 user_resp_time_sum_recon += user_resp_time_sum_ms;
	 break;
       default: printf("WARNING: demo meter update thread: Invalid op mode! \n");
    }
    user_ios_so_far = 0;
    user_resp_time_sum_ms = 0;
#ifndef SIMULATE
    RF_DELAY_THREAD(1,0);
  }
#endif /* !SIMULATE */
}

void rf_finish_iops_demo()
{
  long status;

  if (!iops_initialized) return;
  iops_initialized = 0;              /* make sure any subsequent update calls don't do anything */
  meter_update_terminate = 1;
#ifndef SIMULATE
  pthread_join(update_thread_desc, (pthread_addr_t)&status);
#endif /* !SIMULATE */

  rf_DestroyMeter(user_iops_meter, (doMax) ? 1 : 0);
  rf_DestroyMeter(disk_iops_meter, (doMax) ? 1 : 0);
  rf_DestroyMeter(max_user_meter, 0);
  rf_DestroyMeter(max_disk_meter, 0);
  rf_DestroyMeter(avg_resp_time_meter, 0);
  rf_mutex_destroy(&iops_mutex);
}

void rf_demo_update_mode(arg_mode)
  int  arg_mode;
{
  int hpos;
  char buf[100], title[100];

  switch (rf_demo_op_mode = arg_mode) {
  case RF_DEMO_DEGRADED: 

    /* freeze fault-free response time meter; create degraded mode meter */
    hpos=rf_demoMeterHpos+2; 
    sprintf(buf, "%dx%d-%d+%d",RF_DEMO_METER_WIDTH, RF_DEMO_METER_HEIGHT, hpos * (RF_DEMO_METER_WIDTH+RF_DEMO_METER_SPACING), vpos * (RF_DEMO_METER_HEIGHT+RF_DEMO_METER_VSPACE));
    sprintf(title,"Degraded Mode Average Response Time (ms)",demoMeterTags[rf_demoMeterTag]);
    deg_avg_resp_time_meter = rf_CreateMeter(title, buf, "purple");
    rf_UpdateMeter(ff_avg_resp_time_meter, (user_ios_ff == 0)? 0: user_resp_time_sum_ff/user_ios_ff);
    break;

  case RF_DEMO_RECON:

    /* freeze degraded mode response time meter; create recon meters */
    hpos = rf_demoMeterHpos+1;
    sprintf(buf, "%dx%d-%d+%d",RF_DEMO_METER_WIDTH, RF_DEMO_METER_HEIGHT, hpos * (RF_DEMO_METER_WIDTH+RF_DEMO_METER_SPACING), vpos * (RF_DEMO_METER_HEIGHT+RF_DEMO_METER_VSPACE));
    sprintf(title,"Reconstruction Average Response Time (ms)",demoMeterTags[rf_demoMeterTag]);
    recon_avg_resp_time_meter  = rf_CreateMeter(title, buf, "darkgreen");
    sprintf(buf, "%dx%d-%d+%d",RF_DEMO_METER_WIDTH, RF_DEMO_METER_HEIGHT, (rf_demoMeterHpos) * (RF_DEMO_METER_WIDTH + RF_DEMO_METER_SPACING), vpos * (RF_DEMO_METER_HEIGHT+RF_DEMO_METER_VSPACE));
     sprintf(title,"Percent Complete / Recon Time");     
     recon_pctg_meter = rf_CreateMeter(title,buf,"red");
    rf_UpdateMeter(deg_avg_resp_time_meter, (user_ios_deg == 0)? 0: user_resp_time_sum_deg/user_ios_deg);
   break;

  default: /*do nothing -- finish_recon_demo will update rest of meters */;
  }
   
}


/****************************************************************************************
 * reconstruction demo code
 ***************************************************************************************/


void rf_startup_recon_demo(meter_vpos, C, G, init)
  int  meter_vpos;
  int  C;
  int  G;
  int  init;
{
  char buf[100], title[100];
  int rc;

  vpos = meter_vpos;
  if (init) {
      /* init demo -- display ff resp time meter */
     sprintf(buf, "%dx%d-%d+%d",RF_DEMO_METER_WIDTH, RF_DEMO_METER_HEIGHT, (rf_demoMeterHpos+3) * (RF_DEMO_METER_WIDTH+RF_DEMO_METER_SPACING), vpos * (RF_DEMO_METER_HEIGHT+RF_DEMO_METER_VSPACE));
     sprintf(title,"%s %d/%d Fault-Free Avg User Resp Time (ms)",demoMeterTags[rf_demoMeterTag],C,G);
     ff_avg_resp_time_meter  = rf_CreateMeter(title, buf, "blue");
  }  
  rc = rf_mutex_init(&iops_mutex);
  if (rc) {
    RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
      __LINE__, rc);
  }

  meter_update_terminate = 0;
#ifndef SIMULATE
  pthread_create(&update_thread_desc, raidframe_attr_default, (pthread_startroutine_t)rf_meter_update_thread, NULL);
#endif /* !SIMULATE */
  gettimeofday(&iops_starttime, NULL);
  recon_initialized = 1;
}

void rf_update_recon_meter(val)
  int  val;
{
  recon_pctg = val;
}


void rf_finish_recon_demo(etime)
  struct timeval  *etime;
{
  long status;
  int hpos;

  hpos = rf_demoMeterHpos;

  recon_initialized = 0;         /* make sure any subsequent 
				update calls don't do anything */
  recon_pctg = etime->tv_sec;      /* display recon time on meter */

  rf_UpdateMeter(recon_avg_resp_time_meter, (user_ios_recon == 0)? 0: user_resp_time_sum_recon/user_ios_recon);

  rf_UpdateMeter(recon_pctg_meter, etime->tv_sec);

  meter_update_terminate = 1;

#ifndef SIMULATE
  pthread_join(update_thread_desc, (pthread_addr_t)&status);   /* join the meter update thread */
#endif /* !SIMULATE */
  rf_DestroyMeter(recon_pctg_meter, 0);
  rf_DestroyMeter(ff_avg_resp_time_meter, 0);
  rf_DestroyMeter(deg_avg_resp_time_meter, 0);
  rf_DestroyMeter(recon_avg_resp_time_meter, 0);
  rf_mutex_destroy(&iops_mutex);
}


/****************************************************************************************
 * meter manipulation code
 ***************************************************************************************/

#define MAXMETERS 50
static struct meter_info { int sd; int pid; char name[100]; } minfo[MAXMETERS];
static int meter_num = 0;

int rf_ConfigureMeters()
{
  int i;
  for (i=0; i<MAXMETERS; i++)
    minfo[i].sd = -1;
  return(0);
}

/* forks a dmeter process to create a 4-digit meter window
 * "title" appears in the title bar of the meter window
 * returns an integer handle (really a socket descriptor) by which
 * the new meter can be accessed.
 */
static int rf_CreateMeter(title, geom, color)
  char  *title;
  char  *geom;
  char  *color;
{
  char geombuf[100], *clr;
  int sd, pid, i, status;
  struct sockaddr sa;

  if (!geom) sprintf(geombuf,"120x40-0+%d", 50*meter_num); else sprintf(geombuf, "%s", geom);
  clr = (color) ? color : "black";
  sprintf(minfo[meter_num].name,"/tmp/xm_%d",meter_num);
  unlink(minfo[meter_num].name);

  if ( !(pid = fork()) ) {
    execlp("dmeter","dmeter","-noscroll","-t",title,"-geometry",geombuf,"-sa",minfo[meter_num].name,"-fg",clr,NULL);
    perror("rf_CreateMeter: exec failed");
    return(-1);
  }

  sd = socket(AF_UNIX,SOCK_STREAM,0);
  sa.sa_family = AF_UNIX;
  strcpy(sa.sa_data, minfo[meter_num].name);
  for (i=0; i<50; i++) {        /* this give us 25 seconds to get the meter running */
    if ( (status = connect(sd,&sa,sizeof(sa))) != -1) break;
#ifdef SIMULATE
    sleep (1);
#else /* SIMULATE */
   RF_DELAY_THREAD(0, 500);
#endif /* SIMULATE */
  }
  if (status == -1) {
    perror("Unable to connect to meter");
    exit(1);
  }
  minfo[meter_num].sd = sd;
  minfo[meter_num].pid = pid;
  return(meter_num++);
}

/* causes the meter to display the given value */
void rf_UpdateMeter(meterid, value)
  int  meterid;
  int  value;
{
  if (write(minfo[meterid].sd, &value, sizeof(int)) < sizeof(int)) {
    fprintf(stderr,"Unable to write to meter %d\n",meterid);
  }
}

void rf_DestroyMeter(meterid, killproc)
  int  meterid;
  int  killproc;
{
  close(minfo[meterid].sd);
  if (killproc) kill(minfo[meterid].pid, SIGTERM);
  minfo[meterid].sd = -1;
}

int rf_ShutdownAllMeters()
{
  int i;

  for (i=0; i<MAXMETERS; i++)
    if (minfo[i].sd >= 0)
      rf_DestroyMeter(i, 0);
  return(0);
}

#endif /* RF_DEMO > 0 */