ctf/org.eclipse.tracecompass.ctf.core/src/org/eclipse/tracecompass/ctf/core/trace/CTFStreamInputReader.java

   1 /*******************************************************************************
   2  * Copyright (c) 2011, 2015 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: Simon Marchi - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.ctf.core.trace;
  14
  15 import java.io.File;
  16 import java.io.IOException;
  17 import java.nio.ByteBuffer;
  18 import java.nio.channels.FileChannel;
  19 import java.nio.channels.FileChannel.MapMode;
  20 import java.nio.file.StandardOpenOption;
  21 import java.util.List;
  22
  23 import org.eclipse.jdt.annotation.NonNullByDefault;
  24 import org.eclipse.jdt.annotation.Nullable;
  25 import org.eclipse.tracecompass.common.core.NonNullUtils;
  26 import org.eclipse.tracecompass.ctf.core.CTFException;
  27 import org.eclipse.tracecompass.ctf.core.event.IEventDeclaration;
  28 import org.eclipse.tracecompass.ctf.core.event.IEventDefinition;
  29 import org.eclipse.tracecompass.ctf.core.event.io.BitBuffer;
  30 import org.eclipse.tracecompass.ctf.core.event.types.IDeclaration;
  31 import org.eclipse.tracecompass.ctf.core.event.types.StructDeclaration;
  32 import org.eclipse.tracecompass.internal.ctf.core.Activator;
  33 import org.eclipse.tracecompass.internal.ctf.core.SafeMappedByteBuffer;
  34 import org.eclipse.tracecompass.internal.ctf.core.trace.CTFPacketReader;
  35 import org.eclipse.tracecompass.internal.ctf.core.trace.NullPacketReader;
  36
  37 /**
  38  * A CTF trace event reader. Reads the events of a trace file.
  39  *
  40  * @author Matthew Khouzam
  41  * @author Simon Marchi
  42  * @since 2.0
  43  */
  44 @NonNullByDefault
  45 public class CTFStreamInputReader implements AutoCloseable {
  46
  47     private static final int BITS_PER_BYTE = Byte.SIZE;
  48
  49     // ------------------------------------------------------------------------
  50     // Attributes
  51     // ------------------------------------------------------------------------
  52
  53     /**
  54      * The StreamInput we are reading.
  55      */
  56     private final File fFile;
  57
  58     private final CTFStreamInput fStreamInput;
  59
  60     private final @Nullable FileChannel fFileChannel;
  61
  62     /**
  63      * The packet reader used to read packets from this trace file.
  64      */
  65     private IPacketReader fPacketReader;
  66
  67     /**
  68      * Iterator on the packet index
  69      */
  70     private int fPacketIndex;
  71
  72     /**
  73      * Reference to the current event of this trace file (iow, the last on that
  74      * was read, the next one to be returned)
  75      */
  76     private @Nullable IEventDefinition fCurrentEvent = null;
  77
  78     private int fId;
  79
  80     /**
  81      * Live trace reading
  82      */
  83     private boolean fLive = false;
  84
  85     // ------------------------------------------------------------------------
  86     // Constructors
  87     // ------------------------------------------------------------------------
  88     /**
  89      * Constructs a StreamInputReader that reads a StreamInput.
  90      *
  91      * @param streamInput
  92      *            The StreamInput to read.
  93      * @throws CTFException
  94      *             If the file cannot be opened
  95      */
  96     public CTFStreamInputReader(CTFStreamInput streamInput) throws CTFException {
  97         fStreamInput = streamInput;
  98         fFile = fStreamInput.getFile();
  99         try {
 100             fFileChannel = FileChannel.open(fFile.toPath(), StandardOpenOption.READ);
 101         } catch (IOException e) {
 102             throw new CTFIOException(e);
 103         }
 104         try {
 105             /*
 106              * Get the iterator on the packet index.
 107              */
 108             fPacketIndex = 0;
 109             /*
 110              * Make first packet the current one.
 111              */
 112             // did we already index the packet?
 113             if (getPacketSize() < (fPacketIndex + 1)) {
 114                 // go to the next packet if there is one, index it at the same
 115                 // time
 116                 if (fStreamInput.addPacketHeaderIndex()) {
 117                     fPacketIndex = getPacketSize() - 1;
 118                 }
 119             }
 120             ICTFPacketDescriptor packet = getPacket();
 121             fPacketReader = getCurrentPacketReader(packet);
 122         } catch (Exception e) {
 123             try {
 124                 close();
 125             } catch (IOException e1) {
 126                 // Ignore
 127             }
 128             throw e;
 129         }
 130     }
 131
 132     private IPacketReader getCurrentPacketReader(@Nullable ICTFPacketDescriptor packet) throws CTFException {
 133         IPacketReader ctfPacketReader = NullPacketReader.INSTANCE;
 134         if (packet != null) {
 135             long size = packet.getContentSizeBits();
 136             if (size < 0) {
 137                 throw new CTFIOException("Cannot have negative sized buffers."); //$NON-NLS-1$
 138             }
 139             BitBuffer bitBuffer = new BitBuffer(getByteBufferAt(packet.getOffsetBits(), size));
 140             bitBuffer.position(packet.getPayloadStartBits());
 141             IDeclaration eventHeaderDeclaration = getStreamInput().getStream().getEventHeaderDeclaration();
 142             CTFTrace trace = getStreamInput().getStream().getTrace();
 143             ctfPacketReader = new CTFPacketReader(bitBuffer, packet, getEventDeclarations(), eventHeaderDeclaration, getStreamEventContextDecl(), trace.getPacketHeaderDef(), trace);
 144         }
 145         return ctfPacketReader;
 146     }
 147
 148     /**
 149      * Get a bytebuffer map of the file
 150      *
 151      * @param position
 152      *            start offset in bits
 153      * @param size
 154      *            size of the map in bits, use caution
 155      * @return a byte buffer
 156      * @throws CTFException
 157      *             if the map failed in its allocation
 158      *
 159      * @since 2.0
 160      */
 161     public ByteBuffer getByteBufferAt(long position, long size) throws CTFException {
 162         ByteBuffer map;
 163         try {
 164             map = SafeMappedByteBuffer.map(fFileChannel, MapMode.READ_ONLY, position / BITS_PER_BYTE, (size + BITS_PER_BYTE - 1) / BITS_PER_BYTE);
 165         } catch (IOException e) {
 166             throw new CTFIOException(e.getMessage(), e);
 167         }
 168         if (map == null) {
 169             throw new CTFIOException("Failed to allocate mapped byte buffer"); //$NON-NLS-1$
 170         }
 171         return map;
 172     }
 173
 174     /**
 175      * Dispose the StreamInputReader, closes the file channel and its packet
 176      * reader
 177      *
 178      * @throws IOException
 179      *             If an I/O error occurs
 180      */
 181     @Override
 182     public void close() throws IOException {
 183         if (fFileChannel != null) {
 184             fFileChannel.close();
 185         }
 186         fPacketReader = NullPacketReader.INSTANCE;
 187     }
 188
 189     // ------------------------------------------------------------------------
 190     // Getters/Setters/Predicates
 191     // ------------------------------------------------------------------------
 192
 193     /**
 194      * Gets the current event in this stream
 195      *
 196      * @return the current event in the stream, null if the stream is
 197      *         finished/empty/malformed
 198      * @since 2.0
 199      */
 200     public @Nullable IEventDefinition getCurrentEvent() {
 201         return fCurrentEvent;
 202     }
 203
 204     /**
 205      * Gets the name of the stream (it's an id and a number)
 206      *
 207      * @return gets the stream name (it's a number)
 208      */
 209     public int getName() {
 210         return fId;
 211     }
 212
 213     /**
 214      * Sets the name of the stream
 215      *
 216      * @param name
 217      *            the name of the stream, (it's a number)
 218      */
 219     public void setName(int name) {
 220         fId = name;
 221     }
 222
 223     /**
 224      * Gets the CPU of a stream. It's the same as the one in /proc or running
 225      * the asm CPUID instruction
 226      *
 227      * @return The CPU id (a number)
 228      */
 229     public int getCPU() {
 230         return fPacketReader.getCPU();
 231     }
 232
 233     /**
 234      * Gets the filename of the stream being read
 235      *
 236      * @return The filename of the stream being read
 237      */
 238     public String getFilename() {
 239         return fStreamInput.getFilename();
 240     }
 241
 242     /*
 243      * for internal use only
 244      */
 245     CTFStreamInput getStreamInput() {
 246         return fStreamInput;
 247     }
 248
 249     /**
 250      * Gets the event definition set for this StreamInput
 251      *
 252      * @return Unmodifiable set with the event definitions
 253      * @since 2.0
 254      */
 255     public List<@Nullable IEventDeclaration> getEventDeclarations() {
 256         return fStreamInput.getStream().getEventDeclarations();
 257     }
 258
 259     /**
 260      * Set the trace to live mode
 261      *
 262      * @param live
 263      *            whether the trace is read live or not
 264      */
 265     public void setLive(boolean live) {
 266         fLive = live;
 267     }
 268
 269     /**
 270      * Get if the trace is to read live or not
 271      *
 272      * @return whether the trace is live or not
 273      */
 274     public boolean isLive() {
 275         return fLive;
 276     }
 277
 278     /**
 279      * Get the event context of the stream
 280      *
 281      * @return the event context declaration of the stream
 282      */
 283     public @Nullable StructDeclaration getStreamEventContextDecl() {
 284         return getStreamInput().getStream().getEventContextDecl();
 285     }
 286
 287     // ------------------------------------------------------------------------
 288     // Operations
 289     // ------------------------------------------------------------------------
 290     /**
 291      * Reads the next event in the current event variable.
 292      *
 293      * @return If an event has been successfully read.
 294      * @throws CTFException
 295      *             if an error occurs
 296      */
 297     public CTFResponse readNextEvent() throws CTFException {
 298
 299         /*
 300          * Change packet if needed
 301          */
 302         if (!fPacketReader.hasMoreEvents()) {
 303             final ICTFPacketDescriptor prevPacket = fPacketReader.getCurrentPacket();
 304             if (prevPacket != null || fLive) {
 305                 goToNextPacket();
 306             }
 307
 308         }
 309
 310         /*
 311          * If an event is available, read it.
 312          */
 313         if (fPacketReader.hasMoreEvents()) {
 314             setCurrentEvent(fPacketReader.readNextEvent());
 315             return CTFResponse.OK;
 316         }
 317         this.setCurrentEvent(null);
 318         return fLive ? CTFResponse.WAIT : CTFResponse.FINISH;
 319     }
 320
 321     /**
 322      * Change the current packet of the packet reader to the next one.
 323      *
 324      * @throws CTFException
 325      *             if an error occurs
 326      */
 327     private void goToNextPacket() throws CTFException {
 328         fPacketIndex++;
 329         // did we already index the packet?
 330         while (getPacketSize() < (fPacketIndex + 1)) {
 331             // go to the next packet if there is one, index it at the same time
 332             if (fStreamInput.addPacketHeaderIndex()) {
 333                 fPacketIndex = getPacketSize() - 1;
 334             } else {
 335                 fPacketReader = NullPacketReader.INSTANCE;
 336                 return;
 337             }
 338
 339         }
 340         ICTFPacketDescriptor packet = getPacket();
 341         fPacketReader = getCurrentPacketReader(packet);
 342
 343     }
 344
 345     /**
 346      * @return
 347      */
 348     private int getPacketSize() {
 349         return fStreamInput.getIndex().size();
 350     }
 351
 352     /**
 353      * Changes the location of the trace file reader so that the current event
 354      * is the first event with a timestamp greater or equal the given timestamp.
 355      *
 356      * @param timestamp
 357      *            The timestamp to seek to.
 358      * @return The offset compared to the current position
 359      * @throws CTFException
 360      *             if an error occurs
 361      */
 362     public long seek(long timestamp) throws CTFException {
 363         long offset = 0;
 364
 365         gotoPacket(timestamp);
 366
 367         /*
 368          * index up to the desired timestamp.
 369          */
 370         while ((fPacketReader.getCurrentPacket() != null)
 371                 && (fPacketReader.getCurrentPacket().getTimestampEnd() < timestamp)) {
 372             try {
 373                 fStreamInput.addPacketHeaderIndex();
 374                 goToNextPacket();
 375             } catch (CTFException e) {
 376                 // do nothing here
 377                 Activator.log(e.getMessage());
 378             }
 379         }
 380         if (fPacketReader.getCurrentPacket() == null) {
 381             gotoPacket(timestamp);
 382         }
 383
 384         /*
 385          * Advance until either of these conditions are met:
 386          *
 387          * - reached the end of the trace file (the given timestamp is after the
 388          * last event)
 389          *
 390          * - found the first event with a timestamp greater or equal the given
 391          * timestamp.
 392          */
 393         readNextEvent();
 394         IEventDefinition currentEvent = getCurrentEvent();
 395         while (currentEvent != null && (currentEvent.getTimestamp() < timestamp)) {
 396             readNextEvent();
 397             currentEvent = getCurrentEvent();
 398             offset++;
 399         }
 400         return offset;
 401     }
 402
 403     /**
 404      * @param timestamp
 405      *            the time to seek
 406      * @throws CTFException
 407      *             if an error occurs
 408      */
 409     private void gotoPacket(long timestamp) throws CTFException {
 410         fPacketIndex = fStreamInput.getIndex().search(timestamp) - 1;
 411         /*
 412          * Switch to this packet.
 413          */
 414         goToNextPacket();
 415     }
 416
 417     /**
 418      * Seeks the last event of a stream and returns it.
 419      *
 420      * @throws CTFException
 421      *             if an error occurs
 422      */
 423     public void goToLastEvent() throws CTFException {
 424
 425         /*
 426          * Go to the beginning of the trace
 427          */
 428         seek(0);
 429
 430         /*
 431          * Check that there is at least one event
 432          */
 433         if ((fStreamInput.getIndex().isEmpty()) || (!fPacketReader.hasMoreEvents())) {
 434             /*
 435              * This means the trace is empty. abort.
 436              */
 437             return;
 438         }
 439
 440         fPacketIndex = fStreamInput.getIndex().size() - 1;
 441         /*
 442          * Go to last indexed packet
 443          */
 444         fPacketReader = getCurrentPacketReader(getPacket());
 445
 446         /*
 447          * Keep going until you cannot
 448          */
 449         while (fPacketReader.getCurrentPacket() != null) {
 450             goToNextPacket();
 451         }
 452
 453         final int lastPacketIndex = fStreamInput.getIndex().size() - 1;
 454         /*
 455          * Go to the last packet that contains events.
 456          */
 457         for (int pos = lastPacketIndex; pos > 0; pos--) {
 458             fPacketIndex = pos;
 459             fPacketReader = getCurrentPacketReader(getPacket());
 460
 461             if (fPacketReader.hasMoreEvents()) {
 462                 break;
 463             }
 464         }
 465
 466         /*
 467          * Go until the end of that packet
 468          */
 469         IEventDefinition prevEvent = null;
 470         while (fCurrentEvent != null) {
 471             prevEvent = fCurrentEvent;
 472             readNextEvent();
 473         }
 474         /*
 475          * Go back to the previous event
 476          */
 477         setCurrentEvent(prevEvent);
 478     }
 479
 480     /**
 481      * Sets the current event in a stream input reader
 482      *
 483      * @param currentEvent
 484      *            the event to set
 485      * @since 2.0
 486      */
 487     public void setCurrentEvent(@Nullable IEventDefinition currentEvent) {
 488         fCurrentEvent = currentEvent;
 489     }
 490
 491     /**
 492      * @return the packetIndexIt
 493      */
 494     private int getPacketIndex() {
 495         return fPacketIndex;
 496     }
 497
 498     private @Nullable ICTFPacketDescriptor getPacket() {
 499         if (getPacketIndex() >= fStreamInput.getIndex().size()) {
 500             return null;
 501         }
 502         return fStreamInput.getIndex().getElement(getPacketIndex());
 503     }
 504
 505     /**
 506      * Get the current packet reader
 507      *
 508      * @return the packetReader
 509      * @since 2.0
 510      */
 511     public IPacketReader getCurrentPacketReader() {
 512         return fPacketReader;
 513     }
 514
 515     @Override
 516     public int hashCode() {
 517         final int prime = 31;
 518         int result = 1;
 519         result = (prime * result) + fId;
 520         result = (prime * result)
 521                 + fFile.hashCode();
 522         return result;
 523     }
 524
 525     @Override
 526     public boolean equals(@Nullable Object obj) {
 527         if (this == obj) {
 528             return true;
 529         }
 530         if (obj == null) {
 531             return false;
 532         }
 533         if (!(obj instanceof CTFStreamInputReader)) {
 534             return false;
 535         }
 536         CTFStreamInputReader other = (CTFStreamInputReader) obj;
 537         if (fId != other.fId) {
 538             return false;
 539         }
 540         return fFile.equals(other.fFile);
 541     }
 542
 543     @Override
 544     public String toString() {
 545         // this helps debugging
 546         return fId + ' ' + NonNullUtils.nullToEmptyString(fCurrentEvent);
 547     }
 548
 549 }