Ejemplo n.º 1
0
double start_synchronization(void)
{
  switch( current_synchronization ) {
  case SYNC_BARRIER:
    MPI_Barrier(get_measurement_comm());
    start_sync = wtime();
    break;
  case SYNC_REAL:
    logging(DBG_SYNC, "start = %9.1f ", normalize_time(wtime()));
    logging(DBG_SYNC, " -> %9.1f ", (counter+1)*interval*1.0e6 );

    if( !wait_till(should_wait_till(counter, interval, -tds[get_global_rank(0)]), 
		   &start_sync) )
      invalid[counter] = INVALID_STARTED_LATE;
    else
      invalid[counter] = False;
    logging(DBG_SYNC, "start_sync = %9.1f ", normalize_time(start_sync));
    break;
  case SYNC_NOSYNC:
    start_sync = wtime();
    break;
  default:
    error_without_abort("out of cases in measurement.c__start_synchronization() current_synchronization = %d\n", current_synchronization);
  }

  return start_sync;
}
Ejemplo n.º 2
0
/* p_val and p_to are normalized */
int add_time (timeout_t *p_to, timeout_t *p_val)
{

  /* normalize the values */
  (void) normalize_time (p_val);
  (void) normalize_time (p_to);

  /* Addition */
  (p_to->tv_sec)  += p_val->tv_sec;
  (p_to->tv_usec) += p_val->tv_usec;

  /* normalize the result */
  return (normalize_time (p_to));
}
Ejemplo n.º 3
0
INT_TIME decode_time_sdr
   (SDR_TIME	st,		/* SDR_TIME structure to decode.	*/
    int		wordorder)	/* wordorder of time contents.		*/
{
    SDR_TIME ct = st;
    EXT_TIME et;

    if (my_wordorder < 0) get_my_wordorder();
    if (my_wordorder != wordorder) {
	swab2 ((short int *)&ct.year);
	swab2 ((short int *)&ct.day);
	swab2 ((short int *)&ct.ticks);
    }
#ifdef	QLIB_DEBUG
    if (debug_option & 128) 
    fprintf (info, "time = %02d.%02d %02d:%02d:%02d:%04d\n",
	     ct.year,	ct.day,	    ct.hour,
	     ct.minute,	ct.second,  ct.ticks);
#endif
    et.year = ct.year;
    et.doy = ct.day;
    et.hour = ct.hour;
    et.minute = ct.minute;
    et.second = ct.second;
    et.usec = ct.ticks * USECS_PER_TICK;
    dy_to_mdy (et.doy, et.year, &et.month, &et.day);
    return (normalize_time(ext_to_int(et)));
}
Ejemplo n.º 4
0
/*
 ******************************************************************************
 * Function : double_to_time
 *
 * Abstract : Convert a double (seconds dot microseconds) to time
 *
 * Decisions : Normalize the result
 *
 * Input  : from  The double value to convert
 *
 * Output : p_to  address of the converted time structure
 *
 * Return : The double value of conversion
 *
 * Errors : None
 *
 * History :
 *
 *******************************************************************************
*/
extern void double_to_time (double from, timeout_t *p_to) {
  double s, u;

  /* Try to round usecs */
  if (from < HUGE / DMILLION) {
    /* Cannot round usecs: trunc them */
    s = trunc (from);
    u = trunc ((from - s) * MILLION);
  } else {
    /* Round usecs */
    u = from * DMILLION;
    u = (rint (u)) / DMILLION;
    /* Split */
    s = trunc (u);
    u = (u - s) * DMILLION;
  }

  /* Convert to ints, checking overflow */
  p_to->tv_sec = (sizeof(p_to->tv_sec) == sizeof(long) ? LONG_MAX : INT_MAX);
  if (s <= (double) p_to->tv_sec) {
    p_to->tv_sec = (time_t)s;
  }
  p_to->tv_usec = (long)u;
  normalize_time (p_to);

}
Ejemplo n.º 5
0
/* Compares 2 times (-1 if t1 < t2, 0 if t1 = t2, 1 if t1 > t2) */
int comp_time (timeout_t *p_time_1, timeout_t *p_time_2)
{
    normalize_time (p_time_1);
    normalize_time (p_time_2);

    if (p_time_1->tv_sec > p_time_2->tv_sec) {
        return (1);
    } else if (p_time_1->tv_sec < p_time_2->tv_sec) {
        return (-1);
    } else if (p_time_1->tv_usec > p_time_2->tv_usec) {
        return (1);
    } else if (p_time_1->tv_usec < p_time_2->tv_usec) {
        return (-1);
    } else {
        return (0);
    }
}
Ejemplo n.º 6
0
static void sec_gpu_utilization_handler(void *arg)
{
	u64 time_now = get_time_ns();

	struct timeval working_time;
	struct timeval period_time;

	mutex_lock(&time_data_lock);

	if (total_work_time == 0) {
		if (!hw_start_time) {

			mutex_unlock(&time_data_lock);

			sec_gpu_dvfs_handler(0);
			return;
		}
	}

	if (hw_start_time != 0) {
		total_work_time += (time_now - hw_start_time);
		hw_start_time = time_now;
	}

	/* changed way to compute the utilization */
	working_time = (struct timeval)ns_to_timeval(total_work_time);
	period_time = (struct timeval)ns_to_timeval(time_now - period_start_time);
	sgx_gpu_utilization = (normalize_time(working_time) * 256) / normalize_time(period_time);


	total_work_time = 0;
	period_start_time = time_now;

	mutex_unlock(&time_data_lock);

	sec_gpu_dvfs_handler(sgx_gpu_utilization);
}
Ejemplo n.º 7
0
ha_time_t *
parse_time(char **time_str, ha_time_t * a_time, gboolean with_offset)
{
    ha_time_t *new_time = a_time;

    tzset();
    if (a_time == NULL) {
        new_time = new_ha_date(FALSE);
    }

    CRM_CHECK(new_time != NULL, return NULL);
    CRM_CHECK(new_time->has != NULL, free_ha_date(new_time);
              return NULL);

    /* reset the time fields */
    new_time->hours = 0;
    new_time->minutes = 0;
    new_time->seconds = 0;

    crm_trace("Get hours...");
    new_time->has->hours = FALSE;
    if (parse_int(time_str, 2, 24, &new_time->hours)) {
        new_time->has->hours = TRUE;
    }

    crm_trace("Get minutes...");
    new_time->has->minutes = FALSE;
    if (parse_int(time_str, 2, 60, &new_time->minutes)) {
        new_time->has->minutes = TRUE;
    }

    crm_trace("Get seconds...");
    new_time->has->seconds = FALSE;
    if (parse_int(time_str, 2, 60, &new_time->seconds)) {
        new_time->has->seconds = TRUE;
    }

    if (with_offset) {
        crm_trace("Get offset...");
        while (isspace((int)(*time_str)[0])) {
            (*time_str)++;
        }

        new_time->offset = parse_time_offset(time_str);
        normalize_time(new_time);
    }
    return new_time;
}
Ejemplo n.º 8
0
double stop_synchronization(void)
{
  stop_batch = stop_sync = wtime();

  if( current_synchronization == SYNC_REAL ) {

    if( stop_sync - start_sync > interval )
      invalid[counter] = INVALID_TOOK_TOO_LONG;
  
    logging(DBG_SYNC, "stop_sync = %9.1f ", normalize_time(stop_sync));
    switch( invalid[counter] ) {
    case INVALID_TOOK_TOO_LONG: logging(DBG_SYNC, "invalid_too_long\n"); break;
    case INVALID_STARTED_LATE:  logging(DBG_SYNC, "invalid_started_late\n"); break;
    default:                    logging(DBG_SYNC, "\n"); 
    }
  }

  return stop_sync;
}
Ejemplo n.º 9
0
static void exec_action(int op,int arg1,int arg2)
{
  int i, j;
  char *tmpstr;

  switch(op) 
    {
    case 1000:goto_room(arg1-first_room);break;
    case 1001:goto_room(agt_rand(arg1,arg2)-first_room);break;
    case 1002:agt_var[arg1]=loc+first_room;break;
    case 1003:agt_var[arg1]=dobj;break;
    case 1004:agt_var[arg1]=iobj;break;
    case 1005:goto_room(agt_var[arg1]-first_room);break;
    case 1006:it_move(arg1,agt_var[arg2]);break;
    case 1007:get_obj(agt_var[arg1]);break;
    case 1008:msgout(agt_var[arg1],1);break;
    case 1009:get_obj(arg1);break;
    case 1010:get_obj(arg1);it_move(arg1,1000);break;
    case 1011:drop_obj(arg1);break;
    case 1012:
      if (it_loc(arg1)==1000) {
	if (PURE_WEAR) drop_obj(arg1);
	else it_move(arg1,1);
      }
      break;
    case 1013:fontcmd(0,arg1-1);break;  /* Load font */
    case 1014:pictcmd(1,pictable[arg1-1]);break;  /* Show picture */
    case 1015:changepict(arg1,arg2);break; /* ChangePicture */
    case 1016: if (PICT_SUPPORT && 
		     yesno("Would you like to see the picture?"))
      pictcmd(1,pictable[arg1-1]);break;
    case 1017:pictcmd(2,arg1);break;  /* Show room pix */
    case 1018: if (PICT_SUPPORT && 
		   yesno("Would you like to see the picture?"))
      pictcmd(2,arg1-1);break;
    case 1019:musiccmd(1,arg1-1);break;
    case 1020:musiccmd(1,agt_rand(arg1,arg2)-1);break;
    case 1021:musiccmd(2,arg1-1);break;
    case 1022:musiccmd(3,-1); break;  /* Stop Repeat */
    case 1023:musiccmd(4,-1); break;  /* Stop song */
    case 1024:musiccmd(5,-1); break;  /* Suspend song */
    case 1025:musiccmd(6,-1);break;   /* Resume song */
    case 1026: 
      if (tnoun(dobj)) 
	noun[dobj-first_noun].movable=!noun[dobj-first_noun].movable;
      break;
    case 1027: it_newdesc(arg1,&msg_ptr[arg2-1]); break;
    case 1028: 
      if (tnoun(arg1)) noun[arg1-first_noun].points=arg2;
      else if (tcreat(arg1)) creature[arg1-first_creat].points=arg2;
      else if (troom(arg1)) room[arg1-first_room].points=arg2;
      break;
    case 1029:it_destroy(iobj);break;
    case 1030:
      tmpstr=agt_readline(3);
      i=strlen(tmpstr)-1;
      if (i>0 && tmpstr[i]=='\n') tmpstr[i]=0;
      strncpy(userstr[arg1-1],tmpstr,80);
      rfree(tmpstr);
      break;
    case 1031:agt_var[arg1]=read_number();break;
    case 1032:agt_var[arg1]=curr_time;break;
    case 1033:curr_time=normalize_time(agt_var[arg1]);break; 
    case 1034:curr_time=normalize_time(arg1); break;
    case 1035:add_time(arg1);break; 
    case 1036:delta_time=arg1;break;
      /* 1037 and 1038 are subroutine commands */
    case 1039:get_obj(dobj);break;
    case 1040:it_move(dobj,1000);break;
    case 1041:drop_obj(dobj);break;
    case 1042:
      if (it_loc(dobj)==1000) {
	if (PURE_WEAR) it_move(dobj,1);
	else drop_obj(dobj);
      }
      break;
    case 1043: /* drop all */
      safecontloop(i,j,1) drop_obj(i);
      break;
    case 1044: /* remove all */
      safecontloop(i,j,1000) drop_obj(i);
      break;
    case 1045:deadflag=1;break;
    case 1046:it_move(arg1,loc+first_room);break;
    case 1047:it_move(arg1,arg2);break;
    case 1048:it_reposition(arg1,arg2,1);break; /* RePosition */
    case 1049:it_move(dobj,loc+first_room);break;
    case 1050:it_move(dobj,arg1);break;
    case 1051:
      safecontloop(i,j,1) it_move(i,arg1);
      safecontloop(i,j,1000) it_move(i,arg1);
      break;
    case 1052:
      nounloop(i)
	if (player_has(i+first_noun) && noun[i].points>arg2)
	  it_move(i+first_noun,arg1);
      break;
    case 1053:
      safecontloop(i,j,arg1) 
	if (tnoun(i)) it_move(i,arg2);
      break;
    case 1054:it_destroy(arg1);break;
    case 1055:it_destroy(dobj);break;
    case 1056:i=it_loc(arg1);
      it_move(arg1,it_loc(arg2));
      it_move(arg2,i);
      break;
    case 1057:it_move(arg1,it_loc(arg2));break;
    case 1058:it_move(dobj,it_loc(arg2));break;
    case 1059: case 1060: /* Add to/remove from group */
      if (tcreat(arg1))
	creature[arg1-first_creat].groupmemb=(op==1059);
      break;
    case 1061:   /* Move group */
      safecontloop(i,j,loc+first_room)
	if (it_group(i)) it_move(i,arg1);
      break; 
      /* 1062 is RedirectTo */
    case 1063:msgout(agt_rand(arg1,arg2),1);break;
    case 1064:print_contents(arg1,1);break;
    case 1065: case 1066: case 1067: case 1068: 
      obj_act(op-1065,arg1);break;
    case 1069: case 1070: case 1071: case 1072: 
      obj_act(op-1069,dobj);break;
    case 1073:print_score();break;
    case 1074: tscore+=arg1;break;
    case 1075: tscore-=arg1;break;
    case 1076:v_inventory();break;
    case 1077:wait_return();break;
    case 1078:writeln("Time passes...");break;
    case 1079:agt_delay(arg1);break;
    case 1080:agt_clrscr();break;
    case 1081:it_describe(arg1);break;
    case 1082:look_room();break;   /* LOOK */
    case 1083:msgout(arg1,1);break;
    case 1084:writeln("");break;
    case 1085:if (PURE_TONE && sound_on) 
	       agt_tone(arg1,arg2);break; /* Tone */
    case 1086:agt_number=ask_for_number(arg1,arg2);break;
    case 1087:agt_answer=ask_question(arg1);break;
    case 1088:change_passage(loc,arg1,arg2);break;
    case 1089:flag[arg1]=1;break;
    case 1090:flag[arg1]=0;break;
    case 1091:flag[arg1]=!flag[arg1];break;
    case 1092:room[loc].flag_noun_bits|=(1 << (arg1-1) );
      break; /* Roomflag on */ 
    case 1093:room[loc].flag_noun_bits&=~(1 << (arg1-1) );break; /* Off */ 
    case 1094:room[loc].flag_noun_bits^=(1 << (arg1-1) );break; /* Toggle */
    case 1095: /* if (agt_counter[arg1]==-1)*/
      agt_counter[arg1]=1;break;
    case 1096:agt_counter[arg1]=-1;break;
    case 1097:agt_var[arg1]=arg2;break;
    case 1098:agt_var[arg1]+=arg2;break;
    case 1099:agt_var[arg1]-=arg2;break;
    case 1100:agt_var[arg1]+=agt_var[arg2];break;
    case 1101:agt_var[arg1]-=agt_var[arg2];break;
    case 1102:agt_var[arg1]=agt_rand(0,arg2);break;
    case 1103:agt_var[arg1]=dobj_rec->num;break;
    case 1104:agt_var[arg1]=iobj_rec->num;break;
      
      /* The following are v1.8x specific */
    case 1105:quote(arg1);break;
    case 1106:add_time(arg1);break;
    case 1107:add_time(-arg1);break;
    case 1108:curr_time=(curr_time%100)+100*arg1;break;
    case 1109:curr_time=(curr_time/100)*100+arg1;break;
    case 1110:add_time(agt_var[arg1]);break;
    case 1111:add_time(-agt_var[arg1]);break;
    case 1112:curr_time=(curr_time%100)+100*agt_var[arg1];break;
    case 1113:curr_time=(curr_time/100)*100+agt_var[arg1];break;

      /* Now for the AGX additions */
    case 1114:add_time(-arg1);break; /* ME-style SubtractFromTime */
    case 1115: disambig_score=arg1; break; /* SetDisambigPriority */
    case 1116:agt_var[arg1]=delta_time;break;
    case 1117: /* ChangeStatus */
      statusmode=arg1;
      break;
    case 1118:
      if (!mult_rangecheck(agt_var[arg1],arg2)) break;
      agt_var[arg1]*=arg2;break;
    case 1119:
      if (arg2==0) {
	if (!PURE_ERROR)
	  writeln("GAME ERROR: Division by zero.");
      } else agt_var[arg1]/=arg2;
      break;
    case 1120:
      if (arg2==0) {
	if (!PURE_ERROR)
	  writeln("GAME ERROR: Attempt to divide by zero.");
      } else agt_var[arg1]%=arg2;
      break;
    case 1121:agt_waitkey();break;
    case 1122:last_he=arg1;break;   /* SetHE */
    case 1123:last_she=arg1;break;  
    case 1124:last_it=arg1;break;
    case 1125:last_they=arg1;break;
    case 1126:msgout(arg1,0);break;
    case 1127:
      if (!PURE_ERROR)
	sysmsg(arg1,"GAME ERROR: Standard message not defined.");
      break;
    case 1128: msgout(arg1,1);break; /* FailMessage */
    case 1129:  /* StdMessage */
      sysmsg(arg1,"GAME ERROR: Standard message not defined.");
      break;
    case 1130: msgout(arg2,1);break; /* ErrMessage */
    case 1131: /* StdErrMessage */
      sysmsg(arg1,"GAME ERROR: Standard message not defined.");
      break;
    case 1132: /* AND */
      break;  /* These don't do anything under normal circumstances */
    case 1133:  /* SetClass */
      if (troom(arg1)) room[arg1-first_room].oclass=arg2;
      else if (tnoun(arg1)) noun[arg1-first_noun].oclass=arg2;
      else if (tcreat(arg1)) noun[arg1-first_creat].oclass=arg2;
      break;
    case 1134: agt_var[arg1]=it_class(arg2); break; /* SetVariableToClass */
      
      /* Stack commands */
    case 1135: push_stack(arg1); break;
    case 1136: agt_var[arg1]=pop_stack(); break;
    case 1137: case 1138: case 1139: case 1140: case 1141: 
      op_stack(op-1137); /* +,-,*, /,% * */
      break;
    case 1142: { /* DupStack */
      long n;
      n=pop_stack();
      push_stack(n);
      push_stack(n);
      break;
    }    
    case 1143: pop_stack();break; /* Discard TOS */
    case 1144: agt_var[arg1]=agt_number;break; /* SetVariableToInput */
    case 1145: setattr(arg1,arg2,1); break; /* Set */
    case 1146: setattr(arg1,arg2,0); break; /* Clear */
    case 1147: push_stack(getprop(arg1,arg2));break; /* PushProp */
    case 1148: setprop(arg1,arg2,pop_stack());break; /* PopProp */
      /* 1149, 1150 handled by run_metacommand */
      /* 1151 is EndDisambig */
      /* 1152 is XRedirect */
    case 1153: rstrncpy(userstr[arg1-1],userstr[arg2-1],81);break; 
    case 1154: setcase(userstr[arg1-1],1); break;
    case 1155: setcase(userstr[arg1-1],0);break;
    case 1156: op_objflag(1,arg1,arg2);break;
    case 1157: op_objflag(0,arg1,arg2);break;
    case 1158: op_objflag(3,arg1,arg2);break;
    case 1159: push_stack(op_objprop(2,arg1,arg2,0)); break;
    case 1160: op_objprop(1,arg1,arg2,pop_stack()); break;
    case 1161: move_in_dir(arg1,arg2); break;
    default: 
      writeln("INTERNAL ERROR: Action token not supported.");
      rprintf("Action #%d",op);   
      writeln(""); 
    }
}
Ejemplo n.º 10
0
/*
 ******************************************************************************
 * Function : time_to_double
 *
 * Abstract : Convert time to double (seconds dot microseconds)
 *
 * Decisions : None
 *
 * Input  : p_time  The time to convert
 *
 * Output : None
 *
 * Return : The double value of conversion
 *
 * Errors : None
 *
 * History :
 *
 *******************************************************************************
*/
extern double time_to_double (timeout_t *p_time ) {
  normalize_time (p_time);
  return (double) p_time->tv_sec
       + ((double) p_time->tv_usec) / DMILLION;
}
Ejemplo n.º 11
0
int main(int argc, char **argv) {

	int fn,argnum,retval;
        size_t tsdata_size;
        char *iotrace_data_dir, *current_work_dir;
	/* tsdumps for the source and destination sides */
	xdd_ts_header_t *src = NULL;
	xdd_ts_header_t *dst = NULL;
	xdd_ts_header_t *tsdata = NULL;
	/* timestamp entries sorted by ending time */
	xdd_ts_tte_t **read_op = NULL;
	xdd_ts_tte_t **send_op = NULL;
	xdd_ts_tte_t **recv_op = NULL;
	xdd_ts_tte_t **write_op = NULL;

	/* get command line options */
	argnum = getoptions(argc, argv);
	fn = MAX(argnum,1);

	/* get the src or dst data structs */
	retval = xdd_readfile(argv[fn],&tsdata,&tsdata_size);
	if (retval == 0) {
  	  fprintf(stderr,"xdd_readfile() failed...reading 1st xdd timestamp file: %s ...exiting.\n",argv[fn]);
	  exit(1);
	}
        /* determine whether this is the source or destination file */
        /* if only 1 file given, then source==read, destination==write */
        if (READ_OP(tsdata->tsh_tte[0].tte_op_type)) { 
           src = tsdata;
           srcfilename = argv[fn];
	}
        else
        if (WRITE_OP(tsdata->tsh_tte[0].tte_op_type)){
	  dst = tsdata;
          dstfilename = argv[fn];
	}
        else {
           fprintf(stderr,"Timestamp dump had invalid operation in tte[0]: %s\n",argv[fn]);
           exit(1);
        }
        /* if 2nd file specified, this must be an e2e pair (src,dst) */
        if ( argv[fn+1] != NULL ) {
          /* get the src or dst data structs */
          retval = xdd_readfile(argv[fn+1],&tsdata,&tsdata_size);
	  if (retval == 0) {
	    fprintf(stderr,"xdd_readfile() failed...reading 2nd xdd timestamp file: %s ...exiting.\n",argv[fn+1]);
	    exit(1);
	  }
          /* determine whether this is the source or destination file */
          if (READ_OP(tsdata->tsh_tte[0].tte_op_type))  {
            if (src != NULL) {
              fprintf(stderr,"You passed 2 source dump files.\n");
              fprintf(stderr,"Please pass matching source and destination dumps or a single dump .\n");
              exit(1);
            }
            src = tsdata;
            srcfilename = argv[fn+1];
          }
          else 
          if (WRITE_OP(tsdata->tsh_tte[0].tte_op_type)) {
            if (dst != NULL) {
              fprintf(stderr,"You passed 2 destination dump files.\n");
              fprintf(stderr,"Please pass matching source and destination dumps or a single dump .\n");
              exit(1);
            }
            dst = tsdata;
            dstfilename = argv[fn+1];
          } 
          else {
             fprintf(stderr,"Timestamp dump had invalid operation in tte[0]: %s\n",argv[fn+1]);
             exit(1);
          }
          /* If these files are from the same transfer, they should be the same size. */
          if (src->tsh_tt_bytes != dst->tsh_tt_bytes) {
            fprintf(stderr,"Source and destination files are not the same size.\n");
            fprintf(stderr,"Please pass matching source and destination dumps.\n");
            exit(1);
          }
        }

        /* get total threads */
        if (src != NULL) xdd_getthreads(src,&total_threads_src, thread_id_src, &op_mix);
        if (dst != NULL) xdd_getthreads(dst,&total_threads_dst, thread_id_dst, &op_mix);
        /* If e2e, better have same number of threads. */
        if (total_threads_src > 0 && total_threads_dst > 0 && total_threads_src != total_threads_dst) {
          fprintf(stderr,"Warning: source (%d) and destination (%d) files don't have the same number of I/O threads.\n",
                total_threads_src, total_threads_dst);
        }

        /* match-add kernel events with xdd events if specfied */
        /* at this point, src & dst contain all xdd events     */
        /* note that iotrace_data_dir is independent of $PWD   */
        if (kernel_trace)
        {
          if ((iotrace_data_dir=getenv("TRACE_LOG_LOC")) == NULL)
               iotrace_data_dir=getenv("HOME");
               current_work_dir=getenv("PWD");
     
          if (src != NULL) {
            sprintf(kernfilename,"decode %s/dictionary* %s/iotrace_data.%d.out",
	       	iotrace_data_dir, iotrace_data_dir, src->tsh_target_thread_id);
            if ( system(kernfilename) == -1 ) {
               fprintf(stderr,"in main: shell command failed: %s\n",kernfilename);
               exit(1);
            }
            if (strcmp(iotrace_data_dir,current_work_dir) != 0) {
              sprintf(kernfilename,"mv %s/iotrace_data.%d.out.ascii %s",
	  	iotrace_data_dir, src->tsh_target_thread_id,getenv("PWD"));
              if ( system(kernfilename) == -1 ) {
                 fprintf(stderr,"in main: shell command failed: %s\n",kernfilename);
                 exit(1);
              }
            }
            sprintf(kernfilename,"%s/iotrace_data.%d.out.ascii",
                current_work_dir, src->tsh_target_thread_id);
            matchadd_kernel_events(1,total_threads_src,thread_id_src,kernfilename,src);
            if (op_mix > 0.0)
            matchadd_kernel_events(0,total_threads_src,thread_id_src,kernfilename,src);
            /* write out the src and dst data structs that now contain kernel data */
            sprintf(kernfilename,"%s/%sk", current_work_dir, srcfilename);
            retval = xdd_writefile(kernfilename,src,tsdata_size);
            if (retval == 0) {
		fprintf(stderr,"xdd_writefile() failed to write %s ...exiting.\n",kernfilename);
		exit(1);
	    }
          }

          if (dst != NULL) {
            sprintf(kernfilename,"decode %s/dictionary* %s/iotrace_data.%d.out",
		iotrace_data_dir, iotrace_data_dir, dst->tsh_target_thread_id);
            if ( system(kernfilename) == -1 ) {
               fprintf(stderr,"in main: shell command failed: %s\n",kernfilename);
               exit(1);
            }
            if (strcmp(iotrace_data_dir,current_work_dir) != 0) {
              sprintf(kernfilename,"mv %s/iotrace_data.%d.out.ascii %s",
		iotrace_data_dir, dst->tsh_target_thread_id,getenv("PWD"));
              if ( system(kernfilename) == -1 ) {
                 fprintf(stderr,"in main: shell command failed: %s\n",kernfilename);
                 exit(1);
              }
            }
            sprintf(kernfilename,"%s/iotrace_data.%d.out.ascii",
                current_work_dir, dst->tsh_target_thread_id);
            matchadd_kernel_events(0,total_threads_dst,thread_id_dst,kernfilename,dst);
            if (op_mix > 0.0)
            matchadd_kernel_events(1,total_threads_dst,thread_id_dst,kernfilename,dst);
            sprintf(kernfilename,"%s/%sk", current_work_dir, dstfilename);
            retval = xdd_writefile(kernfilename,dst,tsdata_size);
            if (retval == 0) {
		fprintf(stderr,"xdd_writefile() failed to write %s ...exiting.\n",kernfilename);
		exit(1);
	    }
          }

        }

	/* get the MIN timestamp normalize the times */
	if (src!=NULL) normalize_time(src,&src_start_norm);
	if (dst!=NULL) normalize_time(dst,&dst_start_norm);

	/* sort timestamp entries for each operation (read/send/recv/write) */
        /* kernel events are co-located with matching xdd op */
        if (src!=NULL) {
          sort_by_time(src, DISK_END, &read_op);
          if (dst!=NULL) {
          sort_by_time(src, NET_END,  &send_op);
          }
        }
        if (dst!=NULL) {
          sort_by_time(dst, DISK_END, &write_op);
          if (src!=NULL) {
          sort_by_time(dst, NET_END,  &recv_op);
          }
        }

	/* write the outfile(s) */
        write_outfile  (src,dst,read_op,send_op,recv_op,write_op);

	/* free memory */
	free(read_op);
	free(send_op);
	free(recv_op);
	free(write_op);
	free(src);
	free(dst);

	return 0;
}