// experiment selected, build experiment selection context and trigger
// check point creation
expManager.experimentSelected_prep(experiment);
- // Action trigger
+ // buils check points in parallel
expManager.experimentSelected(this, experiment);
// Obtain the singleton event provider
/* (non-Javadoc)
* @see junit.framework.TestCase#setUp()
*/
+ @Override
protected void setUp() throws Exception {
super.setUp();
// Create state resources and assign a parent
/* (non-Javadoc)
* @see junit.framework.TestCase#tearDown()
*/
+ @Override
protected void tearDown() throws Exception {
super.tearDown();
}
/* (non-Javadoc)
* @see junit.framework.TestCase#setUp()
*/
+ @Override
protected void setUp() throws Exception {
super.setUp();
context = getContext();
/* (non-Javadoc)
* @see junit.framework.TestCase#tearDown()
*/
+ @Override
protected void tearDown() throws Exception {
super.tearDown();
}
import org.eclipse.linuxtools.lttng.event.LttngSyntheticEvent;
import org.eclipse.linuxtools.lttng.model.LTTngTreeNode;
import org.eclipse.linuxtools.lttng.state.LttngStateException;
-import org.eclipse.linuxtools.lttng.state.model.LttngTraceState;
-import org.eclipse.linuxtools.lttng.state.model.StateModelFactory;
import org.eclipse.linuxtools.lttng.state.trace.IStateTraceManager;
import org.eclipse.linuxtools.lttng.state.trace.StateTraceManager;
import org.eclipse.linuxtools.tmf.component.TmfEventProvider;
return instanceBook.get(traceUniqueId);
}
- LttngTraceState traceModel = StateModelFactory.getStateEntryInstance();
+ // LttngTraceState traceModel =
+ // StateModelFactory.getStateEntryInstance();
IStateTraceManager manager = null;
if (feventProvider == null) {
LTTngTreeNode parent = null;
try {
- manager = new StateTraceManager(id, parent, traceUniqueId, trace,
- traceModel,
- feventProvider);
+ manager = new StateTraceManager(id, parent, traceUniqueId, trace, feventProvider);
} catch (LttngStateException e) {
e.printStackTrace();
}
super(filename, LttngEvent.class, filename, cacheSize);
fTrace = new RandomAccessFile(filename, "r");
fParser = new LTTngEventParserStub();
- indexTrace(true);
+// indexTrace(true);
}
public ITmfTrace createTraceCopy() {
* org.eclipse.linuxtools.lttng.request.LttngSyntEventRequest#handleData
* ()
*/
+ @Override
public void handleData() {
TmfEvent[] result = getData();
notifyStarting();
}
+ @Override
public void handleCompleted() {
super.handleCompleted();
* (org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent
* )
*/
+ @Override
public void tsfTmProcessSelEvent(TmfTimeSelectionEvent event) {
// common implementation
super.tsfTmProcessSelEvent(event);
* #tsfTmProcessTimeScaleEvent(org.eclipse.linuxtools
* .tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent)
*/
+ @Override
public synchronized void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event) {
super.tsfTmProcessTimeScaleEvent(event);
}
* ITmfTimeAnalysisEntry[], long, long, boolean, long, long,
* java.lang.Object)
*/
+ @Override
public void displayModel(final ITmfTimeAnalysisEntry[] items,
final long startBoundTime, final long endBoundTime,
final boolean updateTimeBounds, final long startVisibleWindow,
*
* @param signal
*/
+ @Override
@TmfSignalHandler
public void synchToTime(TmfTimeSynchSignal signal) {
super.synchToTime(signal);
* @param event The generated mouse event when the mouse double-click was issued.
*/
public void mouseDoubleClick(MouseEvent event) {
- System.out.println("mouseDoubleClick");
+// System.out.println("mouseDoubleClick");
}
/**
import org.eclipse.linuxtools.lttng.event.LttngEvent;
import org.eclipse.linuxtools.lttng.event.LttngTimestamp;
+import org.eclipse.linuxtools.tmf.component.ITmfDataProvider.ExecutionType;
+import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
import org.eclipse.linuxtools.tmf.signal.TmfRangeSynchSignal;
import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
import org.eclipse.linuxtools.tmf.signal.TmfTimeSynchSignal;
+import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
+import org.eclipse.linuxtools.tmf.trace.TmfContext;
import org.eclipse.linuxtools.tmf.ui.views.TmfView;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ControlEvent;
// Save the experiment we are about to use
lastUsedExperiment = newExperiment;
- // Create a copy of the trace that will be use only by the full experiment request
- TmfExperiment<LttngEvent> experimentCopy = newExperiment.createTraceCopy();
+// // Create a copy of the trace that will be use only by the full experiment request
+// TmfExperiment<LttngEvent> experimentCopy = newExperiment.createTraceCopy();
// Create the content for the full experiment.
// This NEED to be created first, as we use it in the selectedWindowCanvas
fullExperimentCanvas.createNewHistogramContent(fullExperimentCanvas.getSize().x, FULL_TRACE_BAR_WIDTH, FULL_TRACE_CANVAS_HEIGHT, FULL_TRACE_DIFFERENCE_TO_AVERAGE);
fullExperimentCanvas.createNewSelectedWindow(DEFAULT_WINDOW_SIZE);
- currentEventTime = newExperiment.getStartTime().getValue();
- // Set the window of the fullTrace canvas visible.
+
+ TmfTimeRange timeRange = getExperimentTimeRange(newExperiment);
+ currentEventTime = timeRange.getStartTime().getValue();
+
+ // Set the window of the fullTrace canvas visible.
fullExperimentCanvas.getCurrentWindow().setSelectedWindowVisible(true);
- fullExperimentCanvas.getHistogramContent().resetTable(newExperiment.getStartTime().getValue(), newExperiment.getEndTime().getValue());
+ fullExperimentCanvas.getHistogramContent().resetTable(timeRange.getStartTime().getValue(), timeRange.getEndTime().getValue());
// Create the content for the selected window.
selectedWindowCanvas.createNewHistogramContent(selectedWindowCanvas.getSize().x ,SELECTED_WINDOW_BAR_WIDTH, SELECTED_WINDOW_CANVAS_HEIGHT, SELECTED_WINDOW_DIFFERENCE_TO_AVERAGE);
// Perform both request.
// Order is important here, the small/synchronous request for the selection window should go first
performSelectedWindowEventsRequest(newExperiment);
- performAllTraceEventsRequest(experimentCopy);
+// performAllTraceEventsRequest(experimentCopy);
+ performAllTraceEventsRequest(newExperiment);
}
-
+
+ // Before completing its indexing, the experiment doesn't know start/end time.
+ // However, LTTng individual traces have this knowledge so we should ask them
+ // directly.
+ private TmfTimeRange getExperimentTimeRange(TmfExperiment<LttngEvent> experiment) {
+ // Before completing its indexing, the experiment doesn't know start/end time.
+ // However, LTTng individual traces have this knowledge so we should ask them
+ // directly.
+ TmfTimestamp startTime = TmfTimestamp.BigCrunch;
+ TmfTimestamp endTime = TmfTimestamp.BigBang;
+ for (ITmfTrace trace : experiment.getTraces()) {
+ TmfContext context = trace.seekLocation(null);
+ context.setRank(0);
+ TmfEvent event = trace.getNextEvent(context);
+ TmfTimestamp traceStartTime = event.getTimestamp();
+ if (traceStartTime.compareTo(startTime, true) < 0)
+ startTime = traceStartTime;
+ TmfTimestamp traceEndTime = trace.getEndTime();
+ if (traceEndTime.compareTo(endTime, true) > 0)
+ endTime = traceEndTime;
+ }
+ TmfTimeRange tmpRange = new TmfTimeRange(startTime, endTime);
+ return tmpRange;
+ }
+
/**
* Perform a new request for the Selection window.<p>
* This assume the full experiment canvas has correct information about the selected window;
HistogramSelectedWindow curSelectedWindow = fullExperimentCanvas.getCurrentWindow();
- // If no selection window exists, we will try to cerate one;
+ // If no selection window exists, we will try to create one;
// however this will most likely fail as the content is probably not created either
if ( curSelectedWindow == null ) {
fullExperimentCanvas.createNewSelectedWindow( DEFAULT_WINDOW_SIZE );
// Set a (dynamic) time interval
long intervalTime = ( (ts2.getValue() - ts1.getValue()) / selectedWindowCanvas.getHistogramContent().getNbElement() );
- selectedWindowRequest = performRequest(experiment, selectedWindowCanvas, tmpRange, intervalTime);
+ selectedWindowRequest = performRequest(experiment, selectedWindowCanvas, tmpRange, intervalTime, ExecutionType.SHORT);
selectedWindowCanvas.redrawAsynchronously();
}
public void performAllTraceEventsRequest(TmfExperiment<LttngEvent> experiment) {
// Create a new time range from "start" to "end"
// That way, we will get "everything" in the trace
- LttngTimestamp ts1 = new LttngTimestamp( experiment.getStartTime() );
- LttngTimestamp ts2 = new LttngTimestamp( experiment.getEndTime() );
- TmfTimeRange tmpRange = new TmfTimeRange(ts1, ts2);
+// LttngTimestamp ts1 = new LttngTimestamp( experiment.getStartTime() );
+// LttngTimestamp ts2 = new LttngTimestamp( experiment.getEndTime() );
+// TmfTimeRange tmpRange = new TmfTimeRange(ts1, ts2);
+
+ TmfTimeRange tmpRange = getExperimentTimeRange(experiment);
+ TmfTimestamp startTime = tmpRange.getStartTime();
+ TmfTimestamp endTime = tmpRange.getEndTime();
// Set a (dynamic) time interval
- long intervalTime = ( (ts2.getValue() - ts1.getValue()) / fullExperimentCanvas.getHistogramContent().getNbElement() );
+ long intervalTime = ( (endTime.getValue() - startTime.getValue()) / fullExperimentCanvas.getHistogramContent().getNbElement() );
// *** VERIFY ***
// This would enable "fixed interval" instead of dynamic one.
// It would be interesting if there was a way to tell the framework to run the request "in parallel" here.
// Mean a completetly independant copy of the Expereiment would be done and we would proceed on that.
//
- dataBackgroundFullRequest = performRequest(experiment, fullExperimentCanvas, tmpRange, intervalTime);
+ dataBackgroundFullRequest = performRequest(experiment, fullExperimentCanvas, tmpRange, intervalTime, ExecutionType.LONG);
fullExperimentCanvas.redrawAsynchronously();
}
* @param newRange The range of the request
* @param newInterval The interval of time we use to store the result into the HistogramContent
*/
- public synchronized HistogramRequest performRequest(TmfExperiment<LttngEvent> experiment, HistogramCanvas targetCanvas, TmfTimeRange newRange, long newInterval) {
+ private synchronized HistogramRequest performRequest(TmfExperiment<LttngEvent> experiment, HistogramCanvas targetCanvas, TmfTimeRange newRange, long newInterval, ExecutionType execType) {
HistogramRequest returnedRequest = null;
// *** FIXME ***
returnedRequest = new HistogramRequest(newRange, Integer.MAX_VALUE, targetCanvas, newInterval );
// Send the request to the framework : it will be queued and processed later
- experiment.sendRequest(returnedRequest);
+ experiment.sendRequest(returnedRequest, execType);
return returnedRequest;
}
if ( lastUsedExperiment != null ) {
// If a request is ongoing, try to stop it
- if ( selectedWindowRequest.isCompleted() == false ) {
+ if ( selectedWindowRequest != null && selectedWindowRequest.isCompleted() == false ) {
selectedWindowRequest.cancel();
}
*/
public void selectExperiment(LTTngExperimentNode experiment) {
String expId = experiment.getName();
- if (fSelectedExperiment != null)
+ if (fSelectedExperiment != null) {
+ System.out.println(fSelectedExperiment.getName() + ": nbEvents=" + fSelectedExperiment.getNbEvents() +
+ ", nbReads=" + ((LTTngTrace) fSelectedExperiment.getTraces()[0]).nbEventsRead);
fSelectedExperiment.dispose();
+ }
try {
LTTngTraceNode[] traceEntries = experiment.getTraces();
int nbTraces = traceEntries.length;
traces[i] = trace;
}
fSelectedExperiment = new TmfExperiment<LttngEvent>(LttngEvent.class, expId, traces);
- fSelectedExperiment.indexExperiment(waitForCompletion);
+
// Make sure the lttng-core, experiment selection context is ready
// for an event request from any view
StateManagerFactory.getExperimentManager().experimentSelected_prep(
* (org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent
* )
*/
+ @Override
public void tsfTmProcessSelEvent(TmfTimeSelectionEvent event) {
// common implementation
super.tsfTmProcessSelEvent(event);
* #tsfTmProcessTimeScaleEvent(org.eclipse.linuxtools
* .tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent)
*/
+ @Override
public void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event) {
super.tsfTmProcessTimeScaleEvent(event);
}
* ITmfTimeAnalysisEntry[], long, long, boolean, long, long,
* java.lang.Object)
*/
+ @Override
public void displayModel(final ITmfTimeAnalysisEntry[] items, final long startBoundTime,
final long endBoundTime, final boolean updateTimeBounds, final long startVisibleWindow,
final long endVisibleWindow, final Object source) {
*
* @param signal
*/
+ @Override
@TmfSignalHandler
public void synchToTime(TmfTimeSynchSignal signal) {
super.synchToTime(signal);
* @see org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#
* getParamsUpdater()
*/
+ @Override
protected ParamsUpdater getParamsUpdater() {
return ResourceModelFactory.getParamsUpdater();
}
return finishProcessor;
}
+ @Override
public boolean process(LttngEvent trcEvent, LttngTraceState traceSt) {
if (trcEvent instanceof LttngSyntheticEvent) {
/**
* @return
*/
+ @Override
public AbsEventToHandlerResolver getEventProcessor() {
return StatsTimeCountHandlerFactory.getInstance();
}
* org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#waitCursor
* (boolean)
*/
+ @Override
protected void waitCursor(final boolean waitInd) {
if (treeViewer == null) {
return;
final ILttngEventProcessor getAfterHandler() {
AbstractStatsEventHandler handler = new StatsModeChangeHandler(null) {
int sched_hash = StateStrings.Events.LTT_EVENT_SCHED_SCHEDULE.getInName().hashCode();
+ @Override
public boolean process(LttngEvent event, LttngTraceState traceState) {
// Step the event counter for any after event
stepCount(event, traceState);
--- /dev/null
+org.eclipse.linuxtools.lttng/debug=false
+org.eclipse.linuxtools.lttng/info=false
+org.eclipse.linuxtools.lttng/warn=false
import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.request.ITmfEventRequest;
-import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.trace.TmfContext;
// TmfDataProvider<LttngEvent> fExtProvider = null;
private ITmfDataRequest<LttngSyntheticEvent> fmainRequest = null;
- private final Map<IStateTraceManager, LttngBaseEventRequest> feventProviderRequests = new HashMap<IStateTraceManager, LttngBaseEventRequest>();
+ private final Map<IStateTraceManager, LttngBaseEventRequest> fEventProviderRequests = new HashMap<IStateTraceManager, LttngBaseEventRequest>();
private final LttngSyntheticEvent fStatusEvent;
private final LttngSyntheticEvent fStatusEventAck;
- private int fmainReqEventCount = 0;
+ private int fMainReqEventCount = 0;
volatile boolean startIndSent = false;
private LTTngTreeNode fExperiment = null;
private ITransEventProcessor fstateUpdateProcessor = StateEventToHandlerFactory
// ========================================================================
// Methods
// ========================================================================
+
@SuppressWarnings("unchecked")
@Override
public ITmfContext armRequest(
reset(fExperiment);
// At least one base provider shall be available
- if (feventProviderRequests.size() < 1) {
+ if (fEventProviderRequests.size() < 1) {
request.cancel();
TraceDebug.debug("No Base event providers available");
return null;
TraceDebug.debug("Main Synthethic event request started on thread: " + Thread.currentThread().getName());
// loop for every traceManager in current experiment
- for (IStateTraceManager traceManager : feventProviderRequests
- .keySet()) {
+ boolean subRequestQueued = false;
+ for (IStateTraceManager traceManager : fEventProviderRequests.keySet()) {
// restore trace state system to nearest check point
TmfTimestamp checkPoint = traceManager
.restoreCheckPointByTimestamp(reqWindow.getStartTime());
+
+ // adjust start time bound to check point
+
// validate so checkpoint restore is within requested bounds
TmfTimeRange traceRange = traceManager.getTrace().getTimeRange();
- if (!(checkPoint.getValue() >= traceRange.getStartTime().getValue()
- && checkPoint.getValue() <= traceRange.getEndTime()
- .getValue() && checkPoint.getValue() < reqWindow
- .getEndTime().getValue())) {
+ if ((checkPoint != null) && !(
+ checkPoint.getValue() >= traceRange.getStartTime().getValue() &&
+ checkPoint.getValue() <= traceRange.getEndTime().getValue() &&
+ checkPoint.getValue() < reqWindow.getEndTime().getValue())
+ ) {
// checkpoint is out of trace bounds
continue;
}
+ TmfTimeRange adjustedRange = reqWindow;
+ if (checkPoint != null) {
+ adjustedRange = new TmfTimeRange(checkPoint, reqWindow.getEndTime());
+ }
- // adjust start time bound to check point
- TmfTimeRange adjustedRange = new TmfTimeRange(checkPoint, reqWindow
- .getEndTime());
-
- LttngTraceState traceModel = traceManager.getStateModel();
+ LttngTraceState traceModel = traceManager.getStateModel(checkPoint);
// create sub-request for one trace within experiment
final LttngBaseEventRequest subRequest = new LttngBaseEventRequest(
adjustedRange, reqWindow.getStartTime(), 0,
// queue the new event data and an ACK
updateSynEvent(e);
-
-
// If time at or above requested time, update application
- if (eventTime >= fDispatchTime) {
- // Before update
- syntheticEvent.setSequenceInd(SequenceInd.BEFORE);
- queueResult(syntheticEvent);
- queueResult(syntheticAckIndicator);
-
- // Update state locally
- syntheticEvent.setSequenceInd(SequenceInd.UPDATE);
- fstateUpdateProcessor.process(syntheticEvent,
+ try {
+ if (eventTime >= fDispatchTime) {
+ // Before update
+ syntheticEvent.setSequenceInd(SequenceInd.BEFORE);
+ queueResult(syntheticEvent);
+ queueResult(syntheticAckIndicator);
+
+ // Update state locally
+ syntheticEvent.setSequenceInd(SequenceInd.UPDATE);
+ fstateUpdateProcessor.process(syntheticEvent,
fTraceModel);
- // After Update
- syntheticEvent.setSequenceInd(SequenceInd.AFTER);
- queueResult(syntheticEvent);
- queueResult(syntheticAckIndicator);
-
- // increment once per dispatch
- incrementSynEvenCount();
- subEventCount++;
- } else {
- // event time is between checkpoint adjusted time and
- // requested time i.e. application does not expect the
- // event, however the state system needs to be re-built
- // to the dispatch point
- syntheticEvent.setSequenceInd(SequenceInd.UPDATE);
- fstateUpdateProcessor.process(syntheticEvent,
- fTraceModel);
+ // After Update
+ syntheticEvent.setSequenceInd(SequenceInd.AFTER);
+ queueResult(syntheticEvent);
+ queueResult(syntheticAckIndicator);
+
+ // increment once per dispatch
+ incrementSynEvenCount();
+ subEventCount++;
+ } else {
+ // event time is between checkpoint adjusted time and
+ // requested time i.e. application does not expect the
+ // event, however the state system needs to be re-built
+ // to the dispatch point
+ syntheticEvent.setSequenceInd(SequenceInd.UPDATE);
+ fstateUpdateProcessor.process(syntheticEvent, fTraceModel);
+ }
+ } catch (InterruptedException e1) {
+ e1.printStackTrace();
}
}
return syntheticEvent;
}
};
-
+
// preserve the associated sub request to control it e.g.
// cancellation
- feventProviderRequests.put(traceManager, subRequest);
+ fEventProviderRequests.put(traceManager, subRequest);
// start request
TmfTrace<LttngEvent> provider = (TmfTrace<LttngEvent>) traceManager
.getTrace();
- provider.sendRequest(subRequest);
+ provider.sendRequest(subRequest, ExecutionType.LONG);
+ subRequestQueued = true;
}
// Return a dummy context, not used for relay provider
- return new TmfContext();
+ return (subRequestQueued) ? new TmfContext() : null;
}
/**
startIndEvent.setSequenceInd(SequenceInd.STARTREQ);
// Notify application
- queueResult(startIndEvent);
- queueResult(fStatusEventAck);
+ try {
+ queueResult(startIndEvent);
+ queueResult(fStatusEventAck);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
// Notify state event processor
fstateUpdateProcessor.process(startIndEvent, null);
// handle completion and cancellations properly
// Close the main request when all sub-requests are marked completed
- for (LttngBaseEventRequest subRequest : feventProviderRequests.values()) {
+ for (LttngBaseEventRequest subRequest : fEventProviderRequests.values()) {
if (subRequest != null) {
if (!subRequest.isCompleted()) {
// Not ready to complete main request
LttngSyntheticEvent finishEvent = new LttngSyntheticEvent(fStatusEvent);
finishEvent.setSequenceInd(SequenceInd.ENDREQ);
finishEvent.setTraceModel(traceModel);
- queueResult(finishEvent);
- queueResult(fStatusEventAck);
- // End the loop in the main request
- queueResult(LttngSyntheticEvent.NullEvent);
+
+ try {
+ queueResult(finishEvent);
+ queueResult(fStatusEventAck);
+ // End the loop in the main request
+ queueResult(LttngSyntheticEvent.NullEvent);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
}
/**
* Increment the global event counter i.e. events from any sub requests
*/
private synchronized void incrementSynEvenCount() {
- fmainReqEventCount++;
+ fMainReqEventCount++;
}
/**
* @return
*/
public synchronized int getSynEvenCount() {
- return fmainReqEventCount;
+ return fMainReqEventCount;
}
/**
fmainRequest = null;
// Make sure previous request are terminated
- for (LttngBaseEventRequest tmpRequest : feventProviderRequests.values()) {
+ for (LttngBaseEventRequest tmpRequest : fEventProviderRequests.values()) {
if (tmpRequest != null && !tmpRequest.isCompleted()) {
tmpRequest.cancel();
}
}
- feventProviderRequests.clear();
- fmainReqEventCount = 0;
+ fEventProviderRequests.clear();
+ fMainReqEventCount = 0;
startIndSent = false;
// set of base event providers
LTTngTreeNode[] traces = fExperiment.getChildren();
for (LTTngTreeNode trace : traces) {
IStateTraceManager traceBaseEventProvider = (IStateTraceManager) trace;
- feventProviderRequests.put(traceBaseEventProvider, null);
+ fEventProviderRequests.put(traceBaseEventProvider, null);
}
}
* org.eclipse.linuxtools.tmf.component.TmfDataProvider#sendRequest(org.
* eclipse.linuxtools.tmf.request.TmfDataRequest)
*/
- public void sendRequest(final TmfDataRequest<LttngSyntheticEvent> request) {
+ public void sendRequest(final ITmfDataRequest<LttngSyntheticEvent> request) {
super.sendRequest(request);
if (waitForRequest) {
try {
@Override
public String toString() {
- String returnedData="";
+ StringBuffer result= new StringBuffer("[LttngEvent(");
+ result.append("Timestamp:" + getTimestamp().getValue());
+ result.append(",Channel:" + getChannelName());
+ result.append(",CPU:" + getCpuId());
+ result.append(",Marker:" + getMarkerName());
+ result.append(",Content:" + getContent() + ")]");
- returnedData += "Event timestamp:" + this.getTimestamp().getValue() + " ";
- returnedData += "Channel:" + getChannelName() + " ";
- returnedData += "CPU:" + getCpuId() + " ";
- returnedData += "Marker:" + getMarkerName() + " ";
-
- return returnedData;
+ return result.toString();
}
}
StringBuffer strBuffer = new StringBuffer();
for ( int pos=0; pos < allFields.length; pos++) {
+ if (pos != 0) strBuffer.append(",");
strBuffer.append(allFields[pos].toString());
}
*
* @see org.eclipse.linuxtools.lttng.event.LttngEvent#getParentTrace()
*/
- public TmfTrace<LttngEvent> getParentTrace() {
+ @Override
+ public TmfTrace<LttngEvent> getParentTrace() {
if (baseEvent != null) {
return baseEvent.getParentTrace();
} else {
* org.eclipse.linuxtools.lttng.event.LttngEvent#setParentTrace(org.eclipse
* .linuxtools.tmf.trace.TmfTrace)
*/
+ @Override
public void setParentTrace(TmfTrace<LttngEvent> parentTrace) {
if (baseEvent != null) {
baseEvent.setParentTrace(parentTrace);
*
* @see org.eclipse.linuxtools.lttng.event.LttngEvent#getChannelName()
*/
+ @Override
public String getChannelName() {
if (baseEvent != null) {
return baseEvent.getChannelName();
*
* @see org.eclipse.linuxtools.lttng.event.LttngEvent#getCpuId()
*/
+ @Override
public long getCpuId() {
if (baseEvent != null) {
return baseEvent.getCpuId();
*
* @see org.eclipse.linuxtools.lttng.event.LttngEvent#getMarkerName()
*/
+ @Override
public String getMarkerName() {
if (baseEvent != null) {
return baseEvent.getMarkerName();
*
* @see org.eclipse.linuxtools.lttng.event.LttngEvent#getContent()
*/
+ @Override
public LttngEventContent getContent() {
if (baseEvent != null) {
return baseEvent.getContent();
* org.eclipse.linuxtools.lttng.event.LttngEvent#setContent(org.eclipse.
* linuxtools.lttng.event.LttngEventContent)
*/
+ @Override
public void setContent(LttngEventContent newContent) {
if (baseEvent != null) {
baseEvent.setContent(newContent);
*
* @see org.eclipse.linuxtools.lttng.event.LttngEvent#getType()
*/
+ @Override
public LttngEventType getType() {
if (baseEvent != null) {
return baseEvent.getType();
* org.eclipse.linuxtools.lttng.event.LttngEvent#setType(org.eclipse.linuxtools
* .lttng.event.LttngEventType)
*/
+ @Override
public void setType(LttngEventType newType) {
if (baseEvent != null) {
baseEvent.setType(newType);
* org.eclipse.linuxtools.lttng.event.LttngEvent#updateJniEventReference
* (org.eclipse.linuxtools.lttng.jni.JniEvent)
*/
+ @Override
public void updateJniEventReference(JniEvent newJniEventReference) {
if (baseEvent != null) {
baseEvent.updateJniEventReference(newJniEventReference);
*
* @see org.eclipse.linuxtools.lttng.event.LttngEvent#convertEventTmfToJni()
*/
+ @Override
public JniEvent convertEventTmfToJni() {
if (baseEvent != null) {
return baseEvent.convertEventTmfToJni();
*
* @see org.eclipse.linuxtools.lttng.event.LttngEvent#isNullRef()
*/
+ @Override
public boolean isNullRef() {
return this == NullEvent;
}
*
* @see org.eclipse.linuxtools.lttng.event.LttngEvent#toString()
*/
+ @Override
public String toString() {
if (baseEvent != null) {
return baseEvent.toString();
* @see
* org.eclipse.linuxtools.lttng.model.LTTngTreeNodeGeneric#getChildren()
*/
+ @Override
public LTTngTreeNode[] getChildren() {
return childrenToArray(fchildren.values(), this.getClass());
}
*
* @see org.eclipse.linuxtools.tmf.event.TmfData#isNullRef()
*/
+ @Override
public boolean isNullRef() {
return false;
}
*
* @see org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleCompleted()
*/
+ @Override
public void handleCompleted() {
// notify listeners
notifyCompletion();
exe_state.setEntry_Time(eventTime.getValue());
exe_state.setChange_Time(eventTime.getValue());
exe_state.setCum_cpu_time(0L);
- exe_state.setProc_status(process.getState().getProc_status());
+// if (process != null)
+ exe_state.setProc_status(process.getState().getProc_status());
process.pushToExecutionStack(exe_state);
}
import org.eclipse.linuxtools.lttng.event.LttngEvent;
import org.eclipse.linuxtools.lttng.model.LTTngTreeNode;
-import org.eclipse.linuxtools.lttng.request.ILttngSyntEventRequest;
-import org.eclipse.linuxtools.lttng.request.IRequestStatusListener;
-import org.eclipse.linuxtools.lttng.state.evProcessor.ITransEventProcessor;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
public interface IStateExperimentManager {
- /**
- * Read all available traces from the nearest checkpoint from start position
- * to the end of a specified time range. One request per trace in the
- * experiment will be triggered
- *
- * @param trange
- * @param obs
- * @param transactionID
- * @param display
- * @return
- */
- public abstract ILttngSyntEventRequest readExperimentTimeWindow(
- TmfTimeRange trange,
- Object origin, IRequestStatusListener listener,
- ITransEventProcessor processor);
-
- /**
- * Read available traces from the Experiment start time, One request per
- * trace in the Experiment
- *
- * @param source
- * @param listener
- * @param processor
- */
- public abstract void readExperiment(Object source,
- IRequestStatusListener listener, ITransEventProcessor processor);
+// /**
+// * Read all available traces from the nearest checkpoint from start position
+// * to the end of a specified time range. One request per trace in the
+// * experiment will be triggered
+// *
+// * @param trange
+// * @param obs
+// * @param transactionID
+// * @param display
+// * @return
+// */
+// public abstract ILttngSyntEventRequest readExperimentTimeWindow(
+// TmfTimeRange trange,
+// Object origin, IRequestStatusListener listener,
+// ITransEventProcessor processor);
+//
+// /**
+// * Read available traces from the Experiment start time, One request per
+// * trace in the Experiment
+// *
+// * @param source
+// * @param listener
+// * @param processor
+// */
+// public abstract void readExperiment(Object source,
+// IRequestStatusListener listener, ITransEventProcessor processor);
/**
* A new Experiment selected, notification received from the framework
*******************************************************************************/
package org.eclipse.linuxtools.lttng.state.experiment;
+import java.util.HashMap;
+import java.util.Map;
+
import org.eclipse.linuxtools.lttng.TraceDebug;
import org.eclipse.linuxtools.lttng.control.LttngCoreProviderFactory;
import org.eclipse.linuxtools.lttng.control.LttngSyntheticEventProvider;
import org.eclipse.linuxtools.lttng.event.LttngEvent;
+import org.eclipse.linuxtools.lttng.event.LttngSyntheticEvent;
+import org.eclipse.linuxtools.lttng.event.LttngSyntheticEvent.SequenceInd;
import org.eclipse.linuxtools.lttng.model.LTTngTreeNode;
-import org.eclipse.linuxtools.lttng.request.ILttngSyntEventRequest;
-import org.eclipse.linuxtools.lttng.request.IRequestStatusListener;
import org.eclipse.linuxtools.lttng.signal.ILttExperimentSelectedListener;
import org.eclipse.linuxtools.lttng.signal.StateExperimentListener;
-import org.eclipse.linuxtools.lttng.state.evProcessor.ITransEventProcessor;
import org.eclipse.linuxtools.lttng.state.trace.IStateTraceManager;
+import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
+import org.eclipse.linuxtools.tmf.request.ITmfEventRequest;
+import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.signal.TmfExperimentUpdatedSignal;
import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
// supported
private final StateExperimentListener fexperimentListener;
private boolean fwaitForCompletion = false;
+ /**
+ * Used to route incoming events to proper trace manager, during check point
+ * building
+ */
+ private final Map<ITmfTrace, IStateTraceManager> ftraceToManagerMap = new HashMap<ITmfTrace, IStateTraceManager>();
+ private LttngSyntheticEvent syntheticEvent = null;
+ private ITmfEventRequest<LttngEvent> fStateCheckPointRequest = null;
// ========================================================================
// Methods
// =======================================================================
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.lttng.state.experiment.IStateExperimentManager#readExperimentTimeWindow(org.eclipse.linuxtools.tmf.event.TmfTimeRange, java.lang.String, org.eclipse.linuxtools.lttng.state.IStateDataRequestListener)
- */
- public ILttngSyntEventRequest readExperimentTimeWindow(TmfTimeRange trange,
- Object source, IRequestStatusListener listener,
- ITransEventProcessor processor) {
-
- ILttngSyntEventRequest request = null;
-
- // validate
- if (fSelectedExperiment != null) {
- // Get all trace manager nodes
- LTTngTreeNode[] traceMgrs = fSelectedExperiment.getChildren();
-
- if (traceMgrs != null && traceMgrs.length > 0) {
- IStateTraceManager traceManager;
- // Trigger one request per trace
- for (LTTngTreeNode traceNode : traceMgrs) {
- traceManager = (IStateTraceManager) traceNode;
- request = traceManager.executeDataRequest(trange, source,
- listener,
- processor);
- }
- }
- } else {
- if (fSelectedExperiment == null) {
- TraceDebug.debug("No experiment selected");
- }
- }
-
- return request;
- }
+// /* (non-Javadoc)
+// * @see org.eclipse.linuxtools.lttng.state.experiment.IStateExperimentManager#readExperimentTimeWindow(org.eclipse.linuxtools.tmf.event.TmfTimeRange, java.lang.String, org.eclipse.linuxtools.lttng.state.IStateDataRequestListener)
+// */
+// public ILttngSyntEventRequest readExperimentTimeWindow(TmfTimeRange trange,
+// Object source, IRequestStatusListener listener,
+// ITransEventProcessor processor) {
+//
+// ILttngSyntEventRequest request = null;
+//
+// // validate
+// if (fSelectedExperiment != null) {
+// // Get all trace manager nodes
+// LTTngTreeNode[] traceMgrs = fSelectedExperiment.getChildren();
+//
+// if (traceMgrs != null && traceMgrs.length > 0) {
+// IStateTraceManager traceManager;
+// // Trigger one request per trace
+// for (LTTngTreeNode traceNode : traceMgrs) {
+// traceManager = (IStateTraceManager) traceNode;
+// request = traceManager.executeDataRequest(trange, source,
+// listener,
+// processor);
+// }
+// }
+// } else {
+// if (fSelectedExperiment == null) {
+// TraceDebug.debug("No experiment selected");
+// }
+// }
+//
+// return request;
+// }
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.lttng.state.experiment.IStateExperimentManager#readExperiment(java.lang.String, org.eclipse.linuxtools.lttng.state.IStateDataRequestListener)
- */
- @SuppressWarnings("unchecked")
- public void readExperiment(Object source, IRequestStatusListener listener,
- ITransEventProcessor processor) {
- // validate
- if (fSelectedExperiment != null) {
- TmfExperiment<LttngEvent> experiment = (TmfExperiment<LttngEvent>) fSelectedExperiment
- .getValue();
- TmfTimeRange trange = experiment.getTimeRange();
- readExperimentTimeWindow(trange, source, listener, processor);
- } else {
- TraceDebug.debug("No selected experiment available");
- }
- }
+// /* (non-Javadoc)
+// * @see org.eclipse.linuxtools.lttng.state.experiment.IStateExperimentManager#readExperiment(java.lang.String, org.eclipse.linuxtools.lttng.state.IStateDataRequestListener)
+// */
+// @SuppressWarnings("unchecked")
+// public void readExperiment(Object source, IRequestStatusListener listener,
+// ITransEventProcessor processor) {
+// // validate
+// if (fSelectedExperiment != null) {
+// TmfExperiment<LttngEvent> experiment = (TmfExperiment<LttngEvent>) fSelectedExperiment
+// .getValue();
+// TmfTimeRange trange = experiment.getTimeRange();
+// readExperimentTimeWindow(trange, source, listener, processor);
+// } else {
+// TraceDebug.debug("No selected experiment available");
+// }
+// }
public void experimentSelected(Object source,
TmfExperiment<LttngEvent> experiment) {
// validate
- if (experiment == null) {
+ if (experiment == null) {
+ TraceDebug.debug("Received expriment is null");
return;
}
- LTTngTreeNode experimentNode = getChildByName(experiment.getName());
- if (experimentNode != null) {
- // get the trace manager nodes
- LTTngTreeNode[] traceNodes = experimentNode.getChildren();
- for (LTTngTreeNode traceStateManagerNode : traceNodes) {
- // The trace node needs to perform its first data request
- // for this experiment with the main goal of building its
- // checkpoints
- if (traceStateManagerNode instanceof ILttExperimentSelectedListener) {
- // no need to provide the trace to the trace manager
- ((ILttExperimentSelectedListener) traceStateManagerNode).experimentUpdated(
- new TmfExperimentUpdatedSignal(source, experiment, null), fwaitForCompletion);
- }
- }
+ // If previous request is ongoing, cancel it before requesting a new
+ // one.
+ if (fStateCheckPointRequest != null && !fStateCheckPointRequest.isCompleted()) {
+ fStateCheckPointRequest.cancel();
}
+
+ // trigger data request to build the state system check points
+ fStateCheckPointRequest = buildCheckPoints(experiment);
+
+// LTTngTreeNode experimentNode = getChildByName(experiment.getName());
+// if (experimentNode != null) {
+// // get the trace manager nodes
+// LTTngTreeNode[] traceNodes = experimentNode.getChildren();
+// for (LTTngTreeNode traceStateManagerNode : traceNodes) {
+// // The trace node needs to perform its first data request
+// // for this experiment with the main goal of building its
+// // checkpoints
+// if (traceStateManagerNode instanceof ILttExperimentSelectedListener) {
+// // no need to provide the trace to the trace manager
+// ((ILttExperimentSelectedListener) traceStateManagerNode).experimentUpdated(
+// new TmfExperimentUpdatedSignal(source, experiment, null), fwaitForCompletion);
+// }
+// }
+// }
}
/*
*
* @see java.lang.Object#finalize()
*/
+ @Override
protected void finalize() {
fexperimentListener.dispose();
}
fwaitForCompletion = wait;
}
+ private ITmfEventRequest<LttngEvent> buildCheckPoints(TmfExperiment<LttngEvent> experiment) {
+ // validate
+ if (experiment == null) {
+ TraceDebug.debug("Received expriment is null");
+ return null;
+ }
+
+ LTTngTreeNode experimentNode = getChildByName(experiment.getName());
+ if (experimentNode == null) {
+ TraceDebug.debug("Expriment Node " + experiment.getName() + " does not exist");
+ return null;
+ }
+
+ // get the trace manager nodes associated to the experiment
+ LTTngTreeNode[] traceNodes = experimentNode.getChildren();
+ synchronized (ftraceToManagerMap) {
+ ftraceToManagerMap.clear();
+ }
+
+ for (LTTngTreeNode traceStateManagerNode : traceNodes) {
+ IStateTraceManager traceManager;
+ try {
+ traceManager = (IStateTraceManager) traceStateManagerNode;
+ } catch (ClassCastException e) {
+ System.out.println(e.getStackTrace().toString());
+ return null;
+ }
+
+ // Clear all previously created check points as preparation to
+ // re-build
+ traceManager.clearCheckPoints();
+
+ // build the trace to manager mapping for event dispatching
+ synchronized (ftraceToManagerMap) {
+ ftraceToManagerMap.put(traceManager.getTrace(), traceManager);
+ }
+ }
+
+ // if no trace mapping
+ if (ftraceToManagerMap.size() < 1) {
+ TraceDebug.debug("No traces associated to experiment " + experiment.getName());
+ return null;
+ }
+
+ // Prepare event data request to build state model
+ ITmfEventRequest<LttngEvent> request = new TmfEventRequest<LttngEvent>(
+ LttngEvent.class, TmfTimeRange.Eternity,
+ TmfDataRequest.ALL_DATA, 1) {
+
+ Long nbEvents = 0L;
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleData()
+ */
+ @Override
+ public void handleData() {
+ TmfEvent[] events = getData();
+ if (events.length > 0) {
+ nbEvents++;
+
+ LttngEvent event = (LttngEvent) events[0];
+ ITmfTrace trace = event.getParentTrace();
+ IStateTraceManager traceManager = ftraceToManagerMap
+ .get(trace);
+ if (traceManager != null) {
+ // obtain synthetic event
+ LttngSyntheticEvent synEvent = updateSynEvent(event,
+ traceManager);
+ // update state system, and save check points as needed
+ traceManager.handleEvent(synEvent, nbEvents);
+ } else {
+ TraceDebug
+ .debug("StateTraceManager not found for trace"
+ + trace.getName());
+ }
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleFailure()
+ */
+ public void handleFailure() {
+ printCompletedMessage();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleCancel()
+ */
+ public void handleCancel() {
+ printCompletedMessage();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleSuccess()
+ */
+ public void handleSuccess() {
+ printCompletedMessage();
+ }
+
+ /**
+ * @param header
+ */
+ private void printCompletedMessage() {
+ // super.handleCompleted();
+ if (TraceDebug.isDEBUG()) {
+ TraceDebug.debug("Trace check point building completed, number of events handled: " + nbEvents
+ + "\n\t\t");
+ for (IStateTraceManager traceMgr : ftraceToManagerMap.values()) {
+ TraceDebug.debug(traceMgr.toString() + "\n\t\t");
+ }
+ }
+ }
+ };
+
+ // Execute event data request
+ experiment.sendRequest(request);
+ if (fwaitForCompletion) {
+ try {
+ request.waitForCompletion();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+
+ return request;
+ }
+
+ private LttngSyntheticEvent updateSynEvent(LttngEvent e,
+ IStateTraceManager stateTraceManager) {
+ if (syntheticEvent == null || syntheticEvent.getBaseEvent() != e) {
+ syntheticEvent = new LttngSyntheticEvent(e);
+ }
+
+ // Trace model needed by application handlers
+ syntheticEvent.setTraceModel(stateTraceManager.getStateModel());
+ syntheticEvent.setSequenceInd(SequenceInd.UPDATE);
+
+ return syntheticEvent;
+ }
+
}
\ No newline at end of file
import org.eclipse.linuxtools.lttng.control.LttngCoreProviderFactory;
import org.eclipse.linuxtools.lttng.model.LTTngTreeNode;
import org.eclipse.linuxtools.lttng.state.LttngStateException;
-import org.eclipse.linuxtools.lttng.state.model.LttngTraceState;
-import org.eclipse.linuxtools.lttng.state.model.StateModelFactory;
import org.eclipse.linuxtools.lttng.state.trace.IStateTraceManager;
import org.eclipse.linuxtools.lttng.state.trace.StateTraceManager;
import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
return managerNode;
}
- LttngTraceState traceModel = StateModelFactory.getStateEntryInstance();
+// LttngTraceState traceModel =
+// StateModelFactory.getStateEntryInstance();
StateTraceManager manager = null;
// catch potential construction problems
try {
- manager = new StateTraceManager(experiment.getNextUniqueId(),
- experiment, traceUniqueId, rtrace, traceModel,
+ manager = new StateTraceManager(experiment.getNextUniqueId(), experiment, traceUniqueId, rtrace,
LttngCoreProviderFactory.getEventProvider());
// Allow the possibility to configure the trace state check point
* org.eclipse.linuxtools.lttng.control.LTTngStateTreeNodeGeneric#getChildren
* ()
*/
+ @Override
public LTTngStateResource[] getChildren() {
return childrenToArray(fchildren.values(), this.getClass());
}
package org.eclipse.linuxtools.lttng.state.trace;
-import org.eclipse.linuxtools.lttng.request.ILttngSyntEventRequest;
-import org.eclipse.linuxtools.lttng.request.IRequestStatusListener;
+import org.eclipse.linuxtools.lttng.event.LttngSyntheticEvent;
import org.eclipse.linuxtools.lttng.signal.ILttExperimentSelectedListener;
-import org.eclipse.linuxtools.lttng.state.evProcessor.ITransEventProcessor;
import org.eclipse.linuxtools.lttng.state.model.LttngTraceState;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
public interface IStateTraceManager extends ILttExperimentSelectedListener {
- /**
- * TODO: Not ready for threading
- * Read events within specific time window, e.g. time range selection
- * </p>
- *
- * @param trange
- * @param source
- * @param listener
- * @param processor
- * @return
- */
- public abstract ILttngSyntEventRequest executeDataRequest(
- TmfTimeRange trange, Object source,
- IRequestStatusListener listener, ITransEventProcessor processor);
+// /**
+// * TODO: Not ready for threading
+// * Read events within specific time window, e.g. time range selection
+// * </p>
+// *
+// * @param trange
+// * @param source
+// * @param listener
+// * @param processor
+// * @return
+// */
+// public abstract ILttngSyntEventRequest executeDataRequest(
+// TmfTimeRange trange, Object source,
+// IRequestStatusListener listener, ITransEventProcessor processor);
/**
* used to obtain details on the log associated with this manager e.g.
public abstract TmfTimeRange getExperimentTimeWindow();
/**
+ * Returns the State model instance associated with this Trace and given
+ * checkPointReference e.g. check point building state model, UI state
+ * model, etc.
+ *
+ * @return
+ */
+ public abstract LttngTraceState getStateModel(TmfTimestamp startingCheckPointReference);
+
+ /**
+ * Returns the State model instance associated with this Trace i.e. not the
+ * checkpoint build state model
* Returns the State model instance associated with this Trace
*
* @return
*/
public abstract LttngTraceState getStateModel();
-}
\ No newline at end of file
+
+ /**
+ * Reset previously stored check points, and initialize the associated state
+ * model
+ */
+ public void clearCheckPoints();
+
+ /**
+ * handles incoming events used to build the associated check points, The
+ * user must call clearCheckPoints before the processing the first synthetic
+ * event.
+ *
+ * @param synEvent
+ * @param eventCount
+ */
+ public void handleEvent(LttngSyntheticEvent synEvent, Long eventCount);
+}
// immutable Objects
private final ITmfTrace fTrace;
+ private final TmfTimestamp fCheckPointsStartTime;
private int fcpuNumber = -1;
private final ITransEventProcessor fStateUpdateProcessor;
private final HashMap<Long, LttngTraceState> stateCheckpointsList = new HashMap<Long, LttngTraceState>();
private final Vector<TmfCheckpoint> timestampCheckpointsList = new Vector<TmfCheckpoint>();
private LttngTraceState fStateModel;
+ private LttngTraceState fCheckPointStateModel;
private int selectionCount = 0;
// locks
* @throws LttngStateException
*/
public StateTraceManager(Long id, LTTngTreeNode parent, String name,
- ITmfTrace trace, LttngTraceState stateModel,
+ ITmfTrace trace,
TmfEventProvider<LttngSyntheticEvent> eventProvider)
throws LttngStateException {
super(id, parent, name, trace);
}
fTrace = trace;
- fStateModel = stateModel;
- fStateModel.init(this);
+ fCheckPointsStartTime = trace.getStartTime().clone();
fStateUpdateProcessor = StateEventToHandlerFactory.getInstance();
fSynEventProvider = eventProvider;
+
init();
+
+ fStateModel = StateModelFactory.getStateEntryInstance(this);
+ fStateModel.init(this);
+
+ fCheckPointStateModel = StateModelFactory.getStateEntryInstance(this);
+ fCheckPointStateModel.init(this);
}
// =======================================================================
// requested time window from trace start to end, this to
// make sure one thread is used so the events arrive in order for proper
// building of the checkpoints
- TmfTimeRange adjustedRange = new TmfTimeRange(fTrace.getTimeRange()
- .getStartTime(), fTrace.getTimeRange().getEndTime());
+ TmfTimeRange adjustedRange = new TmfTimeRange(fCheckPointsStartTime, fTrace.getTimeRange().getEndTime());
+
// Obtain a dataRequest to pass to the processRequest function
ILttngSyntEventRequest request = getDataRequestStateSave(adjustedRange,
null, fStateUpdateProcessor);
}
}
- /*
- * (non-Javadoc)
- *
- * @see org.eclipse.linuxtools.lttng.state.trace.IStateTraceManager#
- * executeDataRequest(org.eclipse.linuxtools.tmf.event.TmfTimeRange,
- * java.lang.Object,
- * org.eclipse.linuxtools.lttng.request.IRequestStatusListener,
- * org.eclipse.linuxtools.lttng.state.evProcessor.ITransEventProcessor)
- */
- public ILttngSyntEventRequest executeDataRequest(TmfTimeRange trange,
- Object source,
- IRequestStatusListener listener, ITransEventProcessor processor) {
- TmfTimestamp restoredStartTime = restoreCheckPointByTimestamp(trange
- .getStartTime());
- // Adjust the time range to consider rewinding to the start time
- trange = new TmfTimeRange(restoredStartTime, trange.getEndTime());
- // Get a data request for the time range we want (nearest checkpoint
- // to timestamp wanted)
-
- // Process request to that point
- ILttngSyntEventRequest request = getDataRequestByTimeRange(trange,
- listener, processor);
- request.setSource(source);
-
- // don't wait for completion i.e. allow cancellations
- request.startRequestInd(fSynEventProvider);
- // fSynEventProvider
- // .sendRequest((TmfDataRequest<LttngSyntheticEvent>) request);
-
- if (TraceDebug.isDEBUG()) {
- TraceDebug
- .debug(" Time Window requested, (start adjusted to checkpoint): "
- + trange.getStartTime()
- + "-"
- + trange.getEndTime()
- + " Total number of processes in the State provider: "
- + fStateModel.getProcesses().length + " Completed");
- }
-
- return request;
- }
+// /*
+// * (non-Javadoc)
+// *
+// * @see org.eclipse.linuxtools.lttng.state.trace.IStateTraceManager#
+// * executeDataRequest(org.eclipse.linuxtools.tmf.event.TmfTimeRange,
+// * java.lang.Object,
+// * org.eclipse.linuxtools.lttng.request.IRequestStatusListener,
+// * org.eclipse.linuxtools.lttng.state.evProcessor.ITransEventProcessor)
+// */
+// public ILttngSyntEventRequest executeDataRequest(TmfTimeRange trange,
+// Object source,
+// IRequestStatusListener listener, ITransEventProcessor processor) {
+// TmfTimestamp restoredStartTime = restoreCheckPointByTimestamp(trange
+// .getStartTime());
+// // Adjust the time range to consider rewinding to the start time
+// trange = new TmfTimeRange(restoredStartTime, trange.getEndTime());
+// // Get a data request for the time range we want (nearest checkpoint
+// // to timestamp wanted)
+//
+// // Process request to that point
+// ILttngSyntEventRequest request = getDataRequestByTimeRange(trange,
+// listener, processor);
+// request.setSource(source);
+//
+// // don't wait for completion i.e. allow cancellations
+// request.startRequestInd(fSynEventProvider);
+// // fSynEventProvider
+// // .sendRequest((TmfDataRequest<LttngSyntheticEvent>) request);
+//
+// if (TraceDebug.isDEBUG()) {
+// TraceDebug
+// .debug(" Time Window requested, (start adjusted to checkpoint): "
+// + trange.getStartTime()
+// + "-"
+// + trange.getEndTime()
+// + " Total number of processes in the State provider: "
+// + fStateModel.getProcesses().length + " Completed");
+// }
+//
+// return request;
+// }
/*
* (non-Javadoc)
// Save a checkpoint every LTTNG_STATE_SAVE_INTERVAL event
if ((eventCounter.longValue() % fcheckPointInterval) == 0) {
LttngTraceState stateCheckPoint;
- synchronized (fStateModel) {
- stateCheckPoint = fStateModel.clone();
+ synchronized (fCheckPointStateModel) {
+ stateCheckPoint = fCheckPointStateModel.clone();
}
TraceDebug.debug("Check point created here: " + eventCounter
this.fcheckPointInterval = check_point_interval;
}
- /*
- * (non-Javadoc)
- *
- * @see
- * org.eclipse.linuxtools.lttng.state.IStateManager#restoreCheckPointByTimestamp
- * (org.eclipse.linuxtools.tmf.event.TmfTimestamp)
+ /* (non-Javadoc)
+ * @see org.eclipse.linuxtools.lttng.state.trace.IStateTraceManager#restoreCheckPointByTimestamp(org.eclipse.linuxtools.tmf.event.TmfTimestamp)
*/
@SuppressWarnings("unchecked")
- public TmfTimestamp restoreCheckPointByTimestamp(TmfTimestamp eventTime) {
- TmfTimeRange experimentRange = fExperiment.getTimeRange();
+ public TmfTimestamp restoreCheckPointByTimestamp(TmfTimestamp eventTime) { TmfTimeRange experimentRange = fExperiment.getTimeRange();
TmfTimestamp nearestTimeStamp = fTrace.getStartTime();
// The GUI can have time limits higher than this log, since GUI can
return null;
}
- // The GUI can have time limits lower than this trace, since experiment
- // can handle multiple traces
- if ((eventTime.getValue() < fTrace.getStartTime().getValue())) {
- eventTime = fTrace.getStartTime();
- }
-
- // Sort the checkpoints, required before the binary search
- Collections.sort(timestampCheckpointsList);
- // Initiate the compare with a checkpoint containing the target time
- // stamp to find
- int index = Collections.binarySearch(timestampCheckpointsList,
- new TmfCheckpoint(eventTime, new TmfLocation<Long>(0L)));
- // adjust index to round down to earlier checkpoint when exact match not
- // found
- index = getPrevIndex(index);
-
+// // The GUI can have time limits lower than this trace, since experiment
+// // can handle multiple traces
+// if ((eventTime.getValue() < fTrace.getStartTime().getValue())) {
+// eventTime = fTrace.getStartTime();
+// }
+//
+// // Sort the checkpoints, required before the binary search
+// Collections.sort(timestampCheckpointsList);
+// // Initiate the compare with a checkpoint containing the target time
+// // stamp to find
+// int index = Collections.binarySearch(timestampCheckpointsList,
+// new TmfCheckpoint(eventTime, new TmfLocation<Long>(0L)));
+// // adjust index to round down to earlier checkpoint when exact match not
+// // found
+// index = getPrevIndex(index);
+//
LttngTraceState traceState;
- if (index == 0) {
- // No checkpoint restore is needed, start with a brand new
- // TraceState
+// if (index == 0) {
+// // No checkpoint restore is needed, start with a brand new
+// // TraceState
+// traceState = StateModelFactory.getStateEntryInstance(this);
+
+ // The reference to fCheckPointsStartTime is used as the indicator to
+ // identify a state check point building request
+ if (eventTime == fCheckPointsStartTime) {
+ // indicates state checkpoint building request
+ nearestTimeStamp = fCheckPointsStartTime;
+ // starting from the trace start time with an empty state model
traceState = StateModelFactory.getStateEntryInstance(this);
- } else {
- synchronized (checkPointsLock) {
- // Useful CheckPoint found
- TmfCheckpoint checkpoint = timestampCheckpointsList.get(index);
- nearestTimeStamp = checkpoint.getTimestamp();
- // get the location associated with the checkpoint
- TmfLocation<Long> location = (TmfLocation<Long>) checkpoint
- .getLocation();
- // reference a new copy of the checkpoint template
- traceState = stateCheckpointsList.get(location.getLocation())
- .clone();
+ // update the instance field variable pointing the the check point
+ // building state model
+ synchronized (fCheckPointStateModel) {
+ fCheckPointStateModel = traceState;
}
- }
- // Restore the stored traceState
- synchronized (fStateModel) {
- fStateModel = traceState;
+ } else {
+// synchronized (checkPointsLock) {
+// // Useful CheckPoint found
+// TmfCheckpoint checkpoint = timestampCheckpointsList.get(index);
+// nearestTimeStamp = checkpoint.getTimestamp();
+// // get the location associated with the checkpoint
+// TmfLocation<Long> location = (TmfLocation<Long>) checkpoint
+// .getLocation();
+// // reference a new copy of the checkpoint template
+// traceState = stateCheckpointsList.get(location.getLocation())
+// .clone();
+ // The GUI requests can have time limits lower than this trace,
+ // since experiment can handle multiple traces
+ if ((eventTime.getValue() < fTrace.getStartTime().getValue())) {
+ eventTime = fTrace.getStartTime();
+ }
+// }
+
+// // Restore the stored traceState
+// synchronized (fStateModel) {
+// fStateModel = traceState;
+ // Sort the checkpoints, required before the binary search
+ Collections.sort(timestampCheckpointsList);
+ // Initiate the compare with a checkpoint containing the target time
+ // stamp to find
+ int index = Collections.binarySearch(timestampCheckpointsList, new TmfCheckpoint(eventTime,
+ new TmfLocation<Long>(0L)));
+ // adjust index to round down to earlier checkpoint when exact match
+ // not
+ // found
+ index = getPrevIndex(index);
+
+ if (index == 0) {
+ // No checkpoint restore is needed, start with a brand new
+ // TraceState
+ traceState = StateModelFactory.getStateEntryInstance(this);
+ } else {
+ synchronized (checkPointsLock) {
+ // Useful CheckPoint found
+ TmfCheckpoint checkpoint = timestampCheckpointsList.get(index);
+ nearestTimeStamp = checkpoint.getTimestamp();
+ // get the location associated with the checkpoint
+ TmfLocation<Long> location = (TmfLocation<Long>) checkpoint.getLocation();
+ // reference a new copy of the checkpoint template
+ traceState = stateCheckpointsList.get(location.getLocation()).clone();
+ }
+ }
+
+ // Restore the stored traceState
+ synchronized (fStateModel) {
+ fStateModel = traceState;
+ }
}
return nearestTimeStamp;
DEFAULT_OFFSET, TmfDataRequest.ALL_DATA, DEFAULT_CHUNK,
requestListener, getExperimentTimeWindow(), processor) {
+ /* (non-Javadoc)
+ * @see org.eclipse.linuxtools.lttng.request.LttngSyntEventRequest#handleCompleted()
+ */
@Override
public void handleCompleted() {
if (isCancelled() || isFailed()) {
+ "\tEvents for a different trace state received: "
+ fprocessor.getFilteredOutEventCount()
+ "\n\t"
- + "Total number of processes in the State provider: "
- + fStateModel.getProcesses().length);
+ + fStateModel.getProcesses().length
+ + "\n\t"
+ + "Total number of processes in the Check point State model: "
+ + fCheckPointStateModel.getProcesses().length);
TmfTimeRange logTimes = fTrace.getTimeRange();
sb.append("\n\tTrace time interval for trace "
}
}
- /*
- * (non-Javadoc)
- *
- * @see
- * org.eclipse.linuxtools.lttng.request.LttngEventRequest#saveCheckPoint
- * (java.lang.Long, org.eclipse.linuxtools.tmf.event.TmfTimestamp)
+ /* (non-Javadoc)
+ * @see org.eclipse.linuxtools.lttng.state.trace.StateTraceManager.StateTraceManagerRequest#saveCheckPoint(java.lang.Long, org.eclipse.linuxtools.tmf.event.TmfTimestamp)
*/
+ @Override
public void saveCheckPoint(Long count, TmfTimestamp time) {
saveCheckPointIfNeeded(count, time);
}
}
}
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.eclipse.linuxtools.lttng.state.trace.IStateTraceManager#getStateModel
+ * (org.eclipse.linuxtools.tmf.event.TmfTimestamp)
+ */
+ public LttngTraceState getStateModel(TmfTimestamp checkPointReference) {
+ // validate
+ if (checkPointReference == null) {
+ return null;
+ }
+
+ // Only two state models supported at this time e.g. one for checkpoint
+ // building and the second one is shared for UI requests which are
+ // either coalesced or sequential (i.e. within the same trace data
+ // provider)
+ if (checkPointReference == fCheckPointsStartTime) {
+ synchronized (fCheckPointStateModel) {
+ return fCheckPointStateModel;
+ }
+ } else {
+ synchronized (fStateModel) {
+ return fStateModel;
+ }
+ }
+ }
+
/**
* @return the stateCheckpointsList
*/
public ITmfTrace getTraceIdRef() {
return fTrace;
}
-}
\ No newline at end of file
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.eclipse.linuxtools.lttng.state.trace.IStateTraceManager#clearCheckPoints
+ * ()
+ */
+ public void clearCheckPoints() {
+ synchronized (checkPointsLock) {
+ stateCheckpointsList.clear();
+ timestampCheckpointsList.clear();
+
+ fCheckPointStateModel = StateModelFactory
+ .getStateEntryInstance(this);
+ try {
+ fCheckPointStateModel.init(this);
+ } catch (LttngStateException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * org.eclipse.linuxtools.lttng.state.trace.IStateTraceManager#handleEvent
+ * (org.eclipse.linuxtools.lttng.event.LttngSyntheticEvent, java.lang.Long)
+ */
+ public void handleEvent(LttngSyntheticEvent synEvent, Long eventCount) {
+ fStateUpdateProcessor.process(synEvent, fCheckPointStateModel);
+
+ // Save checkpoint as needed
+ saveCheckPointIfNeeded(eventCount - 1, synEvent.getTimestamp());
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ public String toString() {
+ StringBuilder sb = new StringBuilder(super.toString());
+ sb.append("\n\tTotal number of processes in the Shared State model: " + fStateModel.getProcesses().length
+ + "\n\t" + "Total number of processes in the Check point State model: "
+ + fCheckPointStateModel.getProcesses().length);
+
+ TmfTimeRange traceTRange = fTrace.getTimeRange();
+ sb.append("\n\tTrace time interval for trace " + fTrace.getName() + "\n\t"
+ + new LttngTimestamp(traceTRange.getStartTime()));
+ sb.append(" - " + new LttngTimestamp(traceTRange.getEndTime()));
+ sb.append("\n\tCheckPoints available at: ");
+ for (TmfCheckpoint cpoint : timestampCheckpointsList) {
+ sb.append("\n\t" + "Location: " + cpoint.getLocation() + " - " + cpoint.getTimestamp());
+ }
+
+ return sb.toString();
+ }
+
+}
fIndexPageSize = 1000;
// Skip indexing if asked
- if ( skipIndexing == true ) {
+// if ( skipIndexing == true ) {
fCheckpoints.add(new TmfCheckpoint(new LttngTimestamp(0L), new TmfLocation<Long>(0L)));
- }
- else {
- indexTrace(true);
- }
+// }
+// else {
+// indexTrace(true);
+// }
Long endTime = currentLttngEvent.getTimestamp().getValue();
positionToFirstEvent();
import org.eclipse.linuxtools.lttng.jni.JniTrace;
import org.eclipse.linuxtools.lttng.jni.JniTracefile;
import org.eclipse.linuxtools.lttng.jni.common.JniTime;
+import org.eclipse.linuxtools.lttng.jni.exception.JniException;
import org.eclipse.linuxtools.lttng.jni.factory.JniTraceFactory;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.trace.ITmfLocation;
-import org.eclipse.linuxtools.tmf.trace.TmfCheckpoint;
import org.eclipse.linuxtools.tmf.trace.TmfContext;
import org.eclipse.linuxtools.tmf.trace.TmfTrace;
// Set the currentEvent to the eventContent
eventContent.setEvent(currentLttngEvent);
- // Bypass indexing if asked
- if ( bypassIndexing == false ) {
- indexTrace(true);
- }
- else {
+// // Bypass indexing if asked
+// if ( bypassIndexing == false ) {
+// indexTrace(true);
+// }
+// else {
// Even if we don't have any index, set ONE checkpoint
- fCheckpoints.add(new TmfCheckpoint(new LttngTimestamp(0L) , new LttngLocation() ) );
+// fCheckpoints.add(new TmfCheckpoint(new LttngTimestamp(0L) , new LttngLocation() ) );
// Set the start time of the trace
setTimeRange( new TmfTimeRange( new LttngTimestamp(currentJniTrace.getStartTime().getTime()),
new LttngTimestamp(currentJniTrace.getEndTime().getTime())
) );
- }
+// }
}
/*
return returnedTrace;
}
+ @Override
+ public LTTngTrace clone() {
+ LTTngTrace clone = null;
+ try {
+ clone = (LTTngTrace) super.clone();
+ try {
+ clone.currentJniTrace = JniTraceFactory.getJniTrace(getPath(), SHOW_LTT_DEBUG_DEFAULT);
+ } catch (JniException e) {
+ e.printStackTrace();
+ }
+
+ // Export all the event types from the JNI side
+ clone.traceTypes = new HashMap<String, LttngEventType>();
+ clone.traceTypeNames = new Vector<String>();
+ clone.initialiseEventTypes(clone.currentJniTrace);
+
+ // Verify that all those "default constructor" are safe to use
+ clone.eventTimestamp = new LttngTimestamp();
+ clone.eventSource = new LttngEventSource();
+ clone.eventType = new LttngEventType();
+ clone.eventContent = new LttngEventContent(clone.currentLttngEvent);
+ clone.eventReference = new LttngEventReference(this.getName());
+
+ // Create the skeleton event
+ clone.currentLttngEvent = new LttngEvent(this, clone.eventTimestamp, clone.eventSource, clone.eventType, clone.eventContent, clone.eventReference, null);
+
+ // Create a new current location
+ clone.previousLocation = new LttngLocation();
+
+ // Set the currentEvent to the eventContent
+ clone.eventContent.setEvent(clone.currentLttngEvent);
+
+ // Set the start time of the trace
+ setTimeRange(new TmfTimeRange(
+ new LttngTimestamp(clone.currentJniTrace.getStartTime().getTime()),
+ new LttngTimestamp(clone.currentJniTrace.getEndTime().getTime())
+ ));
+ }
+ catch (CloneNotSupportedException e) {
+ }
+
+ return clone;
+ }
+
+
/*
* Fill out the HashMap with "Type" (Tracefile/Marker)
*
this.traceTypeNames.add(newTypeKey);
}
- /**
- * Index the current trace.
- *
- * @param useless This boolean is only to comply to the interface and will be ignored.
- */
- @Override
- public synchronized void indexTrace(boolean useless) {
-
- long nbEvents=0L;
-
- // Start time need to be null to detect none have been set
- // LastTime need to exist so we can ajust it as we go
- LttngTimestamp startTime = null;
- LttngTimestamp lastTime = new LttngTimestamp();
-
- // Position the trace at the beginning
- TmfContext context = seekEvent( new LttngTimestamp(0L) );
-
- // Read the first event and extract the location
- LttngEvent tmpEvent = (LttngEvent)getNextEvent(context);
-
- // If we read the first event, define the start time.
- if ( tmpEvent != null ) {
- startTime = new LttngTimestamp( tmpEvent.getTimestamp() );
- lastTime.setValue(tmpEvent.getTimestamp().getValue());
- }
-
- // Now, we read each event until we hit the end of the trace
- // We will create a new checkpoint every "getCacheSize()" event
- while ( tmpEvent != null) {
- // Update the last time each time we read a new event
- lastTime.setValue(tmpEvent.getTimestamp().getValue());
-
- // Save a check point if needed
- if ((nbEvents++ % getCacheSize()) == 0) {
- // *** IMPORTANT
- // We need to NEW each stuff we put in checkpoint
- // Otherwise everything will be the same!
- LttngTimestamp tmpTimestamp = new LttngTimestamp( (LttngTimestamp)tmpEvent.getTimestamp() );
- LttngLocation newLocation = new LttngLocation( (LttngTimestamp)tmpEvent.getTimestamp() );
-
- fCheckpoints.add(new TmfCheckpoint(tmpTimestamp, newLocation ) );
- }
- // Read the next event
- tmpEvent = (LttngEvent)getNextEvent(context);
- }
-
- // If we have a start time, we should have an end time as well
- // Issue the new range
- if (startTime != null) {
- setTimeRange( new TmfTimeRange(startTime, lastTime) );
- notifyListeners(getTimeRange() );
- }
-
- // Ajust the total number of event in the trace
- fNbEvents = nbEvents;
- //printCheckpointsVector();
- //printDebug = true;
- }
+// /**
+// * Index the current trace.
+// *
+// * @param useless This boolean is only to comply to the interface and will be ignored.
+// */
+// @Override
+// public synchronized void indexTrace(boolean useless) {
+//
+// long nbEvents=0L;
+//
+// // Start time need to be null to detect none have been set
+// // LastTime need to exist so we can ajust it as we go
+// LttngTimestamp startTime = null;
+// LttngTimestamp lastTime = new LttngTimestamp();
+//
+// // Position the trace at the beginning
+// TmfContext context = seekEvent( new LttngTimestamp(0L) );
+//
+// // Read the first event and extract the location
+// LttngEvent tmpEvent = (LttngEvent)getNextEvent(context);
+//
+// // If we read the first event, define the start time.
+// if ( tmpEvent != null ) {
+// startTime = new LttngTimestamp( tmpEvent.getTimestamp() );
+// lastTime.setValue(tmpEvent.getTimestamp().getValue());
+// }
+//
+// // Now, we read each event until we hit the end of the trace
+// // We will create a new checkpoint every "getCacheSize()" event
+// while ( tmpEvent != null) {
+// // Update the last time each time we read a new event
+// lastTime.setValue(tmpEvent.getTimestamp().getValue());
+//
+// // Save a check point if needed
+// if ((nbEvents++ % getCacheSize()) == 0) {
+// // *** IMPORTANT
+// // We need to NEW each stuff we put in checkpoint
+// // Otherwise everything will be the same!
+// LttngTimestamp tmpTimestamp = new LttngTimestamp( (LttngTimestamp)tmpEvent.getTimestamp() );
+// LttngLocation newLocation = new LttngLocation( (LttngTimestamp)tmpEvent.getTimestamp() );
+//
+// fCheckpoints.add(new TmfCheckpoint(tmpTimestamp, newLocation ) );
+// }
+// // Read the next event
+// tmpEvent = (LttngEvent)getNextEvent(context);
+// }
+//
+// // If we have a start time, we should have an end time as well
+// // Issue the new range
+// if (startTime != null) {
+// setTimeRange( new TmfTimeRange(startTime, lastTime) );
+// notifyListeners(getTimeRange() );
+// }
+//
+// // Ajust the total number of event in the trace
+// fNbEvents = nbEvents;
+// //printCheckpointsVector();
+// //printDebug = true;
+// }
/**
* Return the latest saved location.
* @see org.eclipse.linuxtools.lttng.event.LttngLocation
* @see org.eclipse.linuxtools.tmf.trace.TmfContext
*/
+
+ public int nbEventsRead = 0;
@Override
public synchronized LttngEvent getNextEvent(TmfContext context) {
// To do so, we avoid moving for call to "GetNextEvent()" that follow call to a call to "ParseEvent()".
// However, calling ParseEvent() -> GetNextEvent() -> GetNextEvent() will only move next by one.
- // *** Positionning trick :
+ // *** Positioning trick :
// GetNextEvent only read the trace if :
// 1- The last operation was NOT a ParseEvent --> A read is required
// OR
}
// Read the next event from the trace. The last one will NO LONGER BE VALID.
returnedEvent = readEvent(curLocation);
+ nbEventsRead++;
// Set the operation marker as read to both location, to be able to detect we did "read" this event
previousLocation.setLastOperationReadNext();
if ( returnedEvent != null ) {
previousLocation.setOperationTime((LttngTimestamp)returnedEvent.getTimestamp());
curLocation.setOperationTime((LttngTimestamp)returnedEvent.getTimestamp());
+
+ updateIndex(context, context.getRank(), returnedEvent.getTimestamp());
+ context.updateRank(1);
}
return returnedEvent;
private void setupExperiment() {
if (fExperiment == null) {
fExperiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, fTraces);
- fExperiment.indexExperiment(true);
+ fExperiment.indexExperiment();
}
}
public void testParseEvent() throws Exception {
- // On lower bound, returns the first event (ts = 0)
+ // On lower bound, returns the first event (ts = 1)
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(0, SCALE, 0));
TmfEvent event = fExperiment.parseEvent(context);
private void setupExperiment() {
if (fExperiment == null) {
fExperiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, fTrace);
- fExperiment.indexExperiment(true);
+ fExperiment.indexExperiment();
}
}
public void testTmfContextDefault() {
TmfContext context = new TmfContext();
assertEquals("getLocation", null, context.getLocation());
- assertEquals("getRank", 0, context.getRank());
+ assertEquals("getRank", TmfContext.UNKNOWN_RANK, context.getRank());
}
public void testTmfContextNoRank() {
assertEquals("getLocation", fLocation2, context2.getLocation());
assertEquals("getLocation", fLocation3, context3.getLocation());
- assertEquals("getRank", 0, context1.getRank());
- assertEquals("getRank", 0, context2.getRank());
- assertEquals("getRank", 0, context3.getRank());
+ assertEquals("getRank", TmfContext.UNKNOWN_RANK, context1.getRank());
+ assertEquals("getRank", TmfContext.UNKNOWN_RANK, context2.getRank());
+ assertEquals("getRank", TmfContext.UNKNOWN_RANK, context3.getRank());
}
public void testTmfContext() {
private void setupExperiment() {
if (fExperiment == null) {
fExperiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, fTraces);
- fExperiment.indexExperiment(true);
+ fExperiment.indexExperiment();
}
}
URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
File test = new File(FileLocator.toFileURL(location).toURI());
fTrace = new TmfTraceStub(test.getPath(), BLOCK_SIZE, false);
- fTrace.indexTrace(true);
+// fTrace.indexTrace(true);
} catch (URISyntaxException e) {
e.printStackTrace();
} catch (IOException e) {
}
}
};
- provider.sendRequest(subRequest); // , false);
+ provider.sendRequest(subRequest);
// Return a dummy context
return new TmfContext();
// Queue 2 synthetic events per base event
private void handleIncomingData(TmfEvent e) {
- queueResult(new TmfSyntheticEventStub(e));
- queueResult(new TmfSyntheticEventStub(e));
+ try {
+ queueResult(new TmfSyntheticEventStub(e));
+ queueResult(new TmfSyntheticEventStub(e));
+ } catch (InterruptedException e1) {
+ e1.printStackTrace();
+ }
+ }
+
+ @Override
+ public void sendRequest(ITmfDataRequest<TmfSyntheticEventStub> request, ExecutionType execType) {
+ super.sendRequest(request, execType);
+ }
+
+ @Override
+ public void sendRequest(ITmfDataRequest<TmfSyntheticEventStub> request) {
+ super.sendRequest(request);
}
}
import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.signal.TmfExperimentSelectedSignal;
import org.eclipse.linuxtools.tmf.signal.TmfExperimentUpdatedSignal;
+import org.eclipse.linuxtools.tmf.signal.TmfRangeSynchSignal;
import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
import org.eclipse.linuxtools.tmf.signal.TmfTimeSynchSignal;
import org.eclipse.swt.SWT;
cache = tmpEvent;
cacheStartIndex = index;
cacheEndIndex = index + tmpEvent.length;
+// System.out.println("TmfTableView: entry#" + index);
}
}
};
// Perform the updates on the UI thread
fTable.getDisplay().asyncExec(new Runnable() {
public void run() {
- // TODO: Potentially long operation. Add some feedback for the user
fTable.setSelection(0);
fTable.clearAll();
cacheStartIndex = cacheEndIndex = 0; // Clear the cache
fTable.getDisplay().asyncExec(new Runnable() {
public void run() {
if (!fTable.isDisposed() && fExperiment != null) {
- fTable.setItemCount((int) fExperiment.getNbEvents());
+ int nbEvents = (int) fExperiment.getNbEvents();
+ fTable.setItemCount((nbEvents > 100) ? nbEvents : 100);
}
}
});
}
+ private boolean fRefreshPending = false;
+ @TmfSignalHandler
+ public synchronized void rangeSynched(TmfRangeSynchSignal signal) {
+ if (!fRefreshPending) {
+ // Perform the refresh on the UI thread
+ fRefreshPending = true;
+ fTable.getDisplay().asyncExec(new Runnable() {
+ public void run() {
+ fRefreshPending = false;
+ if (!fTable.isDisposed() && fExperiment != null) {
+ fTable.setItemCount((int) fExperiment.getNbEvents());
+// if (Tracer.INTERNALS) Tracer.trace("TmfEventsView: itemCount=" + fTable.getItemCount());
+ }
+ }
+ });
+ }
+ }
+
// @TmfSignalHandler
// public void currentTimeUpdated(TmfTimeSynchSignal signal) {
// if (signal.getSource() != fTable && fExperiment != null) {
-org.eclipse.linuxtools.tmf/trace=false
+org.eclipse.linuxtools.tmf/component=false
+org.eclipse.linuxtools.tmf/request=false
+org.eclipse.linuxtools.tmf/event=false
+org.eclipse.linuxtools.tmf/exceptions=false
+org.eclipse.linuxtools.tmf/signals=false
+org.eclipse.linuxtools.tmf/internals=false
package org.eclipse.linuxtools.tmf;\r
\r
+import java.io.BufferedWriter;\r
+import java.io.FileWriter;\r
+import java.io.IOException;\r
+\r
import org.eclipse.core.runtime.Platform;\r
+import org.eclipse.linuxtools.tmf.component.ITmfComponent;\r
+import org.eclipse.linuxtools.tmf.component.ITmfDataProvider;\r
+import org.eclipse.linuxtools.tmf.event.TmfData;\r
+import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;\r
\r
public class Tracer {\r
\r
- static Boolean TRACE = Boolean.FALSE;\r
-\r
private static String pluginID = TmfCorePlugin.PLUGIN_ID;\r
\r
+ static Boolean ERROR = Boolean.FALSE;\r
+\r
+ static Boolean COMPONENT = Boolean.FALSE;\r
+ static Boolean REQUEST = Boolean.FALSE;\r
+ static Boolean EVENT = Boolean.FALSE;\r
+ static Boolean EXCEPTION = Boolean.FALSE;\r
+\r
+// static Boolean SIGNALS = Boolean.FALSE;\r
+// static Boolean INTERNALS = Boolean.FALSE;\r
+\r
+ private static BufferedWriter fTraceLog = null;\r
+\r
+ private static BufferedWriter openLogFile(String filename) {\r
+ BufferedWriter outfile = null;\r
+ try {\r
+ outfile = new BufferedWriter(new FileWriter(filename));\r
+ } catch (IOException e) {\r
+ e.printStackTrace();\r
+ }\r
+ return outfile;\r
+ }\r
+\r
public static void init() {\r
- String traceKey = Platform.getDebugOption(pluginID + "/trace");\r
\r
+ String traceKey;\r
+ \r
+ traceKey = Platform.getDebugOption(pluginID + "/error");\r
+ if (traceKey != null) {\r
+ ERROR = (new Boolean(traceKey)).booleanValue();\r
+ }\r
+\r
+ traceKey = Platform.getDebugOption(pluginID + "/component");\r
+ if (traceKey != null) {\r
+ COMPONENT = (new Boolean(traceKey)).booleanValue();\r
+ }\r
+\r
+ traceKey = Platform.getDebugOption(pluginID + "/request");\r
if (traceKey != null) {\r
- TRACE = (new Boolean(traceKey)).booleanValue();\r
+ REQUEST = (new Boolean(traceKey)).booleanValue();\r
}\r
+\r
+ traceKey = Platform.getDebugOption(pluginID + "/event");\r
+ if (traceKey != null) {\r
+ EVENT = (new Boolean(traceKey)).booleanValue();\r
+ }\r
+\r
+ traceKey = Platform.getDebugOption(pluginID + "/exception");\r
+ if (traceKey != null) {\r
+ EXCEPTION = (new Boolean(traceKey)).booleanValue();\r
+ }\r
+\r
+ // Create trace log file if needed\r
+ if (ERROR || COMPONENT || REQUEST || EVENT || EXCEPTION) {\r
+ fTraceLog = openLogFile("trace.log");\r
+ }\r
+\r
+// String signalsKey = Platform.getDebugOption(pluginID + "/signals");\r
+// if (signalsKey != null) {\r
+// SIGNALS = (new Boolean(signalsKey)).booleanValue();\r
+// }\r
+//\r
+// String internalsKey = Platform.getDebugOption(pluginID + "/internals");\r
+// if (internalsKey != null) {\r
+// INTERNALS = (new Boolean(signalsKey)).booleanValue();\r
+// }\r
+ }\r
+\r
+ // Predicates\r
+ public static boolean isErrorTraced() {\r
+ return ERROR;\r
}\r
\r
- public static void trace(String message) {\r
- if (TRACE) {\r
- System.out.println(Thread.currentThread() + ": " + message);\r
+ public static boolean isComponentTraced() {\r
+ return COMPONENT;\r
+ }\r
+ \r
+ public static boolean isRequestTraced() {\r
+ return REQUEST;\r
+ }\r
+ \r
+ public static boolean isEventTraced() {\r
+ return EVENT;\r
+ }\r
+ \r
+ public static boolean isExceptionTraced() {\r
+ return EXCEPTION;\r
+ }\r
+\r
+ // Tracers\r
+ private static void trace(String message) {\r
+ System.out.println(message);\r
+ try {\r
+ if (fTraceLog != null) {\r
+ fTraceLog.write(message);\r
+ fTraceLog.newLine();\r
+ fTraceLog.flush();\r
+ }\r
+ } catch (IOException e) {\r
+ e.printStackTrace();\r
}\r
}\r
+\r
+ public static void traceComponent(ITmfComponent component, String msg) {\r
+ String message = ("[CMP] Thread=" + Thread.currentThread().getId() + " Cmp=" + component.getName() + " " + msg);\r
+ trace(message);\r
+ }\r
+\r
+ public static void traceRequest(ITmfDataRequest<?> request, String msg) {\r
+ String message = ("[REQ] Thread=" + Thread.currentThread().getId() + " Req=" + request.getRequestId() + ", Type=" + request.getDataType().getSimpleName() + " " + msg);\r
+ trace(message);\r
+ }\r
+\r
+ public static void traceEvent(ITmfDataProvider<?> provider, ITmfDataRequest<?> request, TmfData data) {\r
+ String message = ("[EVT] Provider=" + provider.toString() + ", Req=" + request.getRequestId() + ", Event=" + data.toString());\r
+ trace(message);\r
+ }\r
+\r
+ public static void traceException(Exception e) {\r
+ }\r
+\r
+ \r
+ public static void traceError(String msg) {\r
+ String message = ("[ERR] Thread=" + Thread.currentThread().getId() + msg);\r
+ trace(message);\r
+ }\r
+\r
+// public static void traceComponent(String message) {\r
+// if (COMPONENTS)\r
+// trace(Thread.currentThread() + ": " + message);\r
+// }\r
+//\r
+// public static void traceSignal(TmfSignal signal) {\r
+// if (SIGNALS)\r
+// trace(Thread.currentThread() + ": " + signal.toString());\r
+// }\r
+//\r
+// public static void traceInternal(String message) {\r
+// if (INTERNALS)\r
+// trace(Thread.currentThread() + ": " + message);\r
+// }\r
+\r
}\r
+/*******************************************************************************
+ * Copyright (c) 2009, 2010 Ericsson
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Francois Chouinard - Initial API and implementation
+ *******************************************************************************/
+
package org.eclipse.linuxtools.tmf.component;
import org.eclipse.linuxtools.tmf.event.TmfData;
import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
+/**
+ * <b><u>ITmfDataRequest</u></b>
+ * <p>
+ * TODO: Implement me. Please.
+ */
public interface ITmfDataProvider<T extends TmfData> {
+ // ------------------------------------------------------------------------
+ // Constants
+ // ------------------------------------------------------------------------
+
+ public enum ExecutionType { SHORT, LONG };
+
/**
* Queues the request for processing.
*
* @param request The request to process
*/
public void sendRequest(ITmfDataRequest<T> request);
+ public void sendRequest(ITmfDataRequest<T> request, ExecutionType type);
+ public void fireRequests();
}
package org.eclipse.linuxtools.tmf.component;
+import org.eclipse.linuxtools.tmf.Tracer;
import org.eclipse.linuxtools.tmf.signal.TmfSignal;
import org.eclipse.linuxtools.tmf.signal.TmfSignalManager;
public TmfComponent(String name) {
fName = name;
+ if (Tracer.isComponentTraced()) Tracer.traceComponent(this, "created");
TmfSignalManager.register(this);
}
*/
public void dispose() {
TmfSignalManager.deregister(this);
+ if (Tracer.isComponentTraced()) Tracer.traceComponent(this, "terminated");
}
/* (non-Javadoc)
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.TimeUnit;
import org.eclipse.linuxtools.tmf.Tracer;
import org.eclipse.linuxtools.tmf.event.TmfData;
public abstract class TmfDataProvider<T extends TmfData> extends TmfComponent implements ITmfDataProvider<T> {
final protected Class<T> fType;
+ final protected boolean fLogData;
+ final protected boolean fLogException;
public static final int DEFAULT_QUEUE_SIZE = 1000;
protected final int fQueueSize;
protected final BlockingQueue<T> fDataQueue;
protected final TmfRequestExecutor fExecutor;
- private int fCoalescingLevel = 0;
+ private int fSignalDepth = 0;
// ------------------------------------------------------------------------
// Constructors
fQueueSize = queueSize;
fDataQueue = (queueSize > 1) ? new LinkedBlockingQueue<T>(fQueueSize) : new SynchronousQueue<T>();
- Tracer.trace(getName() + " created");
+// Tracer.traceComponent(getName() + " created");
fExecutor = new TmfRequestExecutor();
- fCoalescingLevel = 0;
+ fSignalDepth = 0;
+
+ fLogData = Tracer.isEventTraced();
+ fLogException = Tracer.isEventTraced();
TmfProviderManager.register(fType, this);
- Tracer.trace(getName() + " started");
+// Tracer.traceComponent(getName() + " started");
}
public TmfDataProvider(TmfDataProvider<T> other) {
fDataQueue = (fQueueSize > 1) ? new LinkedBlockingQueue<T>(fQueueSize) : new SynchronousQueue<T>();
fExecutor = new TmfRequestExecutor();
- fCoalescingLevel = 0;
+ fSignalDepth = 0;
+
+ fLogData = Tracer.isEventTraced();
+ fLogException = Tracer.isEventTraced();
}
@Override
public void dispose() {
TmfProviderManager.deregister(fType, this);
fExecutor.stop();
- Tracer.trace(getName() + " stopped");
+// Tracer.traceComponent(getName() + " stopped");
+ if (fClone != null) fClone.dispose();
super.dispose();
}
// ITmfRequestHandler
// ------------------------------------------------------------------------
+// public synchronized void sendRequest(final ITmfDataRequest<T> request, ExecutionType execType) {
+// sendRequest(request);
+// }
+
public synchronized void sendRequest(final ITmfDataRequest<T> request) {
+ sendRequest(request, ExecutionType.SHORT);
+ }
- if (fCoalescingLevel > 0) {
- // We are in coalescing mode: client should NEVER wait
- // (otherwise we will have deadlock...)
- coalesceDataRequest(request);
- } else {
- // Process the request immediately
- queueRequest(request);
+ protected TmfDataProvider<T> fClone;
+ public synchronized void sendRequest(final ITmfDataRequest<T> request, ExecutionType execType) {
+ if (fClone == null || execType == ExecutionType.SHORT) {
+ if (fSignalDepth > 0) {
+ coalesceDataRequest(request);
+ } else {
+ queueRequest(request);
+ }
+ }
+ else {
+ fClone.sendRequest(request);
}
}
*
* @param thread
*/
- private synchronized void fireRequests() {
+ public synchronized void fireRequests() {
for (TmfDataRequest<T> request : fPendingCoalescedRequests) {
queueRequest(request);
}
fPendingCoalescedRequests.clear();
+
+ if (fClone != null)
+ fClone.fireRequests();
}
// ------------------------------------------------------------------------
protected void queueRequest(final ITmfDataRequest<T> request) {
- final String provider = getName();
-
+// final String provider = getName();
+ final ITmfDataProvider<T> provider = this;
+
// Process the request
Thread thread = new Thread() {
public void run() {
// Extract the generic information
+ request.start();
int blockSize = request.getBlockize();
int nbRequested = request.getNbRequested();
// Initialize the execution
ITmfContext context = armRequest(request);
if (context == null) {
- request.fail();
+ request.cancel();
return;
}
- // Get the ordered events
- Tracer.trace("Request #" + request.getRequestId() + " is serviced by " + provider);
- T data = getNext(context);
- Tracer.trace("Request #" + request.getRequestId() + " read first event");
- while (data != null && !isCompleted(request, data, nbRead))
- {
- result.add(data);
- if (++nbRead % blockSize == 0) {
- pushData(request, result);
- }
- // To avoid an unnecessary read passed the last data requested
- if (nbRead < nbRequested) {
- data = getNext(context);
- if (data == null || data.isNullRef()) {
- Tracer.trace("Request #" + request.getRequestId() + " end of data");
+ try {
+ // Get the ordered events
+// Tracer.traceLog("Request #" + request.getRequestId() + " is serviced by " + provider);
+ T data = getNext(context);
+// Tracer.traceLog("Request #" + request.getRequestId() + " read first event");
+ while (data != null && !isCompleted(request, data, nbRead))
+ {
+ if (fLogData) Tracer.traceEvent(provider, request, data);
+ result.add(data);
+ if (++nbRead % blockSize == 0) {
+ pushData(request, result);
+ }
+ // To avoid an unnecessary read passed the last data requested
+ if (nbRead < nbRequested) {
+ data = getNext(context);
+ if (data == null || data.isNullRef()) {
+// Tracer.traceLog("Request #" + request.getRequestId() + " end of data");
+ }
}
}
+ pushData(request, result);
+ request.done();
+ }
+ catch (Exception e) {
+ e.printStackTrace();
+ if (fLogException) Tracer.traceException(e);
+ request.fail();
}
- pushData(request, result);
- request.done();
}
};
fExecutor.execute(thread);
+ if (Tracer.isRequestTraced()) Tracer.traceRequest(request, "queued");
}
/**
* @param context
* @return
*/
- public T getNext(ITmfContext context) {
- try {
- T event = fDataQueue.take();
- return event;
- } catch (InterruptedException e) {
- e.printStackTrace();
+ private final int TIMEOUT = 5000;
+ public T getNext(ITmfContext context) throws InterruptedException {
+ T event = fDataQueue.poll(TIMEOUT, TimeUnit.MILLISECONDS);
+ if (event == null) {
+ if (Tracer.isErrorTraced()) Tracer.traceError("Request timeout on read");
+ throw new InterruptedException();
}
- return null;
+ return event;
}
/**
*
* @param data
*/
- public void queueResult(T data) {
- try {
- fDataQueue.put(data);
- } catch (InterruptedException e1) {
- e1.printStackTrace();
+ public void queueResult(T data) throws InterruptedException {
+ boolean ok = fDataQueue.offer(data, TIMEOUT, TimeUnit.MILLISECONDS);
+ if (!ok) {
+ if (Tracer.isErrorTraced()) Tracer.traceError("Request timeout on write");
+ throw new InterruptedException();
}
}
@TmfSignalHandler
public void startSynch(TmfStartSynchSignal signal) {
synchronized(this) {
- fCoalescingLevel++;
+ fSignalDepth++;
}
}
@TmfSignalHandler
public void endSynch(TmfEndSynchSignal signal) {
synchronized(this) {
- fCoalescingLevel--;
- if (fCoalescingLevel == 0) {
+ fSignalDepth--;
+ if (fSignalDepth == 0) {
fireRequests();
}
}
return (fStartTime.compareTo(ts, true) <= 0) && (fEndTime.compareTo(ts, true) >= 0);
}
+ /**
+ * Check if the time range is within the time range
+ *
+ * @param range
+ * @return
+ */
+ public boolean contains(TmfTimeRange range) {
+ TmfTimestamp startTime = range.getStartTime();
+ TmfTimestamp endTime = range.getEndTime();
+ return (fStartTime.compareTo(startTime, true) <= 0) && (fEndTime.compareTo(endTime, true) >= 0);
+ }
+
// ------------------------------------------------------------------------
// Object
// ------------------------------------------------------------------------
import java.util.Collections;
import java.util.Vector;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.linuxtools.tmf.component.TmfEventProvider;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.request.ITmfEventRequest;
+import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.signal.TmfExperimentSelectedSignal;
import org.eclipse.linuxtools.tmf.signal.TmfExperimentUpdatedSignal;
-import org.eclipse.linuxtools.tmf.signal.TmfRangeSynchSignal;
import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
+import org.eclipse.linuxtools.tmf.signal.TmfSignalManager;
import org.eclipse.linuxtools.tmf.signal.TmfTraceUpdatedSignal;
import org.eclipse.linuxtools.tmf.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.trace.ITmfLocation;
// The currently selected experiment
private static TmfExperiment<?> fCurrentExperiment = null;
- // The set of traces that constitute the experiment
+ // The set of traces that constitute the experiment
private ITmfTrace[] fTraces;
// The total number of events
fTraces = traces;
fEpoch = epoch;
fIndexPageSize = indexPageSize;
+ fClone = createTraceCopy();
updateNbEvents();
updateTimeRange();
- }
+ }
/**
* @param type
this(type, id, traces, TmfTimestamp.Zero, indexPageSize);
}
-
public TmfExperiment(TmfExperiment<T> other) {
- super(other.getName(), other.fType);
+ super(other.getName() + "(clone)", other.fType);
fEpoch = other.fEpoch;
fIndexPageSize = other.fIndexPageSize;
fNbEvents = other.fNbEvents;
fTimeRange = other.fTimeRange;
+ fClone = null;
}
public TmfExperiment<T> createTraceCopy() {
- return new TmfExperiment<T>(this);
+ TmfExperiment<T> experiment = new TmfExperiment<T>(this);
+ TmfSignalManager.deregister(experiment);
+ return experiment;
}
/**
*/
@Override
public void dispose() {
- for (ITmfTrace trace : fTraces) {
- trace.dispose();
- }
- fTraces = null;
+ for (ITmfTrace trace : fTraces) {
+ trace.dispose();
+ }
+ fTraces = null;
fCheckpoints.clear();
super.dispose();
}
return null;
}
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
// ITmfTrace trace positioning
// ------------------------------------------------------------------------
// Update the experiment context and set the "next" event
TmfEvent event = null;
if (trace >= 0) {
+ long savedRank = expContext.getRank();
expContext.setLastTrace(trace);
expContext.updateRank(1);
TmfExperimentLocation expLocation = (TmfExperimentLocation) expContext.getLocation();
expLocation.getLocation()[trace] = traceContext.getLocation().clone();
expLocation.getRanks()[trace] = traceContext.getRank();
event = expContext.getEvents()[trace];
+ updateIndex(expContext, savedRank, timestamp);
}
return event;
}
+ public synchronized void updateIndex(ITmfContext context, long rank, TmfTimestamp timestamp) {
+ // Build the index as we go along
+ if (context.isValidRank() && (rank % fIndexPageSize) == 0) {
+ // Determine the table position
+ long position = context.getRank() / fIndexPageSize;
+ // Add new entry at proper location (if empty)
+ if (fCheckpoints.size() == position) {
+ ITmfLocation<?> location = context.getLocation().clone();
+ fCheckpoints.add(new TmfCheckpoint(timestamp, location));
+// System.out.println(this + "[" + (fCheckpoints.size() - 1) + "] " + timestamp + ", " + location.toString());
+ }
+ }
+ }
+
/* (non-Javadoc)
* @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#parseEvent(org.eclipse.linuxtools.tmf.trace.TmfContext)
*/
// The index page size
private static final int DEFAULT_INDEX_PAGE_SIZE = 1000;
- private final int fIndexPageSize;
-
- // Indicates that an indexing job is already running
- private Boolean fIndexing = false;
- private Boolean fIndexed = false;
-
- // The indexing job
- private IndexingJob job;
+ private final int fIndexPageSize;
- /**
- * indexExperiment
- *
- * Creates the experiment index.
- */
- public void indexExperiment(boolean waitForCompletion) {
-
- synchronized(this) {
- if (fIndexed || fIndexing) {
- // An indexing job is already running but a new request came
- // in (probably due to a change in the trace set). The index
- // being currently built is therefore already invalid.
- // TODO: Cancel and restart the job
- // TODO: Add support for dynamically adding/removing traces
- return;
+ @SuppressWarnings("unchecked")
+ public void indexExperiment() {
+
+ final TmfExperiment<?> experiment = getCurrentExperiment();
+ fCheckpoints.clear();
+
+ ITmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, TmfTimeRange.Eternity, TmfDataRequest.ALL_DATA, 1) {
+
+ long indexingStart = System.nanoTime();
+
+ TmfTimestamp startTime = null;
+ TmfTimestamp lastTime = null;
+ int nbEvents = 0;
+
+ @Override
+ public void handleData() {
+ TmfEvent[] events = getData();
+ if (events.length > 0) {
+ nbEvents++;
+ TmfTimestamp ts = events[0].getTimestamp();
+ if (startTime == null)
+ startTime = new TmfTimestamp(ts);
+ lastTime = new TmfTimestamp(ts);
+
+ if ((nbEvents % DEFAULT_INDEX_PAGE_SIZE) == 0) {
+ updateExperiment();
+ }
+ }
}
- fIndexing = true;
- }
-
- job = new IndexingJob(new TmfExperiment<T>(this));
- job.schedule();
-
- if (waitForCompletion) {
- try {
- job.join();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
-
- private class IndexingJob extends Job {
- private final String experimentId;
- private final ITmfTrace[] traces;
- private Vector<TmfCheckpoint> checkpoints;
-
- public IndexingJob(TmfExperiment<T> experiment) {
- super(experiment.getName());
- experimentId = experiment.getName();
- traces = experiment.getTraces();
- }
-
- /* (non-Javadoc)
- * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
- */
- @Override
- protected IStatus run(IProgressMonitor monitor) {
-
- // Minimal check
- if (traces.length == 0) {
- fIndexing = false;
- return Status.OK_STATUS;
+ @Override
+ public void handleSuccess() {
+ long indexingEnd = System.nanoTime();
+
+ updateExperiment();
+// experiment.fCheckpoints = new Vector<TmfCheckpoint>();
+// for (int i = 0; i < fCheckpoints.size(); i++) {
+// TmfCheckpoint checkpoint = fCheckpoints.get(i).clone();
+// experiment.fCheckpoints.add(checkpoint);
+// System.out.println("fCheckpoints[" + i + "] " + checkpoint.getTimestamp() + ", " + checkpoint.getLocation().toString());
+// }
+
+// clone.dispose();
+// if (Tracer.INTERNALS) Tracer.trace(getName() + ": nbEvents=" + nbEvents + " (" + ((indexingEnd-indexingStart)/nbEvents)+ " ns/evt), start=" + startTime + ", end=" + lastTime);
+
+ System.out.println(getName() + ": start=" + startTime + ", end=" + lastTime + ", elapsed=" + (indexingEnd*1.0 - indexingStart) / 1000000000);
+ System.out.println(getName() + ": nbEvents=" + fNbEvents + " (" + ((indexingEnd-indexingStart)/nbEvents)+ " ns/evt)");
+// for (int i = 0; i < experiment.fCheckpoints.size(); i++) {
+// TmfCheckpoint checkpoint = experiment.fCheckpoints.get(i);
+// System.out.println("fCheckpoints[" + i + "] " + checkpoint.getTimestamp() + ", " + checkpoint.getLocation().toString());
+// }
}
- monitor.beginTask("Indexing " + experimentId, IProgressMonitor.UNKNOWN);
-
- int nbEvents = 0;
- TmfTimestamp startTime = null;
- TmfTimestamp lastTime = null;
-
- // Reset the index
- checkpoints = new Vector<TmfCheckpoint>();
-
- try {
- // Position the trace at the beginning
- TmfExperimentContext context = seekLocation(null);
- TmfExperimentLocation location = (TmfExperimentLocation) context.getLocation().clone();
-
- // Get the first event
- TmfEvent event = getNextEvent(context);
- if (event != null) {
- startTime = new TmfTimestamp(event.getTimestamp());
- }
-
- // Index the experiment
- while (event != null) {
- lastTime = event.getTimestamp();
- if ((nbEvents++ % fIndexPageSize) == 0) {
- checkpoints.add(new TmfCheckpoint(lastTime, location));
-
- monitor.worked(1);
-
- // Check monitor *after* fCheckpoints has been updated
- if (monitor.isCanceled()) {
- monitor.done();
- return Status.CANCEL_STATUS;
- }
- }
-
- // We will need the contexts at the next iteration
- if ((nbEvents % fIndexPageSize) == 0) {
- location = (TmfExperimentLocation) context.getLocation().clone();
- }
-
- event = getNextEvent(context);
- }
-
- }
- finally {
- synchronized(this) {
- fCheckpoints = checkpoints;
- fNbEvents = nbEvents;
- fTimeRange = new TmfTimeRange(startTime, lastTime);
- fIndexing = false;
- fIndexed = true;
- }
-// notifyListeners(fTimeRange);
- monitor.done();
- }
-
- return Status.OK_STATUS;
- }
- }
+ private void updateExperiment() {
+ if (experiment == fCurrentExperiment)
+ experiment.fTimeRange = new TmfTimeRange(startTime, new TmfTimestamp(lastTime));
+ experiment.fNbEvents = nbEvents;
+ experiment.fCheckpoints = ((TmfExperiment<T>) fClone).fCheckpoints;
+ notifyListeners();
+ }
+ };
- protected void notifyListeners(TmfTimeRange range) {
- broadcast(new TmfRangeSynchSignal(this, range, range.getStartTime()));
+ sendRequest((ITmfDataRequest<T>) request, ExecutionType.LONG);
+ }
+
+ protected void notifyListeners() {
+ broadcast(new TmfExperimentUpdatedSignal(this, this, null));
}
// ------------------------------------------------------------------------
TmfExperiment<?> experiment = signal.getExperiment();
if (experiment == this) {
setCurrentExperiment(experiment);
+ indexExperiment();
}
else {
dispose();
}
-// if (signal.getExperiment() == this) {
-// indexExperiment(true);
-// }
}
@TmfSignalHandler
public void experimentUpdated(TmfExperimentUpdatedSignal signal) {
-// indexExperiment(true);
}
@TmfSignalHandler
// Request state
// ------------------------------------------------------------------------
+ public boolean isRunning();
public boolean isCompleted();
public boolean isFailed();
public boolean isCancelled();
// Request handling
// ------------------------------------------------------------------------
+ public void handleStarted();
public void handleCompleted();
public void handleSuccess();
public void handleFailure();
// Request state modifiers
// ------------------------------------------------------------------------
+ public void start();
public void done();
public void fail();
public void cancel();
import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
+import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
/**
* <b><u>TmfCoalescedEventRequest</u></b>
// Attributes
// ------------------------------------------------------------------------
- private final TmfTimeRange fRange; // The requested events time range
+ private TmfTimeRange fRange; // The requested events time range
// ------------------------------------------------------------------------
// Constructor
if (request instanceof ITmfEventRequest<?>) {
boolean ok = getNbRequested() == request.getNbRequested();
ok &= getBlockize() == request.getBlockize();
- ok &= fRange.equals(((ITmfEventRequest<T>) request).getRange());
+ if (ok) {
+ TmfTimestamp startTime = ((ITmfEventRequest<T>) request).getRange().getStartTime();
+ TmfTimestamp endTime = ((ITmfEventRequest<T>) request).getRange().getEndTime();
+ if (!fRange.contains(startTime))
+ fRange = new TmfTimeRange(startTime, fRange.getEndTime());
+ if (!fRange.contains(endTime))
+ fRange = new TmfTimeRange(fRange.getStartTime(), endTime);
+ }
return ok;
}
return false;
}
+ // ------------------------------------------------------------------------
+ // ITmfDataRequest
+ // ------------------------------------------------------------------------
+
+ @Override
+ public void handleData() {
+ for (ITmfDataRequest<T> request : fRequests) {
+ if (request instanceof TmfEventRequest) {
+ TmfEventRequest<T> req = (TmfEventRequest<T>) request;
+ T[] data = getData();
+ if (data.length > 0 && req.getRange().contains(data[0].getTimestamp())) {
+ req.setData(data);
+ req.handleData();
+ }
+ }
+ else {
+ super.handleData();
+ }
+ }
+ }
+
// ------------------------------------------------------------------------
// ITmfEventRequest
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
private final Class<T> fDataType;
- private final int fRequestId; // A unique request ID
- private final int fIndex; // The index (rank) of the requested event
- private final int fNbRequested; // The number of requested events (ALL_DATA for all)
- private final int fBlockSize; // The maximum number of events per chunk
- private int fNbRead; // The number of reads so far
+ private final int fRequestId; // A unique request ID
+ private final int fIndex; // The index (rank) of the requested event
+ private final int fNbRequested; // The number of requested events (ALL_DATA for all)
+ private final int fBlockSize; // The maximum number of events per chunk
+ private int fNbRead; // The number of reads so far
private final Object lock;
- private boolean fRequestCompleted;
- private boolean fRequestFailed;
- private boolean fRequestCanceled;
+ private boolean fRequestRunning = false;
+ private boolean fRequestCompleted = false;
+ private boolean fRequestFailed = false;
+ private boolean fRequestCanceled = false;
private T[] fData; // Data object
fBlockSize = blockSize;
fNbRead = 0;
lock = new Object();
-
- Tracer.trace("Request #" + fRequestId + " (" + getClass().getName() + ", " + fDataType.getName() + ") created");
+ if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "created");
}
/**
*/
@SuppressWarnings("unused")
private TmfDataRequest(TmfDataRequest<T> other) {
- fRequestId = 0;
- fDataType = null;
- fIndex = 0;
- fNbRequested = 0;
- fBlockSize = 0;
- fNbRead = 0;
- lock = new Object();
+ this(null, 0, ALL_DATA, DEFAULT_BLOCK_SIZE);
}
// ------------------------------------------------------------------------
return fNbRead;
}
+ /**
+ * @return indicates if the request is completed
+ */
+ public boolean isRunning() {
+ return fRequestRunning;
+ }
+
/**
* @return indicates if the request is completed
*/
*/
public abstract void handleData();
+ public void handleStarted() {
+ }
+
/**
* Handle the completion of the request. It is called when there is no more
* data available either because:
*/
public void handleCompleted() {
if (fRequestFailed) {
- Tracer.trace("Request #" + fRequestId + " failed, completed");
+ if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "failed");
handleFailure();
}
else if (fRequestCanceled) {
- Tracer.trace("Request #" + fRequestId + " cancelled, completed");
+ if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "cancelled");
handleCancel();
}
else {
- Tracer.trace("Request #" + fRequestId + " succeeded, completed");
+ if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "succeeded");
handleSuccess();
}
}
}
}
+ /**
+ * Called by the request processor upon starting to service the request.
+ */
+ public void start() {
+ if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "starting");
+ synchronized(lock) {
+ fRequestRunning = true;
+ lock.notify();
+ }
+ handleStarted();
+ if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "started");
+ }
+
/**
* Called by the request processor upon completion.
*/
public void done() {
+ if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "completing");
synchronized(lock) {
+ fRequestRunning = false;
fRequestCompleted = true;
lock.notify();
}
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
-import org.eclipse.linuxtools.tmf.Tracer;
-
/**
* <b><u>TmfRequestExecutor</u></b>
*
fExecutor = executor;
String canonicalName = fExecutor.getClass().getCanonicalName();
fExecutorName = canonicalName.substring(canonicalName.lastIndexOf('.') + 1);
- Tracer.trace(fExecutor + " created");
+// if (Tracer.COMPONENTS) Tracer.trace(fExecutor + " created");
}
/**
*/
public void stop() {
fExecutor.shutdown();
- Tracer.trace(fExecutor + " terminated");
+// if (Tracer.COMPONENTS) Tracer.trace(fExecutor + " terminated");
}
// ------------------------------------------------------------------------
* @see java.util.concurrent.Executor#execute(java.lang.Runnable)
*/
public synchronized void execute(final Runnable request) {
- Tracer.trace("Queueing request " + request);
fRequestQueue.offer(new Runnable() {
public void run() {
try {
- Tracer.trace("Processing request " + request);
request.run();
- Tracer.trace("Finishing request " + request);
} finally {
scheduleNext();
}
signal.setReference(fSynchId);
sendSignal(signal);
sendSignal(new TmfEndSynchSignal(fSynchId));
+// Tracer.traceSignal(signal);
}
static private void sendSignal(TmfSignal signal) {
public long getRank();
public void updateRank(int rank);
+ public boolean isValidRank();
}
public ITmfTrace createTraceCopy();
-
/**
* @return the trace path
*/
// Attributes
// ------------------------------------------------------------------------
- private final TmfTimestamp fTimestamp;
- private final ITmfLocation<?> fLocation;
+ private TmfTimestamp fTimestamp;
+ private ITmfLocation<?> fLocation;
// ------------------------------------------------------------------------
// Constructors
// Object
// ------------------------------------------------------------------------
+ @Override
+ public TmfCheckpoint clone() {
+ TmfCheckpoint result = null;
+ try {
+ result = (TmfCheckpoint) super.clone();
+ result.fTimestamp = new TmfTimestamp(fTimestamp);
+ result.fLocation = fLocation.clone();
+ return result;
+ } catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+ }
+ return result;
+ }
+
@Override
public int hashCode() {
return fTimestamp.hashCode();
}
public TmfContext(ITmfLocation<?> location) {
- this(location, 0);
+ this(location, UNKNOWN_RANK);
}
public TmfContext(TmfContext other) {
}
public TmfContext() {
- this(null, 0);
+ this(null, UNKNOWN_RANK);
}
// ------------------------------------------------------------------------
}
public void updateRank(int delta) {
- if (fRank != UNKNOWN_RANK)
+ if (isValidRank())
fRank += delta;
}
+ public boolean isValidRank() {
+ return fRank != UNKNOWN_RANK;
+ }
+
// ------------------------------------------------------------------------
// Object
// ------------------------------------------------------------------------
import java.util.Collections;
import java.util.Vector;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.linuxtools.tmf.component.TmfEventProvider;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.request.ITmfEventRequest;
-import org.eclipse.linuxtools.tmf.signal.TmfTraceUpdatedSignal;
/**
* <b><u>TmfTrace</u></b>
setName(simpleName);
fPath = path;
fIndexPageSize = (cacheSize > 0) ? cacheSize : DEFAULT_CACHE_SIZE;
+
+ try {
+ fClone = clone();
+ } catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+ }
}
/* (non-Javadoc)
return fPath;
}
-// /**
-// * @return the trace name
-// */
-// @Override
-// public String getName() {
-// return fName;
-// }
-
/* (non-Javadoc)
* @see org.eclipse.linuxtools.tmf.stream.ITmfEventStream#getNbEvents()
*/
TmfEvent event = parseEvent(context);
if (event != null) {
context.setLocation(getCurrentLocation());
+ updateIndex(context, context.getRank(), event.getTimestamp());
context.updateRank(1);
processEvent(event);
}
return event;
}
+ public synchronized void updateIndex(ITmfContext context, long rank, TmfTimestamp timestamp) {
+ // Build the index as we go along
+ if (context.isValidRank() && (rank % fIndexPageSize) == 0) {
+ // Determine the table position
+ long position = rank / fIndexPageSize;
+ // Add new entry at proper location (if empty)
+ if (fCheckpoints.size() == position) {
+ ITmfLocation<?> location = getCurrentLocation().clone();
+ fCheckpoints.add(new TmfCheckpoint(timestamp, location));
+// System.out.println(getName() + "[" + (fCheckpoints.size() - 1) + "] " + timestamp + ", " + location.toString());
+ }
+ }
+ }
+
/**
* Hook for "special" processing by the concrete class
* (called by getNextEvent())
public String toString() {
return "[TmfTrace (" + getName() + ")]";
}
-
- // ------------------------------------------------------------------------
- // Indexing
- // ------------------------------------------------------------------------
-
- /*
- * The purpose of the index is to perform a pass over the trace and collect
- * basic information that can be later used to rapidly access a trace events.
- *
- * The information collected:
- * - fCheckpoints, the list of evenly separated checkpoints (timestamp + location)
- * - fTimeRange, the trace time span
- * - fNbEvents, the number of events in the trace
- *
- * NOTE: Doesn't work for streaming traces.
- */
-
- private IndexingJob job;
-
- // Indicates that an indexing job is already running
- private boolean fIndexing = false;
- private Boolean fIndexed = false;
-
- public void indexTrace(boolean waitForCompletion) {
- synchronized (this) {
- if (fIndexed || fIndexing) {
- return;
- }
- fIndexing = true;
- }
-
- job = new IndexingJob("Indexing " + getName());
- job.schedule();
-
- if (waitForCompletion) {
- try {
- job.join();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
-
- private class IndexingJob extends Job {
-
- public IndexingJob(String name) {
- super(name);
- }
-
- /* (non-Javadoc)
- * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
- */
- @Override
- protected IStatus run(IProgressMonitor monitor) {
-
- monitor.beginTask("Indexing " + getName(), IProgressMonitor.UNKNOWN);
-
- int nbEvents = 0;
- TmfTimestamp startTime = null;
- TmfTimestamp lastTime = null;
-
- // Reset the index
- fCheckpoints = new Vector<TmfCheckpoint>();
-
- try {
- // Position the trace at the beginning
- TmfContext context = seekLocation(null);
- ITmfLocation<?> location = context.getLocation().clone();
-
- // Get the first event
- TmfEvent event = getNextEvent(context);
- if (event != null) {
- startTime = new TmfTimestamp(event.getTimestamp());
- }
-
- // Index the trace
- while (event != null) {
- lastTime = event.getTimestamp();
- if ((nbEvents++ % fIndexPageSize) == 0) {
- lastTime = new TmfTimestamp(event.getTimestamp());
- fCheckpoints.add(new TmfCheckpoint(lastTime, location));
-
- monitor.worked(1);
-
- // Check monitor *after* fCheckpoints has been updated
- if (monitor.isCanceled()) {
- monitor.done();
- return Status.CANCEL_STATUS;
- }
- }
-
- // We will need this location at the next iteration
- if ((nbEvents % fIndexPageSize) == 0) {
- location = context.getLocation().clone();
- }
-
- event = getNextEvent(context);
- }
- }
- finally {
- synchronized(this) {
- fNbEvents = nbEvents;
- fTimeRange = new TmfTimeRange(startTime, lastTime);
- fIndexing = false;
- fIndexed = true;
- }
- notifyListeners(fTimeRange);
- monitor.done();
- }
-
- return Status.OK_STATUS;
- }
- }
-
- protected void notifyListeners(TmfTimeRange range) {
- broadcast(new TmfTraceUpdatedSignal(this, this, range));
- }
}
projects / deliverable / tracecompass.git / commitdiff
