ctf/org.eclipse.tracecompass.tmf.ctf.core/src/org/eclipse/tracecompass/internal/tmf/ctf/core/trace/iterator/CtfIterator.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2014 Ericsson, École Polytechnique de Montréal
   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:
  10  *   Matthew Khouzam - Initial API and implementation
  11  *   Florian Wininger - Performance improvements
  12  *******************************************************************************/
  13
  14 package org.eclipse.tracecompass.internal.tmf.ctf.core.trace.iterator;
  15
  16 import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
  17 import static org.eclipse.tracecompass.common.core.NonNullUtils.equalsNullable;
  18
  19 import org.eclipse.tracecompass.ctf.core.CTFException;
  20 import org.eclipse.tracecompass.ctf.core.event.EventDefinition;
  21 import org.eclipse.tracecompass.ctf.core.trace.CTFStreamInputReader;
  22 import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
  23 import org.eclipse.tracecompass.ctf.core.trace.CTFTraceReader;
  24 import org.eclipse.tracecompass.internal.tmf.ctf.core.Activator;
  25 import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
  26 import org.eclipse.tracecompass.tmf.core.trace.location.ITmfLocation;
  27 import org.eclipse.tracecompass.tmf.ctf.core.context.CtfLocation;
  28 import org.eclipse.tracecompass.tmf.ctf.core.context.CtfLocationInfo;
  29 import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
  30 import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
  31
  32 /**
  33  * The CTF trace reader iterator.
  34  *
  35  * It doesn't reserve a file handle, so many iterators can be used without
  36  * worries of I/O errors or resource exhaustion.
  37  *
  38  * @author Matthew Khouzam
  39  */
  40 public class CtfIterator extends CTFTraceReader
  41         implements ITmfContext, Comparable<CtfIterator> {
  42
  43     /** An invalid location */
  44     public static final CtfLocation NULL_LOCATION = new CtfLocation(CtfLocation.INVALID_LOCATION);
  45
  46     private final CtfTmfTrace fTrace;
  47
  48     private CtfLocation fCurLocation;
  49     private long fCurRank;
  50
  51     private CtfLocation fPreviousLocation;
  52     private CtfTmfEvent fPreviousEvent;
  53
  54     // ------------------------------------------------------------------------
  55     // Constructors
  56     // ------------------------------------------------------------------------
  57
  58     /**
  59      * Create a new CTF trace iterator, which initially points at the first
  60      * event in the trace.
  61      *
  62      * @param ctfTrace
  63      *            The {@link CTFTrace} linked to the trace. It should be
  64      *            provided by the corresponding 'ctfTmfTrace'.
  65      *
  66      * @param ctfTmfTrace
  67      *            The {@link CtfTmfTrace} to iterate over
  68      * @throws CTFException
  69      *             If the iterator couldn't not be instantiated, probably due to
  70      *             a read error.
  71      */
  72     public CtfIterator(CTFTrace ctfTrace, CtfTmfTrace ctfTmfTrace) throws CTFException {
  73         super(ctfTrace);
  74         fTrace = ctfTmfTrace;
  75         if (hasMoreEvents()) {
  76             fCurLocation = new CtfLocation(ctfTmfTrace.getStartTime());
  77             fCurRank = 0;
  78         } else {
  79             setUnknownLocation();
  80         }
  81     }
  82
  83     /**
  84      * Create a new CTF trace iterator, which will initially point to the given
  85      * location/rank.
  86      *
  87      * @param ctfTrace
  88      *            The {@link CTFTrace} linked to the trace. It should be
  89      *            provided by the corresponding 'ctfTmfTrace'.
  90      * @param ctfTmfTrace
  91      *            The {@link CtfTmfTrace} to iterate over
  92      * @param ctfLocationData
  93      *            The initial timestamp the iterator will be pointing to
  94      * @param rank
  95      *            The initial rank
  96      * @throws CTFException
  97      *             If the iterator couldn't not be instantiated, probably due to
  98      *             a read error.
  99      */
 100     public CtfIterator(CTFTrace ctfTrace, CtfTmfTrace ctfTmfTrace, CtfLocationInfo ctfLocationData, long rank)
 101             throws CTFException {
 102         super(ctfTrace);
 103
 104         this.fTrace = ctfTmfTrace;
 105         if (this.hasMoreEvents()) {
 106             this.fCurLocation = new CtfLocation(ctfLocationData);
 107             if (this.getCurrentEvent().getTimestamp().getValue() != ctfLocationData.getTimestamp()) {
 108                 this.seek(ctfLocationData);
 109                 this.fCurRank = rank;
 110             }
 111         } else {
 112             setUnknownLocation();
 113         }
 114     }
 115
 116     @Override
 117     public void dispose() {
 118         close();
 119     }
 120
 121     private void setUnknownLocation() {
 122         fCurLocation = NULL_LOCATION;
 123         fCurRank = UNKNOWN_RANK;
 124     }
 125
 126     // ------------------------------------------------------------------------
 127     // Accessors
 128     // ------------------------------------------------------------------------
 129
 130     /**
 131      * Return this iterator's trace.
 132      *
 133      * @return CtfTmfTrace The iterator's trace
 134      */
 135     public CtfTmfTrace getCtfTmfTrace() {
 136         return fTrace;
 137     }
 138
 139     /**
 140      * Return the current event pointed to by the iterator.
 141      *
 142      * @return CtfTmfEvent The current event
 143      */
 144     public synchronized CtfTmfEvent getCurrentEvent() {
 145         final CTFStreamInputReader top = super.getPrio().peek();
 146         if (top != null) {
 147             if (!fCurLocation.equals(fPreviousLocation)) {
 148                 fPreviousLocation = fCurLocation;
 149                 fPreviousEvent = fTrace.getEventFactory().createEvent(fTrace, checkNotNull(top.getCurrentEvent()), top.getFilename());
 150             }
 151             return fPreviousEvent;
 152         }
 153         return null;
 154     }
 155
 156     /**
 157      * Return the current timestamp location pointed to by the iterator. This is
 158      * the timestamp for use in CtfLocation, not the event timestamp.
 159      *
 160      * @return long The current timestamp location
 161      */
 162     public synchronized long getCurrentTimestamp() {
 163         final CTFStreamInputReader top = super.getPrio().peek();
 164         if (top != null) {
 165             EventDefinition currentEvent = top.getCurrentEvent();
 166             if (currentEvent != null) {
 167                 long ts = currentEvent.getTimestamp();
 168                 return fTrace.timestampCyclesToNanos(ts);
 169             }
 170         }
 171         return 0;
 172     }
 173
 174     /**
 175      * Seek this iterator to a given location.
 176      *
 177      * @param ctfLocationData
 178      *            The LocationData representing the position to seek to
 179      * @return boolean True if the seek was successful, false if there was an
 180      *         error seeking.
 181      */
 182     public synchronized boolean seek(CtfLocationInfo ctfLocationData) {
 183         boolean ret = false;
 184         if (ctfLocationData.equals(CtfLocation.INVALID_LOCATION)) {
 185             fCurLocation = NULL_LOCATION;
 186             return false;
 187         }
 188
 189         /* Avoid the cost of seeking at the current location. */
 190         if (fCurLocation.getLocationInfo().equals(ctfLocationData)) {
 191             return super.hasMoreEvents();
 192         }
 193         /* Update location to make sure the current event is updated */
 194         fCurLocation = new CtfLocation(ctfLocationData);
 195
 196         /* Adjust the timestamp depending on the trace's offset */
 197         long currTimestamp = ctfLocationData.getTimestamp();
 198         final long offsetTimestamp = this.getCtfTmfTrace().timestampNanoToCycles(currTimestamp);
 199         try {
 200             if (offsetTimestamp < 0) {
 201                 ret = super.seek(0L);
 202             } else {
 203                 ret = super.seek(offsetTimestamp);
 204             }
 205         } catch (CTFException e) {
 206             Activator.getDefault().logError(e.getMessage(), e);
 207             return false;
 208         }
 209         /*
 210          * Check if there is already one or more events for that timestamp, and
 211          * assign the location index correctly
 212          */
 213         long index = 0;
 214         final CtfTmfEvent currentEvent = this.getCurrentEvent();
 215         if (currentEvent != null) {
 216             currTimestamp = currentEvent.getTimestamp().getValue();
 217
 218             for (long i = 0; i < ctfLocationData.getIndex(); i++) {
 219                 if (currTimestamp == currentEvent.getTimestamp().getValue()) {
 220                     index++;
 221                 } else {
 222                     index = 0;
 223                 }
 224                 this.advance();
 225             }
 226         } else {
 227             ret = false;
 228         }
 229         /* Seek the current location accordingly */
 230         if (ret) {
 231             fCurLocation = new CtfLocation(new CtfLocationInfo(getCurrentEvent().getTimestamp().getValue(), index));
 232         } else {
 233             fCurLocation = NULL_LOCATION;
 234         }
 235
 236         return ret;
 237     }
 238
 239     // ------------------------------------------------------------------------
 240     // CTFTraceReader
 241     // ------------------------------------------------------------------------
 242
 243     @Override
 244     public boolean seek(long timestamp) {
 245         return seek(new CtfLocationInfo(timestamp, 0));
 246     }
 247
 248     @Override
 249     public synchronized boolean advance() {
 250         boolean ret = false;
 251         try {
 252             ret = super.advance();
 253         } catch (CTFException e) {
 254             Activator.getDefault().logError(e.getMessage(), e);
 255         }
 256
 257         if (ret) {
 258             long timestamp = fCurLocation.getLocationInfo().getTimestamp();
 259             final long timestampValue = getCurrentTimestamp();
 260             if (timestamp == timestampValue) {
 261                 long index = fCurLocation.getLocationInfo().getIndex();
 262                 fCurLocation = new CtfLocation(timestampValue, index + 1);
 263             } else {
 264                 fCurLocation = new CtfLocation(timestampValue, 0L);
 265             }
 266         } else {
 267             fCurLocation = NULL_LOCATION;
 268         }
 269         return ret;
 270     }
 271
 272     // ------------------------------------------------------------------------
 273     // ITmfContext
 274     // ------------------------------------------------------------------------
 275
 276     @Override
 277     public long getRank() {
 278         return fCurRank;
 279     }
 280
 281     @Override
 282     public void setRank(long rank) {
 283         fCurRank = rank;
 284     }
 285
 286     @Override
 287     public void increaseRank() {
 288         /* Only increase the rank if it's valid */
 289         if (hasValidRank()) {
 290             fCurRank++;
 291         }
 292     }
 293
 294     @Override
 295     public boolean hasValidRank() {
 296         return (getRank() >= 0);
 297     }
 298
 299     @Override
 300     public void setLocation(ITmfLocation location) {
 301         // FIXME alex: isn't there a cleaner way than a cast here?
 302         fCurLocation = (CtfLocation) location;
 303         seek(((CtfLocation) location).getLocationInfo());
 304     }
 305
 306     @Override
 307     public CtfLocation getLocation() {
 308         return fCurLocation;
 309     }
 310
 311     // ------------------------------------------------------------------------
 312     // Comparable
 313     // ------------------------------------------------------------------------
 314
 315     @Override
 316     public int compareTo(final CtfIterator o) {
 317         if (getRank() < o.getRank()) {
 318             return -1;
 319         } else if (getRank() > o.getRank()) {
 320             return 1;
 321         }
 322         return 0;
 323     }
 324
 325     // ------------------------------------------------------------------------
 326     // Object
 327     // ------------------------------------------------------------------------
 328
 329     @Override
 330     public int hashCode() {
 331         final int prime = 31;
 332         int result = super.hashCode();
 333         result = (prime * result)
 334                 + ((fTrace == null) ? 0 : fTrace.hashCode());
 335         result = (prime * result)
 336                 + ((fCurLocation == null) ? 0 : fCurLocation.hashCode());
 337         result = (prime * result) + (int) (fCurRank ^ (fCurRank >>> 32));
 338         return result;
 339     }
 340
 341     @Override
 342     public boolean equals(Object obj) {
 343         if (this == obj) {
 344             return true;
 345         }
 346         if (!super.equals(obj)) {
 347             return false;
 348         }
 349         if (!(obj instanceof CtfIterator)) {
 350             return false;
 351         }
 352         CtfIterator other = (CtfIterator) obj;
 353         if (!equalsNullable(fTrace, other.fTrace)) {
 354             return false;
 355         }
 356         if (!equalsNullable(fCurLocation, other.fCurLocation)) {
 357             return false;
 358         }
 359         if (fCurRank != other.fCurRank) {
 360             return false;
 361         }
 362         return true;
 363     }
 364 }