rf_genplot.c

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

/*
 * rf_genplot.c
 *
 * Jim Zelenka, CMU/SCS, 11 Jun 1996
 */
/*
 * Copyright (c) 1996 Carnegie-Mellon University.
 * All rights reserved.
 *
 * Authors: Jim Zelenka, Dan Stodolsky
 *
 * Permission to use, copy, modify and distribute this software and
 * its documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 *
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 *
 * Carnegie Mellon requests users of this software to return to
 *
 *  Software Distribution Coordinator  or  [e-mail]
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 *
 * any improvements or extensions that they make and grant Carnegie the
 * rights to redistribute these changes.
 */

typedef unsigned U32; /* luv, DEC */

#include "rf_threadstuff.h"
#include "rf_types.h"
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#ifdef __osf__
#include <sys/utctime.h>
#include <machine/hal/hal_sysinfo.h>
#endif /* __osf__ */
#include <sys/param.h>
#include "rf_raid.h"
#include "rf_dag.h"
#include "rf_threadid.h"
#include "rf_randmacros.h"
#include "rf_parityscan.h"
#include "rf_etimer.h"
#include "rf_script.h"
#include "rf_mcpair.h"
#include "rf_configure.h"
#include "rf_stripelocks.h"
#include "rf_general.h"
#include "rf_utils.h"
#include "rf_testcode.h"
#include "rf_driver.h"
#include "rf_cpuutil.h"
#include "rf_map.h"
#include "rf_dagutils.h"
#include "rf_copyback.h"
#include "rf_raidframe.h"
#include "rf_sys.h"

#if RF_CMU_PDL > 0 && !defined(SIMULATE)
#include <pdl/pdldev.h>
#include <pdl/ccdvar.h>
#include <sys/dkusage.h>
#include <io/cam/scsi_special.h>
#endif /* RF_CMU_PDL > 0 && !SIMULATE */

#ifdef SIMULATE
#include "rf_desc.h"
#include "rf_owner.h"
#include "rf_diskevent.h"
#include "rf_diskthreads.h"
#endif /* SIMULATE */

#ifdef USEC_PER_SEC
#undef USEC_PER_SEC
#endif /* USEC_PER_SEC */
#define USEC_PER_SEC 1000000

char *rf_gp_progname;

/* config params */
static int doplot = 0;
static int runscript = 1;

static char cmd[8192];
static char batch_filename[MAXPATHLEN];

#define TITLELEN 512
static int ncfg;
static char title[TITLELEN];
static char subtitle[TITLELEN];
static char out_filename[MAXPATHLEN];
static char out_ps_filename[MAXPATHLEN];
static char out_mif_filename[MAXPATHLEN];
#if RF_CMU_PDL > 0 && !defined(SIMULATE)
static char out_cpu_filename[MAXPATHLEN];
static char out_cpu_ps_filename[MAXPATHLEN];
static char out_cpu_mif_filename[MAXPATHLEN];
#endif /* RF_CMU_PDL > 0 && !SIMULATE */
static double xmin, xmax, ymin, ymax;
static double xtickmajor, xtickminor, ytickmajor, ytickminor;
static char *kdevname = NULL;
static int nokey = 0;

struct graphsym {
  char *symbol;
  char *symbol_size;
  char *symbol_fill;
  char *color;
  char *linestyle;
};

static struct graphsym gsyms[] = {
  {"2", "1", "0", "1", "1"},
  {"3", "1", "0", "1", "1"},
  {"4", "1", "0", "1", "1"},
  {"5", "1", "0", "1", "1"},
  {"8", "1", "0", "1", "1"},
  {"10", "1", "0", "1", "1"},
  {"9", "1", "0", "1", "1"},
  {"11", "1", "0", "1", "1"}
};

#define NUM_SYMS (sizeof(gsyms)/sizeof(struct graphsym))

struct plconfig {
  char  config_name[MAXPATHLEN];
  char  plot_name[MAXPATHLEN];
  struct plconfig *next;
};

struct workload {
  char  script_name[MAXPATHLEN];
  struct workload *next;
};

static void free_workload(w)
  struct workload  *w;
{
  free(w);
}

static struct workload *get_workload()
{
  struct workload *w;

  w = (struct workload *)malloc(sizeof(struct workload));
  if (w == NULL) {
    fprintf(stderr, "ERROR: out of memory\n");
    exit(1);
  }
  w->next = NULL;
  return(w);
}

static void free_plconfig(p)
  struct plconfig  *p;
{
  free(p);
}

static struct plconfig *get_plconfig()
{
  struct plconfig *p;

