Attachment #179155 for bug #325662

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 325662
Collapse All | Expand All





	}


	@Override
    public void handleData(LttngEvent event) {
		super.handleData(event);
        if ( (event != null) && (PARSE_EVENTS) ) {
            ((LttngEvent) event).getContent().getFields();
        
        if ( (evt != null) && (PARSE_EVENTS) ) {
            ((LttngEvent) evt).getContent().getFields();
            
            // *** Uncomment the following to print the parsed content
            // Warning : this is VERY intensive




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;
//			@Override
//			public void handleData() {
//				LttngSyntheticEvent[] result = getData();
//	
//				TmfEvent evt = (result.length > 0) ? result[0] : null;
////				handleDataCount++;

			@Override
			public void handleData(LttngSyntheticEvent event) {
				super.handleData(event);
				if (event != null) {
				TmfEvent evt = (result.length > 0) ? result[0] : null;
//				handleDataCount++;
				if (evt != null) {
//					handleDataValidCount++;
					LttngSyntheticEvent synEvent = (LttngSyntheticEvent) event;
					// process event
					SequenceInd indicator = synEvent.getSynType();
					if (indicator == SequenceInd.BEFORE
							|| indicator == SequenceInd.AFTER) {
						processor.process(event, synEvent.getTraceModel());
					} else if (indicator == SequenceInd.STARTREQ) {
						handleRequestStarted();
					} else if (indicator == SequenceInd.ENDREQ) {
						processor.process(event, synEvent.getTraceModel());
						// handleCompleted();
					}
	

							modelInputChanged(this, false);
	
							if (TraceDebug.isDEBUG()) {
								frunningTimeStamp = event.getTimestamp();
								TraceDebug.debug("handled: " + fCount + " sequence: " + synEvent.getSynType());
							}
	

Lines 31-36 Link Here

(-)src/org/eclipse/linuxtools/lttng/ui/views/PerspectiveFactory.java (+3 lines)
31	*/	31	*/
32	public class PerspectiveFactory implements IPerspectiveFactory {	32	public class PerspectiveFactory implements IPerspectiveFactory {
33		33
		34	// Perspective ID
		35	public static final String ID = "org.eclipse.linuxtools.lttng.ui.perspective";
		36
34	// LTTng views	37	// LTTng views
35	private static final String PROJECT_VIEW_ID = ProjectView.ID;	38	private static final String PROJECT_VIEW_ID = ProjectView.ID;
36	private static final String CONTROL_VIEW_ID = ControlView.ID;	39	private static final String CONTROL_VIEW_ID = ControlView.ID;




	 * 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 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 ( ( 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 = ( 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 = event.getTimestamp().getValue();
					
					// * NOTE *
					// We can skip several interval at once, so we need to find what was our interval now

Lines 2-8 Link Here

(-)plugin.xml (-1 / +1 lines)
2	<?eclipse version="3.4"?>	2	<?eclipse version="3.4"?>
3	<plugin>	3	<plugin>
4	<extension	4	<extension
5	id="org,eclipse.linuxtools.lttng.ui.perspective"	5	id="org.eclipse.linuxtools.lttng.ui.perspective"
6	name="%extension.name.0"	6	name="%extension.name.0"
7	point="org.eclipse.ui.perspectives">	7	point="org.eclipse.ui.perspectives">
8	<perspective	8	<perspective

Lines 1-3 Link Here

(-)ChangeLog (+7 lines)
		1	2010-09-17 Francois Chouinard <fchouinard@gmail.com>
		2
		3	* plugin.xml: Fixed perspective ID
		4	* src/org/eclipse/linuxtools/lttng/ui/views/common/AbsTimeUpdateView.java: Adjusted to new handleData() API
		5	* src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java: Adjusted to new handleData() API
		6	* src/org/eclipse/linuxtools/lttng/ui/views/PerspectiveFactory.java: Fixed perspective ID
		7
1	2010-09-15 Francois Chouinard <fchouinard@gmail.com>	8	2010-09-15 Francois Chouinard <fchouinard@gmail.com>
2		9
3	* src/org/eclipse/linuxtools/lttng/ui/views/statistics/StatisticsView.java: ExecutionType update	10	* src/org/eclipse/linuxtools/lttng/ui/views/statistics/StatisticsView.java: ExecutionType update

Lines 1-3 Link Here

(-)ChangeLog (+4 lines)
		1	2010-09-17 Francois Chouinard <fchouinard@gmail.com>
		2
		3	* src/org/eclipse/linuxtools/tmf/ui/viewers/events/TmfEventsTable.java: Adjusted to new handleData() API
		4
1	2010-09-12 francois <francois@sushi>	5	2010-09-12 francois <francois@sushi>
2		6
3	* src/org/eclipse/linuxtools/tmf/ui/widgets/TmfVirtualTable.java (handleTableKeyEvent): Fixed table scrolling issues	7	* src/org/eclipse/linuxtools/tmf/ui/widgets/TmfVirtualTable.java (handleTableKeyEvent): Fixed table scrolling issues




                    return;
                }

                fCacheStartIndex = index;
                fCacheEndIndex = index;

                TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, index, fCacheSize) {
//                    @Override
//                    public void handleData() {
//                        TmfEvent[] tmpEvent = getData();
//                        if ((tmpEvent != null) && (tmpEvent.length > 0)) {
//                            fCache = tmpEvent;
//                            fCacheStartIndex = index;
//                            fCacheEndIndex = index + tmpEvent.length;
//                        }
//                    }

                	private int count = 0;

                	@Override
                    public void handleData(TmfEvent event) {
                		super.handleData(event);
                        if (event != null) {
                            fCache[count++] = event.clone();
                            fCacheEndIndex++;
                        }
                    }

                };

                ((ITmfDataProvider<TmfEvent>) fTrace).sendRequest(request);
                try {
                    request.waitForCompletion();




 * @author alvaro
 * 
 */
public class LttngSyntheticEventProvider extends TmfEventProvider<LttngSyntheticEvent> {
		TmfEventProvider<LttngSyntheticEvent> {

	// ========================================================================
	// 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
											// time

	// TmfDataProvider<LttngEvent> fExtProvider = null;
	private ITmfDataRequest<LttngSyntheticEvent> fmainRequest = null;

				 * ()
				 */
				@Override
				public void handleData(LttngEvent event) {
					super.handleData(event);
					if (event != null) {
						handleIncomingData(event);

					if (events.length > 0) {
						for (LttngEvent e : events) {
							handleIncomingData(e);
						}
					} else {
						TraceDebug.debug("handle data received with no data");
//						handleProviderDone(getTraceModel());
//						done();
					}
				}

				/*
				 * (non-Javadoc)
				 * 

					// mark this sub-request as completed
					super.done();
					handleProviderDone(getTraceModel());
//					super.done();
				}
				
				/**

				private void handleIncomingData(LttngEvent e) {
					long eventTime = e.getTimestamp().getValue();

					// if (eventTime == 13589777932952L) {
					// // syscall entry id 78 expected
					// System.out.println("debug mark at 13589777932952L");
					// }

					TmfTrace<LttngEvent> inTrace =  e.getParentTrace();
					if (!(inTrace == getTrace())) {
//						System.out.println("Event from a different trace discarded");
						return;
					}
					

					if (eventTime >= fDispatchTime) {
						// Before update
						syntheticEvent.setSequenceInd(SequenceInd.BEFORE);
						fmainRequest.handleData(syntheticEvent);
						fmainRequest.handleData(syntheticAckIndicator);

						LttngSyntheticEvent[] result = new LttngSyntheticEvent[1];
						result[0] = syntheticEvent;
						fmainRequest.setData(result);
						fmainRequest.handleData();
						result[0] = syntheticAckIndicator;
						fmainRequest.setData(result);
						fmainRequest.handleData();

						// Update state locally
						syntheticEvent.setSequenceInd(SequenceInd.UPDATE);


						// After Update
						syntheticEvent.setSequenceInd(SequenceInd.AFTER);
						fmainRequest.handleData(syntheticEvent);
						fmainRequest.handleData(syntheticAckIndicator);

						result = new LttngSyntheticEvent[1];
						result[0] = syntheticEvent;
						fmainRequest.setData(result);
						fmainRequest.handleData();
						result[0] = syntheticAckIndicator;
						fmainRequest.setData(result);
						fmainRequest.handleData();

						// increment once per dispatch
						incrementSynEvenCount();

		startIndEvent.setSequenceInd(SequenceInd.STARTREQ);

		// Notify application
		fmainRequest.handleData(startIndEvent);
		fmainRequest.handleData(fStatusEventAck);
		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();
//		}

		// Notify state event processor
		fstateUpdateProcessor.process(startIndEvent, null);

		finishEvent.setSequenceInd(SequenceInd.ENDREQ);
		finishEvent.setTraceModel(traceModel);

		fmainRequest.handleData(finishEvent);
		fmainRequest.handleData(fStatusEventAck);
		fmainRequest.setData(result);
		fmainRequest.handleData();
		result[0] = fStatusEventAck;
		fmainRequest.setData(result);
		fmainRequest.handleData();
		
		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();
//		}
	}

	/**

		return null;
	}

//	@Override
//	public LttngSyntheticEvent getNext(ITmfContext context) {
//		return super.getNext(context);
//	}

//	@Override
//	public void queueResult(LttngSyntheticEvent data) {
//		super.queueResult(data);
//	}

}





		// 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 event) {
				super.handleData(event);
				if (event != null) {
					nbEvents++;
		
					LttngEvent event = (LttngEvent) events[0];
					
//					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 event) {
			super.handleData(event);
			if (event != null) {
				synEvent = event;
			if (evt[0] != null) {
				synEvent = (LttngSyntheticEvent) evt[0];
				if (synEvent.getSynType() == SequenceInd.AFTER) {
					// Note : We call this function before incrementing
					// eventCount to save a default check point at the "0th"

Lines 58-68 Link Here

(-)src/org/eclipse/linuxtools/lttng/trace/LTTngTrace.java (-2 / +2 lines)
58	// // [lmcfrch]	58	// // [lmcfrch]
59	// private long lastTime = 0;	59	// private long lastTime = 0;
60		60
61	public static boolean printDebug = false;	61	public static boolean printDebug = false;
62	public static boolean uniqueEvent = false;	62	public static boolean uniqueEvent = false;
63		63
64	private final static boolean SHOW_LTT_DEBUG_DEFAULT = false;	64	private final static boolean SHOW_LTT_DEBUG_DEFAULT = false;
65	private final static boolean IS_PARSING_NEEDED_DEFAULT = true;	65	private final static boolean IS_PARSING_NEEDED_DEFAULT = !uniqueEvent;
66	private final static int CHECKPOINT_PAGE_SIZE = 1000;	66	private final static int CHECKPOINT_PAGE_SIZE = 1000;
67		67
68	// Reference to our JNI trace	68	// Reference to our JNI trace

Lines 65-71 Link Here

(-)src/org/eclipse/linuxtools/lttng/event/LttngEvent.java (-1 / +6 lines)
65		65
66		66
67	/**	67	/**
68	* Return the parent trace asoociated with this event	68	* Return the parent trace associated with this event
69	*	69	*
70	* @return Parent trace	70	* @return Parent trace
71	*/	71	*/
Lines 179-182 Link Here
179		179
180	return result.toString();	180	return result.toString();
181	}	181	}
		182
		183	@Override
		184	public LttngEvent clone() {
		185	return new LttngEvent(this);
		186	}
182	}	187	}

Lines 68-74 Link Here

(-)src/org/eclipse/linuxtools/lttng/request/LttngSyntEventRequest.java (-2 / +2 lines)
68	TmfTimeRange experimentTimeRange, ITransEventProcessor processor, ExecutionType execType) {	68	TmfTimeRange experimentTimeRange, ITransEventProcessor processor, ExecutionType execType) {
69		69
70	super(LttngSyntheticEvent.class, range, nbEvents, maxBlockSize, execType);	70	super(LttngSyntheticEvent.class, range, nbEvents, maxBlockSize, execType);
71	//super(0, nbEvents, maxBlockSize);
72	fExperimentTimeRange = experimentTimeRange;	71	fExperimentTimeRange = experimentTimeRange;
73	addListener(listener);	72	addListener(listener);
74		73
Lines 170-176 Link Here
170	* @see org.eclipse.linuxtools.lttng.request.ILttngEventRequest#handleData()	169	* @see org.eclipse.linuxtools.lttng.request.ILttngEventRequest#handleData()
171	*/	170	*/
172	@Override	171	@Override
173	public void handleData() {	172	public void handleData(LttngSyntheticEvent event) {
		173	super.handleData(event);
174	}	174	}
175		175
176		176




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

Lines 53-60 Link Here

(-)stubs/org/eclipse/linuxtools/tmf/request/TmfDataRequestStub.java (-2 / +2 lines)
53	}	53	}
54		54
55	@Override	55	@Override
56	public void handleData() {	56	public void handleData(T data) {
57	// TODO Auto-generated method stub	57	super.handleData(data);
58	}	58	}
59		59
60	}	60	}

Lines 54-60 Link Here

(-)stubs/org/eclipse/linuxtools/tmf/request/TmfEventRequestStub.java (-2 / +2 lines)
54	}	54	}
55		55
56	@Override	56	@Override
57	public void handleData() {	57	public void handleData(T data) {
58	// TODO Auto-generated method stub	58	super.handleData(data);
59	}	59	}
60	}	60	}




        TmfTimeRange range = eventRequest.getRange();
        final TmfEventRequest<TmfEvent> subRequest =
        	new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
        		@Override
        		public void handleData(TmfEvent event) {
            		super.handleData(event);
        			if (event != null)
        				handleIncomingData(event);
        			else
        				request.done();
        		}
            			request.done();
            		}
            	}
        	};
        provider.sendRequest(subRequest);





        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 event) {
            	super.handleData(event);
                requestedEvents.add(event);
                    requestedEvents.add(e);
                }
            }
        };
        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 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 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) {
        	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 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 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 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) {
        	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.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)]";
        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());

	}

	// ------------------------------------------------------------------------
	// 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)]";
        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());

	}

	// ------------------------------------------------------------------------
	// 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.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)]";
        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());
		TmfCoalescedDataRequest<TmfEvent> dataRequest2 = new TmfCoalescedDataRequest<TmfEvent>(
				fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
		TmfCoalescedDataRequest<TmfEvent> dataRequest3 = new TmfCoalescedDataRequest<TmfEvent>(
				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)]";
        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(TmfEvent event) {
        		super.handleData(event);
            	if (!isCompleted()) {
          			requestedEvents1.add(event);
            		if (++nbRead >= BLOCK_SIZE && signal.forceCancel)
            			requestedEvents1.add(e);
            		}
            		if (signal.forceCancel)
            			cancel();
            	}
            }

        requestedEvents2 = new Vector<TmfEvent>();
        request2 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
            @Override
            public void handleData(TmfEvent event) {
        		super.handleData(event);
            	if (!isCompleted()) {
            		requestedEvents2.add(event);
            		for (TmfEvent e : events) {
            			requestedEvents2.add(e);
            		}
            	}
            }
        };

        requestedEvents3 = new Vector<TmfEvent>();
        request3 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
            @Override
            public void handleData(TmfEvent event) {
        		super.handleData(event);
            	if (!isCompleted()) {
            		requestedEvents3.add(event);
            		for (TmfEvent e : events) {
            			requestedEvents3.add(e);
            		}
            	}
            }
        };




		// Dummy request to force the trace indexing
    	TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class) {
			@Override
			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 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 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) {
        	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 = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
        	@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 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 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) {
      	int nbRead = 0;
      	@Override
      	public void handleData(TmfEvent event) {
    		super.handleData(event);
      		requestedEvents.add(event);
      		if (++nbRead == blockSize)
      			cancel();
      	}
            }
        };
        fExperiment.sendRequest(request);
        request.waitForCompletion();




        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 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 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();
		}




