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