org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/CTFTraceReader.java

   1 /*******************************************************************************
   2  * Copyright (c) 2011-2012 Ericsson, Ecole Polytechnique de Montreal and others
   3  *
   4  * All rights reserved. This program and the accompanying materials are made
   5  * available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors: Matthew Khouzam - Initial API and implementation
  10  * Contributors: Alexandre Montplaisir - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.ctf.core.trace;
  14
  15 import java.util.Collection;
  16 import java.util.PriorityQueue;
  17 import java.util.Set;
  18 import java.util.Vector;
  19
  20 import org.eclipse.linuxtools.ctf.core.event.EventDefinition;
  21 import org.eclipse.linuxtools.internal.ctf.core.Activator;
  22 import org.eclipse.linuxtools.internal.ctf.core.trace.Stream;
  23 import org.eclipse.linuxtools.internal.ctf.core.trace.StreamInput;
  24 import org.eclipse.linuxtools.internal.ctf.core.trace.StreamInputReaderTimestampComparator;
  25
  26 /**
  27  * Reads the events of a trace.
  28  */
  29
  30 public class CTFTraceReader {
  31
  32     // ------------------------------------------------------------------------
  33     // Attributes
  34     // ------------------------------------------------------------------------
  35
  36     /**
  37      * The trace to read from.
  38      */
  39     private final CTFTrace trace;
  40
  41     /**
  42      * Vector of all the trace file readers.
  43      */
  44     private final Vector<StreamInputReader> streamInputReaders = new Vector<StreamInputReader>();
  45
  46     /**
  47      * Priority queue to order the trace file readers by timestamp.
  48      */
  49     protected PriorityQueue<StreamInputReader> prio;
  50
  51     /**
  52      * Array to count the number of event per trace file.
  53      */
  54     private long[] eventCountPerTraceFile;
  55
  56     /**
  57      * Timestamp of the first event in the trace
  58      */
  59     private long startTime;
  60
  61     /**
  62      * Timestamp of the last event read so far
  63      */
  64     private long endTime;
  65
  66
  67     protected void setEndTime(long endTime) {
  68         this.endTime = endTime;
  69     }
  70
  71     // ------------------------------------------------------------------------
  72     // Constructors
  73     // ------------------------------------------------------------------------
  74
  75     /**
  76      * Constructs a TraceReader to read a trace.
  77      *
  78      * @param trace
  79      *            The trace to read from.
  80      * @throws CTFReaderException
  81      */
  82     public CTFTraceReader(CTFTrace trace) {
  83         this.trace = trace;
  84         streamInputReaders.clear();
  85
  86         /**
  87          * Create the trace file readers.
  88          */
  89         createStreamInputReaders();
  90
  91         /**
  92          * Populate the timestamp-based priority queue.
  93          */
  94         populateStreamInputReaderHeap();
  95
  96         /**
  97          * Get the start Time of this trace bear in mind that the trace could be
  98          * empty.
  99          */
 100         this.startTime = 0;// prio.peek().getPacketReader().getCurrentPacket().getTimestampBegin();
 101         if (hasMoreEvents()) {
 102             this.startTime = prio.peek().getCurrentEvent().getTimestamp();
 103             this.setEndTime(this.startTime);
 104         }
 105     }
 106
 107     /**
 108      * Copy constructor
 109      */
 110     public CTFTraceReader copyFrom() {
 111         CTFTraceReader newReader = null;
 112
 113         newReader = new CTFTraceReader(this.trace);
 114         newReader.startTime = this.startTime;
 115         newReader.setEndTime(this.endTime);
 116         return newReader;
 117     }
 118
 119     // ------------------------------------------------------------------------
 120     // Getters/Setters/Predicates
 121     // ------------------------------------------------------------------------
 122
 123     /**
 124      * Return the start time of this trace (== timestamp of the first event)
 125      *
 126      * @return the trace start time
 127      */
 128     public long getStartTime() {
 129         return this.startTime;
 130     }
 131
 132     // ------------------------------------------------------------------------
 133     // Operations
 134     // ------------------------------------------------------------------------
 135
 136     /**
 137      * Creates one trace file reader per trace file contained in the trace.
 138      */
 139     private void createStreamInputReaders() {
 140         Collection<Stream> streams = this.trace.getStreams().values();
 141
 142         /*
 143          * For each stream.
 144          */
 145         for (Stream stream : streams) {
 146             Set<StreamInput> streamInputs = stream.getStreamInputs();
 147
 148             /*
 149              * For each trace file of the stream.
 150              */
 151             for (StreamInput streamInput : streamInputs) {
 152                 streamInput.getIndex().getEntries().clear();
 153                 /*
 154                  * Create a reader.
 155                  */
 156                 StreamInputReader streamInputReader = new StreamInputReader(
 157                         streamInput);
 158
 159                 /*
 160                  * Add it to the group.
 161                  */
 162                 this.streamInputReaders.add(streamInputReader);
 163             }
 164         }
 165
 166         /*
 167          * Create the array to count the number of event per trace file.
 168          */
 169         this.eventCountPerTraceFile = new long[this.streamInputReaders.size()];
 170     }
 171
 172     /**
 173      * Initializes the priority queue used to choose the trace file with the
 174      * lower next event timestamp.
 175      */
 176     private void populateStreamInputReaderHeap() {
 177         /*
 178          * Create the priority queue with a size twice as bigger as the number
 179          * of reader in order to avoid constant resizing.
 180          */
 181         this.prio = new PriorityQueue<StreamInputReader>(
 182                 this.streamInputReaders.size() * 2,
 183                 new StreamInputReaderTimestampComparator());
 184
 185         int pos = 0;
 186
 187         for (StreamInputReader reader : this.streamInputReaders) {
 188             /*
 189              * Add each trace file reader in the priority queue, if we are able
 190              * to read an event from it.
 191              */
 192             reader.setParent(this);
 193             if (reader.readNextEvent()) {
 194                 this.prio.add(reader);
 195
 196                 this.eventCountPerTraceFile[pos] = 0;
 197                 reader.setName(pos);
 198
 199                 pos++;
 200             }
 201         }
 202     }
 203
 204     /**
 205      * Get the current event, which is the current event of the trace file
 206      * reader with the lowest timestamp.
 207      *
 208      * @return An event definition, or null of the trace reader reached the end
 209      *         of the trace.
 210      */
 211     public EventDefinition getCurrentEventDef() {
 212         StreamInputReader top = getTopStream();
 213
 214         return (top != null) ? top.getCurrentEvent() : null;
 215     }
 216
 217     /**
 218      * Go to the next event.
 219      *
 220      * @return True if an event was read.
 221      */
 222     public boolean advance() {
 223         /*
 224          * Index the
 225          */
 226         /*
 227          * Remove the reader from the top of the priority queue.
 228          */
 229         StreamInputReader top = this.prio.poll();
 230
 231         /*
 232          * If the queue was empty.
 233          */
 234         if (top == null) {
 235             return false;
 236         }
 237         /*
 238          * Read the next event of this reader.
 239          */
 240         if (top.readNextEvent()) {
 241             /*
 242              * Add it back in the queue.
 243              */
 244             this.prio.add(top);
 245             final long topEnd = top.getCurrentEvent().getTimestamp() + this.getTrace().getOffset();
 246             this.setEndTime( Math.max(topEnd, this.getEndTime()));
 247             this.eventCountPerTraceFile[top.getName()]++;
 248             /*
 249              * increment the index
 250              */
 251
 252             if (top.getCurrentEvent() != null) {
 253                 this.endTime = Math.max(top.getCurrentEvent().getTimestamp(),
 254                         this.endTime);
 255             }
 256         }
 257         /*
 258          * If there is no reader in the queue, it means the trace reader reached
 259          * the end of the trace.
 260          */
 261         return hasMoreEvents();
 262     }
 263
 264     /**
 265      * Go to the last event in the trace.
 266      *
 267      * @throws CTFReaderException
 268      */
 269     public void goToLastEvent() {
 270         seek(this.getEndTime());
 271         while (this.prio.size() > 1) {
 272             this.advance();
 273         }
 274     }
 275
 276     /**
 277      * Seeks to a given timestamp It will go to the event just after the
 278      * timestamp or the timestamp itself. if a if a trace is 10 20 30 40 and
 279      * you're looking for 19, it'll give you 20, it you want 20, you'll get 20,
 280      * if you want 21, you'll get 30. You want -inf, you'll get the first
 281      * element, you want +inf, you'll get the end of the file with no events.
 282      *
 283      * @param timestamp
 284      *            the timestamp to seek to
 285      * @return true if the trace has more events following the timestamp
 286      */
 287     public boolean seek(long timestamp) {
 288         /*
 289          * Remove all the trace readers from the priority queue
 290          */
 291         this.prio.clear();
 292         for (StreamInputReader streamInputReader : this.streamInputReaders) {
 293             /*
 294              * Seek the trace reader.
 295              */
 296             streamInputReader.seek(timestamp);
 297
 298             /*
 299              * Add it to the priority queue if there is a current event.
 300              */
 301
 302         }
 303         for (StreamInputReader streamInputReader : this.streamInputReaders) {
 304             if (streamInputReader.getCurrentEvent() != null) {
 305                 this.prio.add(streamInputReader);
 306
 307             }
 308         }
 309         return hasMoreEvents();
 310     }
 311
 312     /**
 313      * Go to the first entry of a trace
 314      *
 315      * @return 0, the first index.
 316      */
 317     private long goToZero() {
 318         long tempIndex;
 319         for (StreamInputReader streamInputReader : this.streamInputReaders) {
 320             /*
 321              * Seek the trace reader.
 322              */
 323             streamInputReader.seek(0);
 324         }
 325         tempIndex = 0;
 326         return tempIndex;
 327     }
 328
 329     public StreamInputReader getTopStream() {
 330         return this.prio.peek();
 331     }
 332
 333     /**
 334      * Does the trace have more events?
 335      *
 336      * @return true if yes.
 337      */
 338     public boolean hasMoreEvents() {
 339         return this.prio.size() > 0;
 340     }
 341
 342     /**
 343      * Prints the event count stats.
 344      */
 345     public void printStats() {
 346         printStats(60);
 347     }
 348
 349     /**
 350      * Prints the event count stats.
 351      *
 352      * @param width
 353      *            Width of the display.
 354      */
 355     public void printStats(int width) {
 356         int numEvents = 0;
 357         if (width == 0) {
 358             return;
 359         }
 360
 361         for (long i : this.eventCountPerTraceFile) {
 362             numEvents += i;
 363         }
 364
 365         for (int j = 0; j < this.eventCountPerTraceFile.length; j++) {
 366             StreamInputReader se = this.streamInputReaders.get(j);
 367
 368             long len = (width * this.eventCountPerTraceFile[se.getName()])
 369                     / numEvents;
 370
 371             StringBuilder sb = new StringBuilder(se.getFilename() + "\t["); //$NON-NLS-1$
 372
 373             for (int i = 0; i < len; i++) {
 374                 sb.append('+');
 375             }
 376
 377             for (long i = len; i < width; i++) {
 378                 sb.append(' ');
 379             }
 380
 381             sb.append("]\t" + this.eventCountPerTraceFile[se.getName()] + " Events"); //$NON-NLS-1$//$NON-NLS-2$
 382             Activator.getDefault().log(sb.toString());
 383         }
 384     }
 385
 386     public long getEndTime() {
 387         return this.endTime;
 388     }
 389
 390     @Override
 391     public int hashCode() {
 392         final int prime = 31;
 393         int result = 1;
 394         result = (prime * result) + (int) (startTime ^ (startTime >>> 32));
 395         result = (prime * result)
 396                 + ((streamInputReaders == null) ? 0 : streamInputReaders
 397                         .hashCode());
 398         result = (prime * result) + ((trace == null) ? 0 : trace.hashCode());
 399         return result;
 400     }
 401
 402     @Override
 403     public boolean equals(Object obj) {
 404         if (this == obj) {
 405             return true;
 406         }
 407         if (obj == null) {
 408             return false;
 409         }
 410         if (!(obj instanceof CTFTraceReader)) {
 411             return false;
 412         }
 413         CTFTraceReader other = (CTFTraceReader) obj;
 414         if (streamInputReaders == null) {
 415             if (other.streamInputReaders != null) {
 416                 return false;
 417             }
 418         } else if (!streamInputReaders.equals(other.streamInputReaders)) {
 419             return false;
 420         }
 421         if (trace == null) {
 422             if (other.trace != null) {
 423                 return false;
 424             }
 425         } else if (!trace.equals(other.trace)) {
 426             return false;
 427         }
 428         return true;
 429     }
 430
 431     /*
 432      * (non-Javadoc)
 433      *
 434      * @see java.lang.Object#toString()
 435      */
 436     @Override
 437     public String toString() {
 438         /* Only for debugging, shouldn't be externalized */
 439         return "CTFTraceReader [trace=" + trace + ']'; //$NON-NLS-1$
 440     }
 441
 442     public CTFTrace getTrace() {
 443         return trace;
 444     }
 445 }