2010-09-17  Francois Chouinard  <fchouinard@gmail.com>

	* 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 

2010-09-09  Francois Chouinard  <fchouinard@gmail.com>

    * src/org/eclipse/linuxtools/tmf/tests/experiment/TmfExperimentTest.java: Added a few checks

Lines 29-35 Link Here

(-)src/org/eclipse/linuxtools/tmf/event/TmfEvent.java (-1 / +6 lines)
29	* Notice that for performance reasons TmfEvent is NOT immutable. If a copy	29	* Notice that for performance reasons TmfEvent is NOT immutable. If a copy
30	* of the event is needed, use the copy constructor.	30	* of the event is needed, use the copy constructor.
31	*/	31	*/
32	public class TmfEvent extends TmfData {	32	public class TmfEvent extends TmfData implements Cloneable {
33		33
34	// ------------------------------------------------------------------------	34	// ------------------------------------------------------------------------
35	// Constants	35	// Constants
Lines 190-193 Link Here
190	return "[TmfEvent(" + fEffectiveTimestamp + "," + fSource + "," + fType + "," + fContent + ")]";	190	return "[TmfEvent(" + fEffectiveTimestamp + "," + fSource + "," + fType + "," + fContent + ")]";
191	}	191	}
192		192
		193	@Override
		194	public TmfEvent clone() {
		195	return new TmfEvent(this);
		196	}
		197
193	}	198	}




	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(T data) {
    	super.handleData(data);
    	for (ITmfDataRequest<T> request : fRequests) {
    		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() + ")]";
    }

}

Lines 57-67 Link Here

(-)src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java (-8 / +1 lines)
57	public int getNbRequested();	57	public int getNbRequested();
58		58
59	/**	59	/**
60	* @return the block size
61	*/
62	public int getBlockize();
63
64	/**
65	* @return the number of events read so far	60	* @return the number of events read so far
66	*/	61	*/
67	public int getNbRead();	62	public int getNbRead();
Lines 79-87 Link Here
79	// Data handling	74	// Data handling
80	// ------------------------------------------------------------------------	75	// ------------------------------------------------------------------------
81		76
82	public void setData(T[] data);	77	public void handleData(T data);
83	public T[] getData();
84	public void handleData();
85		78
86	// ------------------------------------------------------------------------	79	// ------------------------------------------------------------------------
87	// Request handling	80	// Request handling




    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       int      		fNbRead;        // The number of reads so far
    protected     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 the block size
     */
    public int getBlockize() {
        return fBlockSize;
    }

    /**
     * @return the number of events read so far
     */
    public synchronized int getNbRead() {

    /** 
     * 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 events
     */
    public void handleData(T data) {
        if (data != null) {
        	fNbRead++;
        }
    }

    public void handleStarted() {
    }

        if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "starting");
        synchronized(lock) {
            fRequestRunning = true;
            lock.notifyAll();
        }
        handleStarted();
        if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "started");

                fRequestCompleted = true;
            }
            handleCompleted();
            lock.notifyAll();
        }
    }


    @Override
    public String toString() {
		return "[TmfDataRequest(" + fRequestId + "," + fDataType.getSimpleName() 
			+ "," + fIndex + "," + fNbRequested + ")]";
    }

}

Lines 114-120 Link Here

