Robust/CoreProf/Trace.java

   1 import java.io.FileInputStream;
   2 import java.io.InputStream;
   3 import java.io.BufferedInputStream;
   4 import java.util.Vector;
   5 import java.util.Hashtable;
   6 import java.util.Iterator;
   7 import java.util.Set;
   8
   9 public class Trace {
  10   int numThreads;
  11   int[] eventCounts;
  12   Event[][] eventstack;
  13   Hashtable<Integer, Counter> getcounter[];
  14
  15   public static final int STACKMAX=512;
  16
  17   public void printStats() {
  18     for(int i=0;i<numThreads;i++) {
  19       System.out.println("Thread "+i);
  20       for(Iterator<Integer> evit=getcounter[i].keySet().iterator();evit.hasNext();) {
  21         Integer event=evit.next();
  22         Counter c=getcounter[i].get(event);
  23         System.out.println("Event: "+event+" self time="+c.selftime+"  total time"+c.totaltime);
  24       }
  25       System.out.println("-------------------------------------------------------------");
  26     }
  27   }
  28
  29   public static int readInt(InputStream is) {
  30     try {
  31       int b1=is.read();
  32       int b2=is.read();
  33       int b3=is.read();
  34       int b4=is.read();
  35       int retval=(b4<<24)|(b3<<16)|(b2<<8)|b1;
  36       if (retval<0)
  37         throw new Error();
  38       return retval;
  39     } catch (Exception e) {
  40       throw new Error();
  41     }
  42   }
  43
  44   public static long readLong(InputStream is) {
  45     try {
  46     long b1=is.read();
  47     long b2=is.read();
  48     long b3=is.read();
  49     long b4=is.read();
  50     long b5=is.read();
  51     long b6=is.read();
  52     long b7=is.read();
  53     long b8=is.read();
  54     long retval=(b8<<56)|(b7<<48)|(b6<<40)|(b5<<32)|
  55         (b4<<24)|(b3<<16)|(b2<<8)|b1;
  56     if (retval<0)
  57       throw new Error();
  58     return retval;
  59     } catch (Exception e) {
  60       throw new Error();
  61     }
  62   }
  63
  64   int readHeader(BufferedInputStream bir) {
  65     //First check version
  66     int offset=4;
  67     int version=readInt(bir);
  68     if (version!=0)
  69       throw new Error("Unsupported Version");
  70
  71     //Second read number of threads
  72     offset+=4;
  73     numThreads=readInt(bir);
  74
  75     //Third read event counts for each Thread
  76     eventCounts=new int[numThreads];
  77     eventstack=new Event[numThreads][STACKMAX];
  78     for(int i=0;i<numThreads;i++) {
  79       eventCounts[i]=readInt(bir);
  80       offset+=4;
  81     }
  82     return offset;
  83   }
  84
  85   BufferedInputStream threads[];
  86
  87   public Trace(String filename) {
  88     BufferedInputStream bir=null;
  89     int offset=0;
  90     try {
  91       bir=new BufferedInputStream(new FileInputStream(filename));
  92       offset=readHeader(bir);
  93       bir.close();
  94     } catch (Exception e) {
  95       e.printStackTrace();
  96       System.exit(-1);
  97     }
  98     threads=new BufferedInputStream[numThreads];
  99     getcounter=new Hashtable[numThreads];
 100
 101     for(int i=0;i<numThreads;i++) {
 102       getcounter[i]=new Hashtable<Integer,Counter>();
 103       try {
 104         threads[i]=new BufferedInputStream(new FileInputStream(filename));
 105         int skip=offset;
 106         while (skip>0) {
 107           skip-=threads[i].skip(skip);
 108         }
 109         offset+=4*eventCounts[i];
 110       } catch (Exception e) {
 111         e.printStackTrace();
 112         System.exit(-1);
 113       }
 114     }
 115   }
 116
 117   public void readThread(int t) {
 118     BufferedInputStream bis=threads[t];
 119     int numevents=eventCounts[t];
 120     int i=0;
 121     Event[] stack=eventstack[t];
 122     int depth=0;
 123     Hashtable<Integer, Counter> countertab=getcounter[t];
 124
 125     while(i<numevents) {
 126       int event=readInt(bis);
 127       long time=readLong(bis);
 128       int baseevent=event>>CP_BASE_SHIFT;
 129       i+=3; //time and event
 130
 131       switch(event&CP_MASK) {
 132       case CP_BEGIN:
 133         enqueue(stack, depth, baseevent, time, countertab);
 134         depth++;
 135         break;
 136       case CP_END: {
 137         Event e=stack[depth];
 138         long elapsedtime=time-e.time;
 139         Counter c=e.counter;
 140         c.totaltime+=elapsedtime;
 141         c.selftime+=elapsedtime;
 142         depth--;
 143         for(int j=depth;j>=0;j--) {
 144           Counter cn=e.counter;
 145           cn.totaltime-=elapsedtime;
 146         }
 147         break;
 148       }
 149       case CP_EVENT:
 150         break;
 151       }
 152     }
 153   }
 154
 155   public static void enqueue(Event[] stack, int depth, int event, long time, Hashtable<Integer, Counter> getcounter) {
 156     Counter counter=getcounter.get(event);
 157     if (counter==null) {
 158       Counter c=new Counter();
 159       getcounter.put(event, c);
 160     }
 161     if (stack[depth]==null) {
 162       stack[depth]=new Event(time,event);
 163       stack[depth].counter=counter;
 164     } else {
 165       stack[depth].time=time;
 166       stack[depth].event=event;
 167       stack[depth].counter=counter;
 168     }
 169   }
 170
 171   public static final int CP_BEGIN=0;
 172   public static final int CP_END=1;
 173   public static final int CP_EVENT=2;
 174   public static final int CP_MASK=3;
 175   public static final int CP_BASE_SHIFT=2;
 176
 177   public static final int CP_MAIN=0;
 178   public static final int CP_RUNMALLOC=1;
 179   public static final int CP_RUNFREE=2;
 180   public static void main(String x[]) {
 181     Trace t=new Trace(x[0]);
 182     t.printStats();
 183   }
 184 }