fix bugs
[IRC.git] / 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 }