ctf/org.eclipse.tracecompass.tmf.ctf.core/src/org/eclipse/tracecompass/tmf/ctf/core/trace/CtfTmfTrace.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2015 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  *   Patrick Tasse - Updated for removal of context clone
  12  *   Geneviève Bastien - Added the createTimestamp function
  13  *******************************************************************************/
  14
  15 package org.eclipse.tracecompass.tmf.ctf.core.trace;
  16
  17 import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
  18
  19 import java.nio.BufferOverflowException;
  20 import java.nio.ByteBuffer;
  21 import java.util.ArrayList;
  22 import java.util.Collection;
  23 import java.util.Collections;
  24 import java.util.HashMap;
  25 import java.util.HashSet;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.Set;
  29
  30 import org.eclipse.core.resources.IProject;
  31 import org.eclipse.core.resources.IResource;
  32 import org.eclipse.core.runtime.CoreException;
  33 import org.eclipse.core.runtime.IStatus;
  34 import org.eclipse.core.runtime.Status;
  35 import org.eclipse.jdt.annotation.NonNull;
  36 import org.eclipse.tracecompass.ctf.core.CTFException;
  37 import org.eclipse.tracecompass.ctf.core.event.CTFClock;
  38 import org.eclipse.tracecompass.ctf.core.event.IEventDeclaration;
  39 import org.eclipse.tracecompass.ctf.core.event.types.StructDeclaration;
  40 import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
  41 import org.eclipse.tracecompass.ctf.core.trace.CTFTraceReader;
  42 import org.eclipse.tracecompass.ctf.core.trace.Metadata;
  43 import org.eclipse.tracecompass.internal.tmf.ctf.core.Activator;
  44 import org.eclipse.tracecompass.internal.tmf.ctf.core.trace.iterator.CtfIterator;
  45 import org.eclipse.tracecompass.internal.tmf.ctf.core.trace.iterator.CtfIteratorManager;
  46 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  47 import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
  48 import org.eclipse.tracecompass.tmf.core.event.TmfEventField;
  49 import org.eclipse.tracecompass.tmf.core.event.aspect.TmfBaseAspects;
  50 import org.eclipse.tracecompass.tmf.core.event.aspect.ITmfEventAspect;
  51 import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
  52 import org.eclipse.tracecompass.tmf.core.project.model.ITmfPropertiesProvider;
  53 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
  54 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  55 import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
  56 import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceWithPreDefinedEvents;
  57 import org.eclipse.tracecompass.tmf.core.trace.TmfTrace;
  58 import org.eclipse.tracecompass.tmf.core.trace.TraceValidationStatus;
  59 import org.eclipse.tracecompass.tmf.core.trace.indexer.ITmfPersistentlyIndexable;
  60 import org.eclipse.tracecompass.tmf.core.trace.indexer.ITmfTraceIndexer;
  61 import org.eclipse.tracecompass.tmf.core.trace.indexer.TmfBTreeTraceIndexer;
  62 import org.eclipse.tracecompass.tmf.core.trace.indexer.checkpoint.ITmfCheckpoint;
  63 import org.eclipse.tracecompass.tmf.core.trace.indexer.checkpoint.TmfCheckpoint;
  64 import org.eclipse.tracecompass.tmf.core.trace.location.ITmfLocation;
  65 import org.eclipse.tracecompass.tmf.ctf.core.CtfConstants;
  66 import org.eclipse.tracecompass.tmf.ctf.core.context.CtfLocation;
  67 import org.eclipse.tracecompass.tmf.ctf.core.context.CtfLocationInfo;
  68 import org.eclipse.tracecompass.tmf.ctf.core.context.CtfTmfContext;
  69 import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
  70 import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEventFactory;
  71 import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEventType;
  72 import org.eclipse.tracecompass.tmf.ctf.core.event.aspect.CtfChannelAspect;
  73 import org.eclipse.tracecompass.tmf.ctf.core.event.aspect.CtfCpuAspect;
  74
  75 import com.google.common.collect.ImmutableList;
  76 import com.google.common.collect.ImmutableSet;
  77
  78 /**
  79  * The CTf trace handler
  80  *
  81  * @version 1.0
  82  * @author Matthew khouzam
  83  */
  84 public class CtfTmfTrace extends TmfTrace
  85         implements ITmfPropertiesProvider, ITmfPersistentlyIndexable,
  86         ITmfTraceWithPreDefinedEvents {
  87
  88     // -------------------------------------------
  89     // Constants
  90     // -------------------------------------------
  91
  92     /**
  93      * Clock offset property
  94      * @since 2.0
  95      */
  96     public static final String CLOCK_OFFSET = "clock_offset"; //$NON-NLS-1$
  97
  98     /**
  99      * Default cache size for CTF traces
 100      */
 101     protected static final int DEFAULT_CACHE_SIZE = 50000;
 102
 103     /**
 104      * Event aspects available for all CTF traces
 105      * @since 1.0
 106      */
 107     protected static final @NonNull Collection<@NonNull ITmfEventAspect<?>> CTF_ASPECTS =
 108             ImmutableList.of(
 109                     TmfBaseAspects.getTimestampAspect(),
 110                     new CtfChannelAspect(),
 111                     new CtfCpuAspect(),
 112                     TmfBaseAspects.getEventTypeAspect(),
 113                     TmfBaseAspects.getContentsAspect()
 114                     );
 115
 116     /**
 117      * The Ctf clock unique identifier field
 118      */
 119     private static final String CLOCK_HOST_PROPERTY = "uuid"; //$NON-NLS-1$
 120     private static final int CONFIDENCE = 10;
 121     private static final int MIN_CONFIDENCE = 1;
 122
 123     // -------------------------------------------
 124     // Fields
 125     // -------------------------------------------
 126
 127     private final Map<@NonNull String, @NonNull CtfTmfEventType> fContainedEventTypes =
 128             Collections.synchronizedMap(new HashMap<>());
 129
 130     private final CtfIteratorManager fIteratorManager = new CtfIteratorManager(this);
 131
 132     private final @NonNull CtfTmfEventFactory fEventFactory;
 133
 134     /** Reference to the CTF Trace */
 135     private CTFTrace fTrace;
 136
 137     // -------------------------------------------
 138     // Constructor
 139     // -------------------------------------------
 140
 141     /**
 142      * Default constructor
 143      */
 144     public CtfTmfTrace() {
 145         super();
 146
 147         /* Use default event factory */
 148         fEventFactory = CtfTmfEventFactory.instance();
 149     }
 150
 151     /**
 152      * Constructor for sub-classes to specify their own event factory.
 153      *
 154      * @param eventFactory
 155      *            The event factory to use to generate trace events
 156      * @since 2.0
 157      */
 158     protected CtfTmfTrace(@NonNull CtfTmfEventFactory eventFactory) {
 159         super();
 160         fEventFactory = eventFactory;
 161     }
 162
 163     // -------------------------------------------
 164     // TmfTrace Overrides
 165     // -------------------------------------------
 166     /**
 167      * Method initTrace.
 168      *
 169      * @param resource
 170      *            The resource associated with this trace
 171      * @param path
 172      *            The path to the trace file
 173      * @param eventType
 174      *            The type of events that will be read from this trace
 175      * @throws TmfTraceException
 176      *             If something went wrong while reading the trace
 177      */
 178     @Override
 179     public void initTrace(final IResource resource, final String path, final Class<? extends ITmfEvent> eventType)
 180             throws TmfTraceException {
 181         /*
 182          * Set the cache size. This has to be done before the call to super()
 183          * because the super needs to know the cache size.
 184          */
 185         setCacheSize();
 186
 187         super.initTrace(resource, path, eventType);
 188
 189         try {
 190             this.fTrace = new CTFTrace(path);
 191             CtfTmfContext ctx;
 192             /* Set the start and (current) end times for this trace */
 193             ctx = (CtfTmfContext) seekEvent(0L);
 194             CtfTmfEvent event = getNext(ctx);
 195             if ((ctx.getLocation().equals(CtfIterator.NULL_LOCATION)) || (ctx.getCurrentEvent() == null)) {
 196                 /* Handle the case where the trace is empty */
 197                 this.setStartTime(TmfTimestamp.BIG_BANG);
 198             } else {
 199                 final ITmfTimestamp curTime = event.getTimestamp();
 200                 this.setStartTime(curTime);
 201                 this.setEndTime(curTime);
 202             }
 203             /*
 204              * Register every event type. When you call getType, it will
 205              * register a trace to that type in the TmfEventTypeManager
 206              */
 207             try (CtfIterator iter = fIteratorManager.getIterator(ctx)) {
 208                 Set<@NonNull ITmfEventField> streamContextNames = new HashSet<>();
 209                 for (IEventDeclaration ied : iter.getEventDeclarations()) {
 210                     CtfTmfEventType ctfTmfEventType = fContainedEventTypes.get(ied.getName());
 211                     if (ctfTmfEventType == null) {
 212                         List<ITmfEventField> content = new ArrayList<>();
 213
 214                         /* Should only return null the first time */
 215                         final StructDeclaration fields = ied.getFields();
 216                         if (fields != null) {
 217                             for (String fieldName : fields.getFieldsList()) {
 218                                 content.add(new TmfEventField(checkNotNull(fieldName), null, null));
 219                             }
 220                         }
 221
 222                         /* Add stream contexts */
 223                         final StructDeclaration streamContexts = ied.getStream().getEventContextDecl();
 224                         if (streamContextNames.isEmpty()) {
 225                             if (streamContexts != null) {
 226                                 for (String fieldName : streamContexts.getFieldsList()) {
 227                                     streamContextNames.add(new TmfEventField(checkNotNull(CtfConstants.CONTEXT_FIELD_PREFIX + fieldName), null, null));
 228                                 }
 229                             }
 230                         }
 231                         content.addAll(streamContextNames);
 232
 233                         if (!content.isEmpty()) {
 234                             ITmfEventField contentTree = new TmfEventField(
 235                                     ITmfEventField.ROOT_FIELD_ID,
 236                                     null,
 237                                     content.toArray(new ITmfEventField[content.size()]));
 238
 239                             ctfTmfEventType = new CtfTmfEventType(checkNotNull(ied.getName()), contentTree);
 240                             fContainedEventTypes.put(ctfTmfEventType.getName(), ctfTmfEventType);
 241                         }
 242                     }
 243                 }
 244             }
 245             ctx.dispose();
 246         } catch (final CTFException e) {
 247             /*
 248              * If it failed at the init(), we can assume it's because the file
 249              * was not found or was not recognized as a CTF trace. Throw into
 250              * the new type of exception expected by the rest of TMF.
 251              */
 252             throw new TmfTraceException(e.getMessage(), e);
 253         }
 254     }
 255
 256     @Override
 257     public synchronized void dispose() {
 258         fIteratorManager.dispose();
 259         if (fTrace != null) {
 260             fTrace = null;
 261         }
 262         super.dispose();
 263     }
 264
 265     /**
 266      * {@inheritDoc}
 267      * <p>
 268      * The default implementation of a CTF trace.
 269      *
 270      * Firstly a weak validation of the metadata is done to determine if the
 271      * path is actually for a CTF trace. After that a full validation is done.
 272      *
 273      * If the weak and full validation are successful the confidence is set
 274      * to 10.
 275      *
 276      * If the weak validation was successful, but the full validation fails
 277      * a TraceValidationStatus with severity warning and confidence of 1 is
 278      * returned.
 279      *
 280      * If both weak and full validation fails an error status is returned.
 281      */
 282     @Override
 283     public IStatus validate(final IProject project, final String path) {
 284         boolean isMetadataFile = false;
 285         try {
 286             isMetadataFile = Metadata.preValidate(path);
 287         } catch (final CTFException e) {
 288             return new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.CtfTmfTrace_ReadingError + ": " + e.toString(), e); //$NON-NLS-1$
 289         }
 290
 291         if (isMetadataFile) {
 292             // Trace is pre-validated, continue will full validation
 293             try {
 294                 final CTFTrace trace = new CTFTrace(path);
 295                 if (!trace.majorIsSet()) {
 296                     if (isMetadataFile) {
 297                         return new TraceValidationStatus(MIN_CONFIDENCE, IStatus.WARNING, Activator.PLUGIN_ID, Messages.CtfTmfTrace_MajorNotSet, null);
 298                     }
 299                     return new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.CtfTmfTrace_MajorNotSet);
 300                 }
 301
 302                 // Validate using reader initialization
 303                 try (CTFTraceReader ctfTraceReader = new CTFTraceReader(trace)) {}
 304
 305                 // Trace is validated, return with confidence
 306                 return new CtfTraceValidationStatus(CONFIDENCE, Activator.PLUGIN_ID, trace.getEnvironment());
 307
 308             } catch (final CTFException | BufferOverflowException e ) {
 309                 // return warning since it's a CTF trace but with errors in it
 310                 return new TraceValidationStatus(MIN_CONFIDENCE, IStatus.WARNING, Activator.PLUGIN_ID, Messages.CtfTmfTrace_ReadingError + ": " + e.toString(), e); //$NON-NLS-1$
 311             }
 312         }
 313         return new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.CtfTmfTrace_ReadingError);
 314     }
 315
 316     @Override
 317     public Iterable<ITmfEventAspect<?>> getEventAspects() {
 318         return CTF_ASPECTS;
 319     }
 320
 321     /**
 322      * Method getCurrentLocation. This is not applicable in CTF
 323      *
 324      * @return null, since the trace has no knowledge of the current location
 325      * @see org.eclipse.tracecompass.tmf.core.trace.ITmfTrace#getCurrentLocation()
 326      */
 327     @Override
 328     public ITmfLocation getCurrentLocation() {
 329         return null;
 330     }
 331
 332     @Override
 333     public double getLocationRatio(ITmfLocation location) {
 334         final CtfLocation curLocation = (CtfLocation) location;
 335         final long startTime = getStartTime().getValue();
 336         final double diff = curLocation.getLocationInfo().getTimestamp() - startTime;
 337         final double total = getEndTime().getValue() - startTime;
 338         return Math.max(0.0, Math.min(1.0, diff / total));
 339     }
 340
 341     /**
 342      * Method seekEvent.
 343      *
 344      * @param location
 345      *            ITmfLocation<?>
 346      * @return ITmfContext
 347      */
 348     @Override
 349     public synchronized ITmfContext seekEvent(final ITmfLocation location) {
 350         CtfLocation currentLocation = (CtfLocation) location;
 351         CtfTmfContext context = new CtfTmfContext(this);
 352         if (fTrace == null) {
 353             context.setLocation(null);
 354             context.setRank(ITmfContext.UNKNOWN_RANK);
 355             return context;
 356         }
 357         /*
 358          * The rank is set to 0 if the iterator seeks the beginning. If not, it
 359          * will be set to UNKNOWN_RANK, since CTF traces don't support seeking
 360          * by rank for now.
 361          */
 362         if (currentLocation == null) {
 363             currentLocation = new CtfLocation(new CtfLocationInfo(0L, 0L));
 364             context.setRank(0);
 365         } else {
 366             context.setRank(ITmfContext.UNKNOWN_RANK);
 367         }
 368         /* This will seek and update the location after the seek */
 369         context.setLocation(currentLocation);
 370         return context;
 371     }
 372
 373     @Override
 374     public synchronized ITmfContext seekEvent(double ratio) {
 375         CtfTmfContext context = new CtfTmfContext(this);
 376         if (fTrace == null) {
 377             context.setLocation(null);
 378             context.setRank(ITmfContext.UNKNOWN_RANK);
 379             return context;
 380         }
 381         final long end = getEndTime().getValue();
 382         final long start = getStartTime().getValue();
 383         final long diff = end - start;
 384         final long ratioTs = Math.round(diff * ratio) + start;
 385         context.seek(ratioTs);
 386         context.setRank(ITmfContext.UNKNOWN_RANK);
 387         return context;
 388     }
 389
 390     /**
 391      * Method readNextEvent.
 392      *
 393      * @param context
 394      *            ITmfContext
 395      * @return CtfTmfEvent
 396      * @see org.eclipse.tracecompass.tmf.core.trace.ITmfTrace#getNext(ITmfContext)
 397      */
 398     @Override
 399     public synchronized CtfTmfEvent getNext(final ITmfContext context) {
 400         if (fTrace == null) {
 401             return null;
 402         }
 403         CtfTmfEvent event = null;
 404         if (context instanceof CtfTmfContext) {
 405             if (context.getLocation() == null || CtfLocation.INVALID_LOCATION.equals(context.getLocation().getLocationInfo())) {
 406                 return null;
 407             }
 408             CtfTmfContext ctfContext = (CtfTmfContext) context;
 409             event = ctfContext.getCurrentEvent();
 410
 411             if (event != null) {
 412                 updateAttributes(context, event);
 413                 ctfContext.advance();
 414                 ctfContext.increaseRank();
 415             }
 416         }
 417
 418         return event;
 419     }
 420
 421     /**
 422      * Ctf traces have a clock with a unique uuid that will be used to identify
 423      * the host. Traces with the same clock uuid will be known to have been made
 424      * on the same machine.
 425      *
 426      * Note: uuid is an optional field, it may not be there for a clock.
 427      */
 428     @Override
 429     public String getHostId() {
 430         CTFClock clock = fTrace.getClock();
 431         if (clock != null) {
 432             String clockHost = (String) clock.getProperty(CLOCK_HOST_PROPERTY);
 433             if (clockHost != null) {
 434                 return clockHost;
 435             }
 436         }
 437         return super.getHostId();
 438     }
 439
 440     /**
 441      * Get the CTF environment variables defined in this CTF trace, in <name,
 442      * value> form. This comes from the trace's CTF metadata.
 443      *
 444      * @return The CTF environment
 445      */
 446     public Map<String, String> getEnvironment() {
 447         return fTrace.getEnvironment();
 448     }
 449
 450     // -------------------------------------------
 451     // ITmfPropertiesProvider
 452     // -------------------------------------------
 453
 454     /**
 455      * @since 2.0
 456      */
 457     @Override
 458     public Map<String, String> getProperties() {
 459         Map<String, String> properties = new HashMap<>();
 460         properties.putAll(fTrace.getEnvironment());
 461         properties.put(CLOCK_OFFSET, Long.toUnsignedString(fTrace.getOffset()));
 462         properties.put(Messages.CtfTmfTrace_HostID, getHostId());
 463         return properties;
 464     }
 465
 466     // -------------------------------------------
 467     // Clocks
 468     // -------------------------------------------
 469
 470     /**
 471      * gets the clock offset
 472      *
 473      * @return the clock offset in ns
 474      */
 475     public long getOffset() {
 476         if (fTrace != null) {
 477             return fTrace.getOffset();
 478         }
 479         return 0;
 480     }
 481
 482     /**
 483      * Convert a CTF timestamp in CPU cycles to its equivalent in nanoseconds
 484      * for this trace.
 485      *
 486      * @param cycles
 487      *            The timestamp in cycles
 488      * @return The timestamp in nanoseconds
 489      */
 490     public long timestampCyclesToNanos(long cycles) {
 491         return fTrace.timestampCyclesToNanos(cycles);
 492     }
 493
 494     /**
 495      * Convert a CTF timestamp in nanoseconds to its equivalent in CPU cycles
 496      * for this trace.
 497      *
 498      * @param nanos
 499      *            The timestamp in nanoseconds
 500      * @return The timestamp in cycles
 501      */
 502     public long timestampNanoToCycles(long nanos) {
 503         return fTrace.timestampNanoToCycles(nanos);
 504     }
 505
 506     /**
 507      * Gets the list of declared events
 508      */
 509     @Override
 510     public Set<@NonNull CtfTmfEventType> getContainedEventTypes() {
 511         return ImmutableSet.copyOf(fContainedEventTypes.values());
 512     }
 513
 514     /**
 515      * Register an event type to this trace.
 516      *
 517      * Public visibility so that {@link CtfTmfEvent#getType} can call it.
 518      *
 519      * FIXME This could probably be made cleaner?
 520      *
 521      * @param eventType
 522      *            The event type to register
 523      */
 524     public void registerEventType(CtfTmfEventType eventType) {
 525         fContainedEventTypes.put(eventType.getName(), eventType);
 526     }
 527
 528     // -------------------------------------------
 529     // Parser
 530     // -------------------------------------------
 531
 532     @Override
 533     public CtfTmfEvent parseEvent(ITmfContext context) {
 534         CtfTmfEvent event = null;
 535         if (context instanceof CtfTmfContext) {
 536             final ITmfContext tmpContext = seekEvent(context.getLocation());
 537             event = getNext(tmpContext);
 538         }
 539         return event;
 540     }
 541
 542     /**
 543      * Sets the cache size for a CtfTmfTrace.
 544      */
 545     protected void setCacheSize() {
 546         setCacheSize(DEFAULT_CACHE_SIZE);
 547     }
 548
 549     // -------------------------------------------
 550     // CtfIterator factory methods
 551     // -------------------------------------------
 552
 553     /**
 554      * Get the event factory for this trace to generate new events for it.
 555      *
 556      * @return The event factory
 557      * @since 2.0
 558      */
 559     public @NonNull CtfTmfEventFactory getEventFactory() {
 560         return fEventFactory;
 561     }
 562
 563     /**
 564      * Get an iterator to the trace
 565      *
 566      * @return an iterator to the trace
 567      */
 568     public ITmfContext createIterator() {
 569         try {
 570             return new CtfIterator(fTrace, this);
 571         } catch (CTFException e) {
 572             Activator.getDefault().logError(e.getMessage(), e);
 573         }
 574         return null;
 575     }
 576
 577     /**
 578      * Get an iterator to the trace, , which will initially point to the given
 579      * location/rank.
 580      *
 581      * @param ctfLocationData
 582      *            The initial timestamp the iterator will be pointing to
 583      * @param rank
 584      *            The initial rank
 585      * @return The new iterator
 586      */
 587     public ITmfContext createIterator(CtfLocationInfo ctfLocationData, long rank) {
 588         try {
 589             return new CtfIterator(fTrace, this, ctfLocationData, rank);
 590         } catch (CTFException e) {
 591             Activator.getDefault().logError(e.getMessage(), e);
 592         }
 593         return null;
 594     }
 595
 596     /**
 597      * Create the 'CtfIterator' object from a CtfTmfContext.
 598      *
 599      * @param context
 600      *            The iterator will initially be pointing to this context
 601      * @return A new CtfIterator object
 602      * @since 1.0
 603      */
 604     public ITmfContext createIteratorFromContext(CtfTmfContext context) {
 605         return fIteratorManager.getIterator(context);
 606     }
 607
 608     /**
 609      * Dispose an iterator that was create with
 610      * {@link #createIteratorFromContext}
 611      *
 612      * @param context
 613      *            The last context that was pointed to by the iterator (this is
 614      *            the 'key' to find the correct iterator to dispose).
 615      * @since 1.0
 616      */
 617     public void disposeContext(CtfTmfContext context) {
 618         fIteratorManager.removeIterator(context);
 619     }
 620
 621     // ------------------------------------------------------------------------
 622     // Timestamp transformation functions
 623     // ------------------------------------------------------------------------
 624
 625     /**
 626      * @since 1.0
 627      */
 628     @Override
 629     public @NonNull ITmfTimestamp createTimestamp(long ts) {
 630         return TmfTimestamp.fromNanos(getTimestampTransform().transform(ts));
 631     }
 632
 633     private static int fCheckpointSize = -1;
 634
 635     @Override
 636     public synchronized int getCheckpointSize() {
 637         if (fCheckpointSize == -1) {
 638             TmfCheckpoint c = new TmfCheckpoint(TmfTimestamp.fromNanos(0), new CtfLocation(0, 0), 0);
 639             ByteBuffer b = ByteBuffer.allocate(ITmfCheckpoint.MAX_SERIALIZE_SIZE);
 640             b.clear();
 641             c.serialize(b);
 642             fCheckpointSize = b.position();
 643         }
 644
 645         return fCheckpointSize;
 646     }
 647
 648     @Override
 649     protected ITmfTraceIndexer createIndexer(int interval) {
 650         return new TmfBTreeTraceIndexer(this, interval);
 651     }
 652
 653     @Override
 654     public ITmfLocation restoreLocation(ByteBuffer bufferIn) {
 655         return new CtfLocation(bufferIn);
 656     }
 657
 658     @Override
 659     public boolean isComplete() {
 660         if (getResource() == null) {
 661             return true;
 662         }
 663
 664         String host = null;
 665         String port = null;
 666         String sessionName = null;
 667         try {
 668             host = getResource().getPersistentProperty(CtfConstants.LIVE_HOST);
 669             port = getResource().getPersistentProperty(CtfConstants.LIVE_PORT);
 670             sessionName = getResource().getPersistentProperty(CtfConstants.LIVE_SESSION_NAME);
 671         } catch (CoreException e) {
 672             Activator.getDefault().logError(e.getMessage(), e);
 673             // Something happened to the resource, assume we won't get any more
 674             // data from it
 675             return true;
 676         }
 677         return host == null || port == null || sessionName == null;
 678     }
 679
 680     @Override
 681     public void setComplete(final boolean isComplete) {
 682         super.setComplete(isComplete);
 683         try {
 684             if (isComplete) {
 685                 getResource().setPersistentProperty(CtfConstants.LIVE_HOST, null);
 686                 getResource().setPersistentProperty(CtfConstants.LIVE_PORT, null);
 687                 getResource().setPersistentProperty(CtfConstants.LIVE_SESSION_NAME, null);
 688             }
 689         } catch (CoreException e) {
 690             Activator.getDefault().logError(e.getMessage(), e);
 691         }
 692     }
 693 }