  p = (struct plconfig *)malloc(sizeof(struct plconfig));
  if (p == NULL) {
    fprintf(stderr, "ERROR: out of memory\n");
    exit(1);
  }
  p->next = NULL;
  return(p);
}

static int doScriptTest(raidPtr, scriptname, listp)
  RF_Raid_t           *raidPtr;
  char                *scriptname;
  RF_ShutdownList_t  **listp;
{
  RF_Script_t *script;
  RF_GRpair_t *grp, *fgrp;
  int rc;
  long nthreads;
#ifndef SIMULATE
  RF_Thread_t *threads, fthread;
  RF_ThreadAttr_t attr;
#endif /* !SIMULATE */
  int status, i;
  char buf[10];

  grp = rf_GetGrpair(listp);
  if (grp == NULL) {
    RF_PANIC();
  }
  grp->raidPtr = raidPtr;
  fgrp = rf_GetGrpair(listp);
  if (fgrp == NULL) {
    RF_PANIC();
  }
  fgrp->raidPtr = raidPtr;

  nthreads =0;

  script = ConfigureScript(scriptname, raidPtr->totalSectors, &nthreads);
  if (script == NULL) {
    printf("bad script %s\n", scriptname);
    exit(1);
  }
  grp->script = script;
  rf_testcode_degr_mode_type = 'n';

  if ((rf_testcode_degr_mode_type == 'c') || (rf_testcode_degr_mode_type == '2')) {
    rf_FailDisk(raidPtr, 0, 0, 0);
    if (rf_testcode_degr_mode_type == '2') {
      rf_FailDisk(raidPtr, 0, 1, 0);
    }
  }

#ifdef SIMULATE
  RF_INIT_RANDOM(1);

  RunScriptTestFunc(grp, nthreads);
#else /* SIMULATE */

  grp->script = script;
  RF_Malloc(threads, nthreads*sizeof(RF_Thread_t), (RF_Thread_t *));
  for (i=0; i<nthreads; i++) {
    if (RF_CREATE_THREAD(threads[i], ScriptTestFunc, grp)) {
      RF_ERRORMSG("Unable to create ScriptTestFunc thread!\n");
      exit(1);
    }
    RF_THREADGROUP_STARTED(&grp->group);
  }
  RF_THREADGROUP_WAIT_START(&grp->group);
  
  rf_start_cpu_monitor();

  if (rf_testcode_degr_mode_type == 'r' || rf_testcode_degr_mode_type == 'a' ) {
    if (RF_CREATE_THREAD(fthread, DiskFailingThread, fgrp)) {
      RF_ERRORMSG("Unable to create disk failing thread\n");
      exit(1);
    }
    RF_THREADGROUP_STARTED(&fgrp->group);
    RF_THREADGROUP_WAIT_START(&fgrp->group);
    RF_THREADGROUP_WAIT_STOP(&fgrp->group);
    rf_terminate_script_test = 1;
  }
  else {
    rf_start_cpu_monitor();
  }

  RF_THREADGROUP_WAIT_STOP(&grp->group);
  if (rf_testcode_degr_mode_type != 'r') {
    rf_stop_cpu_monitor();
    rf_print_cpu_util("script run");
  }
  RF_Free(threads, nthreads*sizeof(RF_Thread_t));
#endif /* SIMULATE */
  ShutdownScript(script);
}

#if RF_CMU_PDL > 0 && !defined(SIMULATE)
int PDL_get_total_idle_time(int fd, struct timespec *ts)
{
  PDL_idle_stats is;
  int rc;

  rc = ioctl(fd, PDL_GET_IDLE_STATS, &is);
  *ts = is.idle_time;
  return(rc);
}

/*
 * Striper test
 */
