org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/trace/TmfExperiment.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2010, 2012 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made 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  *   Francois Chouinard - Initial API and implementation
  11  *   Francois Chouinard - Updated as per TMF Trace Model 1.0
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.tmf.core.trace;
  15
  16 import org.eclipse.core.resources.IFile;
  17 import org.eclipse.core.resources.IProject;
  18 import org.eclipse.core.resources.IResource;
  19 import org.eclipse.linuxtools.internal.tmf.core.trace.TmfExperimentContext;
  20 import org.eclipse.linuxtools.internal.tmf.core.trace.TmfExperimentLocation;
  21 import org.eclipse.linuxtools.internal.tmf.core.trace.TmfLocationArray;
  22 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  23 import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
  24 import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
  25 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  26 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
  27 import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
  28 import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
  29 import org.eclipse.linuxtools.tmf.core.signal.TmfEndSynchSignal;
  30 import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentDisposedSignal;
  31 import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentRangeUpdatedSignal;
  32 import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal;
  33 import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentUpdatedSignal;
  34 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  35 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceUpdatedSignal;
  36
  37 /**
  38  * TmfExperiment presents a time-ordered, unified view of a set of ITmfTrace:s
  39  * that are part of a tracing experiment.
  40  *
  41  * @version 1.0
  42  * @author Francois Chouinard
  43  */
  44 public class TmfExperiment<T extends ITmfEvent> extends TmfTrace<T> implements ITmfEventParser<T> {
  45
  46     // ------------------------------------------------------------------------
  47     // Constants
  48     // ------------------------------------------------------------------------
  49
  50     /**
  51      * The default index page size
  52      */
  53     public static final int DEFAULT_INDEX_PAGE_SIZE = 5000;
  54
  55     // ------------------------------------------------------------------------
  56     // Attributes
  57     // ------------------------------------------------------------------------
  58
  59     /**
  60      * The currently selected experiment (null if none)
  61      */
  62     protected static TmfExperiment<?> fCurrentExperiment = null;
  63
  64     /**
  65      * The set of traces that constitute the experiment
  66      */
  67     protected ITmfTrace<T>[] fTraces;
  68
  69     /**
  70      * The set of traces that constitute the experiment
  71      */
  72     private boolean fInitialized = false;
  73
  74     /**
  75      * The experiment bookmarks file
  76      */
  77     private IFile fBookmarksFile;
  78
  79
  80     // Saved experiment context (optimization)
  81     private TmfExperimentContext fExperimentContext;
  82
  83     // ------------------------------------------------------------------------
  84     // Construction
  85     // ------------------------------------------------------------------------
  86
  87     /**
  88      * @param type
  89      * @param id
  90      * @param traces
  91      * @throws TmfTraceException
  92      */
  93     public TmfExperiment(final Class<T> type, final String id, final ITmfTrace<T>[] traces) {
  94         this(type, id, traces, DEFAULT_INDEX_PAGE_SIZE);
  95     }
  96
  97     /**
  98      * @param type
  99      * @param id
 100      * @param traces
 101      * @param indexPageSize
 102      * @throws TmfTraceException
 103      */
 104     @SuppressWarnings({ "unchecked", "rawtypes" })
 105     public TmfExperiment(final Class<T> type, final String path, final ITmfTrace<T>[] traces, final int indexPageSize) {
 106         setCacheSize(indexPageSize);
 107         setStreamingInterval(0);
 108         setIndexer(new TmfCheckpointIndexer(this, indexPageSize));
 109         setParser(this);
 110         try {
 111             super.initialize(null, path, type);
 112         } catch (TmfTraceException e) {
 113             e.printStackTrace();
 114         }
 115
 116         fTraces = traces;
 117         setTimeRange(TmfTimeRange.NULL_RANGE);
 118     }
 119
 120     /**
 121      * Clears the experiment
 122      */
 123     @Override
 124     @SuppressWarnings("rawtypes")
 125     public synchronized void dispose() {
 126
 127         final TmfExperimentDisposedSignal<T> signal = new TmfExperimentDisposedSignal<T>(this, this);
 128         broadcast(signal);
 129
 130         if (fCurrentExperiment == this) {
 131             fCurrentExperiment = null;
 132         }
 133
 134         // Clean up the index if applicable
 135         if (getIndexer() != null) {
 136             getIndexer().dispose();
 137         }
 138
 139         if (fTraces != null) {
 140             for (final ITmfTrace trace : fTraces)
 141                 trace.dispose();
 142             fTraces = null;
 143         }
 144         super.dispose();
 145     }
 146
 147     // ------------------------------------------------------------------------
 148     // ITmfTrace - Initializers
 149     // ------------------------------------------------------------------------
 150
 151     /* (non-Javadoc)
 152      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#validate(org.eclipse.core.resources.IProject, java.lang.String)
 153      */
 154     @Override
 155     public boolean validate(final IProject project, final String path) {
 156         return true;
 157     }
 158
 159     /* (non-Javadoc)
 160      * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#initTrace(org.eclipse.core.resources.IResource, java.lang.String, java.lang.Class)
 161      */
 162     @Override
 163     public void initTrace(final IResource resource, final String path, final Class<T> type) {
 164     }
 165
 166     // ------------------------------------------------------------------------
 167     // Accessors
 168     // ------------------------------------------------------------------------
 169
 170     /**
 171      * Selects the current, framework-wide, experiment
 172      *
 173      * @param experiment das experiment
 174      */
 175     public static void setCurrentExperiment(final TmfExperiment<?> experiment) {
 176         if (fCurrentExperiment != null && fCurrentExperiment != experiment) {
 177             fCurrentExperiment.dispose();
 178         }
 179         fCurrentExperiment = experiment;
 180     }
 181
 182     /**
 183      * @return das experiment
 184      */
 185     public static TmfExperiment<?> getCurrentExperiment() {
 186         return fCurrentExperiment;
 187     }
 188
 189     /**
 190      * Get the list of traces. Handle with care...
 191      *
 192      * @return the experiment traces
 193      */
 194     public ITmfTrace<T>[] getTraces() {
 195         return fTraces;
 196     }
 197
 198     /**
 199      * Returns the timestamp of the event at the requested index. If none,
 200      * returns null.
 201      *
 202      * @param index the event index (rank)
 203      * @return the corresponding event timestamp
 204      */
 205     public ITmfTimestamp getTimestamp(final int index) {
 206         final ITmfContext context = seekEvent(index);
 207         final ITmfEvent event = getNext(context);
 208         return (event != null) ? event.getTimestamp() : null;
 209     }
 210
 211     /**
 212      * Set the file to be used for bookmarks on this experiment
 213      *
 214      * @param file the bookmarks file
 215      */
 216     public void setBookmarksFile(final IFile file) {
 217         fBookmarksFile = file;
 218     }
 219
 220     /**
 221      * Get the file used for bookmarks on this experiment
 222      *
 223      * @return the bookmarks file or null if none is set
 224      */
 225     public IFile getBookmarksFile() {
 226         return fBookmarksFile;
 227     }
 228
 229     // ------------------------------------------------------------------------
 230     // Request management
 231     // ------------------------------------------------------------------------
 232
 233     /* (non-Javadoc)
 234      * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#armRequest(org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest)
 235      */
 236     @Override
 237     protected synchronized ITmfContext armRequest(final ITmfDataRequest<T> request) {
 238
 239         // Make sure we have something to read from
 240         if (fTraces == null) {
 241             return null;
 242         }
 243
 244         if (request instanceof ITmfEventRequest<?>
 245             && !TmfTimestamp.BIG_BANG.equals(((ITmfEventRequest<T>) request).getRange().getStartTime())
 246             && request.getIndex() == 0)
 247         {
 248             final ITmfContext context = seekEvent(((ITmfEventRequest<T>) request).getRange().getStartTime());
 249             ((ITmfEventRequest<T>) request).setStartIndex((int) context.getRank());
 250             return context;
 251
 252         }
 253
 254         // Check if we are already at the right index
 255         if ((fExperimentContext != null) && fExperimentContext.getRank() == request.getIndex()) {
 256             return fExperimentContext;
 257         }
 258
 259         return seekEvent(request.getIndex());
 260     }
 261
 262     // ------------------------------------------------------------------------
 263     // ITmfTrace trace positioning
 264     // ------------------------------------------------------------------------
 265
 266     /* (non-Javadoc)
 267      * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#seekEvent(long)
 268      *
 269      * TmfTrace.seekEvent(rank) will return a context that will position the
 270      * trace to read the event at rank 'rank' in the trace. In the case of an
 271      * experiment context, that event has to be actually read in the fEvents
 272      * buffer and the corresponding trace context has to point to the next
 273      * event (rank + 1) in the trace (the sum of the traces contexts ranks
 274      * should equal [exp context rank + #traces] (corner cases not considered).
 275      *
 276      * In the likely case that TmfTrace.seekEvent() computed the context
 277      * by using a read loop (reading from the experiment), the 'lastTraceRead'
 278      * field will be set to the actual trace that needs to be read to obtain
 279      * event at rank 'rank'.
 280      *
 281      * Therefore, if 'lastTraceRead' is set, we need to read that particular
 282      * trace *and* then decrease the context rank (which has to correspond to
 283      * the rank of the event to be returned next by TmfExperiemnt.getNext().
 284      */
 285     @Override
 286     public synchronized ITmfContext seekEvent(final long rank) {
 287         TmfExperimentContext context = (TmfExperimentContext) super.seekEvent(rank);
 288         int lastTrace = context.getLastTrace();
 289         if (lastTrace != TmfExperimentContext.NO_TRACE) {
 290             getNext(context);
 291             context.setRank(rank);
 292             context.setLastTrace(TmfExperimentContext.NO_TRACE);
 293         }
 294         return context;
 295     }
 296
 297     /* (non-Javadoc)
 298      *
 299      * Returns a brand new context based on the location provided and
 300      * initializes the event queues
 301      *
 302      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#seekEvent(org.eclipse.linuxtools.tmf.core.trace.ITmfLocation)
 303      */
 304     @Override
 305     public synchronized ITmfContext seekEvent(final ITmfLocation<?> location) {
 306         // Validate the location
 307         if (location != null && !(location instanceof TmfExperimentLocation)) {
 308             return null; // Throw an exception?
 309         }
 310         // Make sure we have something to read from
 311         if (fTraces == null) {
 312             return null;
 313         }
 314
 315         // Instantiate the location
 316         final TmfExperimentLocation expLocation = (location == null)
 317                 ? new TmfExperimentLocation(new TmfLocationArray(new ITmfLocation<?>[fTraces.length]))
 318                 : (TmfExperimentLocation) location.clone();
 319
 320         // Create and populate the context's traces contexts
 321         final TmfExperimentContext context = new TmfExperimentContext(new ITmfContext[fTraces.length]);
 322
 323         for (int i = 0; i < fTraces.length; i++) {
 324             // Get the relevant trace attributes
 325             final ITmfLocation<?> trcLocation = expLocation.getLocation().getLocations()[i];
 326             context.getContexts()[i] = fTraces[i].seekEvent(trcLocation);
 327             expLocation.getLocation().getLocations()[i] = context.getContexts()[i].getLocation().clone();
 328             context.getEvents()[i] = fTraces[i].getNext(context.getContexts()[i]);
 329         }
 330
 331         // Finalize context
 332         context.setLocation(expLocation);
 333         context.setLastTrace(TmfExperimentContext.NO_TRACE);
 334         context.setRank(ITmfContext.UNKNOWN_RANK);
 335
 336         fExperimentContext = context;
 337         return (ITmfContext) context;
 338     }
 339
 340     // ------------------------------------------------------------------------
 341     // ITmfTrace - SeekEvent operations (returning a trace context)
 342     // ------------------------------------------------------------------------
 343
 344     /* (non-Javadoc)
 345      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#seekEvent(double)
 346      */
 347     @Override
 348     public ITmfContext seekEvent(final double ratio) {
 349         final ITmfContext context = seekEvent((long) (ratio * getNbEvents()));
 350         return context;
 351     }
 352
 353     /* (non-Javadoc)
 354      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getLocationRatio(org.eclipse.linuxtools.tmf.core.trace.ITmfLocation)
 355      */
 356     @Override
 357     public double getLocationRatio(final ITmfLocation<?> location) {
 358         if (location instanceof TmfExperimentLocation) {
 359             return (double) seekEvent(location).getRank() / getNbEvents();
 360         }
 361         return 0.0;
 362     }
 363
 364     /* (non-Javadoc)
 365      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getCurrentLocation()
 366      */
 367     @Override
 368     public ITmfLocation<?> getCurrentLocation() {
 369         ITmfLocation<?>[] locations = new ITmfLocation<?>[fTraces.length];
 370         for (int i = 0; i < fTraces.length; i++) {
 371             locations[i] = fTraces[i].getCurrentLocation();
 372         }
 373         return new TmfExperimentLocation(new TmfLocationArray(locations));
 374     }
 375
 376     // ------------------------------------------------------------------------
 377     // ITmfTrace trace positioning
 378     // ------------------------------------------------------------------------
 379
 380     /* (non-Javadoc)
 381      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfEventParser#parseEvent(org.eclipse.linuxtools.tmf.core.trace.ITmfContext)
 382      */
 383     @Override
 384     public synchronized T parseEvent(final ITmfContext context) {
 385         final ITmfContext savedContext = context.clone();
 386         final T event = getNext(savedContext);
 387         return event;
 388     }
 389
 390     /* (non-Javadoc)
 391      * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#getNext(org.eclipse.linuxtools.tmf.core.trace.ITmfContext)
 392      */
 393     @Override
 394     @SuppressWarnings("unchecked")
 395     public synchronized T getNext(ITmfContext context) {
 396
 397         // Validate the context
 398         if (!(context instanceof TmfExperimentContext)) {
 399             return null; // Throw an exception?
 400         }
 401
 402         // Make sure that we have something to read from
 403         if (fTraces == null) {
 404             return null;
 405         }
 406
 407         TmfExperimentContext expContext = (TmfExperimentContext) context;
 408
 409         // If an event was consumed previously, first get the next one from that trace
 410         final int lastTrace = expContext.getLastTrace();
 411         if (lastTrace != TmfExperimentContext.NO_TRACE) {
 412             final ITmfContext traceContext = expContext.getContexts()[lastTrace];
 413
 414             TmfExperimentLocation location = (TmfExperimentLocation) expContext.getLocation();
 415             if (location != null) {
 416                 location.getLocation().getLocations()[lastTrace] = traceContext.getLocation().clone();
 417             }
 418
 419             expContext.getEvents()[lastTrace] = fTraces[lastTrace].getNext(traceContext);
 420             expContext.setLastTrace(TmfExperimentContext.NO_TRACE);
 421         }
 422
 423         // Scan the candidate events and identify the "next" trace to read from
 424         int trace = TmfExperimentContext.NO_TRACE;
 425         ITmfTimestamp timestamp = TmfTimestamp.BIG_CRUNCH;
 426         for (int i = 0; i < fTraces.length; i++) {
 427             final ITmfEvent event = expContext.getEvents()[i];
 428             if (event != null && event.getTimestamp() != null) {
 429                 final ITmfTimestamp otherTS = event.getTimestamp();
 430                 if (otherTS.compareTo(timestamp, true) < 0) {
 431                     trace = i;
 432                     timestamp = otherTS;
 433                 }
 434             }
 435         }
 436
 437         T event = null;
 438         if (trace != TmfExperimentContext.NO_TRACE) {
 439             event = (T) expContext.getEvents()[trace];
 440             if (event != null) {
 441                 updateAttributes(expContext, event.getTimestamp());
 442                 expContext.increaseRank();
 443                 expContext.setLastTrace(trace);
 444                 fExperimentContext = expContext;
 445                 processEvent(event);
 446             }
 447         }
 448
 449         return event;
 450     }
 451
 452     /* (non-Javadoc)
 453      * @see java.lang.Object#toString()
 454      */
 455     @Override
 456     @SuppressWarnings("nls")
 457     public String toString() {
 458         return "[TmfExperiment (" + getName() + ")]";
 459     }
 460
 461     // ------------------------------------------------------------------------
 462     // Streaming support
 463     // ------------------------------------------------------------------------
 464
 465     private synchronized void initializeStreamingMonitor() {
 466
 467         if (fInitialized) {
 468             return;
 469         }
 470         fInitialized = true;
 471
 472         if (getStreamingInterval() == 0) {
 473             final ITmfContext context = seekEvent(0);
 474             final ITmfEvent event = getNext(context);
 475             if (event == null)
 476                 return;
 477             final TmfTimeRange timeRange = new TmfTimeRange(event.getTimestamp().clone(), TmfTimestamp.BIG_CRUNCH);
 478             final TmfExperimentRangeUpdatedSignal signal = new TmfExperimentRangeUpdatedSignal(this, this, timeRange);
 479
 480             // Broadcast in separate thread to prevent deadlock
 481             new Thread() {
 482                 @Override
 483                 public void run() {
 484                     broadcast(signal);
 485                 }
 486             }.start();
 487             return;
 488         }
 489
 490         final Thread thread = new Thread("Streaming Monitor for experiment " + getName()) { //$NON-NLS-1$
 491             private ITmfTimestamp safeTimestamp = null;
 492             private TmfTimeRange timeRange = null;
 493
 494             @Override
 495             public void run() {
 496                 while (!fExecutor.isShutdown()) {
 497                     if (!getIndexer().isIndexing()) {
 498                         ITmfTimestamp startTimestamp = TmfTimestamp.BIG_CRUNCH;
 499                         ITmfTimestamp endTimestamp = TmfTimestamp.BIG_BANG;
 500                         for (final ITmfTrace<T> trace : fTraces) {
 501                             if (trace.getStartTime().compareTo(startTimestamp) < 0)
 502                                 startTimestamp = trace.getStartTime();
 503                             if (trace.getStreamingInterval() != 0 && trace.getEndTime().compareTo(endTimestamp) > 0)
 504                                 endTimestamp = trace.getEndTime();
 505                         }
 506                         if (safeTimestamp != null && safeTimestamp.compareTo(getTimeRange().getEndTime(), false) > 0)
 507                             timeRange = new TmfTimeRange(startTimestamp, safeTimestamp);
 508                         else
 509                             timeRange = null;
 510                         safeTimestamp = endTimestamp;
 511                         if (timeRange != null) {
 512                             final TmfExperimentRangeUpdatedSignal signal =
 513                                     new TmfExperimentRangeUpdatedSignal(TmfExperiment.this, TmfExperiment.this, timeRange);
 514                             broadcast(signal);
 515                         }
 516                     }
 517                     try {
 518                         Thread.sleep(getStreamingInterval());
 519                     } catch (final InterruptedException e) {
 520                         e.printStackTrace();
 521                     }
 522                 }
 523             }
 524         };
 525         thread.start();
 526     }
 527
 528     /* (non-Javadoc)
 529      * @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#getStreamingInterval()
 530      */
 531     @Override
 532     public long getStreamingInterval() {
 533         long interval = 0;
 534         for (final ITmfTrace<T> trace : fTraces)
 535             interval = Math.max(interval, trace.getStreamingInterval());
 536         return interval;
 537     }
 538
 539     // ------------------------------------------------------------------------
 540     // Signal handlers
 541     // ------------------------------------------------------------------------
 542
 543     private Integer fEndSynchReference;
 544
 545     /**
 546      * Signal handler for the TmfExperimentSelectedSignal signal
 547      *
 548      * @param signal
 549      */
 550     @TmfSignalHandler
 551     public void experimentSelected(final TmfExperimentSelectedSignal<T> signal) {
 552         final TmfExperiment<?> experiment = signal.getExperiment();
 553         if (experiment == this) {
 554             setCurrentExperiment(experiment);
 555             fEndSynchReference = Integer.valueOf(signal.getReference());
 556         }
 557     }
 558
 559     /**
 560      * Signal handler for the TmfEndSynchSignal signal
 561      *
 562      * @param signal
 563      */
 564     @TmfSignalHandler
 565     public void endSync(final TmfEndSynchSignal signal) {
 566         if (fEndSynchReference != null && fEndSynchReference.intValue() == signal.getReference()) {
 567             fEndSynchReference = null;
 568             initializeStreamingMonitor();
 569         }
 570     }
 571
 572     /**
 573      * Signal handler for the TmfTraceUpdatedSignal signal
 574      *
 575      * @param signal
 576      */
 577     @TmfSignalHandler
 578     public void traceUpdated(final TmfTraceUpdatedSignal signal) {
 579         if (signal.getTrace() == this) {
 580             broadcast(new TmfExperimentUpdatedSignal(this, this));
 581         }
 582     }
 583
 584     /**
 585      * Signal handler for the TmfExperimentRangeUpdatedSignal signal
 586      *
 587      * @param signal
 588      */
 589     @TmfSignalHandler
 590     public void experimentRangeUpdated(final TmfExperimentRangeUpdatedSignal signal) {
 591         if (signal.getExperiment() == this) {
 592             getIndexer().buildIndex(getNbEvents(), signal.getRange(), false);
 593         }
 594     }
 595
 596 }