import java.util.Collections;
import java.util.Vector;
+import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
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.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentUpdatedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
-import org.eclipse.linuxtools.tmf.core.signal.TmfSignalManager;
import org.eclipse.linuxtools.tmf.core.signal.TmfTraceUpdatedSignal;
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
* TmfExperiment presents a time-ordered, unified view of a set of TmfTraces that are part of a tracing experiment.
* <p>
*/
-public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> implements ITmfTrace<T> {
+public class TmfExperiment<T extends ITmfEvent> extends TmfEventProvider<T> implements ITmfTrace<T> {
// ------------------------------------------------------------------------
// Attributes
// Flag to initialize only once
private boolean fInitialized = false;
- // The experiment resource
+ // The experiment bookmarks file
+ private IFile fBookmarksFile;
+
+ // The properties resource
private IResource fResource;
// ------------------------------------------------------------------------
}
@Override
- public void initTrace(String name, String path, Class<T> eventType) {
- }
-
- @Override
- public void initTrace(String name, String path, Class<T> eventType, boolean indexTrace) {
- if (indexTrace) {
- initializeStreamingMonitor();
- }
- }
-
- @Override
- public void initTrace(String name, String path, Class<T> eventType, int cacheSize) {
- }
-
- @Override
- public void initTrace(String name, String path, Class<T> eventType, int cacheSize, boolean indexTrace) {
- if (indexTrace) {
- initializeStreamingMonitor();
- }
+ public void initTrace(String name, String path, Class<T> eventType, int pageSize) {
}
/**
* @param indexPageSize
*/
public TmfExperiment(Class<T> type, String id, ITmfTrace<T>[] traces, ITmfTimestamp epoch, int indexPageSize) {
- this(type, id, traces, TmfTimestamp.Zero, indexPageSize, false);
+ this(type, id, traces, TmfTimestamp.ZERO, indexPageSize, false);
}
public TmfExperiment(Class<T> type, String id, ITmfTrace<T>[] traces, ITmfTimestamp epoch, int indexPageSize, boolean preIndexExperiment) {
fTraces = traces;
fEpoch = epoch;
fIndexPageSize = indexPageSize;
- fTimeRange = TmfTimeRange.Null;
+ fTimeRange = TmfTimeRange.NULL_RANGE;
if (preIndexExperiment) {
- indexExperiment(true);
+ indexExperiment(true, 0, TmfTimeRange.ETERNITY);
updateTimeRange();
}
-
}
protected TmfExperiment(String id, Class<T> type) {
* @param traces
*/
public TmfExperiment(Class<T> type, String id, ITmfTrace<T>[] traces) {
- this(type, id, traces, TmfTimestamp.Zero, DEFAULT_INDEX_PAGE_SIZE);
+ this(type, id, traces, TmfTimestamp.ZERO, DEFAULT_INDEX_PAGE_SIZE);
}
/**
* @param indexPageSize
*/
public TmfExperiment(Class<T> type, String id, ITmfTrace<T>[] traces, int indexPageSize) {
- this(type, id, traces, TmfTimestamp.Zero, indexPageSize);
- }
-
- /**
- * Copy constructor
- *
- * @param other
- */
- @SuppressWarnings("unchecked")
- public TmfExperiment(TmfExperiment<T> other) {
- super(other.getName() + "(clone)", other.fType); //$NON-NLS-1$
-
- fEpoch = other.fEpoch;
- fIndexPageSize = other.fIndexPageSize;
-
- fTraces = new ITmfTrace[other.fTraces.length];
- for (int trace = 0; trace < other.fTraces.length; trace++) {
- fTraces[trace] = other.fTraces[trace].copy();
- }
-
- fNbEvents = other.fNbEvents;
- fTimeRange = other.fTimeRange;
- }
-
- @Override
- public TmfExperiment<T> copy() {
- TmfExperiment<T> experiment = new TmfExperiment<T>(this);
- TmfSignalManager.deregister(experiment);
- return experiment;
+ this(type, id, traces, TmfTimestamp.ZERO, indexPageSize);
}
/**
* Returns the rank of the first event with the requested timestamp. If none, returns the index of the next event
* (if any).
*
- * @param timestamp
- * @return
+ * @param timestamp the event timestamp
+ * @return the corresponding event rank
*/
@Override
public long getRank(ITmfTimestamp timestamp) {
/**
* Returns the timestamp of the event at the requested index. If none, returns null.
*
- * @param index
- * @return
+ * @param index the event index (rank)
+ * @return the corresponding event timestamp
*/
public ITmfTimestamp getTimestamp(int index) {
TmfExperimentContext context = seekEvent(index);
- TmfEvent event = getNextEvent(context);
+ ITmfEvent event = getNextEvent(context);
return (event != null) ? event.getTimestamp() : null;
}
* Update the global time range
*/
protected void updateTimeRange() {
- ITmfTimestamp startTime = fTimeRange != TmfTimeRange.Null ? fTimeRange.getStartTime() : TmfTimestamp.BigCrunch;
- ITmfTimestamp endTime = fTimeRange != TmfTimeRange.Null ? fTimeRange.getEndTime() : TmfTimestamp.BigBang;
+ ITmfTimestamp startTime = fTimeRange != TmfTimeRange.NULL_RANGE ? fTimeRange.getStartTime() : TmfTimestamp.BIG_CRUNCH;
+ ITmfTimestamp endTime = fTimeRange != TmfTimeRange.NULL_RANGE ? fTimeRange.getEndTime() : TmfTimestamp.BIG_BANG;
for (ITmfTrace<T> trace : fTraces) {
ITmfTimestamp traceStartTime = trace.getStartTime();
ITmfTimestamp timestamp = (request instanceof ITmfEventRequest<?>) ? ((ITmfEventRequest<T>) request).getRange().getStartTime()
: null;
- if (TmfTimestamp.BigBang.equals(timestamp) || request.getIndex() > 0) {
+ if (TmfTimestamp.BIG_BANG.equals(timestamp) || request.getIndex() > 0) {
timestamp = null; // use request index
}
rank += traceRank;
// Set the trace location and read the corresponding event
- expLocation.getLocation().locations[i] = context.getContexts()[i].getLocation().clone();
+ /* The (TmfContext) cast should be safe since we created 'context'
+ * ourselves higher up. */
+ expLocation.getLocation().locations[i] = ((TmfContext) context.getContexts()[i]).getLocation().clone();
context.getEvents()[i] = fTraces[i].getNextEvent(context.getContexts()[i]);
}
// Tracer.trace("Ctx: seekEvent(TS) - start");
if (timestamp == null) {
- timestamp = TmfTimestamp.BigBang;
+ timestamp = TmfTimestamp.BIG_BANG;
}
// First, find the right checkpoint
context.setRank((long) index * fIndexPageSize);
// And locate the event
- TmfEvent event = parseEvent(context);
+ ITmfEvent event = parseEvent(context);
while (event != null && event.getTimestamp().compareTo(timestamp, false) < 0) {
getNextEvent(context);
event = parseEvent(context);
context.setRank((long) index * fIndexPageSize);
// And locate the event
- TmfEvent event = parseEvent(context);
+ ITmfEvent event = parseEvent(context);
long pos = context.getRank();
while (event != null && pos++ < rank) {
getNextEvent(context);
return null;
}
- /**
- * Scan the next events from all traces and return the next one in chronological order.
- *
- * @param context
- * @return
- */
-
// private void dumpContext(TmfExperimentContext context, boolean isBefore) {
// TmfContext context0 = context.getContexts()[0];
// Tracer.trace(result.toString());
// }
+ /**
+ * Scan the next events from all traces and return the next one in chronological order.
+ *
+ * @param context the trace context
+ * @return the next event
+ */
+ @SuppressWarnings("unchecked")
@Override
- public synchronized TmfEvent getNextEvent(TmfContext context) {
+ public synchronized ITmfEvent getNextEvent(ITmfContext context) {
// Validate the context
if (!(context instanceof TmfExperimentContext)) {
// If an event was consumed previously, get the next one from that trace
int lastTrace = expContext.getLastTrace();
if (lastTrace != TmfExperimentContext.NO_TRACE) {
- TmfContext traceContext = expContext.getContexts()[lastTrace];
+ ITmfContext traceContext = expContext.getContexts()[lastTrace];
expContext.getEvents()[lastTrace] = expContext.getTraces()[lastTrace].getNextEvent(traceContext);
expContext.setLastTrace(TmfExperimentContext.NO_TRACE);
}
// Scan the candidate events and identify the "next" trace to read from
- TmfEvent eventArray[] = expContext.getEvents();
+ ITmfEvent eventArray[] = expContext.getEvents();
if (eventArray == null) {
return null;
}
int trace = TmfExperimentContext.NO_TRACE;
- ITmfTimestamp timestamp = TmfTimestamp.BigCrunch;
+ ITmfTimestamp timestamp = TmfTimestamp.BIG_CRUNCH;
if (eventArray.length == 1) {
if (eventArray[0] != null) {
timestamp = eventArray[0].getTimestamp();
}
} else {
for (int i = 0; i < eventArray.length; i++) {
- TmfEvent event = eventArray[i];
+ ITmfEvent event = eventArray[i];
if (event != null && event.getTimestamp() != null) {
ITmfTimestamp otherTS = event.getTimestamp();
if (otherTS.compareTo(timestamp, true) < 0) {
}
}
// Update the experiment context and set the "next" event
- TmfEvent event = null;
+ ITmfEvent event = null;
if (trace != TmfExperimentContext.NO_TRACE) {
updateIndex(expContext, timestamp);
- TmfContext traceContext = expContext.getContexts()[trace];
+ ITmfContext traceContext = expContext.getContexts()[trace];
TmfExperimentLocation expLocation = (TmfExperimentLocation) expContext.getLocation();
// expLocation.getLocation()[trace] = traceContext.getLocation().clone();
- expLocation.getLocation().locations[trace] = traceContext.getLocation().clone();
+ expLocation.getLocation().locations[trace] = (ITmfLocation<? extends Comparable<?>>) traceContext.getLocation().clone();
// updateIndex(expContext, timestamp);
* @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#parseEvent(org.eclipse.linuxtools .tmf.trace.TmfContext)
*/
@Override
- public TmfEvent parseEvent(TmfContext context) {
+ public ITmfEvent parseEvent(ITmfContext context) {
// Validate the context
if (!(context instanceof TmfExperimentContext)) {
// If an event was consumed previously, get the next one from that trace
int lastTrace = expContext.getLastTrace();
if (lastTrace != TmfExperimentContext.NO_TRACE) {
- TmfContext traceContext = expContext.getContexts()[lastTrace];
+ ITmfContext traceContext = expContext.getContexts()[lastTrace];
expContext.getEvents()[lastTrace] = expContext.getTraces()[lastTrace].getNextEvent(traceContext);
expContext.setLastTrace(TmfExperimentContext.NO_TRACE);
fExperimentContext = (TmfExperimentContext) context;
// Scan the candidate events and identify the "next" trace to read from
int trace = TmfExperimentContext.NO_TRACE;
- ITmfTimestamp timestamp = TmfTimestamp.BigCrunch;
+ ITmfTimestamp timestamp = TmfTimestamp.BIG_CRUNCH;
for (int i = 0; i < expContext.getTraces().length; i++) {
- TmfEvent event = expContext.getEvents()[i];
+ ITmfEvent event = expContext.getEvents()[i];
if (event != null && event.getTimestamp() != null) {
ITmfTimestamp otherTS = event.getTimestamp();
if (otherTS.compareTo(timestamp, true) < 0) {
}
}
- TmfEvent event = null;
+ ITmfEvent event = null;
if (trace != TmfExperimentContext.NO_TRACE) {
event = expContext.getEvents()[trace];
}
if (getStreamingInterval() == 0) {
TmfContext context = seekLocation(null);
- TmfEvent event = getNext(context);
+ ITmfEvent event = getNext(context);
if (event == null) {
return;
}
- TmfTimeRange timeRange = new TmfTimeRange(event.getTimestamp(), TmfTimestamp.BigCrunch);
+ TmfTimeRange timeRange = new TmfTimeRange(event.getTimestamp().clone(), TmfTimestamp.BIG_CRUNCH);
final TmfExperimentRangeUpdatedSignal signal = new TmfExperimentRangeUpdatedSignal(this, this, timeRange);
// Broadcast in separate thread to prevent deadlock
public void run() {
while (!fExecutor.isShutdown()) {
if (!isIndexingBusy()) {
- ITmfTimestamp startTimestamp = TmfTimestamp.BigCrunch;
- ITmfTimestamp endTimestamp = TmfTimestamp.BigBang;
+ ITmfTimestamp startTimestamp = TmfTimestamp.BIG_CRUNCH;
+ ITmfTimestamp endTimestamp = TmfTimestamp.BIG_BANG;
for (ITmfTrace<T> trace : fTraces) {
if (trace.getStartTime().compareTo(startTimestamp) < 0) {
startTimestamp = trace.getStartTime();
private static final int DEFAULT_INDEX_PAGE_SIZE = 5000;
protected int fIndexPageSize;
protected boolean fIndexing = false;
- protected TmfTimeRange fIndexingPendingRange = TmfTimeRange.Null;
+ protected TmfTimeRange fIndexingPendingRange = TmfTimeRange.NULL_RANGE;
private Integer fEndSynchReference;
}
}
- protected void indexExperiment(boolean waitForCompletion) {
- indexExperiment(waitForCompletion, 0, TmfTimeRange.Eternity);
+ @Override
+ public void indexTrace(boolean waitForCompletion) {
+ if (waitForCompletion) {
+ initializeStreamingMonitor();
+ }
}
@SuppressWarnings("unchecked")
// fEventLog = openLogFile("TraceEvent.log");
// System.out.println(System.currentTimeMillis() + ": Experiment indexing started");
- ITmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, timeRange, index, TmfDataRequest.ALL_DATA,
+ ITmfEventRequest<ITmfEvent> request = new TmfEventRequest<ITmfEvent>(ITmfEvent.class, timeRange, index, TmfDataRequest.ALL_DATA,
fIndexPageSize, ITmfDataRequest.ExecutionType.BACKGROUND) { // PATA FOREGROUND
// long indexingStart = System.nanoTime();
- ITmfTimestamp startTime = (fTimeRange == TmfTimeRange.Null) ? null : fTimeRange.getStartTime();
- ITmfTimestamp lastTime = (fTimeRange == TmfTimeRange.Null) ? null : fTimeRange.getEndTime();
+ ITmfTimestamp startTime = (fTimeRange == TmfTimeRange.NULL_RANGE) ? null : fTimeRange.getStartTime();
+ ITmfTimestamp lastTime = (fTimeRange == TmfTimeRange.NULL_RANGE) ? null : fTimeRange.getEndTime();
long initialNbEvents = fNbEvents;
@Override
}
@Override
- public void handleData(TmfEvent event) {
+ public void handleData(ITmfEvent event) {
super.handleData(event);
if (event != null) {
ITmfTimestamp ts = event.getTimestamp();
public void handleSuccess() {
// long indexingEnd = System.nanoTime();
- if (getRange() != TmfTimeRange.Eternity) {
+ // if the end time is a real value then it is the streaming safe time stamp
+ // set the last time to the safe time stamp to prevent unnecessary indexing requests
+ if (getRange().getEndTime() != TmfTimestamp.BIG_CRUNCH) {
lastTime = getRange().getEndTime();
}
updateExperiment();
super.handleCompleted();
synchronized (fCheckpoints) {
fIndexing = false;
- if (fIndexingPendingRange != TmfTimeRange.Null) {
+ if (fIndexingPendingRange != TmfTimeRange.NULL_RANGE) {
indexExperiment(false, (int) fNbEvents, fIndexingPendingRange);
- fIndexingPendingRange = TmfTimeRange.Null;
+ fIndexingPendingRange = TmfTimeRange.NULL_RANGE;
}
}
}
TmfExperiment<?> experiment = signal.getExperiment();
if (experiment == this) {
setCurrentExperiment(experiment);
- fEndSynchReference = new Integer(signal.getReference());
+ fEndSynchReference = Integer.valueOf(signal.getReference());
}
}
if (trace == signal.getTrace()) {
synchronized (fCheckpoints) {
if (fIndexing) {
- if (fIndexingPendingRange == TmfTimeRange.Null) {
+ if (fIndexingPendingRange == TmfTimeRange.NULL_RANGE) {
fIndexingPendingRange = signal.getRange();
} else {
ITmfTimestamp startTime = fIndexingPendingRange.getStartTime();
}
/**
- * Set the resource to be used for bookmarks on this experiment
- * @param resource the bookmarks resource
+ * Set the file to be used for bookmarks on this experiment
+ * @param file the bookmarks file
*/
+ public void setBookmarksFile(IFile file) {
+ fBookmarksFile = file;
+ }
+
+ /**
+ * Get the file used for bookmarks on this experiment
+ * @return the bookmarks file or null if none is set
+ */
+ public IFile getBookmarksFile() {
+ return fBookmarksFile;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#setResource(org.eclipse.core.resources.IResource)
+ */
+ @Override
public void setResource(IResource resource) {
fResource = resource;
}
- /**
- * Get the resource used for bookmarks on this experiment
- * @return the bookmarks resource or null if none is set
+ /* (non-Javadoc)
+ * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getResource()
*/
+ @Override
public IResource getResource() {
return fResource;
}
projects / deliverable / tracecompass.git / blobdiff