Robust/TransSim/Executor.java

   1 import java.util.Random;
   2 import java.io.FileInputStream;
   3 import java.io.InputStream;
   4 import java.io.BufferedInputStream;
   5 import java.util.Vector;
   6
   7 public class Executor {
   8   int numThreads;
   9   int numTrans;
  10   int deltaTrans;
  11   int numObjects;
  12   int numAccesses;
  13   int deltaAccesses;
  14   int delay;
  15   int deltaDelay;
  16   int nonTrans;
  17   int deltaNonTrans;
  18   int readPercent;
  19   Random r;
  20   ThreadClass[] threads;
  21   int splitobjects;
  22   int splitaccesses;
  23   int readPercentSecond;
  24
  25   public String toString() {
  26     String s="";
  27     for(int i=0;i<numThreads;i++)
  28       s+=threads[i].toString();
  29
  30     return s;
  31   }
  32
  33   public Executor(int numThreads, int numTrans, int deltaTrans, int numObjects, int numAccesses, int deltaAccesses, int readPercent, int delay, int deltaDelay, int nonTrans, int deltaNonTrans) {
  34     this(numThreads, numTrans, deltaTrans, numObjects, numAccesses, deltaAccesses, readPercent, delay, deltaDelay, nonTrans, deltaNonTrans, 100, 100, 0);
  35   }
  36
  37   public static int readInt(InputStream is) {
  38     try {
  39       int b1=is.read();
  40       int b2=is.read();
  41       int b3=is.read();
  42       int b4=is.read();
  43       int retval=(b4<<24)|(b3<<16)|(b2<<8)|b1;
  44       if (retval<0)
  45         throw new Error();
  46       return retval;
  47     } catch (Exception e) {
  48       throw new Error();
  49     }
  50   }
  51
  52   public static long readLong(InputStream is) {
  53     try {
  54     long b1=is.read();
  55     long b2=is.read();
  56     long b3=is.read();
  57     long b4=is.read();
  58     long b5=is.read();
  59     long b6=is.read();
  60     long b7=is.read();
  61     long b8=is.read();
  62     long retval=(b8<<56)|(b7<<48)|(b6<<40)|(b5<<32)|
  63         (b4<<24)|(b3<<16)|(b2<<8)|b1;
  64     if (retval<0)
  65       throw new Error();
  66     return retval;
  67     } catch (Exception e) {
  68       throw new Error();
  69     }
  70   }
  71
  72   public Executor(String filename) {
  73     BufferedInputStream bir=null;
  74     try {
  75       bir=new BufferedInputStream(new FileInputStream(filename));
  76     } catch (Exception e) {
  77       e.printStackTrace();
  78       System.exit(-1);
  79     }
  80     numThreads=readInt(bir);
  81     threads=new ThreadClass[numThreads];
  82     long earliest=-1;
  83     for(int i=0;i<numThreads;i++) {
  84       System.out.println("Loading thread "+i+" of "+numThreads);
  85       threads[i]=readThread(bir);
  86       long inittime=threads[i].trans[0].getTime(0);
  87       if (earliest==-1||earliest>inittime) {
  88         earliest=inittime;
  89       }
  90     }
  91     for(int i=0;i<numThreads;i++) {
  92       long inittime=threads[i].trans[0].getTime(0);
  93       assert(threads[i].trans[0].numEvents()==1);
  94       threads[i].trans[0].setTime(0, inittime-earliest);
  95     }
  96   }
  97
  98   public static final int EV_THREAD=0;
  99   public static final int EV_ENTERBARRIER=1;
 100   public static final int EV_READ=2;
 101   public static final int EV_WRITE=3;
 102   public static final int EV_START=4;
 103   public static final int EV_COMMIT=5;
 104   public static final int EV_ABORT=6;
 105   public static final int EV_ARRAYREAD=7;
 106   public static final int EV_ARRAYWRITE=8;
 107   public static final int EV_EXITBARRIER=9;
 108
 109   private Transaction createTransaction(Vector<TEvent> v, boolean started) {
 110     Transaction t=new Transaction(v.size(),started);
 111     for(int i=0;i<v.size();i++) {
 112       TEvent e=v.get(i);
 113       t.setTime(i,e.time);
 114       t.setEvent(i,e.type);
 115       t.setObject(i,e.oid);
 116       t.setIndex(i,e.index);
 117     }
 118     return t;
 119   }
 120
 121   private ThreadClass readThread(InputStream is) {
 122     int numEvents=readInt(is);
 123     long low=-1;
 124     long high=-1;
 125     boolean started=false;
 126     Vector<Transaction> transactions=new Vector<Transaction>();
 127     Vector<TEvent> currtrans=null;
 128     long starttime=-1;
 129     long lasttime=0;
 130     long firsttime=-1;
 131     for(int i=0;i<numEvents;i++) {
 132       int eventType=readInt(is);
 133       int object=-1;
 134       int index=-1;
 135       switch(eventType) {
 136       case EV_READ:
 137       case EV_WRITE:
 138         object=readInt(is);i++;
 139         break;
 140       case EV_ARRAYREAD:
 141       case EV_ARRAYWRITE:
 142         object=readInt(is);i++;
 143         index=readInt(is);i++;
 144         break;
 145       default:
 146         break;
 147       }
 148       long time=readLong(is);i+=2;
 149       if (low==-1||time<low)
 150         low=time;
 151       if (high==-1||time>high)
 152         high=time;
 153       //create dummy first transaction
 154       if (firsttime==-1) {
 155         Transaction t=new Transaction(1,started);
 156         t.setEvent(0, Transaction.DELAY);
 157         t.setTime(0, time);
 158         t.setObject(0, -1);
 159         t.setIndex(0, -1);
 160         transactions.add(t);
 161         firsttime=time;
 162         lasttime=time;
 163       }
 164       //have read all data in
 165       switch(eventType) {
 166       case EV_START:
 167         starttime=time;
 168         currtrans=new Vector<TEvent>();
 169         started=true;
 170         if (lasttime!=-1&&lasttime!=time) {
 171           Transaction t=new Transaction(1,started);
 172           t.setEvent(0, Transaction.DELAY);
 173           t.setTime(0, time-lasttime);
 174           t.setObject(0, -1);
 175           t.setIndex(0, -1);
 176           transactions.add(t);
 177         }
 178         break;
 179       case EV_READ:
 180       case EV_ARRAYREAD: {
 181         long delta=time-starttime;
 182         TEvent ev=new TEvent(Transaction.READ, delta, object, index);
 183         currtrans.add(ev);
 184       }
 185         break;
 186       case EV_WRITE:
 187       case EV_ARRAYWRITE: {
 188         long delta=time-starttime;
 189         TEvent ev=new TEvent(Transaction.WRITE, delta, object, index);
 190         currtrans.add(ev);
 191       }
 192         break;
 193       case EV_COMMIT: {
 194         long delta=time-starttime;
 195         TEvent ev=new TEvent(Transaction.DELAY, delta);
 196         currtrans.add(ev);
 197         lasttime=time;
 198         transactions.add(createTransaction(currtrans, started));
 199       }
 200         break;
 201       case EV_ABORT:
 202         //No need to generate new delay transaction
 203         lasttime=-1;
 204         break;
 205       case EV_THREAD:
 206         //No need to do anything
 207         break;
 208       case EV_ENTERBARRIER: {
 209         //Barrier
 210         Transaction t=new Transaction(1, started);
 211         t.setEvent(0, Transaction.BARRIER);
 212         if (lasttime!=-1) {
 213           t.setTime(0, time-lasttime);
 214         }
 215         t.setObject(0, -1);
 216         t.setIndex(0, -1);
 217         transactions.add(t);
 218         lasttime=time;
 219       }
 220         break;
 221       case EV_EXITBARRIER: {
 222         //Barrier
 223         lasttime=time;
 224       }
 225         break;
 226       }
 227     }
 228     ThreadClass tc=new ThreadClass(transactions.size());
 229     for(int i=0;i<transactions.size();i++) {
 230       tc.setTransaction(i,transactions.get(i));
 231     }
 232     System.out.println(low+"  "+high);
 233     return tc;
 234   }
 235
 236   public Executor(int numThreads, int numTrans, int deltaTrans, int numObjects, int numAccesses, int deltaAccesses, int readPercent, int delay, int deltaDelay, int nonTrans, int deltaNonTrans, int splitobjects, int splitaccesses, int readPercentSecond) {
 237     this.numThreads=numThreads;
 238     this.numTrans=numTrans;
 239     this.deltaTrans=deltaTrans;
 240     this.numObjects=numObjects;
 241     this.numAccesses=numAccesses;
 242     this.deltaAccesses=deltaAccesses;
 243     this.readPercent=readPercent;
 244     this.delay=delay;
 245     this.deltaDelay=deltaDelay;
 246     this.nonTrans=nonTrans;
 247     this.deltaNonTrans=deltaNonTrans;
 248     this.splitobjects=splitobjects;
 249     this.splitaccesses=splitaccesses;
 250     this.readPercentSecond=readPercentSecond;
 251     r=new Random();
 252     threads=new ThreadClass[numThreads];
 253     generateThreads();
 254   }
 255
 256   public long maxTime() {
 257     long maxtime=0;
 258     for(int i=0;i<numThreads;i++) {
 259       long time=0;
 260       boolean started=false;
 261       for(int j=0;j<getThread(i).numTransactions();j++) {
 262         Transaction trans=getThread(i).getTransaction(j);
 263         if (trans.started)
 264           started=true;
 265         if (started)
 266           time+=trans.getTime(trans.numEvents()-1);
 267       }
 268       if (time>maxtime)
 269         maxtime=time;
 270     }
 271     return maxtime;
 272   }
 273
 274   public int numObjects() {
 275     return numObjects;
 276   }
 277
 278   public int numThreads() {
 279     return numThreads;
 280   }
 281
 282   public int numEvents() {
 283     int events=0;
 284     for(int i=0;i<numThreads();i++) {
 285       events+=getThread(i).numTransactions();
 286     }
 287     return events;
 288   }
 289
 290   public int maxEvents() {
 291     int events=0;
 292     for(int i=0;i<numThreads();i++) {
 293       if (events<getThread(i).numTransactions())
 294         events=getThread(i).numTransactions();
 295     }
 296     return events;
 297   }
 298
 299   public ThreadClass getThread(int i) {
 300     return threads[i];
 301   }
 302
 303   private int getRandom(int base, int delta) {
 304     return base+delta-r.nextInt(2*delta+1);
 305   }
 306
 307   public void generateThreads() {
 308     for(int i=0;i<numThreads;i++) {
 309       threads[i]=generateThread();
 310     }
 311   }
 312
 313   private Transaction generateTransaction() {
 314     int accesses=getRandom(numAccesses, deltaAccesses);
 315     Transaction t=new Transaction(accesses,true);
 316     int time=0;
 317     int splitpoint=(numObjects*splitobjects)/100;
 318     for(int i=0;i<(accesses-1); i++) {
 319       if (r.nextInt(100)<splitaccesses) {
 320         boolean isRead=r.nextInt(100)<readPercent;
 321         time+=getRandom(delay, deltaDelay);
 322         int object=r.nextInt(splitpoint);
 323         t.setObject(i, object);
 324         t.setTime(i, time);
 325         if (isRead)
 326           t.setEvent(i, Transaction.READ);
 327         else
 328           t.setEvent(i, Transaction.WRITE);
 329       } else {
 330         boolean isRead=r.nextInt(100)<readPercentSecond;
 331         time+=getRandom(delay, deltaDelay);
 332         int object=r.nextInt(numObjects-splitpoint)+splitpoint;
 333         t.setObject(i, object);
 334         t.setTime(i, time);
 335         if (isRead)
 336           t.setEvent(i, Transaction.READ);
 337         else
 338           t.setEvent(i, Transaction.WRITE);
 339       }
 340     }
 341     t.setEvent(accesses-1, Transaction.DELAY);
 342     t.setObject(accesses-1, Transaction.DELAY);
 343     time+=getRandom(delay, deltaDelay);
 344     t.setTime(accesses-1, time);
 345
 346     return t;
 347   }
 348
 349   private ThreadClass generateThread() {
 350     int numTransactions=getRandom(numTrans, deltaTrans);
 351     ThreadClass t=new ThreadClass(numTransactions*2);
 352     for(int i=0;i<numTransactions;i++) {
 353       Transaction trans=generateTransaction();
 354       t.setTransaction(i*2, trans);
 355       Transaction transdelay=new Transaction(1,true);
 356       transdelay.setObject(0,Transaction.DELAY);
 357       transdelay.setEvent(0,Transaction.DELAY);
 358       transdelay.setTime(0, getRandom(nonTrans, deltaNonTrans));
 359       t.setTransaction(i*2+1, transdelay);
 360     }
 361     return t;
 362   }
 363 }