+ public static int readInt(InputStream is) {
+ try {
+ int b1=is.read();
+ int b2=is.read();
+ int b3=is.read();
+ int b4=is.read();
+ int retval=(b4<<24)|(b3<<16)|(b2<<8)|b1;
+ if (retval<0)
+ throw new Error();
+ return retval;
+ } catch (Exception e) {
+ throw new Error();
+ }
+ }
+
+ public static long readLong(InputStream is) {
+ try {
+ long b1=is.read();
+ long b2=is.read();
+ long b3=is.read();
+ long b4=is.read();
+ long b5=is.read();
+ long b6=is.read();
+ long b7=is.read();
+ long b8=is.read();
+ long retval=(b8<<56)|(b7<<48)|(b6<<40)|(b5<<32)|
+ (b4<<24)|(b3<<16)|(b2<<8)|b1;
+ if (retval<0)
+ throw new Error();
+ return retval;
+ } catch (Exception e) {
+ throw new Error();
+ }
+ }
+
+ public Executor(String filename) {
+ BufferedInputStream bir=null;
+ try {
+ bir=new BufferedInputStream(new FileInputStream(filename));
+ } catch (Exception e) {
+ e.printStackTrace();
+ System.exit(-1);
+ }
+ numThreads=readInt(bir);
+ threads=new ThreadClass[numThreads];
+ long earliest=-1;
+ for(int i=0;i<numThreads;i++) {
+ System.out.println("Loading thread "+i+" of "+numThreads);
+ threads[i]=readThread(bir);
+ long inittime=threads[i].trans[0].getTime(0);
+ if (earliest==-1||earliest>inittime) {
+ earliest=inittime;
+ }
+ }
+ for(int i=0;i<numThreads;i++) {
+ long inittime=threads[i].trans[0].getTime(0);
+ assert(threads[i].trans[0].numEvents()==1);
+ threads[i].trans[0].setTime(0, inittime-earliest);
+ }
+ }
+
+ public static final int EV_THREAD=0;
+ public static final int EV_ENTERBARRIER=1;
+ public static final int EV_READ=2;
+ public static final int EV_WRITE=3;
+ public static final int EV_START=4;
+ public static final int EV_COMMIT=5;
+ public static final int EV_ABORT=6;
+ public static final int EV_ARRAYREAD=7;
+ public static final int EV_ARRAYWRITE=8;
+ public static final int EV_EXITBARRIER=9;
+
+ private Transaction createTransaction(Vector<TEvent> v, boolean started) {
+ Transaction t=new Transaction(v.size(),started);
+ for(int i=0;i<v.size();i++) {
+ TEvent e=v.get(i);
+ t.setTime(i,e.time);
+ t.setEvent(i,e.type);
+ t.setObject(i,e.oid);
+ t.setIndex(i,e.index);
+ }
+ return t;
+ }
+
+ private ThreadClass readThread(InputStream is) {
+ int numEvents=readInt(is);
+ long low=-1;
+ long high=-1;
+ boolean started=false;
+ Vector<Transaction> transactions=new Vector<Transaction>();
+ Vector<TEvent> currtrans=null;
+ long starttime=-1;
+ long lasttime=0;
+ long firsttime=-1;
+ for(int i=0;i<numEvents;i++) {
+ int eventType=readInt(is);
+ int object=-1;
+ int index=-1;
+ switch(eventType) {
+ case EV_READ:
+ case EV_WRITE:
+ object=readInt(is);i++;
+ break;
+ case EV_ARRAYREAD:
+ case EV_ARRAYWRITE:
+ object=readInt(is);i++;
+ index=readInt(is);i++;
+ break;
+ default:
+ break;
+ }
+ long time=readLong(is);i+=2;
+ if (low==-1||time<low)
+ low=time;
+ if (high==-1||time>high)
+ high=time;
+ //create dummy first transaction
+ if (firsttime==-1) {
+ Transaction t=new Transaction(1,started);
+ t.setEvent(0, Transaction.DELAY);
+ t.setTime(0, time);
+ t.setObject(0, -1);
+ t.setIndex(0, -1);
+ transactions.add(t);
+ firsttime=time;
+ lasttime=time;
+ }
+ //have read all data in
+ switch(eventType) {
+ case EV_START:
+ starttime=time;
+ currtrans=new Vector<TEvent>();
+ started=true;
+ if (lasttime!=-1&&lasttime!=time) {
+ Transaction t=new Transaction(1,started);
+ t.setEvent(0, Transaction.DELAY);
+ t.setTime(0, time-lasttime);
+ t.setObject(0, -1);
+ t.setIndex(0, -1);
+ transactions.add(t);
+ }
+ break;
+ case EV_READ:
+ case EV_ARRAYREAD: {
+ long delta=time-starttime;
+ TEvent ev=new TEvent(Transaction.READ, delta, object, index);
+ currtrans.add(ev);
+ }
+ break;
+ case EV_WRITE:
+ case EV_ARRAYWRITE: {
+ long delta=time-starttime;
+ TEvent ev=new TEvent(Transaction.WRITE, delta, object, index);
+ currtrans.add(ev);
+ }
+ break;
+ case EV_COMMIT: {
+ long delta=time-starttime;
+ TEvent ev=new TEvent(Transaction.DELAY, delta);
+ currtrans.add(ev);
+ lasttime=time;
+ transactions.add(createTransaction(currtrans, started));
+ }
+ break;
+ case EV_ABORT:
+ //No need to generate new delay transaction
+ lasttime=-1;
+ break;
+ case EV_THREAD:
+ //No need to do anything
+ break;
+ case EV_ENTERBARRIER: {
+ //Barrier
+ Transaction t=new Transaction(1, started);
+ t.setEvent(0, Transaction.BARRIER);
+ if (lasttime!=-1) {
+ t.setTime(0, time-lasttime);
+ }
+ t.setObject(0, -1);
+ t.setIndex(0, -1);
+ transactions.add(t);
+ lasttime=time;
+ }
+ break;
+ case EV_EXITBARRIER: {
+ //Barrier
+ lasttime=time;
+ }
+ break;
+ }
+ }
+ ThreadClass tc=new ThreadClass(transactions.size());
+ for(int i=0;i<transactions.size();i++) {
+ tc.setTransaction(i,transactions.get(i));
+ }
+ System.out.println(low+" "+high);
+ return tc;
+ }
+