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