/*******************************************************************************
- * Copyright (c) 2009, 2010, 2012 Ericsson
+ * Copyright (c) 2009, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Updated as per TMF Trace Model 1.0
+ * Patrick Tasse - Updated for removal of context clone
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.trace;
import java.io.File;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.linuxtools.tmf.core.component.TmfEventProvider;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
+import org.eclipse.linuxtools.tmf.core.signal.TmfRangeSynchSignal;
+import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
+import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;
+import org.eclipse.linuxtools.tmf.core.signal.TmfTraceOpenedSignal;
+import org.eclipse.linuxtools.tmf.core.signal.TmfTraceRangeUpdatedSignal;
+import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystem;
+import org.eclipse.linuxtools.tmf.core.statistics.ITmfStatistics;
+import org.eclipse.linuxtools.tmf.core.statistics.TmfStateStatistics;
+import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
+import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange;
+import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
/**
* Abstract implementation of ITmfTrace.
private long fNbEvents = 0;
// The time span of the event stream
- private ITmfTimestamp fStartTime = TmfTimestamp.BIG_CRUNCH;
+ private ITmfTimestamp fStartTime = TmfTimestamp.BIG_BANG;
private ITmfTimestamp fEndTime = TmfTimestamp.BIG_BANG;
// The trace streaming interval (0 = no streaming)
// The trace parser
private ITmfEventParser fParser;
- // ------------------------------------------------------------------------
- // Construction
- // ------------------------------------------------------------------------
+ // The trace's statistics
+ private ITmfStatistics fStatistics;
- /**
- * The default, parameterless, constructor
- */
- public TmfTrace() {
- super();
- }
+ // The current selected time
+ private ITmfTimestamp fCurrentTime = TmfTimestamp.ZERO;
- /**
- * The standard constructor (non-live trace). Applicable when the trace
- * implements its own parser and if at checkpoint-based index is OK.
- *
- * @param resource the resource associated to the trace
- * @param type the trace event type
- * @param path the trace path
- * @param cacheSize the trace cache size
- * @throws TmfTraceException
- */
- protected TmfTrace(final IResource resource, final Class<? extends ITmfEvent> type, final String path, final int cacheSize) throws TmfTraceException {
- this(resource, type, path, cacheSize, 0);
- }
+ // The current selected range
+ private TmfTimeRange fCurrentRange = TmfTimeRange.NULL_RANGE;
/**
- * The standard constructor (live trace). Applicable when the trace
- * implements its own parser and if at checkpoint-based index is OK.
+ * The collection of state systems that are registered with this trace. Each
+ * sub-class can decide to add its (one or many) state system to this map
+ * during their {@link #buildStateSystem()}.
*
- * @param resource the resource associated to the trace
- * @param type the trace event type
- * @param path the trace path
- * @param cacheSize the trace cache size
- * @param interval the trace streaming interval
- * @throws TmfTraceException
+ * @since 2.0
*/
- protected TmfTrace(final IResource resource, final Class<? extends ITmfEvent> type, final String path, final int cacheSize, final long interval) throws TmfTraceException {
- this(resource, type, path, cacheSize, interval, null);
- }
+ protected final Map<String, ITmfStateSystem> fStateSystems =
+ new LinkedHashMap<String, ITmfStateSystem>();
+
+ // ------------------------------------------------------------------------
+ // Construction
+ // ------------------------------------------------------------------------
/**
- * The 'non-default indexer' constructor. Allows to provide a trace
- * specific indexer.
- *
- * @param resource the resource associated to the trace
- * @param type the trace event type
- * @param path the trace path
- * @param cacheSize the trace cache size
- * @param indexer the trace indexer
- * @throws TmfTraceException
+ * The default, parameterless, constructor
*/
- protected TmfTrace(final IResource resource, final Class<? extends ITmfEvent> type, final String path, final int cacheSize,
- final long interval, final ITmfTraceIndexer indexer) throws TmfTraceException {
- this(resource, type, path, cacheSize, interval, indexer, null);
+ public TmfTrace() {
+ super();
}
/**
- * The full constructor where trace specific indexer/parser are provided.
+ * Full constructor.
*
- * @param resource the resource associated to the trace
- * @param type the trace event type
- * @param path the trace path
- * @param cacheSize the trace cache size
- * @param indexer the trace indexer
- * @param parser the trace event parser
+ * @param resource
+ * The resource associated to the trace
+ * @param type
+ * The type of events that will be read from this trace
+ * @param path
+ * The path to the trace on the filesystem
+ * @param cacheSize
+ * The trace cache size. Pass '-1' to use the default specified
+ * in {@link ITmfTrace#DEFAULT_TRACE_CACHE_SIZE}
+ * @param interval
+ * The trace streaming interval. You can use '0' for post-mortem
+ * traces.
+ * @param indexer
+ * The trace indexer. You can pass 'null' to use a default
+ * checkpoint indexer.
+ * @param parser
+ * The trace event parser. Use 'null' if (and only if) the trace
+ * object itself is also the ITmfEventParser to be used.
* @throws TmfTraceException
- */
- protected TmfTrace(final IResource resource, final Class<? extends ITmfEvent> type, final String path, final int cacheSize,
- final long interval, final ITmfTraceIndexer indexer, final ITmfEventParser parser) throws TmfTraceException {
+ * If something failed during the opening
+ */
+ protected TmfTrace(final IResource resource,
+ final Class<? extends ITmfEvent> type,
+ final String path,
+ final int cacheSize,
+ final long interval,
+ final ITmfTraceIndexer indexer,
+ final ITmfEventParser parser)
+ throws TmfTraceException {
super();
fCacheSize = (cacheSize > 0) ? cacheSize : ITmfTrace.DEFAULT_TRACE_CACHE_SIZE;
fStreamingInterval = interval;
// ITmfTrace - Initializers
// ------------------------------------------------------------------------
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#initTrace(org.eclipse.core.resources.IResource, java.lang.String, java.lang.Class)
- */
@Override
public void initTrace(final IResource resource, final String path, final Class<? extends ITmfEvent> type) throws TmfTraceException {
fIndexer = new TmfCheckpointIndexer(this, fCacheSize);
* @param path the trace path
* @param type the trace event type
*
- * @throws TmfTraceException
+ * @throws TmfTraceException If something failed during the initialization
*/
protected void initialize(final IResource resource, final String path, final Class<? extends ITmfEvent> type) throws TmfTraceException {
if (path == null) {
getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, waitForCompletion);
}
+ /**
+ * The default implementation of TmfTrace uses a TmfStatistics back-end.
+ * Override this if you want to specify another type (or none at all).
+ *
+ * @throws TmfTraceException
+ * If there was a problem setting up the statistics
+ * @since 2.0
+ */
+ protected void buildStatistics() throws TmfTraceException {
+ /*
+ * Initialize the statistics provider, but only if a Resource has been
+ * set (so we don't build it for experiments, for unit tests, etc.)
+ */
+ fStatistics = (fResource == null ? null : new TmfStateStatistics(this) );
+ }
+
+ /**
+ * Build the state system(s) associated with this trace type.
+ *
+ * Suppressing the warning, because the 'throws' will usually happen in
+ * sub-classes.
+ *
+ * @throws TmfTraceException
+ * If there is a problem during the build
+ * @since 2.0
+ */
+ @SuppressWarnings("unused")
+ protected void buildStateSystem() throws TmfTraceException {
+ /*
+ * Nothing is done in the base implementation, please specify
+ * how/if to register a new state system in derived classes.
+ */
+ return;
+ }
+
/**
* Clears the trace
*/
@Override
public synchronized void dispose() {
- // Clean up the index if applicable
+ /* Clean up the index if applicable */
if (getIndexer() != null) {
getIndexer().dispose();
}
+
+ /* Clean up the statistics */
+ if (fStatistics != null) {
+ fStatistics.dispose();
+ }
+
+ /* Clean up the state systems */
+ for (ITmfStateSystem ss : fStateSystems.values()) {
+ ss.dispose();
+ }
+
super.dispose();
}
// ITmfTrace - Basic getters
// ------------------------------------------------------------------------
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getEventType()
+ /**
+ * @since 2.0
*/
+ @Override
+ public ITmfTrace[] getTraces() {
+ return new ITmfTrace[] { this };
+ }
+
@Override
public Class<ITmfEvent> getEventType() {
return (Class<ITmfEvent>) super.getType();
}
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getResource()
- */
@Override
public IResource getResource() {
return fResource;
}
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getPath()
- */
@Override
public String getPath() {
return fPath;
}
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getIndexPageSize()
- */
@Override
public int getCacheSize() {
return fCacheSize;
}
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getStreamingInterval()
- */
@Override
public long getStreamingInterval() {
return fStreamingInterval;
return fParser;
}
+ /**
+ * @since 2.0
+ */
+ @Override
+ public ITmfStatistics getStatistics() {
+ return fStatistics;
+ }
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public final Map<String, ITmfStateSystem> getStateSystems() {
+ return Collections.unmodifiableMap(fStateSystems);
+ }
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public final void registerStateSystem(String id, ITmfStateSystem ss) {
+ fStateSystems.put(id, ss);
+ }
+
// ------------------------------------------------------------------------
// ITmfTrace - Trace characteristics getters
// ------------------------------------------------------------------------
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getNbEvents()
- */
@Override
public synchronized long getNbEvents() {
return fNbEvents;
}
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getTimeRange()
+ /**
+ * @since 2.0
*/
@Override
public TmfTimeRange getTimeRange() {
return new TmfTimeRange(fStartTime, fEndTime);
}
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getStartTime()
+ /**
+ * @since 2.0
*/
@Override
public ITmfTimestamp getStartTime() {
- return fStartTime.clone();
+ return fStartTime;
}
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getEndTime()
+ /**
+ * @since 2.0
*/
@Override
public ITmfTimestamp getEndTime() {
- return fEndTime.clone();
+ return fEndTime;
+ }
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public ITmfTimestamp getCurrentTime() {
+ return fCurrentTime;
+ }
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public TmfTimeRange getCurrentRange() {
+ return fCurrentRange;
+ }
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public ITmfTimestamp getInitialRangeOffset() {
+ final long DEFAULT_INITIAL_OFFSET_VALUE = (1L * 100 * 1000 * 1000); // .1sec
+ return new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE, ITmfTimestamp.NANOSECOND_SCALE);
}
// ------------------------------------------------------------------------
- // Convenience setters/getters
+ // Convenience setters
// ------------------------------------------------------------------------
/**
* Update the trace events time range
*
* @param range the new time range
+ * @since 2.0
*/
protected void setTimeRange(final TmfTimeRange range) {
- fStartTime = range.getStartTime().clone();
- fEndTime = range.getEndTime().clone();
+ fStartTime = range.getStartTime();
+ fEndTime = range.getEndTime();
}
/**
* Update the trace chronologically first event timestamp
*
* @param startTime the new first event timestamp
+ * @since 2.0
*/
protected void setStartTime(final ITmfTimestamp startTime) {
- fStartTime = startTime.clone();
+ fStartTime = startTime;
}
/**
* Update the trace chronologically last event timestamp
*
* @param endTime the new last event timestamp
+ * @since 2.0
*/
protected void setEndTime(final ITmfTimestamp endTime) {
- fEndTime = endTime.clone();
+ fEndTime = endTime;
}
/**
// ITmfTrace - SeekEvent operations (returning a trace context)
// ------------------------------------------------------------------------
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#seekEvent(long)
- */
@Override
public synchronized ITmfContext seekEvent(final long rank) {
return context;
}
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#seekEvent(org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp)
+ /**
+ * @since 2.0
*/
@Override
public synchronized ITmfContext seekEvent(final ITmfTimestamp timestamp) {
ITmfContext context = fIndexer.seekIndex(timestamp);
// And locate the requested event context
- final ITmfContext nextEventContext = context.clone(); // Must use clone() to get the right subtype...
- ITmfEvent event = getNext(nextEventContext);
+ ITmfLocation previousLocation = context.getLocation();
+ long previousRank = context.getRank();
+ ITmfEvent event = getNext(context);
while (event != null && event.getTimestamp().compareTo(timestamp, false) < 0) {
- context = nextEventContext.clone();
- event = getNext(nextEventContext);
+ previousLocation = context.getLocation();
+ previousRank = context.getRank();
+ event = getNext(context);
}
if (event == null) {
context.setLocation(null);
context.setRank(ITmfContext.UNKNOWN_RANK);
+ } else {
+ context.dispose();
+ context = seekEvent(previousLocation);
+ context.setRank(previousRank);
}
return context;
}
// ITmfTrace - Read operations (returning an actual event)
// ------------------------------------------------------------------------
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#readNextEvent(org.eclipse.linuxtools.tmf.core.trace.ITmfContext)
- */
@Override
public synchronized ITmfEvent getNext(final ITmfContext context) {
// parseEvent() does not update the context
*
* @param context the current trace context
* @param timestamp the corresponding timestamp
+ * @since 2.0
*/
protected synchronized void updateAttributes(final ITmfContext context, final ITmfTimestamp timestamp) {
if (fStartTime.equals(TmfTimestamp.BIG_BANG) || (fStartTime.compareTo(timestamp, false) > 0)) {
- fStartTime = timestamp.clone();
+ fStartTime = timestamp;
}
if (fEndTime.equals(TmfTimestamp.BIG_CRUNCH) || (fEndTime.compareTo(timestamp, false) < 0)) {
- fEndTime = timestamp.clone();
+ fEndTime = timestamp;
+ }
+ if (fCurrentRange == TmfTimeRange.NULL_RANGE) {
+ fCurrentTime = timestamp;
+ ITmfTimestamp initialOffset = getInitialRangeOffset();
+ long endValue = timestamp.getValue() + initialOffset.normalize(0, timestamp.getScale()).getValue();
+ ITmfTimestamp endTimestamp = new TmfTimestamp(endValue, timestamp.getScale());
+ fCurrentRange = new TmfTimeRange(timestamp, endTimestamp);
}
if (context.hasValidRank()) {
long rank = context.getRank();
if (fNbEvents <= rank) {
fNbEvents = rank + 1;
}
- fIndexer.updateIndex(context, timestamp);
+ if (fIndexer != null) {
+ fIndexer.updateIndex(context, timestamp);
+ }
}
}
// TmfDataProvider
// ------------------------------------------------------------------------
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.component.TmfDataProvider#armRequest(org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest)
+ /**
+ * @since 2.0
*/
@Override
- protected ITmfContext armRequest(final ITmfDataRequest request) {
+ public synchronized ITmfContext armRequest(final ITmfDataRequest request) {
+ if (executorIsShutdown()) {
+ return null;
+ }
if ((request instanceof ITmfEventRequest)
&& !TmfTimestamp.BIG_BANG.equals(((ITmfEventRequest) request).getRange().getStartTime())
&& (request.getIndex() == 0))
}
// ------------------------------------------------------------------------
- // toString
+ // Signal handlers
// ------------------------------------------------------------------------
- /* (non-Javadoc)
- * @see java.lang.Object#toString()
+ /**
+ * Handler for the Trace Opened signal
+ *
+ * @param signal
+ * The incoming signal
+ * @since 2.0
+ */
+ @TmfSignalHandler
+ public void traceOpened(TmfTraceOpenedSignal signal) {
+ ITmfTrace trace = null;
+ for (ITmfTrace expTrace : signal.getTrace().getTraces()) {
+ if (expTrace == this) {
+ trace = expTrace;
+ break;
+ }
+ }
+
+ if (trace == null) {
+ /* This signal is not for us */
+ return;
+ }
+
+ /*
+ * The signal is for this trace, or for an experiment containing
+ * this trace.
+ */
+ try {
+ buildStatistics();
+ buildStateSystem();
+ } catch (TmfTraceException e) {
+ e.printStackTrace();
+ }
+
+ /* Refresh the project, so it can pick up new files that got created. */
+ try {
+ if (fResource != null) {
+ fResource.getProject().refreshLocal(IResource.DEPTH_INFINITE, null);
+ }
+ } catch (CoreException e) {
+ e.printStackTrace();
+ }
+
+ if (signal.getTrace() == this) {
+ /* Additionally, the signal is directly for this trace or experiment. */
+ if (getNbEvents() == 0) {
+ return;
+ }
+
+ final TmfTimeRange timeRange = new TmfTimeRange(getStartTime(), TmfTimestamp.BIG_CRUNCH);
+ final TmfTraceRangeUpdatedSignal rangeUpdatedsignal = new TmfTraceRangeUpdatedSignal(this, this, timeRange);
+
+ // Broadcast in separate thread to prevent deadlock
+ new Thread() {
+ @Override
+ public void run() {
+ broadcast(rangeUpdatedsignal);
+ }
+ }.start();
+ return;
+ }
+ }
+
+ /**
+ * Signal handler for the TmfTraceRangeUpdatedSignal signal
+ *
+ * @param signal The incoming signal
+ * @since 2.0
+ */
+ @TmfSignalHandler
+ public void traceRangeUpdated(final TmfTraceRangeUpdatedSignal signal) {
+ if (signal.getTrace() == this) {
+ getIndexer().buildIndex(getNbEvents(), signal.getRange(), false);
+ }
+ }
+
+ /**
+ * Signal handler for the TmfTimeSynchSignal signal
+ *
+ * @param signal The incoming signal
+ * @since 2.0
+ */
+ @TmfSignalHandler
+ public void synchToTime(final TmfTimeSynchSignal signal) {
+ if (signal.getCurrentTime().compareTo(fStartTime) >= 0 && signal.getCurrentTime().compareTo(fEndTime) <= 0) {
+ fCurrentTime = signal.getCurrentTime();
+ }
+ }
+
+ /**
+ * Signal handler for the TmfRangeSynchSignal signal
+ *
+ * @param signal The incoming signal
+ * @since 2.0
*/
+ @TmfSignalHandler
+ public void synchToRange(final TmfRangeSynchSignal signal) {
+ if (signal.getCurrentTime().compareTo(fStartTime) >= 0 && signal.getCurrentTime().compareTo(fEndTime) <= 0) {
+ fCurrentTime = signal.getCurrentTime();
+ }
+ if (signal.getCurrentRange().getIntersection(getTimeRange()) != null) {
+ fCurrentRange = signal.getCurrentRange().getIntersection(getTimeRange());
+ }
+ }
+
+ // ------------------------------------------------------------------------
+ // toString
+ // ------------------------------------------------------------------------
+
@Override
@SuppressWarnings("nls")
public synchronized String toString() {
projects / deliverable / tracecompass.git / blobdiff