(-)src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java (-1 / +1 lines)
114	@Override	114	@Override
115	public String toString() {	115	public String toString() {
116	return "[TmfEventRequest(" + getRequestId() + "," + getDataType().getSimpleName()	116	return "[TmfEventRequest(" + getRequestId() + "," + getDataType().getSimpleName()
117	+ "," + getRange() + "," + getNbRequested() + "," + getBlockize() + ")]";	117	+ "," + getRange() + "," + getNbRequested() + ")]";
118	}	118	}
119		119
120	}	120	}





		boolean ok = request.getIndex() == getIndex();
		ok &= request.getNbRequested()  == getNbRequested();
		ok &= request.getBlockize()     == getBlockize();
		ok &= request.getExecType()     == getExecType();
		
		return ok;

    // ------------------------------------------------------------------------

    @Override
	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 void done() {
    	for (ITmfDataRequest<T> request : fRequests) {
    		request.done();

    @Override
    public String toString() {
		return "[TmfCoalescedDataRequest(" + getRequestId() + "," + getDataType().getSimpleName() 
			+ "," + getIndex() + "," + getNbRequested() + ")]";
    }

}




	
	@Override
	public boolean isCompleted(ITmfDataRequest<T> request, T data, int nbRead) {
		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 requestCompleted;
	}

	@Override

		if (request instanceof ITmfEventRequest<?>) {
			ITmfEventRequest<T> eventRequest = (ITmfEventRequest<T>) request;
			TmfCoalescedEventRequest<T> coalescedRequest = 
				new TmfCoalescedEventRequest<T>(fType, eventRequest.getRange(), eventRequest.getNbRequested(), eventRequest.getExecType());
			coalescedRequest.addRequest(eventRequest);
	        if (Tracer.isRequestTraced()) {
		        Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId());





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.getExecType());
			coalescedRequest.addRequest(request);
	        if (Tracer.isRequestTraced()) {
	        	Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId());


				// 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

					while (data != null && !isCompleted(request, data, nbRead))
					{
						if (fLogData) Tracer.traceEvent(provider, request, data);
						request.handleData(data);

							pushData(request, result);
						}
						// To avoid an unnecessary read passed the last data requested
						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();
				}
			}
		};

	}

	/**
	 * 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.
	 * 




		fCheckpoints.clear();
		
//		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) {

			long indexingStart = System.nanoTime();
			
			TmfTimestamp startTime =  null;
			TmfTimestamp lastTime  =  null;

			@Override
			public void handleData(TmfEvent event) {
        		super.handleData(event);
				if (event != null) {
					TmfTimestamp ts = event.getTimestamp();
//					try {
//						if (fEventLog != null) {
//							fEventLog.write(events[0].getTimestamp().toString());
//							fEventLog.newLine();
//							fEventLog.flush();
//						}
//					} catch (IOException e) {
//						e.printStackTrace();
//					}
					
					TmfTimestamp ts = events[0].getTimestamp();
					if (startTime == null)
						startTime = new TmfTimestamp(ts);
					lastTime = new TmfTimestamp(ts);

					if ((getNbRead() % DEFAULT_INDEX_PAGE_SIZE) == 0) {
						updateExperiment();
					}
				}


			@Override
			public void handleSuccess() {
				long indexingEnd = System.nanoTime();
//				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)");

				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)");
//				 }
			}

			private void updateExperiment() {
				int nbRead = getNbRead();
				if (nbRead != 0) {
					fTimeRange = new TmfTimeRange(startTime, new TmfTimestamp(lastTime));
					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], ExecutionType.BACKGROUND)
					{
//						int count = 0;
						@Override
						public void handleData(T data) {
							super.handleData(data);
							eventRequest.handleData(data);
							if (getNbRead() == CHUNK_SIZE[0]) {
								nbRead[0] += getNbRead();
//							}
//							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 (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 (getNbRead() < CHUNK_SIZE[0]) {
								eventRequest.done();
								isFinished[0] = Boolean.TRUE;
								nbRead[0] += getNbRead();
//								System.out.println("fNbRead=" + fNbRead + ", count=" + count +", total=" + nbRead[0]);
							}
							super.handleCompleted();


		thread.start();
	}

}




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 




	
		// request
		validSequence = true;
		TmfEventRequest<T> request = new TmfEventRequest<T>(k, trange, TmfDataRequest.ALL_DATA, DEFAULT_CHUNK) {
				trange, TmfDataRequest.ALL_DATA, DEFAULT_CHUNK) {
	
			@Override
			public void handleData(T event) {
				T[] result = getData();
	
				T event = (result.length > 0) ? result[0] : null;
				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.lttng.event.LttngSyntheticEvent;
import org.eclipse.linuxtools.lttng.state.experiment.IStateExperimentManager;
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);
	}

	/**
	 * 
	 */
	public void testSyntheticEventRequest() {
		init();
		// Create a new Experiment manager context
		IStateExperimentManager expManager = prepareExperimentContext(false);

		// make sure a TmfExperiment instance is registered as provider and
		// selected as current
		TmfExperiment<LttngEvent> experiment = prepareExperimentToTest();

		// experiment selected, build experiment selection context and trigger
		// check point creation
		expManager.experimentSelected_prep(experiment);
		// builds check points in parallel
		expManager.experimentSelected(this, experiment);

		// Obtain the singleton event provider
		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 = prepareEventRequest(LttngSyntheticEvent.class, 11, 13,
				printExpectedEvents); /* 1001 events */

		// execute
		synProvider.sendRequest(request1);
		try {
			request1.waitForCompletion();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("EventCount " + feventCount);

		synProvider.sendRequest(request2);
		try {
			request2.waitForCompletion();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("EventCount " + feventCount);

		// finish
		assertEquals("Unexpected eventCount", 3002, feventCount);
////			request2.waitForCompletion();
////		} catch (InterruptedException e) {
////			e.printStackTrace();
////		}
////		System.out.println("EventCount " + feventCount);
//
//		// finish
//		assertEquals("Unexpected eventCount", 3002, feventCount);
	}

}

Lines 1-3 Link Here

(-)ChangeLog (+5 lines)
		1	2010-09-17 Francois Chouinard <fchouinard@gmail.com>
		2
		3	* src/org/eclipse/linuxtools/lttng/control/LTTngSyntheticEventProviderTest.java: Adjusted unit test
		4	* src/org/eclipse/linuxtools/lttng/LttngTestPreparation.java: Adjusted unit test
		5
1	2010-09-09 Francois Chouinard <fchouinard@gmail.com>	6	2010-09-09 Francois Chouinard <fchouinard@gmail.com>
2		7
3	* src/org/eclipse/linuxtools/lttng/tests/AllLTTngCoreTests.java: Invoke new test	8	* src/org/eclipse/linuxtools/lttng/tests/AllLTTngCoreTests.java: Invoke new test

Return to bug 325662

Lines 26-32 Link Here

(-)src/org/eclipse/linuxtools/lttng/ui/views/common/AbsTimeUpdateView.java (-13 / +16 lines)
26	import org.eclipse.linuxtools.lttng.state.evProcessor.ITransEventProcessor;	26	import org.eclipse.linuxtools.lttng.state.evProcessor.ITransEventProcessor;
27	import org.eclipse.linuxtools.lttng.ui.TraceDebug;	27	import org.eclipse.linuxtools.lttng.ui.TraceDebug;
28	import org.eclipse.linuxtools.lttng.ui.model.trange.ItemContainer;	28	import org.eclipse.linuxtools.lttng.ui.model.trange.ItemContainer;
29	import org.eclipse.linuxtools.tmf.event.TmfEvent;
30	import org.eclipse.linuxtools.tmf.event.TmfTimeRange;	29	import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
31	import org.eclipse.linuxtools.tmf.event.TmfTimestamp;	30	import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
32	import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;	31	import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
Lines 373-398 Link Here
373	* org.eclipse.linuxtools.lttng.request.LttngSyntEventRequest#handleData	372	* org.eclipse.linuxtools.lttng.request.LttngSyntEventRequest#handleData
374	* ()	373	* ()
375	*/	374	*/
376	// int handleDataCount = 0;	375	//// int handleDataCount = 0;
377	// int handleDataValidCount = 0;	376	//// int handleDataValidCount = 0;
		377	// @Override
		378	// public void handleData() {
		379	// LttngSyntheticEvent[] result = getData();
		380	//
		381	// TmfEvent evt = (result.length > 0) ? result[0] : null;
		382	//// handleDataCount++;
		383
378	@Override	384	@Override
379	public void handleData() {	385	public void handleData(LttngSyntheticEvent event) {
380	LttngSyntheticEvent[] result = getData();	386	super.handleData(event);
381		387	if (event != null) {
382	TmfEvent evt = (result.length > 0) ? result[0] : null;
383	// handleDataCount++;
384	if (evt != null) {
385	// handleDataValidCount++;	388	// handleDataValidCount++;
386	LttngSyntheticEvent synEvent = (LttngSyntheticEvent) evt;	389	LttngSyntheticEvent synEvent = (LttngSyntheticEvent) event;
387	// process event	390	// process event
388	SequenceInd indicator = synEvent.getSynType();	391	SequenceInd indicator = synEvent.getSynType();
389	if (indicator == SequenceInd.BEFORE	392	if (indicator == SequenceInd.BEFORE
390	\|\| indicator == SequenceInd.AFTER) {	393	\|\| indicator == SequenceInd.AFTER) {
391	processor.process(evt, synEvent.getTraceModel());	394	processor.process(event, synEvent.getTraceModel());
392	} else if (indicator == SequenceInd.STARTREQ) {	395	} else if (indicator == SequenceInd.STARTREQ) {
393	handleRequestStarted();	396	handleRequestStarted();
394	} else if (indicator == SequenceInd.ENDREQ) {	397	} else if (indicator == SequenceInd.ENDREQ) {
395	processor.process(evt, synEvent.getTraceModel());	398	processor.process(event, synEvent.getTraceModel());
396	// handleCompleted();	399	// handleCompleted();
397	}	400	}
398		401
Lines 403-409 Link Here
403	modelInputChanged(this, false);	406	modelInputChanged(this, false);
404		407
405	if (TraceDebug.isDEBUG()) {	408	if (TraceDebug.isDEBUG()) {
406	frunningTimeStamp = evt.getTimestamp();	409	frunningTimeStamp = event.getTimestamp();
407	TraceDebug.debug("handled: " + fCount + " sequence: " + synEvent.getSynType());	410	TraceDebug.debug("handled: " + fCount + " sequence: " + synEvent.getSynType());
408	}	411	}
409		412

Lines 203-224 Link Here

(-)src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.java (-27 / +3 lines)
203		203
204	// trigger data request to build the state system check points	204	// trigger data request to build the state system check points
205	fStateCheckPointRequest = buildCheckPoints(experiment);	205	fStateCheckPointRequest = buildCheckPoints(experiment);
206
207	// LTTngTreeNode experimentNode = getChildByName(experiment.getName());
208	// if (experimentNode != null) {
209	// // get the trace manager nodes
210	// LTTngTreeNode[] traceNodes = experimentNode.getChildren();
211	// for (LTTngTreeNode traceStateManagerNode : traceNodes) {
212	// // The trace node needs to perform its first data request
213	// // for this experiment with the main goal of building its
214	// // checkpoints
215	// if (traceStateManagerNode instanceof ILttExperimentSelectedListener) {
216	// // no need to provide the trace to the trace manager
217	// ((ILttExperimentSelectedListener) traceStateManagerNode).experimentUpdated(
218	// new TmfExperimentUpdatedSignal(source, experiment, null), fwaitForCompletion);
219	// }
220	// }
221	// }
222	}	206	}
223		207
224	/*	208	/*
Lines 338-352 Link Here
338	* org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleData()	322	* org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleData()
339	*/	323	*/
340	@Override	324	@Override
341	public void handleData() {	325	public void handleData(LttngEvent event) {
342	LttngEvent[] events = getData();	326	super.handleData(event);
343	if (events.length > 0) {	327	if (event != null) {
344	nbEvents++;
345
346	LttngEvent event = (LttngEvent) events[0];
347
348	// Tracer.trace("Chk: " + event.getTimestamp());	328	// Tracer.trace("Chk: " + event.getTimestamp());
349
350	ITmfTrace trace = event.getParentTrace();	329	ITmfTrace trace = event.getParentTrace();
351	IStateTraceManager traceManager = ftraceToManagerMap.get(getTraceKey(trace));	330	IStateTraceManager traceManager = ftraceToManagerMap.get(getTraceKey(trace));
352	if (traceManager != null) {	331	if (traceManager != null) {
Lines 400-408 Link Here
400	* @param header	379	* @param header
401	*/	380	*/
402	private void printCompletedMessage() {	381	private void printCompletedMessage() {
403	// System.out.println(System.currentTimeMillis() + ": StateExperimentManager completed checkpoints");
404
405	// super.handleCompleted();
406	if (TraceDebug.isDEBUG()) {	382	if (TraceDebug.isDEBUG()) {
407	TraceDebug.debug("Trace check point building completed, number of events handled: " + nbEvents	383	TraceDebug.debug("Trace check point building completed, number of events handled: " + nbEvents
408	+ "\n\t\t");	384	+ "\n\t\t");

Lines 351-362 Link Here

(-)src/org/eclipse/linuxtools/lttng/state/trace/StateTraceManager.java (-6 / +4 lines)
351	* ()	351	* ()
352	*/	352	*/
353	@Override	353	@Override
354	public void handleData() {	354	public void handleData(LttngSyntheticEvent event) {
355	LttngSyntheticEvent[] result = getData();	355	super.handleData(event);
356		356	if (event != null) {
357	evt[0] = (result.length > 0) ? result[0] : null;	357	synEvent = event;
358	if (evt[0] != null) {
359	synEvent = (LttngSyntheticEvent) evt[0];
360	if (synEvent.getSynType() == SequenceInd.AFTER) {	358	if (synEvent.getSynType() == SequenceInd.AFTER) {
361	// Note : We call this function before incrementing	359	// Note : We call this function before incrementing
362	// eventCount to save a default check point at the "0th"	360	// eventCount to save a default check point at the "0th"

Lines 563-573 Link Here

(-)src/org/eclipse/linuxtools/tmf/tests/experiment/TmfExperimentTest.java (-28 / +21 lines)
563	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);	563	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
564	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {	564	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
565	@Override	565	@Override
566	public void handleData() {	566	public void handleData(TmfEvent event) {
567	TmfEvent[] events = getData();	567	super.handleData(event);
568	for (TmfEvent e : events) {	568	requestedEvents.add(event);
569	requestedEvents.add(e);
570	}
571	}	569	}
572	};	570	};
573	fExperiment.sendRequest(request);	571	fExperiment.sendRequest(request);
Lines 592-604 Link Here
592		590
593	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);	591	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
594	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {	592	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
595	@Override	593	@Override
596	public void handleData() {	594	public void handleData(TmfEvent event) {
597	TmfEvent[] events = getData();	595	super.handleData(event);
598	for (TmfEvent e : events) {	596	requestedEvents.add(event);
599	requestedEvents.add(e);	597	}
600	}
601	}
602	};	598	};
603	fExperiment.sendRequest(request);	599	fExperiment.sendRequest(request);
604	request.waitForCompletion();	600	request.waitForCompletion();
Lines 623-635 Link Here
623		619
624	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);	620	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
625	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {	621	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
626	@Override	622	@Override
627	public void handleData() {	623	public void handleData(TmfEvent event) {
628	TmfEvent[] events = getData();	624	super.handleData(event);
629	for (TmfEvent e : events) {	625	requestedEvents.add(event);
630	requestedEvents.add(e);	626	}
631	}
632	}
633	};	627	};
634	fExperiment.sendRequest(request);	628	fExperiment.sendRequest(request);
635	request.waitForCompletion();	629	request.waitForCompletion();
Lines 657-671 Link Here
657		651
658	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);	652	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
659	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {	653	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
660	@Override	654	int nbRead = 0;
661	public void handleData() {	655	@Override
662	TmfEvent[] events = getData();	656	public void handleData(TmfEvent event) {
663	for (TmfEvent e : events) {	657	super.handleData(event);
664	requestedEvents.add(e);	658	requestedEvents.add(event);
665	}	659	if (++nbRead == blockSize)
666	// Cancel request after the first chunk is received	660	cancel();
667	cancel();	661	}
668	}
669	@Override	662	@Override
670	public void handleCancel() {	663	public void handleCancel() {
671	if (requestedEvents.size() < blockSize) {	664	if (requestedEvents.size() < blockSize) {

Lines 566-578 Link Here

(-)src/org/eclipse/linuxtools/tmf/tests/experiment/TmfMultiTraceExperimentTest.java (-30 / +23 lines)
566		566
567	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);	567	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
568	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {	568	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
569	@Override	569	@Override
570	public void handleData() {	570	public void handleData(TmfEvent event) {
571	TmfEvent[] events = getData();	571	super.handleData(event);
572	for (TmfEvent e : events) {	572	requestedEvents.add(event);
573	requestedEvents.add(e);	573	}
574	}
575	}
576	};	574	};
577	fExperiment.sendRequest(request);	575	fExperiment.sendRequest(request);
578	request.waitForCompletion();	576	request.waitForCompletion();
Lines 596-608 Link Here
596		594
597	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);	595	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
598	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {	596	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
599	@Override	597	@Override
600	public void handleData() {	598	public void handleData(TmfEvent event) {
601	TmfEvent[] events = getData();	599	super.handleData(event);
602	for (TmfEvent e : events) {	600	requestedEvents.add(event);
603	requestedEvents.add(e);	601	}
604	}
605	}
606	};	602	};
607	fExperiment.sendRequest(request);	603	fExperiment.sendRequest(request);
608	request.waitForCompletion();	604	request.waitForCompletion();
Lines 627-639 Link Here
627		623
628	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);	624	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
629	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {	625	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
630	@Override	626	@Override
631	public void handleData() {	627	public void handleData(TmfEvent event) {
632	TmfEvent[] events = getData();	628	super.handleData(event);
633	for (TmfEvent e : events) {	629	requestedEvents.add(event);
634	requestedEvents.add(e);	630	}
635	}
636	}
637	};	631	};
638	fExperiment.sendRequest(request);	632	fExperiment.sendRequest(request);
639	request.waitForCompletion();	633	request.waitForCompletion();
Lines 661-675 Link Here
661		655
662	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);	656	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
663	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {	657	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
664	@Override	658	int nbRead = 0;
665	public void handleData() {	659	@Override
666	TmfEvent[] events = getData();	660	public void handleData(TmfEvent event) {
667	for (TmfEvent e : events) {	661	super.handleData(event);
668	requestedEvents.add(e);	662	requestedEvents.add(event);
669	}	663	if (++nbRead == blockSize)
670	// Cancel request after the first chunk is received	664	cancel();
671	cancel();	665	}
672	}
673	@Override	666	@Override
674	public void handleCancel() {	667	public void handleCancel() {
675	if (requestedEvents.size() < blockSize) {	668	if (requestedEvents.size() < blockSize) {

Lines 80-94 Link Here

(-)src/TmfTraceTest.java (-8 / +4 lines)
80		80
81	}	81	}
82		82
83
84	@Override	83	@Override
85	public void handleData() {	84	public void handleData(LttngEvent event) {
86	LttngEvent[] result = getData();	85	super.handleData(event);
87		86	if ( (event != null) && (PARSE_EVENTS) ) {
88	LttngEvent evt = (result.length > 0) ? result[0] : null;	87	((LttngEvent) event).getContent().getFields();
89
90	if ( (evt != null) && (PARSE_EVENTS) ) {
91	((LttngEvent) evt).getContent().getFields();
92		88
93	// *** Uncomment the following to print the parsed content	89	// *** Uncomment the following to print the parsed content
94	// Warning : this is VERY intensive	90	// Warning : this is VERY intensive

Lines 80-90 Link Here

(-)src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java (-10 / +12 lines)
80	* HandleData function : will be called by TMF each time a new event is receive for the request.<p>	80	* HandleData function : will be called by TMF each time a new event is receive for the request.<p>
81	* Calculation for the content is done here.	81	* Calculation for the content is done here.
82	*/	82	*/
83	@Override	83	// @Override
84	public void handleData() {	84	// public void handleData() {
85	LttngEvent[] result = getData();	85	// LttngEvent[] result = getData();
86	LttngEvent event = (result.length > 0) ? result[0] : null;	86	// LttngEvent event = (result.length > 0) ? result[0] : null;
87		87
		88	@Override
		89	public void handleData(LttngEvent event) {
		90	super.handleData(event);
		91
88	// * FIXME *	92	// * FIXME *
89	// * EVIL BUG *	93	// * EVIL BUG *
90	// The request by timerange only does not work! (see constructor above)	94	// The request by timerange only does not work! (see constructor above)
Lines 93-115 Link Here
93	//	97	//
94	if (event != null) {	98	if (event != null) {
95		99
96	LttngEvent tmpEvent = (LttngEvent) event;
97
98	// Tracer.trace("Hst: " + event.getTimestamp());	100	// Tracer.trace("Hst: " + event.getTimestamp());
99		101
100	// This check is linked to the evil fix mentionned above	102	// This check is linked to the evil fix mentionned above
101	if ( ( tmpEvent.getTimestamp().getValue() >= parentCanvas.getHistogramContent().getStartTime() ) &&	103	if ( ( event.getTimestamp().getValue() >= parentCanvas.getHistogramContent().getStartTime() ) &&
102	( tmpEvent.getTimestamp().getValue() <= parentCanvas.getHistogramContent().getEndTime() ) )	104	( event.getTimestamp().getValue() <= parentCanvas.getHistogramContent().getEndTime() ) )
103	{	105	{
104		106
105	// Distance (in time) between this event and the last one we read	107	// Distance (in time) between this event and the last one we read
106	long distance = ( tmpEvent.getTimestamp().getValue() - lastRangeTime );	108	long distance = ( event.getTimestamp().getValue() - lastRangeTime );
107		109
108	// Check if we changed of interval (the distance is higher than the interval time)	110	// Check if we changed of interval (the distance is higher than the interval time)
109	if ( distance > parentCanvas.getHistogramContent().getElementsTimeInterval() ) {	111	if ( distance > parentCanvas.getHistogramContent().getElementsTimeInterval() ) {
110		112
111	parentCanvas.getHistogramContent().getElementByIndex(lastInterval).intervalNbEvents = nbEventsInInterval;	113	parentCanvas.getHistogramContent().getElementByIndex(lastInterval).intervalNbEvents = nbEventsInInterval;
112	lastRangeTime = tmpEvent.getTimestamp().getValue();	114	lastRangeTime = event.getTimestamp().getValue();
113		115
114	// * NOTE *	116	// * NOTE *
115	// We can skip several interval at once, so we need to find what was our interval now	117	// We can skip several interval at once, so we need to find what was our interval now

Lines 144-160 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/events/TmfEventsTable.java (-7 / +23 lines)
144	return;	144	return;
145	}	145	}
146		146
		147	fCacheStartIndex = index;
		148	fCacheEndIndex = index;
		149
147	TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, index, fCacheSize) {	150	TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, index, fCacheSize) {
148	@Override	151	// @Override
149	public void handleData() {	152	// public void handleData() {
150	TmfEvent[] tmpEvent = getData();	153	// TmfEvent[] tmpEvent = getData();
151	if ((tmpEvent != null) && (tmpEvent.length > 0)) {	154	// if ((tmpEvent != null) && (tmpEvent.length > 0)) {
152	fCache = tmpEvent;	155	// fCache = tmpEvent;
153	fCacheStartIndex = index;	156	// fCacheStartIndex = index;
154	fCacheEndIndex = index + tmpEvent.length;	157	// fCacheEndIndex = index + tmpEvent.length;
		158	// }
		159	// }
		160
		161	private int count = 0;
		162
		163	@Override
		164	public void handleData(TmfEvent event) {
		165	super.handleData(event);
		166	if (event != null) {
		167	fCache[count++] = event.clone();
		168	fCacheEndIndex++;
155	}	169	}
156	}	170	}
		171
157	};	172	};
		173
158	((ITmfDataProvider<TmfEvent>) fTrace).sendRequest(request);	174	((ITmfDataProvider<TmfEvent>) fTrace).sendRequest(request);
159	try {	175	try {
160	request.waitForCompletion();	176	request.waitForCompletion();

Lines 46-61 Link Here

(-)src/org/eclipse/linuxtools/lttng/control/LttngSyntheticEventProvider.java (-88 / +15 lines)
46	* @author alvaro	46	* @author alvaro
47	*	47	*
48	*/	48	*/
49	public class LttngSyntheticEventProvider extends	49	public class LttngSyntheticEventProvider extends TmfEventProvider<LttngSyntheticEvent> {
50	TmfEventProvider<LttngSyntheticEvent> {
51		50
52	// ========================================================================	51	// ========================================================================
53	// Data	52	// Data
54	// ========================================================================	53	// ========================================================================
		54
55	public static final int BLOCK_SIZE = 1;	55	public static final int BLOCK_SIZE = 1;
56	public static final int NB_EVENTS = 1;	56	public static final int NB_EVENTS = 1;
57	public static final int QUEUE_SIZE = 1; // lttng specific, one event at a	57	public static final int QUEUE_SIZE = 1; // lttng specific, one event at a time
58	// time
59		58
60	// TmfDataProvider<LttngEvent> fExtProvider = null;	59	// TmfDataProvider<LttngEvent> fExtProvider = null;
61	private ITmfDataRequest<LttngSyntheticEvent> fmainRequest = null;	60	private ITmfDataRequest<LttngSyntheticEvent> fmainRequest = null;
Lines 185-206 Link Here
185	* ()	184	* ()
186	*/	185	*/
187	@Override	186	@Override
188	public void handleData() {	187	public void handleData(LttngEvent event) {
189	LttngEvent[] events = getData();	188	super.handleData(event);
190		189	if (event != null) {
191	// Tracer.trace("Sep: " + events[0].getTimestamp());	190	handleIncomingData(event);
192
193	if (events.length > 0) {
194	for (LttngEvent e : events) {
195	handleIncomingData(e);
196	}
197	} else {	191	} else {
198	TraceDebug.debug("handle data received with no data");	192	TraceDebug.debug("handle data received with no data");
199	// handleProviderDone(getTraceModel());
200	// done();
201	}	193	}
202	}	194	}
203
204	/*	195	/*
205	* (non-Javadoc)	196	* (non-Javadoc)
206	*	197	*
Lines 211-217 Link Here
211	// mark this sub-request as completed	202	// mark this sub-request as completed
212	super.done();	203	super.done();
213	handleProviderDone(getTraceModel());	204	handleProviderDone(getTraceModel());
214	// super.done();
215	}	205	}
216		206
217	/**	207	/**
Lines 222-235 Link Here
222	private void handleIncomingData(LttngEvent e) {	212	private void handleIncomingData(LttngEvent e) {
223	long eventTime = e.getTimestamp().getValue();	213	long eventTime = e.getTimestamp().getValue();
224		214
225	// if (eventTime == 13589777932952L) {
226	// // syscall entry id 78 expected
227	// System.out.println("debug mark at 13589777932952L");
228	// }
229
230	TmfTrace<LttngEvent> inTrace = e.getParentTrace();	215	TmfTrace<LttngEvent> inTrace = e.getParentTrace();
231	if (!(inTrace == getTrace())) {	216	if (!(inTrace == getTrace())) {
232	// System.out.println("Event from a different trace discarded");
233	return;	217	return;
234	}	218	}
235		219
Lines 240-255 Link Here
240	if (eventTime >= fDispatchTime) {	224	if (eventTime >= fDispatchTime) {
241	// Before update	225	// Before update
242	syntheticEvent.setSequenceInd(SequenceInd.BEFORE);	226	syntheticEvent.setSequenceInd(SequenceInd.BEFORE);
243	// queueResult(syntheticEvent);	227	fmainRequest.handleData(syntheticEvent);
244	// queueResult(syntheticAckIndicator);	228	fmainRequest.handleData(syntheticAckIndicator);
245
246	LttngSyntheticEvent[] result = new LttngSyntheticEvent[1];
247	result[0] = syntheticEvent;
248	fmainRequest.setData(result);
249	fmainRequest.handleData();
250	result[0] = syntheticAckIndicator;
251	fmainRequest.setData(result);
252	fmainRequest.handleData();
253		229
254	// Update state locally	230	// Update state locally
255	syntheticEvent.setSequenceInd(SequenceInd.UPDATE);	231	syntheticEvent.setSequenceInd(SequenceInd.UPDATE);
Lines 257-272 Link Here
257		233
258	// After Update	234	// After Update
259	syntheticEvent.setSequenceInd(SequenceInd.AFTER);	235	syntheticEvent.setSequenceInd(SequenceInd.AFTER);
260	// queueResult(syntheticEvent);	236	fmainRequest.handleData(syntheticEvent);
261	// queueResult(syntheticAckIndicator);	237	fmainRequest.handleData(syntheticAckIndicator);
262
263	result = new LttngSyntheticEvent[1];
264	result[0] = syntheticEvent;
265	fmainRequest.setData(result);
266	fmainRequest.handleData();
267	result[0] = syntheticAckIndicator;
268	fmainRequest.setData(result);
269	fmainRequest.handleData();
270		238
271	// increment once per dispatch	239	// increment once per dispatch
272	incrementSynEvenCount();	240	incrementSynEvenCount();
Lines 339-359 Link Here
339	startIndEvent.setSequenceInd(SequenceInd.STARTREQ);	307	startIndEvent.setSequenceInd(SequenceInd.STARTREQ);
340		308
341	// Notify application	309	// Notify application
342	LttngSyntheticEvent[] result = new LttngSyntheticEvent[1];	310	fmainRequest.handleData(startIndEvent);
343	result[0] = startIndEvent;	311	fmainRequest.handleData(fStatusEventAck);
344	fmainRequest.setData(result);
345	fmainRequest.handleData();
346	result[0] = fStatusEventAck;
347	fmainRequest.setData(result);
348	fmainRequest.handleData();
349
350	// try {
351	// queueResult(startIndEvent);
352	// queueResult(fStatusEventAck);
353	// } catch (InterruptedException e) {
354	// // TODO: cancel this request
355	// e.printStackTrace();
356	// }
357		312
358	// Notify state event processor	313	// Notify state event processor
359	fstateUpdateProcessor.process(startIndEvent, null);	314	fstateUpdateProcessor.process(startIndEvent, null);
Lines 387-413 Link Here
387	finishEvent.setSequenceInd(SequenceInd.ENDREQ);	342	finishEvent.setSequenceInd(SequenceInd.ENDREQ);
388	finishEvent.setTraceModel(traceModel);	343	finishEvent.setTraceModel(traceModel);
389		344
390	LttngSyntheticEvent[] result = new LttngSyntheticEvent[1];	345	fmainRequest.handleData(finishEvent);
391	result[0] = finishEvent;	346	fmainRequest.handleData(fStatusEventAck);
392	fmainRequest.setData(result);
393	fmainRequest.handleData();
394	result[0] = fStatusEventAck;
395	fmainRequest.setData(result);
396	fmainRequest.handleData();
397
398	fmainRequest.done();	347	fmainRequest.done();
399
400	// try {
401	// queueResult(finishEvent);
402	// queueResult(fStatusEventAck);
403	// // End the loop in the main request
404	// queueResult(LttngSyntheticEvent.NullEvent);
405	// } catch (InterruptedException e) {
406	// // System.out.println(getName() +
407	// // ":handleProviderDone() failed to queue request");
408	// // TODO: Cancel the request
409	//// e.printStackTrace();
410	// }
411	}	348	}
412		349
413	/**	350	/**
Lines 518-531 Link Here
518	return null;	455	return null;
519	}	456	}
520		457
521	// @Override
522	// public LttngSyntheticEvent getNext(ITmfContext context) {
523	// return super.getNext(context);
524	// }
525
526	// @Override
527	// public void queueResult(LttngSyntheticEvent data) {
528	// super.queueResult(data);
529	// }
530
531	}	458	}

Lines 1-3 Link Here

(-)ChangeLog (+9 lines)
		1	2010-09-17 Francois Chouinard <fchouinard@gmail.com>
		2
		3	* src/org/eclipse/linuxtools/lttng/control/LttngSyntheticEventProvider.java: Adjusted to new handleData() API
		4	* src/org/eclipse/linuxtools/lttng/event/LttngEvent.java: Adjusted to new handleData() API
		5	* src/org/eclipse/linuxtools/lttng/request/LttngSyntEventRequest.java: Adjusted to new handleData() API
		6	* src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.java: Adjusted to new handleData() API
		7	* src/org/eclipse/linuxtools/lttng/state/trace/StateTraceManager.java: Adjusted to new handleData() API
		8	* src/org/eclipse/linuxtools/lttng/trace/LTTngTrace.java: Adjusted to new handleData() API
		9
1	2010-09-15 Francois Chouinard <fchouinard@gmail.com>	10	2010-09-15 Francois Chouinard <fchouinard@gmail.com>
2		11
3	* src/org/eclipse/linuxtools/lttng/trace/LTTngExperiment.java: ExecutionType update	12	* src/org/eclipse/linuxtools/lttng/trace/LTTngExperiment.java: ExecutionType update

Lines 55-71 Link Here

(-)stubs/org/eclipse/linuxtools/tmf/component/TmfSyntheticEventProviderStub.java (-11 / +8 lines)
55	TmfTimeRange range = eventRequest.getRange();	55	TmfTimeRange range = eventRequest.getRange();
56	final TmfEventRequest<TmfEvent> subRequest =	56	final TmfEventRequest<TmfEvent> subRequest =
57	new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {	57	new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
58	@Override	58	@Override
59	public void handleData() {	59	public void handleData(TmfEvent event) {
60	TmfEvent[] events = getData();	60	super.handleData(event);
61	if (events.length > 0) {	61	if (event != null)
62	for (TmfEvent e : events) {	62	handleIncomingData(event);
63	handleIncomingData(e);	63	else
64	}	64	request.done();
65	} else {	65	}
66	request.done();
67	}
68	}
69	};	66	};
70	provider.sendRequest(subRequest);	67	provider.sendRequest(subRequest);
71		68

Lines 15-24 Link Here

(-)src/org/eclipse/linuxtools/tmf/tests/request/TmfDataRequestTest.java (-36 / +4 lines)
15	import junit.framework.TestCase;	15	import junit.framework.TestCase;
16		16
17	import org.eclipse.linuxtools.tmf.event.TmfEvent;	17	import org.eclipse.linuxtools.tmf.event.TmfEvent;
18	import org.eclipse.linuxtools.tmf.event.TmfEventReference;
19	import org.eclipse.linuxtools.tmf.event.TmfEventSource;
20	import org.eclipse.linuxtools.tmf.event.TmfEventType;
21	import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
22	import org.eclipse.linuxtools.tmf.request.TmfDataRequest;	18	import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
23	import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;	19	import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
24		20
Lines 107-113 Link Here
107		103
108	assertEquals("getIndex", 0, request.getIndex());	104	assertEquals("getIndex", 0, request.getIndex());
109	assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());	105	assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
110	assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
111		106
112	assertFalse("isCompleted", request.isCompleted());	107	assertFalse("isCompleted", request.isCompleted());
113	assertFalse("isFailed", request.isFailed());	108	assertFalse("isFailed", request.isFailed());
Lines 124-130 Link Here
124		119
125	assertEquals("getIndex", 10, request.getIndex());	120	assertEquals("getIndex", 10, request.getIndex());
126	assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());	121	assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
127	assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
128		122
129	assertFalse("isCompleted", request.isCompleted());	123	assertFalse("isCompleted", request.isCompleted());
130	assertFalse("isFailed", request.isFailed());	124	assertFalse("isFailed", request.isFailed());
Lines 141-147 Link Here
141		135
142	assertEquals("getIndex", 10, request.getIndex());	136	assertEquals("getIndex", 10, request.getIndex());
143	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());	137	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
144	assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
145		138
146	assertFalse("isCompleted", request.isCompleted());	139	assertFalse("isCompleted", request.isCompleted());
147	assertFalse("isFailed", request.isFailed());	140	assertFalse("isFailed", request.isFailed());
Lines 158-164 Link Here
158		151
159	assertEquals("getIndex", 10, request.getIndex());	152	assertEquals("getIndex", 10, request.getIndex());
160	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());	153	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
161	assertEquals("getBlockize", 200, request.getBlockize());
162		154
163	assertFalse("isCompleted", request.isCompleted());	155	assertFalse("isCompleted", request.isCompleted());
164	assertFalse("isFailed", request.isFailed());	156	assertFalse("isFailed", request.isFailed());
Lines 215-224 Link Here
215	// ------------------------------------------------------------------------	207	// ------------------------------------------------------------------------
216		208
217	public void testToString() {	209	public void testToString() {
218	String expected1 = "[TmfDataRequest(0,TmfEvent,10,100,200)]";	210	String expected1 = "[TmfDataRequest(0,TmfEvent,10,100)]";
219	String expected2 = "[TmfDataRequest(1,TmfEvent,20,100,200)]";	211	String expected2 = "[TmfDataRequest(1,TmfEvent,20,100)]";
220	String expected3 = "[TmfDataRequest(2,TmfEvent,20,200,200)]";	212	String expected3 = "[TmfDataRequest(2,TmfEvent,20,200)]";
221	String expected4 = "[TmfDataRequest(3,TmfEvent,20,200,300)]";	213	String expected4 = "[TmfDataRequest(3,TmfEvent,20,200)]";
222		214
223	assertEquals("toString", expected1, fRequest1.toString());	215	assertEquals("toString", expected1, fRequest1.toString());
224	assertEquals("toString", expected2, fRequest2.toString());	216	assertEquals("toString", expected2, fRequest2.toString());
Lines 227-256 Link Here
227	}	219	}
228		220
229	// ------------------------------------------------------------------------	221	// ------------------------------------------------------------------------
230	// setData/getData
231	// ------------------------------------------------------------------------
232
233	public void testSetData() {
234	// Initialize the data
235	int nbEvents = 10;
236	TmfEvent[] events = new TmfEvent[nbEvents];
237	for (int i = 0; i < nbEvents; i++) {
238	events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
239	new TmfEventType(), new TmfEventReference());
240	}
241
242	fRequest1.setData(events);
243	assertEquals("setData", nbEvents, fRequest1.getNbRead());
244
245	TmfEvent[] eventsRead = fRequest1.getData();
246	assertEquals("getData", nbEvents, eventsRead.length);
247
248	for (int i = 0; i < nbEvents; i++) {
249	assertEquals("getData", i, eventsRead[i].getTimestamp().getValue());
250	}
251	}
252
253	// ------------------------------------------------------------------------
254	// done	222	// done
255	// ------------------------------------------------------------------------	223	// ------------------------------------------------------------------------
256		224

Lines 25-39 Link Here

(-)src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedEventRequestTest.java (-84 / +18 lines)
25	import org.eclipse.linuxtools.tmf.component.ITmfDataProvider;	25	import org.eclipse.linuxtools.tmf.component.ITmfDataProvider;
26	import org.eclipse.linuxtools.tmf.component.TmfProviderManager;	26	import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
27	import org.eclipse.linuxtools.tmf.event.TmfEvent;	27	import org.eclipse.linuxtools.tmf.event.TmfEvent;
28	import org.eclipse.linuxtools.tmf.event.TmfEventReference;
29	import org.eclipse.linuxtools.tmf.event.TmfEventSource;
30	import org.eclipse.linuxtools.tmf.event.TmfEventType;
31	import org.eclipse.linuxtools.tmf.event.TmfTimeRange;	28	import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
32	import org.eclipse.linuxtools.tmf.event.TmfTimestamp;	29	import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
33	import org.eclipse.linuxtools.tmf.request.TmfCoalescedDataRequest;	30	import org.eclipse.linuxtools.tmf.request.TmfCoalescedDataRequest;
34	import org.eclipse.linuxtools.tmf.request.TmfCoalescedEventRequest;	31	import org.eclipse.linuxtools.tmf.request.TmfCoalescedEventRequest;
35	import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
36	import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
37	import org.eclipse.linuxtools.tmf.request.TmfEventRequest;	32	import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
38	import org.eclipse.linuxtools.tmf.request.TmfEventRequestStub;	33	import org.eclipse.linuxtools.tmf.request.TmfEventRequestStub;
39	import org.eclipse.linuxtools.tmf.signal.TmfSignal;	34	import org.eclipse.linuxtools.tmf.signal.TmfSignal;
Lines 133-139 Link Here
133		128
134	assertEquals("getRange", range1, request.getRange());	129	assertEquals("getRange", range1, request.getRange());
135	assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());	130	assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
136	assertEquals("getBlockize", TmfEventRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
137		131
138	assertFalse("isCompleted", request.isCompleted());	132	assertFalse("isCompleted", request.isCompleted());
139	assertFalse("isFailed", request.isFailed());	133	assertFalse("isFailed", request.isFailed());
Lines 150-156 Link Here
150		144
151	assertEquals("getRange", range1, request.getRange());	145	assertEquals("getRange", range1, request.getRange());
152	assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());	146	assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
153	assertEquals("getBlockize", TmfEventRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
154		147
155	assertFalse("isCompleted", request.isCompleted());	148	assertFalse("isCompleted", request.isCompleted());
156	assertFalse("isFailed", request.isFailed());	149	assertFalse("isFailed", request.isFailed());
Lines 167-173 Link Here
167		160
168	assertEquals("getRange", range1, request.getRange());	161	assertEquals("getRange", range1, request.getRange());
169	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());	162	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
170	assertEquals("getBlockize", TmfEventRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
171		163
172	assertFalse("isCompleted", request.isCompleted());	164	assertFalse("isCompleted", request.isCompleted());
173	assertFalse("isFailed", request.isFailed());	165	assertFalse("isFailed", request.isFailed());
Lines 184-190 Link Here
184		176
185	assertEquals("getRange", range1, request.getRange());	177	assertEquals("getRange", range1, request.getRange());
186	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());	178	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
187	assertEquals("getBlockize", 200, request.getBlockize());
188		179
189	assertFalse("isCompleted", request.isCompleted());	180	assertFalse("isCompleted", request.isCompleted());
190	assertFalse("isFailed", request.isFailed());	181	assertFalse("isFailed", request.isFailed());
Lines 228-238 Link Here
228		219
229	public void testEqualsSuper() throws Exception {	220	public void testEqualsSuper() throws Exception {
230	TmfCoalescedDataRequest<TmfEvent> dataRequest1 = new TmfCoalescedDataRequest<TmfEvent>(	221	TmfCoalescedDataRequest<TmfEvent> dataRequest1 = new TmfCoalescedDataRequest<TmfEvent>(
231	fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested(), fRequest1.getBlockize());	222	fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
232	TmfCoalescedDataRequest<TmfEvent> dataRequest2 = new TmfCoalescedDataRequest<TmfEvent>(	223	TmfCoalescedDataRequest<TmfEvent> dataRequest2 = new TmfCoalescedDataRequest<TmfEvent>(
233	fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested(), fRequest1.getBlockize());	224	fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
234	TmfCoalescedDataRequest<TmfEvent> dataRequest3 = new TmfCoalescedDataRequest<TmfEvent>(	225	TmfCoalescedDataRequest<TmfEvent> dataRequest3 = new TmfCoalescedDataRequest<TmfEvent>(
235	fRequest3.getDataType(), fRequest3.getIndex(), fRequest3.getNbRequested(), fRequest3.getBlockize());	226	fRequest3.getDataType(), fRequest3.getIndex(), fRequest3.getNbRequested());
236		227
237	assertTrue("equals", fRequest1.equals(dataRequest2));	228	assertTrue("equals", fRequest1.equals(dataRequest2));
238	assertTrue("equals", fRequest2.equals(dataRequest1));	229	assertTrue("equals", fRequest2.equals(dataRequest1));
Lines 255-264 Link Here
255	// ------------------------------------------------------------------------	246	// ------------------------------------------------------------------------
256		247
257	public void testToString() {	248	public void testToString() {
258	String expected1 = "[TmfCoalescedEventRequest(0,TmfEvent," + range1 + ",100,200)]";	249	String expected1 = "[TmfCoalescedEventRequest(0,TmfEvent," + range1 + ",100)]";
259	String expected2 = "[TmfCoalescedEventRequest(1,TmfEvent," + range2 + ",100,200)]";	250	String expected2 = "[TmfCoalescedEventRequest(1,TmfEvent," + range2 + ",100)]";
260	String expected3 = "[TmfCoalescedEventRequest(2,TmfEvent," + range2 + ",200,200)]";	251	String expected3 = "[TmfCoalescedEventRequest(2,TmfEvent," + range2 + ",200)]";
261	String expected4 = "[TmfCoalescedEventRequest(3,TmfEvent," + range2 + ",200,300)]";	252	String expected4 = "[TmfCoalescedEventRequest(3,TmfEvent," + range2 + ",200)]";
262		253
263	assertEquals("toString", expected1, fRequest1.toString());	254	assertEquals("toString", expected1, fRequest1.toString());
264	assertEquals("toString", expected2, fRequest2.toString());	255	assertEquals("toString", expected2, fRequest2.toString());
Lines 275-336 Link Here
275	TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);	266	TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
276	TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 100, 200);	267	TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 100, 200);
277	TmfEventRequest<TmfEvent> request3 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 101, 200);	268	TmfEventRequest<TmfEvent> request3 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 101, 200);
278	TmfEventRequest<TmfEvent> request4 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 201);
279	TmfDataRequest<TmfEvent> request5 = new TmfDataRequestStub<TmfEvent> (TmfEvent.class, 10, 100, 201);
280		269
281	assertTrue ("isCompatible", coalescedRequest.isCompatible(request1));	270	assertTrue ("isCompatible", coalescedRequest.isCompatible(request1));
282	assertTrue ("isCompatible", coalescedRequest.isCompatible(request2));	271	assertTrue ("isCompatible", coalescedRequest.isCompatible(request2));
283	assertFalse("isCompatible", coalescedRequest.isCompatible(request3));	272	assertFalse("isCompatible", coalescedRequest.isCompatible(request3));
284	assertFalse("isCompatible", coalescedRequest.isCompatible(request4));
285	assertFalse("isCompatible", coalescedRequest.isCompatible(request5));
286	}
287
288	// ------------------------------------------------------------------------
289	// setData/getData
290	// ------------------------------------------------------------------------
291
292	public void testSetData() {
293
294	TmfCoalescedEventRequest<TmfEvent> coalescedRequest = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
295	TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
296	TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
297	coalescedRequest.addRequest(request1);
298	coalescedRequest.addRequest(request2);
299
300	// Initialize the data
301	int nbEvents = 10;
302	TmfEvent[] events = new TmfEvent[nbEvents];
303	for (int i = 0; i < nbEvents; i++) {
304	events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
305	new TmfEventType(), new TmfEventReference());
306	}
307
308	coalescedRequest.setData(events);
309	coalescedRequest.handleData();
310
311	// Validate the coalescing request
312	assertEquals("setData", nbEvents, coalescedRequest.getNbRead());
313	TmfEvent[] eventsRead1 = coalescedRequest.getData();
314	assertEquals("getData", nbEvents, eventsRead1.length);
315	for (int i = 0; i < nbEvents; i++) {
316	assertEquals("getData", i, eventsRead1[i].getTimestamp().getValue());
317	}
318
319	// Validate the first coalesced request
320	assertEquals("setData", nbEvents, request1.getNbRead());
321	TmfEvent[] eventsRead2 = request1.getData();
322	assertEquals("getData", nbEvents, eventsRead2.length);
323	for (int i = 0; i < nbEvents; i++) {
324	assertEquals("getData", i, eventsRead2[i].getTimestamp().getValue());
325	}
326
327	// Validate the second coalesced request
328	assertEquals("setData", nbEvents, request2.getNbRead());
329	TmfEvent[] eventsRead3 = request2.getData();
330	assertEquals("getData", nbEvents, eventsRead3.length);
331	for (int i = 0; i < nbEvents; i++) {
332	assertEquals("getData", i, eventsRead3[i].getTimestamp().getValue());
333	}
334	}	273	}
335		274
336	// ------------------------------------------------------------------------	275	// ------------------------------------------------------------------------
Lines 499-512 Link Here
499		438
500	requestedEvents1 = new Vector<TmfEvent>();	439	requestedEvents1 = new Vector<TmfEvent>();
501	request1 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {	440	request1 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
		441	int nbRead = 0;
502	@Override	442	@Override
503	public void handleData() {	443	public void handleData(TmfEvent event) {
		444	super.handleData(event);
504	if (!isCompleted()) {	445	if (!isCompleted()) {
505	TmfEvent[] events = getData();	446	requestedEvents1.add(event);
506	for (TmfEvent e : events) {	447	if (++nbRead >= BLOCK_SIZE && signal.forceCancel)
507	requestedEvents1.add(e);
508	}
509	if (signal.forceCancel)
510	cancel();	448	cancel();
511	}	449	}
512	}	450	}
Lines 515-526 Link Here
515	requestedEvents2 = new Vector<TmfEvent>();	453	requestedEvents2 = new Vector<TmfEvent>();
516	request2 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {	454	request2 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
517	@Override	455	@Override
518	public void handleData() {	456	public void handleData(TmfEvent event) {
		457	super.handleData(event);
519	if (!isCompleted()) {	458	if (!isCompleted()) {
520	TmfEvent[] events = getData();	459	requestedEvents2.add(event);
521	for (TmfEvent e : events) {
522	requestedEvents2.add(e);
523	}
524	}	460	}
525	}	461	}
526	};	462	};
Lines 528-539 Link Here
528	requestedEvents3 = new Vector<TmfEvent>();	464	requestedEvents3 = new Vector<TmfEvent>();
529	request3 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {	465	request3 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
530	@Override	466	@Override
531	public void handleData() {	467	public void handleData(TmfEvent event) {
		468	super.handleData(event);
532	if (!isCompleted()) {	469	if (!isCompleted()) {
533	TmfEvent[] events = getData();	470	requestedEvents3.add(event);
534	for (TmfEvent e : events) {
535	requestedEvents3.add(e);
536	}
537	}	471	}
538	}	472	}
539	};	473	};

Lines 69-75 Link Here

(-)src/org/eclipse/linuxtools/tmf/tests/trace/TmfTraceTest.java (-24 / +20 lines)
69	// Dummy request to force the trace indexing	69	// Dummy request to force the trace indexing
70	TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class) {	70	TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class) {
71	@Override	71	@Override
72	public void handleData() {	72	public void handleData(TmfEvent event) {
		73	super.handleData(event);
73	}	74	}
74	};	75	};
75	fTrace.sendRequest(request);	76	fTrace.sendRequest(request);
Lines 705-717 Link Here
705		706
706	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);	707	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
707	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {	708	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
708	@Override	709	@Override
709	public void handleData() {	710	public void handleData(TmfEvent event) {
710	TmfEvent[] events = getData();	711	super.handleData(event);
711	for (TmfEvent e : events) {	712	requestedEvents.add(event);
712	requestedEvents.add(e);	713	}
713	}
714	}
715	};	714	};
716	ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);	715	ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
717	providers[0].sendRequest(request);	716	providers[0].sendRequest(request);
Lines 735-747 Link Here
735		734
736	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);	735	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
737	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {	736	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
738	@Override	737	@Override
739	public void handleData() {	738	public void handleData(TmfEvent event) {
740	TmfEvent[] events = getData();	739	super.handleData(event);
741	for (TmfEvent e : events) {	740	requestedEvents.add(event);
742	requestedEvents.add(e);	741	}
743	}
744	}
745	};	742	};
746	ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);	743	ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
747	providers[0].sendRequest(request);	744	providers[0].sendRequest(request);
Lines 768-782 Link Here
768		765
769	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);	766	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
770	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {	767	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
771	@Override	768	int nbRead = 0;
772	public void handleData() {	769	@Override
773	TmfEvent[] events = getData();	770	public void handleData(TmfEvent event) {
774	for (TmfEvent e : events) {	771	super.handleData(event);
775	requestedEvents.add(e);	772	requestedEvents.add(event);
776	}	773	if (++nbRead == BLOCK_SIZE)
777	// Cancel request after the first chunk is received	774	cancel();
778	cancel();	775	}
779	}
780	};	776	};
781	ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);	777	ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
782	providers[0].sendRequest(request);	778	providers[0].sendRequest(request);

Lines 1-3 Link Here

(-)ChangeLog (+15 lines)
		1	2010-09-17 Francois Chouinard <fchouinard@gmail.com>
		2
		3	* src/org/eclipse/linuxtools/tmf/tests/component/TmfEventProviderTest.java: Adjusted unit test
		4	* src/org/eclipse/linuxtools/tmf/tests/experiment/TmfExperimentTest.java: Adjusted to new handleData() API
		5	* src/org/eclipse/linuxtools/tmf/tests/experiment/TmfMultiTraceExperimentTest.java:Adjusted to new handleData() API
		6	* src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedDataRequestTest.java: Adjusted to new handleData() API
		7	* src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedEventRequestTest.java: Adjusted to new handleData() API
		8	* src/org/eclipse/linuxtools/tmf/tests/request/TmfDataRequestTest.java: Adjusted to new handleData() API
		9	* src/org/eclipse/linuxtools/tmf/tests/request/TmfEventRequestTest.java: Adjusted to new handleData() API
		10	* src/org/eclipse/linuxtools/tmf/tests/trace/TmfExperimentTest.java: Adjusted to new handleData() API
		11	* src/org/eclipse/linuxtools/tmf/tests/trace/TmfTraceTest.java: Adjusted to new handleData() API
		12	* stubs/org/eclipse/linuxtools/tmf/component/TmfSyntheticEventProviderStub.java: Adjusted to new handleData() API
		13	* stubs/org/eclipse/linuxtools/tmf/request/TmfDataRequestStub.java: Adjusted to new handleData() API
		14	* stubs/org/eclipse/linuxtools/tmf/request/TmfEventRequestStub.java: Adjusted to new handleData() API
		15
1	2010-09-09 Francois Chouinard <fchouinard@gmail.com>	16	2010-09-09 Francois Chouinard <fchouinard@gmail.com>
2		17
3	* src/org/eclipse/linuxtools/tmf/tests/experiment/TmfExperimentTest.java: Added a few checks	18	* src/org/eclipse/linuxtools/tmf/tests/experiment/TmfExperimentTest.java: Added a few checks

Lines 90-96 Link Here

(-)src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java (-17 / +17 lines)
90	public boolean isCompatible(ITmfDataRequest<T> request) {	90	public boolean isCompatible(ITmfDataRequest<T> request) {
91	if (request instanceof ITmfEventRequest<?>) {	91	if (request instanceof ITmfEventRequest<?>) {
92	boolean ok = getNbRequested() == request.getNbRequested();	92	boolean ok = getNbRequested() == request.getNbRequested();
93	ok &= getBlockize() == request.getBlockize();
94	ok &= getExecType() == request.getExecType();	93	ok &= getExecType() == request.getExecType();
95	if (ok) {	94	if (ok) {
96	TmfTimestamp startTime = ((ITmfEventRequest<T>) request).getRange().getStartTime();	95	TmfTimestamp startTime = ((ITmfEventRequest<T>) request).getRange().getStartTime();
Lines 110-131 Link Here
110	// ------------------------------------------------------------------------	109	// ------------------------------------------------------------------------
111		110
112	@Override	111	@Override
113	public void handleData() {	112	public void handleData(T data) {
		113	super.handleData(data);
114	for (ITmfDataRequest<T> request : fRequests) {	114	for (ITmfDataRequest<T> request : fRequests) {
115	if (request instanceof TmfEventRequest<?>) {	115	if (data == null) {
116	TmfEventRequest<T> req = (TmfEventRequest<T>) request;	116	request.handleData(null);
117	T[] data = getData();	117	} else {
118	TmfTimestamp ts = data[0].getTimestamp();	118	if (request instanceof TmfEventRequest<?>) {
119	if (data.length > 0 && req.getRange().contains(ts)) {	119	TmfEventRequest<T> req = (TmfEventRequest<T>) request;
120	req.setData(data);	120	TmfTimestamp ts = data.getTimestamp();
121	req.handleData();	121	if (req.getRange().contains(ts)) {
122	}	122	req.handleData(data);
123	}	123	}
124	else {	124	}
125	TmfDataRequest<T> req = (TmfDataRequest<T>) request;	125	else {
126	T[] data = getData();	126	TmfDataRequest<T> req = (TmfDataRequest<T>) request;
127	req.setData(data);	127	req.handleData(data);
128	req.handleData();	128	}
129	}	129	}
130	}	130	}
131	}	131	}
Lines 166-172 Link Here
166	@Override	166	@Override
167	public String toString() {	167	public String toString() {
168	return "[TmfCoalescedEventRequest(" + getRequestId() + "," + getDataType().getSimpleName()	168	return "[TmfCoalescedEventRequest(" + getRequestId() + "," + getDataType().getSimpleName()
169	+ "," + getRange() + "," + getNbRequested() + "," + getBlockize() + ")]";	169	+ "," + getRange() + "," + getNbRequested() + ")]";
170	}	170	}
171		171
172	}	172	}

Lines 90-97 Link Here

(-)src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java (-30 / +11 lines)
90	private final int fRequestId; // A unique request ID	90	private final int fRequestId; // A unique request ID
91	private final int fIndex; // The index (rank) of the requested event	91	private final int fIndex; // The index (rank) of the requested event
92	private final int fNbRequested; // The number of requested events (ALL_DATA for all)	92	private final int fNbRequested; // The number of requested events (ALL_DATA for all)
93	private final int fBlockSize; // The maximum number of events per chunk	93	private int fNbRead; // The number of reads so far
94	protected int fNbRead; // The number of reads so far
95		94
96	private final Object lock;	95	private final Object lock;
97	private boolean fRequestRunning = false;	96	private boolean fRequestRunning = false;
Lines 99-106 Link Here
99	private boolean fRequestFailed = false;	98	private boolean fRequestFailed = false;
100	private boolean fRequestCanceled = false;	99	private boolean fRequestCanceled = false;
101		100
102	private T[] fData; // Data object
103
104	// ------------------------------------------------------------------------	101	// ------------------------------------------------------------------------
105	// Constructors	102	// Constructors
106	// ------------------------------------------------------------------------	103	// ------------------------------------------------------------------------
Lines 165-171 Link Here
165	fDataType = dataType;	162	fDataType = dataType;
166	fIndex = index;	163	fIndex = index;
167	fNbRequested = nbRequested;	164	fNbRequested = nbRequested;
168	fBlockSize = blockSize;
169	fExecType = execType;	165	fExecType = execType;
170	fNbRead = 0;	166	fNbRead = 0;
171	lock = new Object();	167	lock = new Object();
Lines 213-225 Link Here
213	}	209	}
214		210
215	/**	211	/**
216	* @return the block size
217	*/
218	public int getBlockize() {
219	return fBlockSize;
220	}
221
222	/**
223	* @return the number of events read so far	212	* @return the number of events read so far
224	*/	213	*/
225	public synchronized int getNbRead() {	214	public synchronized int getNbRead() {
Lines 268-287 Link Here
268	/**	257	/**
269	* Sets the data object to specified value. To be called by the	258	* Sets the data object to specified value. To be called by the
270	* asynchronous method implementor.	259	* asynchronous method implementor.
		260	*
271	* @param data Data value to set.	261	* @param data Data value to set.
272	*/	262	*/
273	public synchronized void setData(T[] data) {
274	fNbRead += data.length;
275	fData = data;
276	}
277
278	/**
279	* Returns the data value, null if not set.
280	*/
281	public synchronized T[] getData() {
282	return fData;
283	}
284
285	/**	263	/**
286	* Handle a block of incoming data. This method is called every time	264	* Handle a block of incoming data. This method is called every time
287	* a block of data becomes available.	265	* a block of data becomes available.
Lines 295-303 Link Here
295	* (or a copy) if some persistence is needed between invocations.	273	* (or a copy) if some persistence is needed between invocations.
296	* - When there is no more data, done() is called.	274	* - When there is no more data, done() is called.
297	*	275	*
298	* @param events - an array of events	276	* @param events - an events
299	*/	277	*/
300	public abstract void handleData();	278	public void handleData(T data) {
		279	if (data != null) {
		280	fNbRead++;
		281	}
		282	}
301		283
302	public void handleStarted() {	284	public void handleStarted() {
303	}	285	}
Lines 356-362 Link Here
356	if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "starting");	338	if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "starting");
357	synchronized(lock) {	339	synchronized(lock) {
358	fRequestRunning = true;	340	fRequestRunning = true;
359	lock.notify();	341	lock.notifyAll();
360	}	342	}
361	handleStarted();	343	handleStarted();
362	if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "started");	344	if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "started");
Lines 373-379 Link Here
373	fRequestCompleted = true;	355	fRequestCompleted = true;
374	}	356	}
375	handleCompleted();	357	handleCompleted();
376	lock.notify();	358	lock.notifyAll();
377	}	359	}
378	}	360	}
379		361
Lines 421-427 Link Here
421	@Override	403	@Override
422	public String toString() {	404	public String toString() {
423	return "[TmfDataRequest(" + fRequestId + "," + fDataType.getSimpleName()	405	return "[TmfDataRequest(" + fRequestId + "," + fDataType.getSimpleName()
424	+ "," + fIndex + "," + fNbRequested + "," + fBlockSize + ")]";	406	+ "," + fIndex + "," + fNbRequested + ")]";
425	}	407	}
426
427	}	408	}

Lines 92-98 Link Here

(-)src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java (-8 / +12 lines)
92		92
93	boolean ok = request.getIndex() == getIndex();	93	boolean ok = request.getIndex() == getIndex();
94	ok &= request.getNbRequested() == getNbRequested();	94	ok &= request.getNbRequested() == getNbRequested();
95	ok &= request.getBlockize() == getBlockize();
96	ok &= request.getExecType() == getExecType();	95	ok &= request.getExecType() == getExecType();
97		96
98	return ok;	97	return ok;
Lines 103-116 Link Here
103	// ------------------------------------------------------------------------	102	// ------------------------------------------------------------------------
104		103
105	@Override	104	@Override
106	public void handleData() {	105	public void handleData(T data) {
107	for (ITmfDataRequest<T> request : fRequests) {	106	super.handleData(data);
108	request.setData(getData());	107	// Don't call sub-requests handleData() unless this is a
109	request.handleData();	108	// TmfCoalescedDataRequest; extended classes should call
110	}	109	// the sub-requests handleData().
		110	if (getClass() == TmfCoalescedDataRequest.class) {
		111	for (ITmfDataRequest<T> request : fRequests) {
		112	request.handleData(data);
		113	}
		114	}
111	}	115	}
112		116
113	@Override	117	@Override
114	public void done() {	118	public void done() {
115	for (ITmfDataRequest<T> request : fRequests) {	119	for (ITmfDataRequest<T> request : fRequests) {
116	request.done();	120	request.done();
Lines 159-165 Link Here
159	@Override	163	@Override
160	public String toString() {	164	public String toString() {
161	return "[TmfCoalescedDataRequest(" + getRequestId() + "," + getDataType().getSimpleName()	165	return "[TmfCoalescedDataRequest(" + getRequestId() + "," + getDataType().getSimpleName()
162	+ "," + getIndex() + "," + getNbRequested() + "," + getBlockize() + ")]";	166	+ "," + getIndex() + "," + getNbRequested() + ")]";
163	}	167	}
164		168
165	}	169	}

Lines 40-51 Link Here

(-)src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java (-4 / +4 lines)
40		40
41	@Override	41	@Override
42	public boolean isCompleted(ITmfDataRequest<T> request, T data, int nbRead) {	42	public boolean isCompleted(ITmfDataRequest<T> request, T data, int nbRead) {
43	boolean dataRequestCompleted = super.isCompleted(request, data, nbRead);	43	boolean requestCompleted = super.isCompleted(request, data, nbRead);
44	if (!dataRequestCompleted && request instanceof ITmfEventRequest<?> && !data.isNullRef()) {	44	if (!requestCompleted && request instanceof ITmfEventRequest<?> && !data.isNullRef()) {
45	TmfTimestamp endTime = ((ITmfEventRequest<?>) request).getRange().getEndTime();	45	TmfTimestamp endTime = ((ITmfEventRequest<?>) request).getRange().getEndTime();
46	return data.getTimestamp().compareTo(endTime, false) > 0;	46	return data.getTimestamp().compareTo(endTime, false) > 0;
47	}	47	}
48	return dataRequestCompleted;	48	return requestCompleted;
49	}	49	}
50		50
51	@Override	51	@Override
Lines 53-59 Link Here
53	if (request instanceof ITmfEventRequest<?>) {	53	if (request instanceof ITmfEventRequest<?>) {
54	ITmfEventRequest<T> eventRequest = (ITmfEventRequest<T>) request;	54	ITmfEventRequest<T> eventRequest = (ITmfEventRequest<T>) request;
55	TmfCoalescedEventRequest<T> coalescedRequest =	55	TmfCoalescedEventRequest<T> coalescedRequest =
56	new TmfCoalescedEventRequest<T>(fType, eventRequest.getRange(), eventRequest.getNbRequested(), eventRequest.getBlockize(), eventRequest.getExecType());	56	new TmfCoalescedEventRequest<T>(fType, eventRequest.getRange(), eventRequest.getNbRequested(), eventRequest.getExecType());
57	coalescedRequest.addRequest(eventRequest);	57	coalescedRequest.addRequest(eventRequest);
58	if (Tracer.isRequestTraced()) {	58	if (Tracer.isRequestTraced()) {
59	Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId());	59	Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId());

Lines 12-18 Link Here

(-)src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java (-80 / +5 lines)
12		12
13	package org.eclipse.linuxtools.tmf.component;	13	package org.eclipse.linuxtools.tmf.component;
14		14
15	import java.lang.reflect.Array;
16	import java.util.Vector;	15	import java.util.Vector;
17	import java.util.concurrent.BlockingQueue;	16	import java.util.concurrent.BlockingQueue;
18	import java.util.concurrent.LinkedBlockingQueue;	17	import java.util.concurrent.LinkedBlockingQueue;
Lines 159-166 Link Here
159		158
160	protected void newCoalescedDataRequest(ITmfDataRequest<T> request) {	159	protected void newCoalescedDataRequest(ITmfDataRequest<T> request) {
161	synchronized(fLock) {	160	synchronized(fLock) {
162	TmfCoalescedDataRequest<T> coalescedRequest =	161	TmfCoalescedDataRequest<T> coalescedRequest = new TmfCoalescedDataRequest<T>(
163	new TmfCoalescedDataRequest<T>(fType, request.getIndex(), request.getNbRequested(), request.getBlockize(), request.getExecType());	162	fType, request.getIndex(), request.getNbRequested(),request.getExecType());
164	coalescedRequest.addRequest(request);	163	coalescedRequest.addRequest(request);
165	if (Tracer.isRequestTraced()) {	164	if (Tracer.isRequestTraced()) {
166	Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId());	165	Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId());
Lines 216-226 Link Here
216		215
217	// Extract the generic information	216	// Extract the generic information
218	request.start();	217	request.start();
219	int blockSize = request.getBlockize();
220	int nbRequested = request.getNbRequested();	218	int nbRequested = request.getNbRequested();
221
222	// Create the result buffer
223	Vector<T> result = new Vector<T>();
224	int nbRead = 0;	219	int nbRead = 0;
225		220
226	// Initialize the execution	221	// Initialize the execution
Lines 238-258 Link Here
238	while (data != null && !isCompleted(request, data, nbRead))	233	while (data != null && !isCompleted(request, data, nbRead))
239	{	234	{
240	if (fLogData) Tracer.traceEvent(provider, request, data);	235	if (fLogData) Tracer.traceEvent(provider, request, data);
241	result.add(data);	236	request.handleData(data);
242	if (++nbRead % blockSize == 0) {	237
243	pushData(request, result);
244	}
245	// To avoid an unnecessary read passed the last data requested	238	// To avoid an unnecessary read passed the last data requested
246	if (nbRead < nbRequested) {	239	if (++nbRead < nbRequested) {
247	data = getNext(context);	240	data = getNext(context);
248	if (Tracer.isRequestTraced() && (data == null \|\| data.isNullRef())) {	241	if (Tracer.isRequestTraced() && (data == null \|\| data.isNullRef())) {
249	Tracer.trace("Request #" + request.getRequestId() + " end of data");	242	Tracer.trace("Request #" + request.getRequestId() + " end of data");
250	}	243	}
251	}	244	}
252	}	245	}
253	if (result.size() > 0) {
254	pushData(request, result);
255	}
256	request.done();	246	request.done();
257		247
258	if (Tracer.isRequestTraced()) Tracer.traceRequest(request, "completed");	248	if (Tracer.isRequestTraced()) Tracer.traceRequest(request, "completed");
Lines 260-266 Link Here
260	catch (Exception e) {	250	catch (Exception e) {
261	if (Tracer.isRequestTraced()) Tracer.traceRequest(request, "exception (failed)");	251	if (Tracer.isRequestTraced()) Tracer.traceRequest(request, "exception (failed)");
262	request.fail();	252	request.fail();
263	// e.printStackTrace();
264	}	253	}
265	}	254	}
266	};	255	};
Lines 276-301 Link Here
276	}	265	}
277		266
278	/**	267	/**
279	* Format the result data and forwards it to the requester.
280	* Note: after handling, the data is removed.
281	*
282	* @param request
283	* @param data
284	*/
285	@SuppressWarnings("unchecked")
286	protected void pushData(ITmfDataRequest<T> request, Vector<T> data) {
287	synchronized(request) {
288	if (!request.isCompleted()) {
289	T[] result = (T[]) Array.newInstance(fType, data.size());
290	data.toArray(result);
291	request.setData(result);
292	request.handleData();
293	data.removeAllElements();
294	}
295	}
296	}
297
298	/**
299	* Initialize the provider based on the request. The context is	268	* Initialize the provider based on the request. The context is
300	* provider specific and will be updated by getNext().	269	* provider specific and will be updated by getNext().
301	*	270	*
Lines 305-354 Link Here
305	public abstract ITmfContext armRequest(ITmfDataRequest<T> request);	274	public abstract ITmfContext armRequest(ITmfDataRequest<T> request);
306	public abstract T getNext(ITmfContext context);	275	public abstract T getNext(ITmfContext context);
307		276
308	// public abstract void queueResult(T data);
309
310	/**
311	* Return the next piece of data based on the context supplied. The context
312	* would typically be updated for the subsequent read.
313	*
314	* @param context
315	* @return
316	*/
317	// private static final int TIMEOUT = 10000;
318	//// public abstract T getNext(ITmfContext context) throws InterruptedException;
319	//// private int getLevel = 0;
320	// public T getNext(ITmfContext context) throws InterruptedException {
321	//// String name = Thread.currentThread().getName(); getLevel++;
322	//// System.out.println("[" + System.currentTimeMillis() + "] " + name + " " + (getLevel) + " getNext() - entering");
323	// T data = fDataQueue.poll(TIMEOUT, TimeUnit.MILLISECONDS);
324	// if (data == null) {
325	//// if (Tracer.isErrorTraced()) Tracer.traceError(getName() + ": Request timeout on read");
326	// throw new InterruptedException();
327	// }
328	//// System.out.println("[" + System.currentTimeMillis() + "] " + name + " " + (getLevel) + " getNext() - leaving");
329	//// getLevel--;
330	// return data;
331	// }
332	//
333	// /**
334	// * Makes the generated result data available for getNext()
335	// *
336	// * @param data
337	// */
338	//// public abstract void queueResult(T data) throws InterruptedException;
339	//// private int putLevel = 0;
340	// public void queueResult(T data) throws InterruptedException {
341	//// String name = Thread.currentThread().getName(); putLevel++;
342	//// System.out.println("[" + System.currentTimeMillis() + "] " + name + " " + (putLevel) + " queueResult() - entering");
343	// boolean ok = fDataQueue.offer(data, TIMEOUT, TimeUnit.MILLISECONDS);
344	// if (!ok) {
345	//// if (Tracer.isErrorTraced()) Tracer.traceError(getName() + ": Request timeout on write");
346	// throw new InterruptedException();
347	// }
348	//// System.out.println("[" + System.currentTimeMillis() + "] " + name + " " + (putLevel) + " queueResult() - leaving");
349	//// putLevel--;
350	// }
351
352	/**	277	/**
353	* Checks if the data meets the request completion criteria.	278	* Checks if the data meets the request completion criteria.
354	*	279	*

Lines 634-669 Link Here

(-)src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java (-62 / +29 lines)
634	fCheckpoints.clear();	634	fCheckpoints.clear();
635		635
636	// fEventLog = openLogFile("TraceEvent.log");	636	// fEventLog = openLogFile("TraceEvent.log");
637	// System.out.println(System.currentTimeMillis() + ": Experiment indexing started");	637	System.out.println(System.currentTimeMillis() + ": Experiment indexing started");
638		638
639	ITmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, TmfTimeRange.Eternity, TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.BACKGROUND) {	639	ITmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, TmfTimeRange.Eternity,
		640	TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.BACKGROUND) {
640		641
641	// long indexingStart = System.nanoTime();	642	long indexingStart = System.nanoTime();
642		643
643	TmfTimestamp startTime = null;	644	TmfTimestamp startTime = null;
644	TmfTimestamp lastTime = null;	645	TmfTimestamp lastTime = null;
645		646
646	@Override	647	@Override
647	public void handleData() {	648	public void handleData(TmfEvent event) {
648	TmfEvent[] events = getData();	649	super.handleData(event);
649	if (events.length > 0) {	650	if (event != null) {
650		651	TmfTimestamp ts = event.getTimestamp();
651	// try {
652	// if (fEventLog != null) {
653	// fEventLog.write(events[0].getTimestamp().toString());
654	// fEventLog.newLine();
655	// fEventLog.flush();
656	// }
657	// } catch (IOException e) {
658	// e.printStackTrace();
659	// }
660
661	TmfTimestamp ts = events[0].getTimestamp();
662	if (startTime == null)	652	if (startTime == null)
663	startTime = new TmfTimestamp(ts);	653	startTime = new TmfTimestamp(ts);
664	lastTime = new TmfTimestamp(ts);	654	lastTime = new TmfTimestamp(ts);
665		655
666	if ((fNbRead % DEFAULT_INDEX_PAGE_SIZE) == 0) {	656	if ((getNbRead() % DEFAULT_INDEX_PAGE_SIZE) == 0) {
667	updateExperiment();	657	updateExperiment();
668	}	658	}
669	}	659	}
Lines 671-703 Link Here
671		661
672	@Override	662	@Override
673	public void handleSuccess() {	663	public void handleSuccess() {
674		664	long indexingEnd = System.nanoTime();
675	// try {
676	// fEventLog.close();
677	// fEventLog = null;
678	// } catch (IOException e) {
679	// e.printStackTrace();
680	// }
681
682	// long indexingEnd = System.nanoTime();
683		665
684	updateExperiment();	666	updateExperiment();
685	// System.out.println(System.currentTimeMillis() + ": Experiment indexing completed");	667	System.out.println(System.currentTimeMillis() + ": Experiment indexing completed");
686	//
687	// long average = (indexingEnd - indexingStart) / fNbEvents;
688	// System.out.println(getName() + ": start=" + startTime + ", end=" + lastTime + ", elapsed=" + (indexingEnd * 1.0 - indexingStart) / 1000000000);
689	// System.out.println(getName() + ": nbEvents=" + fNbEvents + " (" + (average / 1000) + "." + (average % 1000) + " us/evt)");
690		668
691	// for (int i = 0; i < fCheckpoints.size(); i++) {	669	long average = (indexingEnd - indexingStart) / fNbEvents;
692	// TmfCheckpoint checkpoint = fCheckpoints.get(i);	670	System.out.println(getName() + ": start=" + startTime + ", end=" + lastTime + ", elapsed=" + (indexingEnd * 1.0 - indexingStart) / 1000000000);
693	// System.out.println("fCheckpoints[" + i + "] " + checkpoint.getTimestamp() + ", " + checkpoint.getLocation().toString());	671	System.out.println(getName() + ": nbEvents=" + fNbEvents + " (" + (average / 1000) + "." + (average % 1000) + " us/evt)");
694	// }
695	}	672	}
696		673
697	private void updateExperiment() {	674	private void updateExperiment() {
698	if (fNbRead != 0) {	675	int nbRead = getNbRead();
		676	if (nbRead != 0) {
699	fTimeRange = new TmfTimeRange(startTime, new TmfTimestamp(lastTime));	677	fTimeRange = new TmfTimeRange(startTime, new TmfTimestamp(lastTime));
700	fNbEvents = fNbRead;	678	fNbEvents = nbRead;
701	notifyListeners();	679	notifyListeners();
702	}	680	}
703	}	681	}
Lines 746-756 Link Here
746	broadcast(new TmfExperimentUpdatedSignal(this, this)); // , signal.getTrace()));	724	broadcast(new TmfExperimentUpdatedSignal(this, this)); // , signal.getTrace()));
747	}	725	}
748		726
749	// @Override
750	// public void queueResult(T data) {
751	//// super.queueResult(data);
752	// }
753
754	// ------------------------------------------------------------------------	727	// ------------------------------------------------------------------------
755	// TmfDataProvider	728	// TmfDataProvider
756	// ------------------------------------------------------------------------	729	// ------------------------------------------------------------------------
Lines 787-821 Link Here
787	while (!isFinished[0]) {	760	while (!isFinished[0]) {
788		761
789	// TmfEventRequest<T> subRequest = new TmfEventRequest<T>(eventRequest.getDataType(), new TmfTimeRange(timestamp[0], endTS), CHUNK_SIZE[0], eventRequest.getBlockize(), ExecutionType.BACKGROUND)	762	// TmfEventRequest<T> subRequest = new TmfEventRequest<T>(eventRequest.getDataType(), new TmfTimeRange(timestamp[0], endTS), CHUNK_SIZE[0], eventRequest.getBlockize(), ExecutionType.BACKGROUND)
790	TmfDataRequest<T> subRequest = new TmfDataRequest<T>(eventRequest.getDataType(), nbRead[0], CHUNK_SIZE[0], eventRequest.getBlockize(), ExecutionType.BACKGROUND)	763	// TmfDataRequest<T> subRequest = new TmfDataRequest<T>(eventRequest.getDataType(), nbRead[0], CHUNK_SIZE[0], eventRequest.getBlockize(), ExecutionType.BACKGROUND)
		764	TmfDataRequest<T> subRequest = new TmfDataRequest<T>(eventRequest.getDataType(), nbRead[0], CHUNK_SIZE[0], ExecutionType.BACKGROUND)
791	{	765	{
792	// int count = 0;
793	@Override	766	@Override
794	public void handleData() {	767	public void handleData(T data) {
795	T[] data = getData();	768	super.handleData(data);
796	// timestamp[0] = data[data.length-1].getTimestamp();	769	eventRequest.handleData(data);
797	// if (count == 0) {	770	if (getNbRead() == CHUNK_SIZE[0]) {
798	// System.out.println("First event of the block: " + data[0].getTimestamp());	771	nbRead[0] += getNbRead();
799	// }
800	// count++;
801	// Tracer.trace("Ndx: " + ((TmfEvent) data[0]).getTimestamp());
802	eventRequest.setData(data);
803	eventRequest.handleData();
804	if (fNbRead == CHUNK_SIZE[0]) {
805	nbRead[0] += fNbRead;
806	// System.out.println("fNbRead=" + fNbRead + ", count=" + count +", total=" + nbRead[0] + ", TS=" + data[0].getTimestamp());
807	}	772	}
808	if (fNbRead > CHUNK_SIZE[0]) {	773	if (getNbRead() > CHUNK_SIZE[0]) {
809	System.out.println("ERROR - Read too many events");	774	System.out.println("ERROR - Read too many events");
810	}	775	}
811	}	776	}
		777
812	@Override	778	@Override
813	public void handleCompleted() {	779	public void handleCompleted() {
814	// System.out.println("Request completed at: " + timestamp[0]);	780	// System.out.println("Request completed at: " + timestamp[0]);
815	if (fNbRead < CHUNK_SIZE[0]) {	781	if (getNbRead() < CHUNK_SIZE[0]) {
816	eventRequest.done();	782	eventRequest.done();
817	isFinished[0] = Boolean.TRUE;	783	isFinished[0] = Boolean.TRUE;
818	nbRead[0] += fNbRead;	784	nbRead[0] += getNbRead();
819	// System.out.println("fNbRead=" + fNbRead + ", count=" + count +", total=" + nbRead[0]);	785	// System.out.println("fNbRead=" + fNbRead + ", count=" + count +", total=" + nbRead[0]);
820	}	786	}
821	super.handleCompleted();	787	super.handleCompleted();
Lines 845-848 Link Here
845		811
846	thread.start();	812	thread.start();
847	}	813	}
		814
848	}	815	}

Lines 1-3 Link Here

(-)ChangeLog (+12 lines)
		1	2010-09-17 Francois Chouinard <fchouinard@gmail.com>
		2
		3	* src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java: Adjusted to new handleData() API
		4	* src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java: Adjusted to new handleData() API
		5	* src/org/eclipse/linuxtools/tmf/event/TmfEvent.java: Support for single event
		6	* src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java: Adjusted to new handleData() API
		7	* src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java: Adjusted to new handleData() API
		8	* src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java: Adjusted to new handleData() API
		9	* src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java: Adjusted to new handleData() API
		10	* src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java: Adjusted to new handleData() API
		11	* src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java: Adjusted to new handleData() API
		12
1	2010-09-15 Francois Chouinard <fchouinard@gmail.com>	13	2010-09-15 Francois Chouinard <fchouinard@gmail.com>
2		14
3	* src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java: Optimized TmfExperimentContext handling	15	* src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java: Optimized TmfExperimentContext handling

Lines 211-224 Link Here

(-)src/org/eclipse/linuxtools/lttng/LttngTestPreparation.java (-6 / +2 lines)
211		211
212	// request	212	// request
213	validSequence = true;	213	validSequence = true;
214	TmfEventRequest<T> request = new TmfEventRequest<T>(k,	214	TmfEventRequest<T> request = new TmfEventRequest<T>(k, trange, TmfDataRequest.ALL_DATA, DEFAULT_CHUNK) {
215	trange, TmfDataRequest.ALL_DATA, DEFAULT_CHUNK) {
216		215
217	@Override	216	@Override
218	public void handleData() {	217	public void handleData(T event) {
219	T[] result = getData();
220
221	T event = (result.length > 0) ? result[0] : null;
222	if (event == null) {	218	if (event == null) {
223	System.out	219	System.out
224	.println("Syntheric Event Received is null, after event: "	220	.println("Syntheric Event Received is null, after event: "

Lines 12-17 Link Here

(-)src/org/eclipse/linuxtools/lttng/control/LTTngSyntheticEventProviderTest.java (-71 / +68 lines)
12	package org.eclipse.linuxtools.lttng.control;	12	package org.eclipse.linuxtools.lttng.control;
13		13
14	import org.eclipse.linuxtools.lttng.LttngTestPreparation;	14	import org.eclipse.linuxtools.lttng.LttngTestPreparation;
		15	import org.eclipse.linuxtools.lttng.event.LttngEvent;
		16	import org.eclipse.linuxtools.lttng.event.LttngSyntheticEvent;
		17	import org.eclipse.linuxtools.lttng.state.experiment.IStateExperimentManager;
		18	import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
		19	import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
15		20
16	public class LTTngSyntheticEventProviderTest extends LttngTestPreparation {	21	public class LTTngSyntheticEventProviderTest extends LttngTestPreparation {
17	// ========================================================================	22	// ========================================================================
Lines 19-101 Link Here
19	// ========================================================================	24	// ========================================================================
20		25
21	public void testPlainDataRequest() {	26	public void testPlainDataRequest() {
22	// // prepare	27	// prepare
23	// init();	28	init();
24	// TmfExperiment<LttngEvent> experiment = prepareExperimentToTest();	29	TmfExperiment<LttngEvent> experiment = prepareExperimentToTest();
25	// TmfEventRequest<LttngEvent> request = prepareEventRequest(	30	TmfEventRequest<LttngEvent> request = prepareEventRequest(
26	// LttngEvent.class, 0, 31);	31	LttngEvent.class, 0, 31);
27	//	32
28	// // execute	33	// execute
29	// experiment.sendRequest(request);	34	experiment.sendRequest(request);
30	// try {	35	try {
31	// request.waitForCompletion();	36	request.waitForCompletion();
32	// } catch (InterruptedException e) {	37	} catch (InterruptedException e) {
33	// e.printStackTrace();	38	e.printStackTrace();
34	// }	39	}
35	//	40
36	// // finish	41	// finish
37	// assertEquals("Unexpected eventCount", 15316, feventCount);	42	assertEquals("Unexpected eventCount", 15316, feventCount);
38	// boolean expected = true;	43	boolean expected = true;
39	// assertEquals("Events received out of expected order", expected,	44	assertEquals("Events received out of expected order", expected,
40	// validSequence);	45	validSequence);
41	}	46	}
42		47
43	/**	48	/**
44	*	49	*
45	*/	50	*/
46	public void testSyntheticEventRequest() {	51	public void testSyntheticEventRequest() {
47	// init();	52	init();
48	// // Create a new Experiment manager context	53	// Create a new Experiment manager context
49	// IStateExperimentManager expManager = prepareExperimentContext(false);	54	IStateExperimentManager expManager = prepareExperimentContext(false);
50	//	55
51	// // make sure a TmfExperiment instance is registered as provider and	56	// make sure a TmfExperiment instance is registered as provider and
52	// // selected as current	57	// selected as current
53	// TmfExperiment<LttngEvent> experiment = prepareExperimentToTest();	58	TmfExperiment<LttngEvent> experiment = prepareExperimentToTest();
54	//	59
55	// // experiment selected, build experiment selection context and trigger	60	// experiment selected, build experiment selection context and trigger
56	// // check point creation	61	// check point creation
57	// expManager.experimentSelected_prep(experiment);	62	expManager.experimentSelected_prep(experiment);
58	// // builds check points in parallel	63	// builds check points in parallel
59	// expManager.experimentSelected(this, experiment);	64	expManager.experimentSelected(this, experiment);
60	//	65
61	// // Obtain the singleton event provider	66	// Obtain the singleton event provider
62	// LttngSyntheticEventProvider synProvider = LttngCoreProviderFactory	67	LttngSyntheticEventProvider synProvider = LttngCoreProviderFactory
63	// .getEventProvider();	68	.getEventProvider();
64	//	69
65	// // prepare synthetic event requests	70	// prepare synthetic event requests
66	// boolean printExpectedEvents = false;	71	boolean printExpectedEvents = false;
67	// TmfEventRequest<LttngSyntheticEvent> request1 = prepareEventRequest(LttngSyntheticEvent.class, 5, 9,	72	TmfEventRequest<LttngSyntheticEvent> request1 = prepareEventRequest(LttngSyntheticEvent.class, 5, 9,
68	// printExpectedEvents); /* 2001 events */	73	printExpectedEvents); /* 2001 events */
69	// TmfEventRequest<LttngSyntheticEvent> request2 = prepareEventRequest(LttngSyntheticEvent.class, 11, 13,	74	TmfEventRequest<LttngSyntheticEvent> request2 = prepareEventRequest(LttngSyntheticEvent.class, 11, 13,
70	// printExpectedEvents); /* 1001 events */	75	printExpectedEvents); /* 1001 events */
71	//	76
72	// // execute	77	// execute
73	// synProvider.sendRequest(request1);	78	synProvider.sendRequest(request1);
74	// try {	79	try {
75	// request1.waitForCompletion();	80	request1.waitForCompletion();
76	// } catch (InterruptedException e) {	81	} catch (InterruptedException e) {
77	// e.printStackTrace();	82	e.printStackTrace();
78	// }	83	}
79	// System.out.println("EventCount " + feventCount);	84	System.out.println("EventCount " + feventCount);
80	//	85
81	// synProvider.sendRequest(request2);	86	synProvider.sendRequest(request2);
82	// try {	87	try {
83	// request2.waitForCompletion();	88	request2.waitForCompletion();
84	// } catch (InterruptedException e) {	89	} catch (InterruptedException e) {
85	// e.printStackTrace();	90	e.printStackTrace();
86	// }	91	}
87	// System.out.println("EventCount " + feventCount);	92	System.out.println("EventCount " + feventCount);
88	//	93
89	//// try {	94	// finish
90	//// request1.waitForCompletion();	95	assertEquals("Unexpected eventCount", 3002, feventCount);
91	//// request2.waitForCompletion();
92	//// } catch (InterruptedException e) {
93	//// e.printStackTrace();
94	//// }
95	//// System.out.println("EventCount " + feventCount);
96	//
97	// // finish
98	// assertEquals("Unexpected eventCount", 3002, feventCount);
99	}	96	}
100		97
101	}	98	}