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