* src/org/eclipse/linuxtools/lttng/control/LttngSyntheticEventProvider.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/lttng/event/LttngEvent.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/lttng/request/LttngSyntEventRequest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/lttng/state/trace/StateTraceManager.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/lttng/trace/LTTngTrace.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/lttng/control/LTTngSyntheticEventProviderTest.java: Adjusted unit test
* src/org/eclipse/linuxtools/lttng/LttngTestPreparation.java: Adjusted unit test
* src/org/eclipse/linuxtools/lttng/ui/views/common/AbsTimeUpdateView.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/lttng/ui/views/PerspectiveFactory.java: Fixed perspective ID
* src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/event/TmfEvent.java: Support for single event
* src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/tests/component/TmfEventProviderTest.java: Adjusted unit test
* src/org/eclipse/linuxtools/tmf/tests/experiment/TmfExperimentTest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/tests/experiment/TmfMultiTraceExperimentTest.java:Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedDataRequestTest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedEventRequestTest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/tests/request/TmfDataRequestTest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/tests/request/TmfEventRequestTest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/tests/trace/TmfExperimentTest.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/tests/trace/TmfTraceTest.java: Adjusted to new handleData() API
* stubs/org/eclipse/linuxtools/tmf/component/TmfSyntheticEventProviderStub.java: Adjusted to new handleData() API
* stubs/org/eclipse/linuxtools/tmf/request/TmfDataRequestStub.java: Adjusted to new handleData() API
* stubs/org/eclipse/linuxtools/tmf/request/TmfEventRequestStub.java: Adjusted to new handleData() API
* src/org/eclipse/linuxtools/tmf/ui/viewers/events/TmfEventsTable.java: Adjusted to new handleData() API
}
-
@Override
- public void handleData() {
- LttngEvent[] result = getData();
-
- LttngEvent evt = (result.length > 0) ? result[0] : null;
-
- if ( (evt != null) && (PARSE_EVENTS) ) {
- ((LttngEvent) evt).getContent().getFields();
+ public void handleData(LttngEvent event) {
+ super.handleData(event);
+ if ( (event != null) && (PARSE_EVENTS) ) {
+ ((LttngEvent) event).getContent().getFields();
// *** Uncomment the following to print the parsed content
// Warning : this is VERY intensive
+2010-09-17 Francois Chouinard <fchouinard@gmail.com>
+
+ * src/org/eclipse/linuxtools/lttng/control/LTTngSyntheticEventProviderTest.java: Adjusted unit test
+ * src/org/eclipse/linuxtools/lttng/LttngTestPreparation.java: Adjusted unit test
+
2010-09-15 Francois Chouinard <fchouinard@gmail.com>
* src/org/eclipse/linuxtools/lttng/control/LTTngSyntheticEventProviderTest.java: Problematic test
// request
validSequence = true;
- TmfEventRequest<T> request = new TmfEventRequest<T>(k,
- trange, TmfDataRequest.ALL_DATA, DEFAULT_CHUNK) {
+ TmfEventRequest<T> request = new TmfEventRequest<T>(k, trange, TmfDataRequest.ALL_DATA, DEFAULT_CHUNK) {
@Override
- public void handleData() {
- T[] result = getData();
-
- T event = (result.length > 0) ? result[0] : null;
+ public void handleData(T event) {
if (event == null) {
System.out
.println("Syntheric Event Received is null, after event: "
// request
validSequence = true;
- TmfEventRequest<T> request = new TmfEventRequest<T>(k,
- trange, TmfDataRequest.ALL_DATA, DEFAULT_CHUNK) {
+ TmfEventRequest<T> request = new TmfEventRequest<T>(k, trange, TmfDataRequest.ALL_DATA, DEFAULT_CHUNK) {
@Override
- public void handleData() {
- T[] result = getData();
-
- T event = (result.length > 0) ? result[0] : null;
+ public void handleData(T event) {
if (event == null) {
System.out
.println("Syntheric Event Received is null, after event: "
package org.eclipse.linuxtools.lttng.control;
import org.eclipse.linuxtools.lttng.LttngTestPreparation;
+import org.eclipse.linuxtools.lttng.event.LttngEvent;
+import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
+import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
public class LTTngSyntheticEventProviderTest extends LttngTestPreparation {
// ========================================================================
// ========================================================================
public void testPlainDataRequest() {
-// // prepare
-// init();
-// TmfExperiment<LttngEvent> experiment = prepareExperimentToTest();
-// TmfEventRequest<LttngEvent> request = prepareEventRequest(LttngEvent.class, 0, 31);
-//
-// // execute
-// experiment.sendRequest(request);
-// try {
-// request.waitForCompletion();
-// } catch (InterruptedException e) {
-// e.printStackTrace();
-// }
-//
-// // finish
-// assertEquals("Unexpected eventCount", 15316, feventCount);
-// boolean expected = true;
-// assertEquals("Events received out of expected order", expected, validSequence);
+ // prepare
+ init();
+ TmfExperiment<LttngEvent> experiment = prepareExperimentToTest();
+ TmfEventRequest<LttngEvent> request = prepareEventRequest(
+ LttngEvent.class, 0, 31);
+
+ // execute
+ experiment.sendRequest(request);
+ try {
+ request.waitForCompletion();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+
+ // finish
+ assertEquals("Unexpected eventCount", 15316, feventCount);
+ boolean expected = true;
+ assertEquals("Events received out of expected order", expected,
+ validSequence);
}
- /**
- *
- */
- public void testSyntheticEventRequest() {
+// /**
+// *
+// */
+// public void testSyntheticEventRequest() {
// init();
// // Create a new Experiment manager context
// IStateExperimentManager expManager = prepareExperimentContext(false);
// expManager.experimentSelected(this, experiment);
//
// // Obtain the singleton event provider
-// LttngSyntheticEventProvider synProvider = LttngCoreProviderFactory.getEventProvider();
+// LttngSyntheticEventProvider synProvider = LttngCoreProviderFactory
+// .getEventProvider();
//
// // prepare synthetic event requests
// boolean printExpectedEvents = false;
// TmfEventRequest<LttngSyntheticEvent> request1 = prepareEventRequest(LttngSyntheticEvent.class, 5, 9,
// printExpectedEvents); /* 2001 events */
-// TmfEventRequest<LttngSyntheticEvent> request2 = prepareEventRequest2(LttngSyntheticEvent.class, 11, 13,
+// TmfEventRequest<LttngSyntheticEvent> request2 = prepareEventRequest(LttngSyntheticEvent.class, 11, 13,
// printExpectedEvents); /* 1001 events */
//
// // execute
// synProvider.sendRequest(request1);
-// System.out.println("Request1 sent");
// try {
// request1.waitForCompletion();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
-// System.out.println("Event Count=" + feventCount);
+// System.out.println("EventCount " + feventCount);
//
// synProvider.sendRequest(request2);
-// System.out.println("Request2 sent");
// try {
// request2.waitForCompletion();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
-// System.out.println("Event Count=" + feventCount);
+// System.out.println("EventCount " + feventCount);
//
// // finish
// assertEquals("Unexpected eventCount", 3002, feventCount);
- }
+// }
}
\ No newline at end of file
+2010-09-17 Francois Chouinard <fchouinard@gmail.com>
+
+ * plugin.xml: Fixed perspective ID
+ * src/org/eclipse/linuxtools/lttng/ui/views/common/AbsTimeUpdateView.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/lttng/ui/views/PerspectiveFactory.java: Fixed perspective ID
+
2010-09-15 Francois Chouinard <fchouinard@gmail.com>
* src/org/eclipse/linuxtools/lttng/ui/views/statistics/StatisticsView.java: ExecutionType update
<?eclipse version="3.4"?>
<plugin>
<extension
- id="org,eclipse.linuxtools.lttng.ui.perspective"
+ id="org.eclipse.linuxtools.lttng.ui.perspective"
name="%extension.name.0"
point="org.eclipse.ui.perspectives">
<perspective
*/
public class PerspectiveFactory implements IPerspectiveFactory {
+ // Perspective ID
+ public static final String ID = "org.eclipse.linuxtools.lttng.ui.perspective";
+
// LTTng views
private static final String PROJECT_VIEW_ID = ProjectView.ID;
private static final String CONTROL_VIEW_ID = ControlView.ID;
import org.eclipse.linuxtools.lttng.state.evProcessor.ITransEventProcessor;
import org.eclipse.linuxtools.lttng.ui.TraceDebug;
import org.eclipse.linuxtools.lttng.ui.model.trange.ItemContainer;
-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;
* org.eclipse.linuxtools.lttng.request.LttngSyntEventRequest#handleData
* ()
*/
-// int handleDataCount = 0;
-// int handleDataValidCount = 0;
+//// int handleDataCount = 0;
+//// int handleDataValidCount = 0;
+// @Override
+// public void handleData() {
+// LttngSyntheticEvent[] result = getData();
+//
+// TmfEvent evt = (result.length > 0) ? result[0] : null;
+//// handleDataCount++;
+
@Override
- public void handleData() {
- LttngSyntheticEvent[] result = getData();
-
- TmfEvent evt = (result.length > 0) ? result[0] : null;
-// handleDataCount++;
- if (evt != null) {
+ public void handleData(LttngSyntheticEvent event) {
+ super.handleData(event);
+ if (event != null) {
// handleDataValidCount++;
- LttngSyntheticEvent synEvent = (LttngSyntheticEvent) evt;
+ LttngSyntheticEvent synEvent = (LttngSyntheticEvent) event;
// process event
SequenceInd indicator = synEvent.getSynType();
if (indicator == SequenceInd.BEFORE
|| indicator == SequenceInd.AFTER) {
- processor.process(evt, synEvent.getTraceModel());
+ processor.process(event, synEvent.getTraceModel());
} else if (indicator == SequenceInd.STARTREQ) {
handleRequestStarted();
} else if (indicator == SequenceInd.ENDREQ) {
- processor.process(evt, synEvent.getTraceModel());
+ processor.process(event, synEvent.getTraceModel());
// handleCompleted();
}
modelInputChanged(this, false);
if (TraceDebug.isDEBUG()) {
- frunningTimeStamp = evt.getTimestamp();
+ frunningTimeStamp = event.getTimestamp();
TraceDebug.debug("handled: " + fCount + " sequence: " + synEvent.getSynType());
}
* HandleData function : will be called by TMF each time a new event is receive for the request.<p>
* Calculation for the content is done here.
*/
- @Override
- public void handleData() {
- LttngEvent[] result = getData();
- LttngEvent event = (result.length > 0) ? result[0] : null;
+// @Override
+// public void handleData() {
+// LttngEvent[] result = getData();
+// LttngEvent event = (result.length > 0) ? result[0] : null;
+ @Override
+ public void handleData(LttngEvent event) {
+ super.handleData(event);
+
// *** FIXME ***
// *** EVIL BUG ***
// The request by timerange only does not work! (see constructor above)
//
if (event != null) {
- LttngEvent tmpEvent = (LttngEvent) event;
-
// Tracer.trace("Hst: " + event.getTimestamp());
// This check is linked to the evil fix mentionned above
- if ( ( tmpEvent.getTimestamp().getValue() >= parentCanvas.getHistogramContent().getStartTime() ) &&
- ( tmpEvent.getTimestamp().getValue() <= parentCanvas.getHistogramContent().getEndTime() ) )
+ if ( ( event.getTimestamp().getValue() >= parentCanvas.getHistogramContent().getStartTime() ) &&
+ ( event.getTimestamp().getValue() <= parentCanvas.getHistogramContent().getEndTime() ) )
{
// Distance (in time) between this event and the last one we read
- long distance = ( tmpEvent.getTimestamp().getValue() - lastRangeTime );
+ long distance = ( event.getTimestamp().getValue() - lastRangeTime );
// Check if we changed of interval (the distance is higher than the interval time)
if ( distance > parentCanvas.getHistogramContent().getElementsTimeInterval() ) {
parentCanvas.getHistogramContent().getElementByIndex(lastInterval).intervalNbEvents = nbEventsInInterval;
- lastRangeTime = tmpEvent.getTimestamp().getValue();
+ lastRangeTime = event.getTimestamp().getValue();
// * NOTE *
// We can skip several interval at once, so we need to find what was our interval now
+2010-09-17 Francois Chouinard <fchouinard@gmail.com>
+
+ * src/org/eclipse/linuxtools/lttng/control/LttngSyntheticEventProvider.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/lttng/event/LttngEvent.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/lttng/request/LttngSyntEventRequest.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/lttng/state/trace/StateTraceManager.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/lttng/trace/LTTngTrace.java: Adjusted to new handleData() API
+
2010-09-15 Francois Chouinard <fchouinard@gmail.com>
* src/org/eclipse/linuxtools/lttng/trace/LTTngExperiment.java: ExecutionType update
// ========================================================================
// Data
// ========================================================================
+
public static final int BLOCK_SIZE = 1;
public static final int NB_EVENTS = 1;
- public static final int QUEUE_SIZE = 1; // lttng specific, one event at a
- // time
+ public static final int QUEUE_SIZE = 1; // lttng specific, one event at a time
// TmfDataProvider<LttngEvent> fExtProvider = null;
private ITmfDataRequest<LttngSyntheticEvent> fmainRequest = null;
private int fMainReqEventCount = 0;
volatile boolean startIndSent = false;
private LTTngTreeNode fExperiment = null;
- private ITransEventProcessor fstateUpdateProcessor = StateEventToHandlerFactory.getInstance();
+ private ITransEventProcessor fstateUpdateProcessor = StateEventToHandlerFactory
+ .getInstance();
private boolean waitForRequest = false;
// ========================================================================
// the framework
TmfEventSource source = new TmfEventSource(this);
LttngEventType dtype = new LttngEventType();
- LttngTimestamp statusTimeStamp = new LttngTimestamp(TmfTimestamp.Zero);
+ LttngTimestamp statusTimeStamp = new LttngTimestamp(
+ TmfTimestamp.Zero);
- fStatusEvent = new LttngSyntheticEvent(null, statusTimeStamp, source, dtype, null, null, null);
+ fStatusEvent = new LttngSyntheticEvent(null, statusTimeStamp, source,
+ dtype, null, null, null);
fStatusEvent.setSequenceInd(SequenceInd.STARTREQ);
- fStatusEventAck = new LttngSyntheticEvent(null, statusTimeStamp, source, dtype, null, null, null);
+ fStatusEventAck = new LttngSyntheticEvent(null, statusTimeStamp,
+ source, dtype, null, null, null);
fStatusEventAck.setSequenceInd(SequenceInd.ACK);
}
@SuppressWarnings("unchecked")
@Override
- public ITmfContext armRequest(final ITmfDataRequest<LttngSyntheticEvent> request) {
+ public ITmfContext armRequest(
+ final ITmfDataRequest<LttngSyntheticEvent> request) {
// validate
// make sure we have the right type of request
if (!(request instanceof ITmfEventRequest<?>)) {
for (IStateTraceManager traceManager : fEventProviderRequests.keySet()) {
// restore trace state system to nearest check point
- TmfTimestamp checkPoint = traceManager.restoreCheckPointByTimestamp(reqWindow.getStartTime());
+ TmfTimestamp checkPoint = traceManager
+ .restoreCheckPointByTimestamp(reqWindow.getStartTime());
// adjust start time bound to check point
private final long fDispatchTime = getDispatchTime().getValue();
private final LttngTraceState fTraceModel = getTraceModel();
- private LttngSyntheticEvent[] fresult = new LttngSyntheticEvent[1];
/*
* (non-Javadoc)
*
- * @see org.eclipse.linuxtools.lttng.control.LttngEventRequest#handleData ()
+ * @see org.eclipse.linuxtools.lttng.control.LttngEventRequest#handleData()
*/
@Override
- public void handleData() {
- LttngEvent[] events = getData();
-
- // Tracer.trace("Sep: " + events[0].getTimestamp());
-
- if (events.length > 0) {
- handleIncomingData(events[0]);
+ public void handleData(LttngEvent event) {
+ super.handleData(event);
+ if (event != null) {
+ handleIncomingData(event);
} else {
TraceDebug.debug("handle data received with no data");
- // handleProviderDone(getTraceModel());
- // done();
}
}
-
/*
* (non-Javadoc)
*
public void done() {
// mark this sub-request as completed
super.done();
- handleProviderDone();
- // super.done();
+ handleProviderDone(getTraceModel());
}
-
+
/**
* Trigger the Analysis and sequential control of the events.
*
private void handleIncomingData(LttngEvent e) {
long eventTime = e.getTimestamp().getValue();
- TmfTrace<LttngEvent> inTrace = e.getParentTrace();
+ TmfTrace<LttngEvent> inTrace = e.getParentTrace();
if (!(inTrace == getTrace())) {
- // System.out.println("Event from a different trace discarded");
return;
}
-
+
// queue the new event data and an ACK
updateSynEvent(e);
// If time at or above requested time, update application
if (eventTime >= fDispatchTime) {
- // Load synthetic event as the result data
- fresult[0] = syntheticEvent;
-
- // BEFORE UPDATE : update to the before state-update handlers
+ // Before update
syntheticEvent.setSequenceInd(SequenceInd.BEFORE);
- // queueResult(syntheticEvent);
- // queueResult(syntheticAckIndicator);
- fmainRequest.setData(fresult);
- fmainRequest.handleData();
- // result[0] = syntheticAckIndicator;
- // fmainRequest.setData(result);
- // fmainRequest.handleData();
-
- // STATE UPDATE: local handlers
+ fmainRequest.handleData(syntheticEvent);
+ fmainRequest.handleData(syntheticAckIndicator);
+
+ // Update state locally
syntheticEvent.setSequenceInd(SequenceInd.UPDATE);
fstateUpdateProcessor.process(syntheticEvent, fTraceModel);
- // AFTER UPDATE: update to the after state-update handlers
+ // After Update
syntheticEvent.setSequenceInd(SequenceInd.AFTER);
- // queueResult(syntheticEvent);
- // queueResult(syntheticAckIndicator);
- fmainRequest.setData(fresult);
- fmainRequest.handleData();
- // result[0] = syntheticAckIndicator;
- // fmainRequest.setData(result);
- // fmainRequest.handleData();
+ fmainRequest.handleData(syntheticEvent);
+ fmainRequest.handleData(syntheticAckIndicator);
// increment once per dispatch
incrementSynEvenCount();
}
/**
- * Create a synthetic event from the received new reference, if the reference is the same there is no
- * need for a new instance
+ * Create a synthetic event from the received new reference, if
+ * the reference is the same there is no need for a new instance
*
- * if this is the first event for this request, call start handler
+ * if this is the first event for this request, call start
+ * handler
*
* @param e
* @return
*/
private LttngSyntheticEvent updateSynEvent(LttngEvent e) {
- if (syntheticEvent == null || syntheticEvent.getBaseEvent() != e) {
+ if (syntheticEvent == null
+ || syntheticEvent.getBaseEvent() != e) {
syntheticEvent = new LttngSyntheticEvent(e);
syntheticAckIndicator = new LttngSyntheticEvent(e);
syntheticAckIndicator.setSequenceInd(SequenceInd.ACK);
return syntheticEvent;
}
};
-
+
// preserve the associated sub request to control it e.g.
// cancellation
fEventProviderRequests.put(traceManager, subRequest);
startIndEvent.setSequenceInd(SequenceInd.STARTREQ);
// Notify application
- LttngSyntheticEvent[] result = new LttngSyntheticEvent[1];
- result[0] = startIndEvent;
- fmainRequest.setData(result);
- fmainRequest.handleData();
- // result[0] = fStatusEventAck;
- // fmainRequest.setData(result);
- // fmainRequest.handleData();
-
- // try {
- // queueResult(startIndEvent);
- // queueResult(fStatusEventAck);
- // } catch (InterruptedException e) {
- // // TODO: cancel this request
- // e.printStackTrace();
- // }
+ fmainRequest.handleData(startIndEvent);
+ fmainRequest.handleData(fStatusEventAck);
// Notify state event processor
fstateUpdateProcessor.process(startIndEvent, null);
}
/**
- * Notify listeners, no more events for the current request will be distributed e.g. update view.
+ * Notify listeners, no more events for the current request will be
+ * distributed e.g. update view.
*/
- public synchronized void handleProviderDone() {
+ public synchronized void handleProviderDone(LttngTraceState traceModel) {
// TODO: The use of a thread per main request and thread per sub-request
// requires
// to make sure the proper main request is marked completed. So a
}
}
- // Notify application. One notification per trace so the last state of each trace can be
- // drawn
- LttngTraceState traceModel;
- for (IStateTraceManager traceMgr : fEventProviderRequests.keySet()) {
- traceModel = traceMgr.getStateModel();
-
- LttngSyntheticEvent finishEvent = new LttngSyntheticEvent(fStatusEvent);
- // finishEvent.setTraceModel(traceModel);
- // finishEvent.setParentTrace((TmfTrace<LttngEvent>) traceModel.getContext().getTraceIdRef());
- finishEvent.setSequenceInd(SequenceInd.ENDREQ);
- finishEvent.setTraceModel(traceModel);
-
- LttngSyntheticEvent[] result = new LttngSyntheticEvent[1];
- // End Request indication
- result[0] = finishEvent;
- fmainRequest.setData(result);
- fmainRequest.handleData();
-
- // // End Request processed indication
- // result[0] = fStatusEventAck;
- // fmainRequest.setData(result);
- // fmainRequest.handleData();
- }
+ // All sub-requests are marked completed so the main request can be
+ // completed as well
+ // Notify application,
+ LttngSyntheticEvent finishEvent = new LttngSyntheticEvent(fStatusEvent);
+ finishEvent.setSequenceInd(SequenceInd.ENDREQ);
+ finishEvent.setTraceModel(traceModel);
- // All sub-requests are marked completed so the main request can be completed as well
+ fmainRequest.handleData(finishEvent);
+ fmainRequest.handleData(fStatusEventAck);
fmainRequest.done();
-
- // try {
- // queueResult(finishEvent);
- // queueResult(fStatusEventAck);
- // // End the loop in the main request
- // queueResult(LttngSyntheticEvent.NullEvent);
- // } catch (InterruptedException e) {
- // // System.out.println(getName() +
- // // ":handleProviderDone() failed to queue request");
- // // TODO: Cancel the request
- // // e.printStackTrace();
- // }
}
/**
* @param experiment
*/
private synchronized void updateExperimentNode(LTTngTreeNode experiment) {
- if (experiment != null && experiment.getValue() instanceof TmfExperiment<?>) {
+ if (experiment != null
+ && experiment.getValue() instanceof TmfExperiment<?>) {
fExperiment = experiment;
} else {
TraceDebug
- .debug("Experiment received is not instance of TmfExperiment: " + experiment.getClass().getName());
+ .debug("Experiment received is not instance of TmfExperiment: "
+ + experiment.getClass().getName());
}
}
/*
* (non-Javadoc)
*
- * @see org.eclipse.linuxtools.tmf.component.TmfDataProvider#sendRequest(org.
+ * @see
+ * org.eclipse.linuxtools.tmf.component.TmfDataProvider#sendRequest(org.
* eclipse.linuxtools.tmf.request.TmfDataRequest)
*/
@Override
return null;
}
- // @Override
- // public LttngSyntheticEvent getNext(ITmfContext context) {
- // return super.getNext(context);
- // }
-
- // @Override
- // public void queueResult(LttngSyntheticEvent data) {
- // super.queueResult(data);
- // }
-
}
/**
- * Return the parent trace asoociated with this event
+ * Return the parent trace associated with this event
*
* @return Parent trace
*/
return result.toString();
}
+
+ @Override
+ public LttngEvent clone() {
+ return new LttngEvent(this);
+ }
}
TmfTimeRange experimentTimeRange, ITransEventProcessor processor, ExecutionType execType) {
super(LttngSyntheticEvent.class, range, nbEvents, maxBlockSize, execType);
- //super(0, nbEvents, maxBlockSize);
fExperimentTimeRange = experimentTimeRange;
addListener(listener);
* @see org.eclipse.linuxtools.lttng.request.ILttngEventRequest#handleData()
*/
@Override
- public void handleData() {
+ public void handleData(LttngSyntheticEvent event) {
+ super.handleData(event);
}
// 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);
-// }
-// }
-// }
}
/*
* org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleData()
*/
@Override
- public void handleData() {
- LttngEvent[] events = getData();
- if (events.length > 0) {
- nbEvents++;
-
- LttngEvent event = (LttngEvent) events[0];
-
+ public void handleData(LttngEvent event) {
+ super.handleData(event);
+ if (event != null) {
// Tracer.trace("Chk: " + event.getTimestamp());
-
ITmfTrace trace = event.getParentTrace();
IStateTraceManager traceManager = ftraceToManagerMap.get(getTraceKey(trace));
if (traceManager != null) {
* @param header
*/
private void printCompletedMessage() {
-// System.out.println(System.currentTimeMillis() + ": StateExperimentManager completed checkpoints");
-
- // super.handleCompleted();
if (TraceDebug.isDEBUG()) {
TraceDebug.debug("Trace check point building completed, number of events handled: " + nbEvents
+ "\n\t\t");
* ()
*/
@Override
- public void handleData() {
- LttngSyntheticEvent[] result = getData();
-
- evt[0] = (result.length > 0) ? result[0] : null;
- if (evt[0] != null) {
- synEvent = (LttngSyntheticEvent) evt[0];
+ public void handleData(LttngSyntheticEvent event) {
+ super.handleData(event);
+ if (event != null) {
+ synEvent = event;
if (synEvent.getSynType() == SequenceInd.AFTER) {
// Note : We call this function before incrementing
// eventCount to save a default check point at the "0th"
// // [lmcfrch]
// private long lastTime = 0;
- public static boolean printDebug = false;
+ public static boolean printDebug = false;
public static boolean uniqueEvent = false;
private final static boolean SHOW_LTT_DEBUG_DEFAULT = false;
- private final static boolean IS_PARSING_NEEDED_DEFAULT = true;
+ private final static boolean IS_PARSING_NEEDED_DEFAULT = !uniqueEvent;
private final static int CHECKPOINT_PAGE_SIZE = 1000;
// Reference to our JNI trace
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request =
new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- }
- };
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ }
+ };
provider.sendRequest(request);
try {
request.waitForCompletion();
final TmfEventRequest<TmfSyntheticEventStub> request =
new TmfEventRequest<TmfSyntheticEventStub>(TmfSyntheticEventStub.class, range, nbEvents, blockSize) {
- @Override
- public void handleData() {
- TmfSyntheticEventStub[] events = getData();
- for (TmfSyntheticEventStub e : events) {
- requestedEvents.add(e);
- }
- }
+ @Override
+ public void handleData(TmfSyntheticEventStub event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ }
};
provider.sendRequest(request);
TmfTimeRange range = new TmfTimeRange(start, end);
try {
getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
-// System.out.println("aie");
} catch (InterruptedException e) {
fail();
}
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
@Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
}
};
fExperiment.sendRequest(request);
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- }
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ }
};
fExperiment.sendRequest(request);
request.waitForCompletion();
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- }
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ }
};
fExperiment.sendRequest(request);
request.waitForCompletion();
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- // Cancel request after the first chunk is received
- cancel();
- }
+ int nbRead = 0;
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ if (++nbRead == blockSize)
+ cancel();
+ }
@Override
public void handleCancel() {
if (requestedEvents.size() < blockSize) {
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- }
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ }
};
fExperiment.sendRequest(request);
request.waitForCompletion();
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- }
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ }
};
fExperiment.sendRequest(request);
request.waitForCompletion();
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- }
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ }
};
fExperiment.sendRequest(request);
request.waitForCompletion();
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- // Cancel request after the first chunk is received
- cancel();
- }
+ int nbRead = 0;
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ if (++nbRead == blockSize)
+ cancel();
+ }
@Override
public void handleCancel() {
if (requestedEvents.size() < blockSize) {
import junit.framework.TestCase;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.event.TmfEventReference;
-import org.eclipse.linuxtools.tmf.event.TmfEventSource;
-import org.eclipse.linuxtools.tmf.event.TmfEventType;
-import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.request.TmfCoalescedDataRequest;
import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
- assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
- assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
- assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
- assertEquals("getBlockize", 200, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
// ------------------------------------------------------------------------
public void testToString() {
- String expected1 = "[TmfCoalescedDataRequest(0,TmfEvent,10,100,200)]";
- String expected2 = "[TmfCoalescedDataRequest(1,TmfEvent,20,100,200)]";
- String expected3 = "[TmfCoalescedDataRequest(2,TmfEvent,20,200,200)]";
- String expected4 = "[TmfCoalescedDataRequest(3,TmfEvent,20,200,300)]";
+ String expected1 = "[TmfCoalescedDataRequest(0,TmfEvent,10,100)]";
+ String expected2 = "[TmfCoalescedDataRequest(1,TmfEvent,20,100)]";
+ String expected3 = "[TmfCoalescedDataRequest(2,TmfEvent,20,200)]";
+ String expected4 = "[TmfCoalescedDataRequest(3,TmfEvent,20,200)]";
assertEquals("toString", expected1, fRequest1.toString());
assertEquals("toString", expected2, fRequest2.toString());
TmfDataRequest<TmfEvent> request1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
TmfDataRequest<TmfEvent> request2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 11, 100, 200);
TmfDataRequest<TmfEvent> request3 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 101, 200);
- TmfDataRequest<TmfEvent> request4 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 201);
assertTrue ("isCompatible", coalescedRequest.isCompatible(request1));
assertFalse("isCompatible", coalescedRequest.isCompatible(request2));
assertFalse("isCompatible", coalescedRequest.isCompatible(request3));
- assertFalse("isCompatible", coalescedRequest.isCompatible(request4));
- }
-
- // ------------------------------------------------------------------------
- // setData/getData
- // ------------------------------------------------------------------------
-
- public void testSetData() {
-
- TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
- TmfDataRequest<TmfEvent> request1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
- TmfDataRequest<TmfEvent> request2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
- coalescedRequest.addRequest(request1);
- coalescedRequest.addRequest(request2);
-
- // Initialize the data
- int nbEvents = 10;
- TmfEvent[] events = new TmfEvent[nbEvents];
- for (int i = 0; i < nbEvents; i++) {
- events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
- new TmfEventType(), new TmfEventReference());
- }
-
- coalescedRequest.setData(events);
- coalescedRequest.handleData();
-
- // Validate the coalescing request
- assertEquals("setData", nbEvents, coalescedRequest.getNbRead());
- TmfEvent[] eventsRead1 = coalescedRequest.getData();
- assertEquals("getData", nbEvents, eventsRead1.length);
- for (int i = 0; i < nbEvents; i++) {
- assertEquals("getData", i, eventsRead1[i].getTimestamp().getValue());
- }
-
- // Validate the first coalesced request
- assertEquals("setData", nbEvents, request1.getNbRead());
- TmfEvent[] eventsRead2 = request1.getData();
- assertEquals("getData", nbEvents, eventsRead2.length);
- for (int i = 0; i < nbEvents; i++) {
- assertEquals("getData", i, eventsRead2[i].getTimestamp().getValue());
- }
-
- // Validate the second coalesced request
- assertEquals("setData", nbEvents, request2.getNbRead());
- TmfEvent[] eventsRead3 = request2.getData();
- assertEquals("getData", nbEvents, eventsRead3.length);
- for (int i = 0; i < nbEvents; i++) {
- assertEquals("getData", i, eventsRead3[i].getTimestamp().getValue());
- }
}
// ------------------------------------------------------------------------
import org.eclipse.linuxtools.tmf.component.ITmfDataProvider;
import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.event.TmfEventReference;
-import org.eclipse.linuxtools.tmf.event.TmfEventSource;
-import org.eclipse.linuxtools.tmf.event.TmfEventType;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.request.TmfCoalescedDataRequest;
import org.eclipse.linuxtools.tmf.request.TmfCoalescedEventRequest;
-import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
-import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.request.TmfEventRequestStub;
import org.eclipse.linuxtools.tmf.signal.TmfSignal;
assertEquals("getRange", range1, request.getRange());
assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
- assertEquals("getBlockize", TmfEventRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
assertEquals("getRange", range1, request.getRange());
assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
- assertEquals("getBlockize", TmfEventRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
assertEquals("getRange", range1, request.getRange());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
- assertEquals("getBlockize", TmfEventRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
assertEquals("getRange", range1, request.getRange());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
- assertEquals("getBlockize", 200, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
public void testEqualsSuper() throws Exception {
TmfCoalescedDataRequest<TmfEvent> dataRequest1 = new TmfCoalescedDataRequest<TmfEvent>(
- fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested(), fRequest1.getBlockize());
+ fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
TmfCoalescedDataRequest<TmfEvent> dataRequest2 = new TmfCoalescedDataRequest<TmfEvent>(
- fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested(), fRequest1.getBlockize());
+ fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
TmfCoalescedDataRequest<TmfEvent> dataRequest3 = new TmfCoalescedDataRequest<TmfEvent>(
- fRequest3.getDataType(), fRequest3.getIndex(), fRequest3.getNbRequested(), fRequest3.getBlockize());
+ fRequest3.getDataType(), fRequest3.getIndex(), fRequest3.getNbRequested());
assertTrue("equals", fRequest1.equals(dataRequest2));
assertTrue("equals", fRequest2.equals(dataRequest1));
// ------------------------------------------------------------------------
public void testToString() {
- String expected1 = "[TmfCoalescedEventRequest(0,TmfEvent," + range1 + ",100,200)]";
- String expected2 = "[TmfCoalescedEventRequest(1,TmfEvent," + range2 + ",100,200)]";
- String expected3 = "[TmfCoalescedEventRequest(2,TmfEvent," + range2 + ",200,200)]";
- String expected4 = "[TmfCoalescedEventRequest(3,TmfEvent," + range2 + ",200,300)]";
+ String expected1 = "[TmfCoalescedEventRequest(0,TmfEvent," + range1 + ",100)]";
+ String expected2 = "[TmfCoalescedEventRequest(1,TmfEvent," + range2 + ",100)]";
+ String expected3 = "[TmfCoalescedEventRequest(2,TmfEvent," + range2 + ",200)]";
+ String expected4 = "[TmfCoalescedEventRequest(3,TmfEvent," + range2 + ",200)]";
assertEquals("toString", expected1, fRequest1.toString());
assertEquals("toString", expected2, fRequest2.toString());
TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 100, 200);
TmfEventRequest<TmfEvent> request3 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 101, 200);
- TmfEventRequest<TmfEvent> request4 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 201);
- TmfDataRequest<TmfEvent> request5 = new TmfDataRequestStub<TmfEvent> (TmfEvent.class, 10, 100, 201);
assertTrue ("isCompatible", coalescedRequest.isCompatible(request1));
assertTrue ("isCompatible", coalescedRequest.isCompatible(request2));
assertFalse("isCompatible", coalescedRequest.isCompatible(request3));
- assertFalse("isCompatible", coalescedRequest.isCompatible(request4));
- assertFalse("isCompatible", coalescedRequest.isCompatible(request5));
- }
-
- // ------------------------------------------------------------------------
- // setData/getData
- // ------------------------------------------------------------------------
-
- public void testSetData() {
-
- TmfCoalescedEventRequest<TmfEvent> coalescedRequest = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
- TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
- TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
- coalescedRequest.addRequest(request1);
- coalescedRequest.addRequest(request2);
-
- // Initialize the data
- int nbEvents = 10;
- TmfEvent[] events = new TmfEvent[nbEvents];
- for (int i = 0; i < nbEvents; i++) {
- events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
- new TmfEventType(), new TmfEventReference());
- }
-
- coalescedRequest.setData(events);
- coalescedRequest.handleData();
-
- // Validate the coalescing request
- assertEquals("setData", nbEvents, coalescedRequest.getNbRead());
- TmfEvent[] eventsRead1 = coalescedRequest.getData();
- assertEquals("getData", nbEvents, eventsRead1.length);
- for (int i = 0; i < nbEvents; i++) {
- assertEquals("getData", i, eventsRead1[i].getTimestamp().getValue());
- }
-
- // Validate the first coalesced request
- assertEquals("setData", nbEvents, request1.getNbRead());
- TmfEvent[] eventsRead2 = request1.getData();
- assertEquals("getData", nbEvents, eventsRead2.length);
- for (int i = 0; i < nbEvents; i++) {
- assertEquals("getData", i, eventsRead2[i].getTimestamp().getValue());
- }
-
- // Validate the second coalesced request
- assertEquals("setData", nbEvents, request2.getNbRead());
- TmfEvent[] eventsRead3 = request2.getData();
- assertEquals("getData", nbEvents, eventsRead3.length);
- for (int i = 0; i < nbEvents; i++) {
- assertEquals("getData", i, eventsRead3[i].getTimestamp().getValue());
- }
}
// ------------------------------------------------------------------------
requestedEvents1 = new Vector<TmfEvent>();
request1 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ int nbRead = 0;
@Override
- public void handleData() {
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
if (!isCompleted()) {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents1.add(e);
- }
- if (signal.forceCancel)
+ requestedEvents1.add(event);
+ if (++nbRead >= BLOCK_SIZE && signal.forceCancel)
cancel();
}
}
requestedEvents2 = new Vector<TmfEvent>();
request2 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
@Override
- public void handleData() {
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
if (!isCompleted()) {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents2.add(e);
- }
+ requestedEvents2.add(event);
}
}
};
requestedEvents3 = new Vector<TmfEvent>();
request3 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
@Override
- public void handleData() {
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
if (!isCompleted()) {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents3.add(e);
- }
+ requestedEvents3.add(event);
}
}
};
import junit.framework.TestCase;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.event.TmfEventReference;
-import org.eclipse.linuxtools.tmf.event.TmfEventSource;
-import org.eclipse.linuxtools.tmf.event.TmfEventType;
-import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
- assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
- assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
- assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
- assertEquals("getBlockize", 200, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
// ------------------------------------------------------------------------
public void testToString() {
- String expected1 = "[TmfDataRequest(0,TmfEvent,10,100,200)]";
- String expected2 = "[TmfDataRequest(1,TmfEvent,20,100,200)]";
- String expected3 = "[TmfDataRequest(2,TmfEvent,20,200,200)]";
- String expected4 = "[TmfDataRequest(3,TmfEvent,20,200,300)]";
+ String expected1 = "[TmfDataRequest(0,TmfEvent,10,100)]";
+ String expected2 = "[TmfDataRequest(1,TmfEvent,20,100)]";
+ String expected3 = "[TmfDataRequest(2,TmfEvent,20,200)]";
+ String expected4 = "[TmfDataRequest(3,TmfEvent,20,200)]";
assertEquals("toString", expected1, fRequest1.toString());
assertEquals("toString", expected2, fRequest2.toString());
assertEquals("toString", expected4, fRequest4.toString());
}
- // ------------------------------------------------------------------------
- // setData/getData
- // ------------------------------------------------------------------------
-
- public void testSetData() {
- // Initialize the data
- int nbEvents = 10;
- TmfEvent[] events = new TmfEvent[nbEvents];
- for (int i = 0; i < nbEvents; i++) {
- events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
- new TmfEventType(), new TmfEventReference());
- }
-
- fRequest1.setData(events);
- assertEquals("setData", nbEvents, fRequest1.getNbRead());
-
- TmfEvent[] eventsRead = fRequest1.getData();
- assertEquals("getData", nbEvents, eventsRead.length);
-
- for (int i = 0; i < nbEvents; i++) {
- assertEquals("getData", i, eventsRead[i].getTimestamp().getValue());
- }
- }
-
// ------------------------------------------------------------------------
// done
// ------------------------------------------------------------------------
import junit.framework.TestCase;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.event.TmfEventReference;
-import org.eclipse.linuxtools.tmf.event.TmfEventSource;
-import org.eclipse.linuxtools.tmf.event.TmfEventType;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
- assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
- assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
- assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
- assertEquals("getBlockize", 200, request.getBlockize());
assertFalse("isCompleted", request.isCompleted());
assertFalse("isFailed", request.isFailed());
// ------------------------------------------------------------------------
public void testToString() {
- String expected1 = "[TmfEventRequest(0,TmfEvent," + range1 + ",100,200)]";
- String expected2 = "[TmfEventRequest(1,TmfEvent," + range2 + ",100,200)]";
- String expected3 = "[TmfEventRequest(2,TmfEvent," + range2 + ",200,200)]";
- String expected4 = "[TmfEventRequest(3,TmfEvent," + range2 + ",200,300)]";
+ String expected1 = "[TmfEventRequest(0,TmfEvent," + range1 + ",100)]";
+ String expected2 = "[TmfEventRequest(1,TmfEvent," + range2 + ",100)]";
+ String expected3 = "[TmfEventRequest(2,TmfEvent," + range2 + ",200)]";
+ String expected4 = "[TmfEventRequest(3,TmfEvent," + range2 + ",200)]";
assertEquals("toString", expected1, fRequest1.toString());
assertEquals("toString", expected2, fRequest2.toString());
assertEquals("toString", expected4, fRequest4.toString());
}
- // ------------------------------------------------------------------------
- // setData/getData
- // ------------------------------------------------------------------------
-
- public void testSetData() {
- // Initialize the data
- int nbEvents = 10;
- TmfEvent[] events = new TmfEvent[nbEvents];
- for (int i = 0; i < nbEvents; i++) {
- events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
- new TmfEventType(), new TmfEventReference());
- }
-
- fRequest1.setData(events);
- assertEquals("setData", nbEvents, fRequest1.getNbRead());
-
- TmfEvent[] eventsRead = fRequest1.getData();
- assertEquals("getData", nbEvents, eventsRead.length);
-
- for (int i = 0; i < nbEvents; i++) {
- assertEquals("getData", i, eventsRead[i].getTimestamp().getValue());
- }
- }
-
// ------------------------------------------------------------------------
// done
// ------------------------------------------------------------------------
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- }
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ }
};
fExperiment.sendRequest(request);
request.waitForCompletion();
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- }
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ }
};
fExperiment.sendRequest(request);
request.waitForCompletion();
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- }
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ }
};
fExperiment.sendRequest(request);
request.waitForCompletion();
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- // Cancel request after the first chunk is received
- cancel();
- }
+ int nbRead = 0;
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ if (++nbRead == blockSize)
+ cancel();
+ }
};
fExperiment.sendRequest(request);
request.waitForCompletion();
// Dummy request to force the trace indexing
TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class) {
@Override
- public void handleData() {
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
}
};
fTrace.sendRequest(request);
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- }
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ }
};
ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- }
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ }
};
ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents.add(e);
- }
- // Cancel request after the first chunk is received
- cancel();
- }
+ int nbRead = 0;
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ requestedEvents.add(event);
+ if (++nbRead == BLOCK_SIZE)
+ cancel();
+ }
};
ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
TmfTimeRange range = eventRequest.getRange();
final TmfEventRequest<TmfEvent> subRequest =
new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- if (events.length > 0) {
- for (TmfEvent e : events) {
- handleIncomingData(e);
- }
- } else {
- request.done();
- }
- }
+ @Override
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ if (event != null)
+ handleIncomingData(event);
+ else
+ request.done();
+ }
};
provider.sendRequest(subRequest);
}
@Override
- public void handleData() {
- // TODO Auto-generated method stub
+ public void handleData(T data) {
+ super.handleData(data);
}
}
}
@Override
- public void handleData() {
- // TODO Auto-generated method stub
+ public void handleData(T data) {
+ super.handleData(data);
}
}
return;\r
}\r
\r
+ fCacheStartIndex = index;\r
+ fCacheEndIndex = index;\r
+\r
TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, index, fCacheSize) {\r
- @Override\r
- public void handleData() {\r
- TmfEvent[] tmpEvent = getData();\r
- if ((tmpEvent != null) && (tmpEvent.length > 0)) {\r
- fCache = tmpEvent;\r
- fCacheStartIndex = index;\r
- fCacheEndIndex = index + tmpEvent.length;\r
+// @Override\r
+// public void handleData() {\r
+// TmfEvent[] tmpEvent = getData();\r
+// if ((tmpEvent != null) && (tmpEvent.length > 0)) {\r
+// fCache = tmpEvent;\r
+// fCacheStartIndex = index;\r
+// fCacheEndIndex = index + tmpEvent.length;\r
+// }\r
+// }\r
+\r
+ private int count = 0;\r
+\r
+ @Override\r
+ public void handleData(TmfEvent event) {\r
+ super.handleData(event);\r
+ if (event != null) {\r
+ fCache[count++] = event.clone();\r
+ fCacheEndIndex++;\r
}\r
}\r
+\r
};\r
+\r
((ITmfDataProvider<TmfEvent>) fTrace).sendRequest(request);\r
try {\r
request.waitForCompletion();\r
+2010-09-17 Francois Chouinard <fchouinard@gmail.com>
+
+ * src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/event/TmfEvent.java: Support for single event
+ * src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java: Adjusted to new handleData() API
+
+2010-09-17 Francois Chouinard <fchouinard@gmail.com>
+
+ * src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/event/TmfEvent.java: Support for single event
+ * src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java: Adjusted to new handleData() API
+ * src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java: Adjusted to new handleData() API
+
2010-09-15 Francois Chouinard <fchouinard@gmail.com>
* src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java: Optimized TmfExperimentContext handling
package org.eclipse.linuxtools.tmf.component;
-import java.lang.reflect.Array;
import java.util.Vector;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
protected void newCoalescedDataRequest(ITmfDataRequest<T> request) {
synchronized(fLock) {
- TmfCoalescedDataRequest<T> coalescedRequest =
- new TmfCoalescedDataRequest<T>(fType, request.getIndex(), request.getNbRequested(), request.getBlockize(), request.getExecType());
+ TmfCoalescedDataRequest<T> coalescedRequest = new TmfCoalescedDataRequest<T>(
+ fType, request.getIndex(), request.getNbRequested(),request.getExecType());
coalescedRequest.addRequest(request);
if (Tracer.isRequestTraced()) {
Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId());
return;
}
-// final TmfDataProvider<T> provider = this;
+ final TmfDataProvider<T> provider = this;
// Process the request
TmfThread thread = new TmfThread(request.getExecType()) {
@Override
public void run() {
-// if (Tracer.isRequestTraced()) Tracer.traceRequest(request, "started");
+ if (Tracer.isRequestTraced()) Tracer.traceRequest(request, "started");
// Extract the generic information
request.start();
- int blockSize = request.getBlockize();
int nbRequested = request.getNbRequested();
-
- // Create the result buffer
- Vector<T> result = new Vector<T>();
int nbRead = 0;
// Initialize the execution
try {
// Get the ordered events
-// if (Tracer.isRequestTraced()) Tracer.trace("Request #" + request.getRequestId() + " is being serviced by " + provider.getName());
+ if (Tracer.isRequestTraced()) Tracer.trace("Request #" + request.getRequestId() + " is being serviced by " + provider.getName());
T data = getNext(context);
-// if (Tracer.isRequestTraced()) Tracer.trace("Request #" + request.getRequestId() + " read first event");
+ if (Tracer.isRequestTraced()) Tracer.trace("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);
- }
+ if (fLogData) Tracer.traceEvent(provider, request, data);
+ request.handleData(data);
+
// To avoid an unnecessary read passed the last data requested
- if (nbRead < nbRequested) {
+ if (++nbRead < nbRequested) {
data = getNext(context);
if (Tracer.isRequestTraced() && (data == null || data.isNullRef())) {
Tracer.trace("Request #" + request.getRequestId() + " end of data");
}
}
}
- if (result.size() > 0) {
- pushData(request, result);
- }
request.done();
if (Tracer.isRequestTraced()) Tracer.traceRequest(request, "completed");
catch (Exception e) {
if (Tracer.isRequestTraced()) Tracer.traceRequest(request, "exception (failed)");
request.fail();
-// e.printStackTrace();
}
}
};
queueRequest(request);
}
- /**
- * Format the result data and forwards it to the requester.
- * Note: after handling, the data is *removed*.
- *
- * @param request
- * @param data
- */
- @SuppressWarnings("unchecked")
- protected void pushData(ITmfDataRequest<T> request, Vector<T> data) {
- synchronized(request) {
- if (!request.isCompleted()) {
- T[] result = (T[]) Array.newInstance(fType, data.size());
- data.toArray(result);
- request.setData(result);
- request.handleData();
- data.removeAllElements();
- }
- }
- }
-
/**
* Initialize the provider based on the request. The context is
* provider specific and will be updated by getNext().
public abstract ITmfContext armRequest(ITmfDataRequest<T> request);
public abstract T getNext(ITmfContext context);
-// public abstract void queueResult(T data);
-
- /**
- * Return the next piece of data based on the context supplied. The context
- * would typically be updated for the subsequent read.
- *
- * @param context
- * @return
- */
-// private static final int TIMEOUT = 10000;
-//// public abstract T getNext(ITmfContext context) throws InterruptedException;
-//// private int getLevel = 0;
-// public T getNext(ITmfContext context) throws InterruptedException {
-//// String name = Thread.currentThread().getName(); getLevel++;
-//// System.out.println("[" + System.currentTimeMillis() + "] " + name + " " + (getLevel) + " getNext() - entering");
-// T data = fDataQueue.poll(TIMEOUT, TimeUnit.MILLISECONDS);
-// if (data == null) {
-//// if (Tracer.isErrorTraced()) Tracer.traceError(getName() + ": Request timeout on read");
-// throw new InterruptedException();
-// }
-//// System.out.println("[" + System.currentTimeMillis() + "] " + name + " " + (getLevel) + " getNext() - leaving");
-//// getLevel--;
-// return data;
-// }
-//
-// /**
-// * Makes the generated result data available for getNext()
-// *
-// * @param data
-// */
-//// public abstract void queueResult(T data) throws InterruptedException;
-//// private int putLevel = 0;
-// public void queueResult(T data) throws InterruptedException {
-//// String name = Thread.currentThread().getName(); putLevel++;
-//// System.out.println("[" + System.currentTimeMillis() + "] " + name + " " + (putLevel) + " queueResult() - entering");
-// boolean ok = fDataQueue.offer(data, TIMEOUT, TimeUnit.MILLISECONDS);
-// if (!ok) {
-//// if (Tracer.isErrorTraced()) Tracer.traceError(getName() + ": Request timeout on write");
-// throw new InterruptedException();
-// }
-//// System.out.println("[" + System.currentTimeMillis() + "] " + name + " " + (putLevel) + " queueResult() - leaving");
-//// putLevel--;
-// }
-
/**
* Checks if the data meets the request completion criteria.
*
@Override
public boolean isCompleted(ITmfDataRequest<T> request, T data, int nbRead) {
- boolean dataRequestCompleted = super.isCompleted(request, data, nbRead);
- if (!dataRequestCompleted && request instanceof ITmfEventRequest<?> && !data.isNullRef()) {
+ boolean requestCompleted = super.isCompleted(request, data, nbRead);
+ if (!requestCompleted && request instanceof ITmfEventRequest<?> && !data.isNullRef()) {
TmfTimestamp endTime = ((ITmfEventRequest<?>) request).getRange().getEndTime();
return data.getTimestamp().compareTo(endTime, false) > 0;
}
- return dataRequestCompleted;
+ return requestCompleted;
}
@Override
if (request instanceof ITmfEventRequest<?>) {
ITmfEventRequest<T> eventRequest = (ITmfEventRequest<T>) request;
TmfCoalescedEventRequest<T> coalescedRequest =
- new TmfCoalescedEventRequest<T>(fType, eventRequest.getRange(), eventRequest.getNbRequested(), eventRequest.getBlockize(), eventRequest.getExecType());
+ new TmfCoalescedEventRequest<T>(fType, eventRequest.getRange(), eventRequest.getNbRequested(), eventRequest.getExecType());
coalescedRequest.addRequest(eventRequest);
if (Tracer.isRequestTraced()) {
Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId());
* Notice that for performance reasons TmfEvent is NOT immutable. If a copy
* of the event is needed, use the copy constructor.
*/
-public class TmfEvent extends TmfData {
+public class TmfEvent extends TmfData implements Cloneable {
// ------------------------------------------------------------------------
// Constants
return "[TmfEvent(" + fEffectiveTimestamp + "," + fSource + "," + fType + "," + fContent + ")]";
}
+ @Override
+ public TmfEvent clone() {
+ return new TmfEvent(this);
+ }
+
}
// fEventLog = openLogFile("TraceEvent.log");
// System.out.println(System.currentTimeMillis() + ": Experiment indexing started");
- ITmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, TmfTimeRange.Eternity, TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.BACKGROUND) {
+ ITmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, TmfTimeRange.Eternity,
+ TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.BACKGROUND) {
// long indexingStart = System.nanoTime();
TmfTimestamp lastTime = null;
@Override
- public void handleData() {
- TmfEvent[] events = getData();
- if (events.length > 0) {
-
-// try {
-// if (fEventLog != null) {
-// fEventLog.write(events[0].getTimestamp().toString());
-// fEventLog.newLine();
-// fEventLog.flush();
-// }
-// } catch (IOException e) {
-// e.printStackTrace();
-// }
-
- TmfTimestamp ts = events[0].getTimestamp();
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
+ if (event != null) {
+ TmfTimestamp ts = event.getTimestamp();
if (startTime == null)
startTime = new TmfTimestamp(ts);
lastTime = new TmfTimestamp(ts);
- if ((fNbRead % DEFAULT_INDEX_PAGE_SIZE) == 0) {
+ if ((getNbRead() % DEFAULT_INDEX_PAGE_SIZE) == 0) {
updateExperiment();
}
}
@Override
public void handleSuccess() {
-
-// try {
-// fEventLog.close();
-// fEventLog = null;
-// } catch (IOException e) {
-// e.printStackTrace();
-// }
-
// long indexingEnd = System.nanoTime();
updateExperiment();
// System.out.println(System.currentTimeMillis() + ": Experiment indexing completed");
-//
+
// long average = (indexingEnd - indexingStart) / fNbEvents;
// System.out.println(getName() + ": start=" + startTime + ", end=" + lastTime + ", elapsed=" + (indexingEnd * 1.0 - indexingStart) / 1000000000);
// System.out.println(getName() + ": nbEvents=" + fNbEvents + " (" + (average / 1000) + "." + (average % 1000) + " us/evt)");
-
-// for (int i = 0; i < fCheckpoints.size(); i++) {
-// TmfCheckpoint checkpoint = fCheckpoints.get(i);
-// System.out.println("fCheckpoints[" + i + "] " + checkpoint.getTimestamp() + ", " + checkpoint.getLocation().toString());
-// }
}
private void updateExperiment() {
- if (fNbRead != 0) {
+ int nbRead = getNbRead();
+ if (nbRead != 0) {
fTimeRange = new TmfTimeRange(startTime, new TmfTimestamp(lastTime));
- fNbEvents = fNbRead;
+ fNbEvents = nbRead;
notifyListeners();
}
}
broadcast(new TmfExperimentUpdatedSignal(this, this)); // , signal.getTrace()));
}
-// @Override
-// public void queueResult(T data) {
-//// super.queueResult(data);
-// }
-
// ------------------------------------------------------------------------
// TmfDataProvider
// ------------------------------------------------------------------------
while (!isFinished[0]) {
// TmfEventRequest<T> subRequest = new TmfEventRequest<T>(eventRequest.getDataType(), new TmfTimeRange(timestamp[0], endTS), CHUNK_SIZE[0], eventRequest.getBlockize(), ExecutionType.BACKGROUND)
- TmfDataRequest<T> subRequest = new TmfDataRequest<T>(eventRequest.getDataType(), nbRead[0], CHUNK_SIZE[0], eventRequest.getBlockize(), ExecutionType.BACKGROUND)
+// TmfDataRequest<T> subRequest = new TmfDataRequest<T>(eventRequest.getDataType(), nbRead[0], CHUNK_SIZE[0], eventRequest.getBlockize(), ExecutionType.BACKGROUND)
+ TmfDataRequest<T> subRequest = new TmfDataRequest<T>(eventRequest.getDataType(), nbRead[0], CHUNK_SIZE[0], ExecutionType.BACKGROUND)
{
-// int count = 0;
@Override
- public void handleData() {
- T[] data = getData();
-// timestamp[0] = data[data.length-1].getTimestamp();
-// if (count == 0) {
-// System.out.println("First event of the block: " + data[0].getTimestamp());
-// }
-// count++;
-// Tracer.trace("Ndx: " + ((TmfEvent) data[0]).getTimestamp());
- eventRequest.setData(data);
- eventRequest.handleData();
- if (fNbRead == CHUNK_SIZE[0]) {
- nbRead[0] += fNbRead;
-// System.out.println("fNbRead=" + fNbRead + ", count=" + count +", total=" + nbRead[0] + ", TS=" + data[0].getTimestamp());
+ public void handleData(T data) {
+ super.handleData(data);
+ eventRequest.handleData(data);
+ if (getNbRead() == CHUNK_SIZE[0]) {
+ nbRead[0] += getNbRead();
}
- if (fNbRead > CHUNK_SIZE[0]) {
+ if (getNbRead() > CHUNK_SIZE[0]) {
System.out.println("ERROR - Read too many events");
}
}
+
@Override
public void handleCompleted() {
// System.out.println("Request completed at: " + timestamp[0]);
- if (fNbRead < CHUNK_SIZE[0]) {
+ if (getNbRead() < CHUNK_SIZE[0]) {
eventRequest.done();
isFinished[0] = Boolean.TRUE;
- nbRead[0] += fNbRead;
+ nbRead[0] += getNbRead();
// System.out.println("fNbRead=" + fNbRead + ", count=" + count +", total=" + nbRead[0]);
}
super.handleCompleted();
*/
public int getNbRequested();
- /**
- * @return the block size
- */
- public int getBlockize();
-
/**
* @return the number of events read so far
*/
// Data handling
// ------------------------------------------------------------------------
- public void setData(T[] data);
- public T[] getData();
- public void handleData();
+ public void handleData(T data);
// ------------------------------------------------------------------------
// Request handling
fRequests.add(request);
}
- public synchronized boolean isCompatible(ITmfDataRequest<T> request) {
+ public boolean isCompatible(ITmfDataRequest<T> request) {
- boolean ok = !isCompleted();
- ok &= request.getIndex() == getIndex();
- ok &= request.getNbRequested() == getNbRequested();
- ok &= request.getBlockize() == getBlockize();
- ok &= request.getExecType() == getExecType();
+ boolean ok = request.getIndex() == getIndex();
+ ok &= request.getNbRequested() == getNbRequested();
+ ok &= request.getExecType() == getExecType();
return ok;
}
// ------------------------------------------------------------------------
@Override
- public synchronized void handleData() {
- for (ITmfDataRequest<T> request : fRequests) {
- request.setData(getData());
- request.handleData();
- }
+ public void handleData(T data) {
+ super.handleData(data);
+ // Don't call sub-requests handleData() unless this is a
+ // TmfCoalescedDataRequest; extended classes should call
+ // the sub-requests handleData().
+ if (getClass() == TmfCoalescedDataRequest.class) {
+ for (ITmfDataRequest<T> request : fRequests) {
+ request.handleData(data);
+ }
+ }
}
- @Override
- public synchronized void done() {
+ @Override
+ public void done() {
for (ITmfDataRequest<T> request : fRequests) {
request.done();
}
}
@Override
- public synchronized void fail() {
+ public void fail() {
for (ITmfDataRequest<T> request : fRequests) {
request.fail();
}
}
@Override
- public synchronized void cancel() {
+ public void cancel() {
for (ITmfDataRequest<T> request : fRequests) {
request.cancel();
}
@Override
public String toString() {
return "[TmfCoalescedDataRequest(" + getRequestId() + "," + getDataType().getSimpleName()
- + "," + getIndex() + "," + getNbRequested() + "," + getBlockize() + ")]";
+ + "," + getIndex() + "," + getNbRequested() + ")]";
}
}
public boolean isCompatible(ITmfDataRequest<T> request) {
if (request instanceof ITmfEventRequest<?>) {
boolean ok = getNbRequested() == request.getNbRequested();
- ok &= getBlockize() == request.getBlockize();
ok &= getExecType() == request.getExecType();
if (ok) {
TmfTimestamp startTime = ((ITmfEventRequest<T>) request).getRange().getStartTime();
// ------------------------------------------------------------------------
@Override
- public void handleData() {
+ public void handleData(T data) {
+ super.handleData(data);
for (ITmfDataRequest<T> request : fRequests) {
- if (request instanceof TmfEventRequest<?>) {
- TmfEventRequest<T> req = (TmfEventRequest<T>) request;
- T[] data = getData();
- TmfTimestamp ts = data[0].getTimestamp();
- if (data.length > 0 && req.getRange().contains(ts)) {
- req.setData(data);
- req.handleData();
- }
- }
- else {
- TmfDataRequest<T> req = (TmfDataRequest<T>) request;
- T[] data = getData();
- req.setData(data);
- req.handleData();
+ if (data == null) {
+ request.handleData(null);
+ } else {
+ if (request instanceof TmfEventRequest<?>) {
+ TmfEventRequest<T> req = (TmfEventRequest<T>) request;
+ TmfTimestamp ts = data.getTimestamp();
+ if (req.getRange().contains(ts)) {
+ req.handleData(data);
+ }
+ }
+ else {
+ TmfDataRequest<T> req = (TmfDataRequest<T>) request;
+ req.handleData(data);
+ }
}
}
}
@Override
public String toString() {
return "[TmfCoalescedEventRequest(" + getRequestId() + "," + getDataType().getSimpleName()
- + "," + getRange() + "," + getNbRequested() + "," + getBlockize() + ")]";
+ + "," + getRange() + "," + getNbRequested() + ")]";
}
}
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
- protected int fNbRead; // The number of reads so far
+ private int fNbRead; // The number of reads so far
private final Object lock;
private boolean fRequestRunning = false;
private boolean fRequestFailed = false;
private boolean fRequestCanceled = false;
- private T[] fData; // Data object
-
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
fDataType = dataType;
fIndex = index;
fNbRequested = nbRequested;
- fBlockSize = blockSize;
fExecType = execType;
fNbRead = 0;
lock = new Object();
return fNbRequested;
}
- /**
- * @return the block size
- */
- public int getBlockize() {
- return fBlockSize;
- }
-
/**
* @return the number of events read so far
*/
/**
* Sets the data object to specified value. To be called by the
* asynchronous method implementor.
+ *
* @param data Data value to set.
*/
- public synchronized void setData(T[] data) {
- fNbRead += data.length;
- fData = data;
- }
-
- /**
- * Returns the data value, null if not set.
- */
- public synchronized T[] getData() {
- return fData;
- }
-
/**
* Handle a block of incoming data. This method is called every time
* a block of data becomes available.
* (or a copy) if some persistence is needed between invocations.
* - When there is no more data, done() is called.
*
- * @param events - an array of events
+ * @param events - an events
*/
- public abstract void handleData();
+ public void handleData(T data) {
+ if (data != null) {
+ fNbRead++;
+ }
+ }
public void handleStarted() {
}
if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "starting");
synchronized(lock) {
fRequestRunning = true;
- lock.notify();
+ lock.notifyAll();
}
handleStarted();
if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "started");
fRequestCompleted = true;
}
handleCompleted();
- lock.notify();
+ lock.notifyAll();
}
}
@Override
public String toString() {
return "[TmfDataRequest(" + fRequestId + "," + fDataType.getSimpleName()
- + "," + fIndex + "," + fNbRequested + "," + fBlockSize + ")]";
+ + "," + fIndex + "," + fNbRequested + ")]";
}
-
}
@Override
public String toString() {
return "[TmfEventRequest(" + getRequestId() + "," + getDataType().getSimpleName()
- + "," + getRange() + "," + getNbRequested() + "," + getBlockize() + ")]";
+ + "," + getRange() + "," + getNbRequested() + ")]";
}
}
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.request.ITmfDataRequest.ExecutionType;
-import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
-import org.eclipse.linuxtools.tmf.signal.TmfTraceOpenedSignal;
-import org.eclipse.linuxtools.tmf.signal.TmfTraceUpdatedSignal;
/**
* <b><u>TmfTrace</u></b>
// Indexing
// ------------------------------------------------------------------------
- /*
- * The purpose of the index is to keep the information needed to rapidly
- * restore the traces contexts at regular intervals (every INDEX_PAGE_SIZE
- * event).
- */
-
- @SuppressWarnings("unchecked")
- private void indexTrace(boolean waitForCompletion) {
-
- fCheckpoints.clear();
-
- ITmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, TmfTimeRange.Eternity, TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.BACKGROUND) {
-
- TmfTimestamp startTime = null;
- TmfTimestamp lastTime = null;
-
- @Override
- public void handleData() {
- TmfEvent[] events = getData();
- if (events.length > 0) {
- TmfTimestamp ts = events[0].getTimestamp();
- if (startTime == null) {
- startTime = new TmfTimestamp(ts);
- fStartTime = startTime;
- }
- lastTime = new TmfTimestamp(ts);
-
- if ((fNbRead % DEFAULT_INDEX_PAGE_SIZE) == 0) {
- updateTraceData();
- }
- }
- }
-
- @Override
- public void handleSuccess() {
- updateTraceData();
- }
-
- private void updateTraceData() {
- if (fNbRead != 0) {
- fEndTime = new TmfTimestamp(lastTime);
- fNbEvents = fNbRead;
- notifyListeners();
- }
- }
- };
-
- sendRequest((ITmfDataRequest<T>) request);
- if (waitForCompletion)
- try {
- request.waitForCompletion();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
+// /*
+// * The purpose of the index is to keep the information needed to rapidly
+// * restore the traces contexts at regular intervals (every INDEX_PAGE_SIZE
+// * event).
+// */
+//
+// @SuppressWarnings({ "unchecked", "unused" })
+// private void indexTrace(boolean waitForCompletion) {
+//
+// fCheckpoints.clear();
+//
+// ITmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, TmfTimeRange.Eternity, TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.BACKGROUND) {
+//
+// TmfTimestamp startTime = null;
+// TmfTimestamp lastTime = null;
+//
+// @Override
+// public void handleData() {
+// TmfEvent[] events = getData();
+// if (events.length > 0) {
+// TmfTimestamp ts = events[0].getTimestamp();
+// if (startTime == null) {
+// startTime = new TmfTimestamp(ts);
+// fStartTime = startTime;
+// }
+// lastTime = new TmfTimestamp(ts);
+//
+// if ((fNbRead % DEFAULT_INDEX_PAGE_SIZE) == 0) {
+// updateTraceData();
+// }
+// }
+// }
+//
+// @Override
+// public void handleSuccess() {
+// updateTraceData();
+// }
+//
+// private void updateTraceData() {
+// if (fNbRead != 0) {
+// fEndTime = new TmfTimestamp(lastTime);
+// fNbEvents = fNbRead;
+// notifyListeners();
+// }
+// }
+// };
+//
+// sendRequest((ITmfDataRequest<T>) request);
+// if (waitForCompletion)
+// try {
+// request.waitForCompletion();
+// } catch (InterruptedException e) {
+// e.printStackTrace();
+// }
+// }
- protected void notifyListeners() {
- broadcast(new TmfTraceUpdatedSignal(this, this, new TmfTimeRange(fStartTime, fEndTime)));
- }
+// protected void notifyListeners() {
+// broadcast(new TmfTraceUpdatedSignal(this, this, new TmfTimeRange(fStartTime, fEndTime)));
+// }
// ------------------------------------------------------------------------
// TmfDataProvider
// ------------------------------------------------------------------------
- @Override
- protected void queueBackgroundRequest(final ITmfDataRequest<T> request, final int blockSize, final boolean indexing) {
-
- // TODO: Handle the data requests also...
- if (!(request instanceof ITmfEventRequest<?>)) {
- super.queueRequest(request);
- return;
- }
- final ITmfEventRequest<T> eventRequest = (ITmfEventRequest<T>) request;
-
- Thread thread = new Thread() {
- @Override
- public void run() {
-
-// final long requestStart = System.nanoTime();
-
- final Integer[] CHUNK_SIZE = new Integer[1];
- CHUNK_SIZE[0] = blockSize + ((indexing) ? 1 : 0);
-
- final Integer[] nbRead = new Integer[1];
- nbRead[0] = 0;
-
-// final TmfTimestamp[] timestamp = new TmfTimestamp[1];
-// timestamp[0] = new TmfTimestamp(eventRequest.getRange().getStartTime());
-// final TmfTimestamp endTS = eventRequest.getRange().getEndTime();
-
- final Boolean[] isFinished = new Boolean[1];
- isFinished[0] = Boolean.FALSE;
-
- while (!isFinished[0]) {
-
-// TmfEventRequest<T> subRequest = new TmfEventRequest<T>(eventRequest.getDataType(), new TmfTimeRange(timestamp[0], endTS), CHUNK_SIZE[0], eventRequest.getBlockize(), ExecutionType.BACKGROUND)
- TmfDataRequest<T> subRequest = new TmfDataRequest<T>(eventRequest.getDataType(), nbRead[0], CHUNK_SIZE[0], eventRequest.getBlockize(), ExecutionType.BACKGROUND)
- {
-// int count = 0;
- @Override
- public void handleData() {
- T[] data = getData();
-// timestamp[0] = data[data.length-1].getTimestamp();
-// if (count == 0) {
-// System.out.println("First event of the block: " + data[0].getTimestamp());
-// }
-// count++;
-// Tracer.trace("Ndx: " + ((TmfEvent) data[0]).getTimestamp());
- eventRequest.setData(data);
- eventRequest.handleData();
- if (fNbRead == CHUNK_SIZE[0]) {
- nbRead[0] += fNbRead;
-// System.out.println("fNbRead=" + fNbRead + ", count=" + count +", total=" + nbRead[0] + ", TS=" + data[0].getTimestamp());
- }
- if (fNbRead > CHUNK_SIZE[0]) {
- System.out.println("ERROR - Read too many events");
- }
- }
- @Override
- public void handleCompleted() {
-// System.out.println("Request completed at: " + timestamp[0]);
- if (fNbRead < CHUNK_SIZE[0]) {
- eventRequest.done();
- isFinished[0] = Boolean.TRUE;
- nbRead[0] += fNbRead;
-// System.out.println("fNbRead=" + fNbRead + ", count=" + count +", total=" + nbRead[0]);
- }
- super.handleCompleted();
- }
- };
-
- if (!isFinished[0]) {
- queueRequest(subRequest);
-
- try {
- subRequest.waitForCompletion();
-// System.out.println("Finished at " + timestamp[0]);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
-
-// TmfTimestamp newTS = new TmfTimestamp(timestamp[0].getValue() + 1, timestamp[0].getScale(), timestamp[0].getPrecision());
-// timestamp[0] = newTS;
- CHUNK_SIZE[0] = blockSize;
-// System.out.println("New timestamp: " + timestamp[0]);
- }
- }
-// final long requestEnded = System.nanoTime();
-// System.out.println("Background request completed. Elapsed= " + (requestEnded * 1.0 - requestStart) / 1000000000);
- }
- };
-
- thread.start();
- }
-
- // ------------------------------------------------------------------------
- // Signal handlers
- // ------------------------------------------------------------------------
-
- @TmfSignalHandler
- public void traceOpened(TmfTraceOpenedSignal signal) {
- ITmfTrace trace = signal.getTrace();
- if (trace == this) {
- indexTrace(false);
- }
- }
+// @Override
+// protected void queueBackgroundRequest(final ITmfDataRequest<T> request, final int blockSize, final boolean adjust) {
+// super.queueBackgroundRequest(request, fIndexPageSize, true);
+// }
}
projects / deliverable / tracecompass.git / commitdiff