static void sdo_run_script(
  char       *cfg_name,
  char       *script_name,
  RF_uint64  *num_iosp,
  double     *ios_per_secp,
  double     *response_timep,
  double     *cpu_utilp)
{
  unsigned long before_rpcc, after_rpcc, ctimer_ticks_per_sec, rsec, rnsec;
  double sec, before_idle_sec, after_idle_sec, idle_sec;
  timespec_t before_idle_ts, after_idle_ts, idle_ts;
  struct timeval before, after, total_tv, elapsed;
  int dev_fd, rc, keep, i, gook;
  struct ccdiotime ccdt;
  struct ccddevice ccd;
  dku_get_dev_t dkudev;
  RF_Config_t *config;
  dku_dev_t *dev;
  RF_uint64 nio;
  int pdl_fd;

  *ios_per_secp = *response_timep = *cpu_utilp = 0.0;
  *num_iosp = 0;

  config = (RF_Config_t *)malloc(sizeof(RF_Config_t));

  rc = rf_get_cpu_ticks_per_sec((long *)&ctimer_ticks_per_sec);
  if (rc) {
    perror("rf_get_cpu_ticks_per_sec");
    exit(1);
  }

  pdl_fd = open("/dev/pdl", O_RDWR);
  if (pdl_fd < 0) {
    perror("pdl_fd");
    exit(1);
  }
  dev_fd = open(kdevname, O_RDWR);
  if (dev_fd < 0) {
    perror(kdevname);
    fprintf(stderr, "ERROR: could not open %s\n", kdevname);
    exit(1);
  }

  rc = rf_MakeConfig(cfg_name, config);
  if (rc) {
    fprintf(stderr, "ERROR: rc=%d reading %s\n", rc, cfg_name);
    exit(1);
  }

  /*
   * Shut down any old config.
   * Ignore return val- if it's not configged, that's
   * an error, but I don't care.
   */
  gook = 0;
  ioctl(dev_fd, CCDIOCUNCONFIG, &gook);

  ccd.ccd_unit = 0;
  /*
   * XXX assumes 512-byte sectors
   */
  ccd.ccd_interleave = (config->sectPerSU << 9) >> DEV_BSHIFT;
  if (config->numRow != 1) {
    fprintf(stderr, "ERROR: no logical equivalent of multi-row arrays in striper\n");
    exit(1);
  }
  for(i=0;i<config->numCol;i++) {
    ccd.ccd_dev[i] = config->devs[0][i];
    strcpy(ccd.ccd_devname[i], config->devnames[0][i]);
    ccd.ccd_maxreq.len[i] = config->maxOutstandingDiskReqs;
  }
  for(;i<NCCDISKS;i++) {
    ccd.ccd_dev[i] = NODEV;
    ccd.ccd_devname[i][0] = '\0';
    ccd.ccd_maxreq.len[i] = config->maxOutstandingDiskReqs;
  }
  ccd.ccd_flags = 0;
  if (!strcasecmp(config->diskQueueType, "cscan")) {
    ccd.ccd_flags |= CCDF_ONEWAY;
  }
  else if (!strcasecmp(config->diskQueueType, "fifo")) {
    ccd.ccd_flags |= CCDF_FIFOQ;
  }
  else if (strcasecmp(config->diskQueueType, "scan")) {
    fprintf(stderr, "WARNING: disk queue type \"%s\" not directly supported by the striper\n",
      config->diskQueueType);
    fprintf(stderr, "         striper defaults to SCAN sorting (two-way elevator)\n");
    fflush(stderr);
  }

  rc = ioctl(dev_fd, CCDIOCCONFIG, &ccd);
  if (rc) {
    perror("CCDIOCCONFIG");
    exit(1);
  }

  sync(); sync(); sync();

  rc = ioctl(dev_fd, SCSI_DKU_RESET_DEV);
  if (rc) {
    perror("SCSI_DKU_RESET_DEV");
    exit(1);
  }

  rc = ioctl(dev_fd, CCDIOCCIOTIME);
  if (rc) {
    perror("CCDIOCCIOTIME");
    exit(1);
  }

  rc = PDL_get_total_idle_time(pdl_fd, &before_idle_ts);
  if (rc < 0) {
    perror("PDL_get_total_idle_time");
    exit(1);
  }
  before_rpcc = 0xffffffff & rf_rpcc();
  gettimeofday(&before, 0);

  play_trace(script_name, kdevname);

  after_rpcc = 0xffffffff & rf_rpcc();
  gettimeofday(&after, 0);
  rc = PDL_get_total_idle_time(pdl_fd, &after_idle_ts);
  if (rc < 0) {
    perror("PDL_get_total_idle_time");
    exit(1);
  }

  rc = ioctl(dev_fd, SCSI_DKU_DEV, &dkudev);
  if (rc) {
    perror("SCSI_DKU_DEV");
    exit(1);
  }
  rc = ioctl(dev_fd, CCDIOCGIOTIME, &ccdt);
  if (rc) {
    perror("CCDIOCGIOTIME");
    exit(1);
  }

  /*
   * Dan's magic timing code
   */
	{
	unsigned long wraps;
	unsigned long wrap_time = ((unsigned long)0xffffffff);
	
	wrap_time /= (ctimer_ticks_per_sec/100);
	wraps = 100 * ((unsigned long) after.tv_sec - before.tv_sec);
	wraps /= wrap_time;
	if (wraps && ( after_rpcc <= before_rpcc ))
		wraps--;
	
	wrap_time = wraps * ((unsigned long)0xffffffff);
	
	rsec = wrap_time / ctimer_ticks_per_sec;