tmf: only dispatch events to relevant event providers

When coalescing request across event providers (e.g. Experiment and
traces) then the requests done on the traces are not interested
in events from other requests. Before this patch each implementation
of handleData() had to do this.

Change-Id: I1482c79ef3a0359b9b3526212c4555b57c102650
Signed-off-by: Bernd Hufmann <Bernd.Hufmann@ericsson.com>
Signed-off-by: Matthew Khouzam <matthew.khouzam@ericsson.com>
Reviewed-on: https://git.eclipse.org/r/35969
Reviewed-by: Hudson CI
Reviewed-by: Bernd Hufmann <bernd.hufmann@ericsson.com>
Tested-by: Bernd Hufmann <bernd.hufmann@ericsson.com>

diff --git a/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/component/TmfEventProviderCoalescingTest.java b/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/component/TmfEventProviderCoalescingTest.java
index 2c96401c8cc45f42bdd4db94d3eb6a519b42ad44..baa4893a3f86fdf9372581a979395263c0453a14 100644 (file)
--- a/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/component/TmfEventProviderCoalescingTest.java
+++ b/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/component/TmfEventProviderCoalescingTest.java
@@ -13,8 +13,12 @@
 package org.eclipse.tracecompass.tmf.core.tests.component;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 import org.eclipse.tracecompass.internal.tmf.core.request.TmfCoalescedEventRequest;
 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
@@ -24,6 +28,7 @@ import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
 import org.eclipse.tracecompass.tmf.core.signal.TmfEndSynchSignal;
 import org.eclipse.tracecompass.tmf.core.signal.TmfStartSynchSignal;
 import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestTrace;
+import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
 import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfExperimentStub;
 import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
@@ -86,7 +91,6 @@ public class TmfEventProviderCoalescingTest {
         TmfEventRequest.reset();
     }
 
-
     /**
      * Test clean-up
      * @throws Exception if an error occurred
@@ -99,11 +103,11 @@ public class TmfEventProviderCoalescingTest {
         clearPendingRequests();
     }
 
-    // ------------------------------------------------------------------------
-    // Test coalescing across providers - parent request is send first
-    // ------------------------------------------------------------------------
-
     /**
+     * Verify coalescing across providers where a parent request is sent first
+     * before the children requests. All requests are coalesced at the top
+     * level parent.
+     *
      * @throws Exception if an error occurred
      */
     @Test
@@ -127,10 +131,11 @@ public class TmfEventProviderCoalescingTest {
         assertEquals("[0, 1, 2]", coalescedRequest.getSubRequestIds());
     }
 
-    // ------------------------------------------------------------------------
-    // Test coalescing across providers - children requests are send first
-    // ------------------------------------------------------------------------
     /**
+     * Verify coalescing across providers where requests from multiple children
+     * are sent first before the parent request. All requests are coalesced at
+     * the top level parent.
+     *
      * @throws Exception if an error occurred
      */
     @Test
@@ -142,19 +147,46 @@ public class TmfEventProviderCoalescingTest {
         fTmfTrace2.sendRequest(trace2Req);
         fExperiment.sendRequest(expReq);
 
+        // Create expected coalesced request to compare with
+        TmfCoalescedEventRequest expected = new TmfCoalescedEventRequest(ITmfEvent.class, TmfTimeRange.ETERNITY, 0, ITmfEventRequest.ALL_DATA, ExecutionType.BACKGROUND);
+        expected.addRequest(expReq);
+        expected.addRequest(trace1Req);
+        expected.addRequest(trace2Req);
+
         // Verify that requests are coalesced properly with the experiment request
         List<TmfCoalescedEventRequest> pending = fExperiment.getAllPendingRequests();
-
         assertEquals(1, pending.size());
 
         assertEquals(0, fTmfTrace1.getAllPendingRequests().size());
         assertEquals(0, fTmfTrace2.getAllPendingRequests().size());
 
         TmfCoalescedEventRequest coalescedRequest = pending.get(0);
-        assertEquals("[0, 3, 4]", coalescedRequest.getSubRequestIds());
+        assertEquals(expected, coalescedRequest);
+
+        // Now trigger manually the sending of the request
+        fExperiment.notifyPendingRequest(false);
+
+        try {
+            expReq.waitForCompletion();
+        } catch (InterruptedException e) {
+        }
+
+        // Verify that requests only received events from the relevant traces
+        assertTrue(expReq.isTraceHandled(fTmfTrace1));
+        assertTrue(expReq.isTraceHandled(fTmfTrace2));
+
+        assertTrue(trace1Req.isTraceHandled(fTmfTrace1));
+        assertFalse(trace1Req.isTraceHandled(fTmfTrace2));
+
+        assertFalse(trace2Req.isTraceHandled(fTmfTrace1));
+        assertTrue(trace2Req.isTraceHandled(fTmfTrace2));
     }
 
     /**
+     * Verify coalescing across providers (2 level deep) where requests from
+     * multiple children (leafs) are sent first before the parent requests.
+     * All requests are coalesced at the top level parent.
+     *
      * @throws Exception if an error occurred
      */
     @Test
@@ -170,6 +202,14 @@ public class TmfEventProviderCoalescingTest {
         fExperiment2.sendRequest(exp2Req);
         fExperiment.sendRequest(expReq);
 
+        // Create expected coalesced request to compare with
+        TmfCoalescedEventRequest expected = new TmfCoalescedEventRequest(ITmfEvent.class, TmfTimeRange.ETERNITY, 0, ITmfEventRequest.ALL_DATA, ExecutionType.BACKGROUND);
+        expected.addRequest(expReq);
+        expected.addRequest(trace1Req);
+        expected.addRequest(trace2Req);
+        expected.addRequest(exp2Req);
+        expected.addRequest(trace3Req);
+
         // Verify that requests are coalesced properly with the experiment request
         List<TmfCoalescedEventRequest> pending = fExperiment.getAllPendingRequests();
         assertEquals(1, pending.size());
@@ -178,10 +218,43 @@ public class TmfEventProviderCoalescingTest {
         assertEquals(0, fTmfTrace2.getAllPendingRequests().size());
 
         TmfCoalescedEventRequest coalescedRequest = pending.get(0);
-        assertEquals("[0, 5, 6, 8]", coalescedRequest.getSubRequestIds());
+        assertEquals(expected, coalescedRequest);
+
+        // Now trigger manually the sending of the request
+        fExperiment.notifyPendingRequest(false);
+
+        try {
+            expReq.waitForCompletion();
+        } catch (InterruptedException e) {
+        }
+
+        // Verify that requests only received events from the relevant traces
+        assertTrue(expReq.isTraceHandled(fTmfTrace1));
+        assertTrue(expReq.isTraceHandled(fTmfTrace2));
+        assertTrue(expReq.isTraceHandled(fTmfTrace3));
+
+        assertFalse(exp2Req.isTraceHandled(fTmfTrace1));
+        assertFalse(exp2Req.isTraceHandled(fTmfTrace2));
+        assertTrue(exp2Req.isTraceHandled(fTmfTrace3));
+
+        assertTrue(trace1Req.isTraceHandled(fTmfTrace1));
+        assertFalse(trace1Req.isTraceHandled(fTmfTrace2));
+        assertFalse(trace1Req.isTraceHandled(fTmfTrace3));
+
+        assertFalse(trace2Req.isTraceHandled(fTmfTrace1));
+        assertTrue(trace2Req.isTraceHandled(fTmfTrace2));
+        assertFalse(trace2Req.isTraceHandled(fTmfTrace3));
+
+        assertFalse(trace3Req.isTraceHandled(fTmfTrace1));
+        assertFalse(trace3Req.isTraceHandled(fTmfTrace2));
+        assertTrue(trace3Req.isTraceHandled(fTmfTrace3));
     }
 
     /**
+     * Verify coalescing across providers where requests from the parent and
+     * children are sent in mixed order. All requests are coalesced at the
+     * top level parent.
+     *
      * @throws Exception if an error occurred
      */
     @Test
@@ -193,18 +266,115 @@ public class TmfEventProviderCoalescingTest {
         fExperiment.sendRequest(expReq);
         fTmfTrace2.sendRequest(trace2Req);
 
+        // Create expected coalesced request to compare with
+        TmfCoalescedEventRequest expected = new TmfCoalescedEventRequest(ITmfEvent.class, TmfTimeRange.ETERNITY, 0, ITmfEventRequest.ALL_DATA, ExecutionType.BACKGROUND);
+        expected.addRequest(expReq);
+        expected.addRequest(trace1Req);
+        expected.addRequest(trace2Req);
+
+        // Verify that requests are coalesced properly with the experiment request
+        List<TmfCoalescedEventRequest> pending = fExperiment.getAllPendingRequests();
+        assertEquals(1, pending.size());
+
+        assertEquals(0, fTmfTrace1.getAllPendingRequests().size());
+        assertEquals(0, fTmfTrace2.getAllPendingRequests().size());
+
+        TmfCoalescedEventRequest coalescedRequest = pending.get(0);
+        assertEquals(expected, coalescedRequest);
+
+        // Now trigger manually the sending of the request
+        fExperiment.notifyPendingRequest(false);
+
+        try {
+            expReq.waitForCompletion();
+        } catch (InterruptedException e) {
+        }
+
+        // Verify that requests only received events from the relevant traces
+        assertTrue(expReq.isTraceHandled(fTmfTrace1));
+        assertTrue(expReq.isTraceHandled(fTmfTrace2));
+
+        assertTrue(trace1Req.isTraceHandled(fTmfTrace1));
+        assertFalse(trace1Req.isTraceHandled(fTmfTrace2));
+
+        assertFalse(trace2Req.isTraceHandled(fTmfTrace1));
+        assertTrue(trace2Req.isTraceHandled(fTmfTrace2));
+    }
+
+    /**
+     * Verify coalescing across multi-level providers where requests from the
+     * parent and children are sent in mixed order. All requests are coalesced
+     * at the top level parent.
+     *
+     * @throws Exception if an error occurred
+     */
+    @Test
+    public void testMixedCoalescing2() throws Exception {
+        InnerEventRequest expReq = new InnerEventRequest(ITmfEvent.class, 0, ITmfEventRequest.ALL_DATA, ExecutionType.BACKGROUND);
+        InnerEventRequest exp2Req = new InnerEventRequest(ITmfEvent.class, 0, ITmfEventRequest.ALL_DATA, ExecutionType.BACKGROUND);
+        InnerEventRequest trace1Req = new InnerEventRequest(ITmfEvent.class, 0, ITmfEventRequest.ALL_DATA, ExecutionType.BACKGROUND);
+        InnerEventRequest trace2Req = new InnerEventRequest(ITmfEvent.class, 0, ITmfEventRequest.ALL_DATA, ExecutionType.BACKGROUND);
+        InnerEventRequest trace3Req = new InnerEventRequest(ITmfEvent.class, 0, ITmfEventRequest.ALL_DATA, ExecutionType.BACKGROUND);
+        fExperiment2.sendRequest(exp2Req);
+        fExperiment.sendRequest(expReq);
+        fTmfTrace1.sendRequest(trace1Req);
+        fTmfTrace2.sendRequest(trace2Req);
+        fTmfTrace3.sendRequest(trace3Req);
+
+        // Create expected coalesced request to compare with
+        TmfCoalescedEventRequest expected = new TmfCoalescedEventRequest(ITmfEvent.class, TmfTimeRange.ETERNITY, 0, ITmfEventRequest.ALL_DATA, ExecutionType.BACKGROUND);
+        expected.addRequest(expReq);
+        expected.addRequest(exp2Req);
+        expected.addRequest(trace1Req);
+        expected.addRequest(trace2Req);
+        expected.addRequest(trace3Req);
+
         // Verify that requests are coalesced properly with the experiment request
         List<TmfCoalescedEventRequest> pending = fExperiment.getAllPendingRequests();
         assertEquals(1, pending.size());
 
         assertEquals(0, fTmfTrace1.getAllPendingRequests().size());
         assertEquals(0, fTmfTrace2.getAllPendingRequests().size());
+        assertEquals(0, fTmfTrace3.getAllPendingRequests().size());
 
         TmfCoalescedEventRequest coalescedRequest = pending.get(0);
-        assertEquals("[0, 3, 2]", coalescedRequest.getSubRequestIds());
+        assertEquals(expected, coalescedRequest);
+
+        // Now trigger manually the sending of the request
+        fExperiment.notifyPendingRequest(false);
+
+        try {
+            expReq.waitForCompletion();
+        } catch (InterruptedException e) {
+        }
+
+        // Verify that requests only received events from the relevant traces
+        assertTrue(expReq.isTraceHandled(fTmfTrace1));
+        assertTrue(expReq.isTraceHandled(fTmfTrace2));
+        assertTrue(expReq.isTraceHandled(fTmfTrace3));
+
+        assertFalse(exp2Req.isTraceHandled(fTmfTrace1));
+        assertFalse(exp2Req.isTraceHandled(fTmfTrace2));
+        assertTrue(exp2Req.isTraceHandled(fTmfTrace3));
+
+        assertTrue(trace1Req.isTraceHandled(fTmfTrace1));
+        assertFalse(trace1Req.isTraceHandled(fTmfTrace2));
+        assertFalse(trace1Req.isTraceHandled(fTmfTrace3));
+
+        assertFalse(trace2Req.isTraceHandled(fTmfTrace1));
+        assertTrue(trace2Req.isTraceHandled(fTmfTrace2));
+        assertFalse(trace2Req.isTraceHandled(fTmfTrace3));
+
+        assertFalse(trace3Req.isTraceHandled(fTmfTrace1));
+        assertFalse(trace3Req.isTraceHandled(fTmfTrace2));
+        assertTrue(trace3Req.isTraceHandled(fTmfTrace3));
     }
 
     /**
+     * Verify coalescing across multi-level providers where requests from the
+     * parent and children are sent in mixed order. Each provider sends
+     * multiple requests. All requests are coalesced at the top level parent.
+     *
      * @throws Exception if an error occurred
      */
     @Test
@@ -221,6 +391,14 @@ public class TmfEventProviderCoalescingTest {
         fTmfTrace2.sendRequest(trace2Req);
         fExperiment.sendRequest(expReq2);
 
+        // Create expected coalesced request to compare with
+        TmfCoalescedEventRequest expected = new TmfCoalescedEventRequest(ITmfEvent.class, TmfTimeRange.ETERNITY, 0, ITmfEventRequest.ALL_DATA, ExecutionType.BACKGROUND);
+        expected.addRequest(expReq);
+        expected.addRequest(trace1Req);
+        expected.addRequest(trace1Req2);
+        expected.addRequest(trace2Req);
+        expected.addRequest(expReq2);
+
         // Verify that requests are coalesced properly with the experiment request
         List<TmfCoalescedEventRequest> pending = fExperiment.getAllPendingRequests();
         assertEquals(1, pending.size());
@@ -231,10 +409,34 @@ public class TmfEventProviderCoalescingTest {
         assertEquals(0, fExperiment2.getAllPendingRequests().size());
 
         TmfCoalescedEventRequest coalescedRequest = pending.get(0);
-        assertEquals("[0, 5, 4, 1]", coalescedRequest.getSubRequestIds());
+        assertEquals(expected, coalescedRequest);
         sendSync(false);
+
+        try {
+            expReq.waitForCompletion();
+        } catch (InterruptedException e) {
+        }
+
+        assertTrue(expReq.isTraceHandled(fTmfTrace1));
+        assertTrue(expReq.isTraceHandled(fTmfTrace2));
+        assertTrue(expReq.isTraceHandled(fTmfTrace3));
+
+        assertTrue(expReq2.isTraceHandled(fTmfTrace1));
+        assertTrue(expReq2.isTraceHandled(fTmfTrace2));
+        assertTrue(expReq2.isTraceHandled(fTmfTrace3));
+
+        assertTrue(trace1Req.isTraceHandled(fTmfTrace1));
+        assertFalse(trace1Req.isTraceHandled(fTmfTrace2));
+        assertFalse(trace1Req.isTraceHandled(fTmfTrace3));
+
+        assertFalse(trace2Req.isTraceHandled(fTmfTrace1));
+        assertTrue(trace2Req.isTraceHandled(fTmfTrace2));
+        assertFalse(trace2Req.isTraceHandled(fTmfTrace3));
     }
 
+    // ------------------------------------------------------------------------
+    // Helper methods
+    // ------------------------------------------------------------------------
     private static void sendSync(boolean isStart) {
         if (isStart) {
             TmfStartSynchSignal signal = new TmfStartSynchSignal(0);
@@ -271,9 +473,22 @@ public class TmfEventProviderCoalescingTest {
     }
 
     private static class InnerEventRequest extends TmfEventRequest {
+        private Set<String> traces = new HashSet<>();
+
         public InnerEventRequest(Class<? extends ITmfEvent> dataType, long index, int nbRequested, ExecutionType priority) {
             super(dataType, index, nbRequested, priority);
         }
-    }
 
+        @Override
+        public void handleData(ITmfEvent event) {
+            super.handleData(event);
+            if (!traces.contains(event.getTrace().getName())) {
+                traces.add(event.getTrace().getName());
+            }
+        }
+
+        public boolean isTraceHandled(ITmfTrace trace) {
+            return traces.contains(trace.getName());
+        }
+    }
 }

diff --git a/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/component/TmfEventProviderStub.java b/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/component/TmfEventProviderStub.java
index 1be4e0b1ca5c0c9cb338720eaa1dd12f8641cb06..7897e02884278bc2982daeedb8c086bb8b71f764 100644 (file)
--- a/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/component/TmfEventProviderStub.java
+++ b/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/component/TmfEventProviderStub.java
@@ -76,4 +76,9 @@ public class TmfEventProviderStub extends TmfEventProvider {
         return fTrace.getNext(context);
     }
 
+    @Override
+    public boolean providesEvent(ITmfEvent event) {
+        return (super.providesEvent(event) || event.getTrace() == fTrace);
+    }
+
 }

diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/internal/tmf/core/request/TmfCoalescedEventRequest.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/internal/tmf/core/request/TmfCoalescedEventRequest.java
index 6857faaf5612d60d6e914b8644b5609d6689af45..c7701113b6a68de3f1bacac539d583d57ad150ca 100644 (file)
--- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/internal/tmf/core/request/TmfCoalescedEventRequest.java
+++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/internal/tmf/core/request/TmfCoalescedEventRequest.java
@@ -9,12 +9,17 @@
  * Contributors:
  *   Francois Chouinard - Initial API and implementation
  *   Alexandre Montplaisir - Merge with TmfCoalescedDataRequest
+ *   Bernd Hufmann - Updated dispatching of events and added requests cache
  *******************************************************************************/
 
 package org.eclipse.tracecompass.internal.tmf.core.request;
 
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import org.eclipse.tracecompass.internal.tmf.core.TmfCoreTracer;
 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
@@ -44,6 +49,11 @@ public class TmfCoalescedEventRequest extends TmfEventRequest {
      */
     private TmfTimeRange fRange;
 
+    /**
+     * The requests cache to avoid iterating over all requests for each event.
+     */
+    private Map<String, Set<ITmfEventRequest>> fRequestsCache = new HashMap<>();
+
     // ------------------------------------------------------------------------
     // Constructor
     // ------------------------------------------------------------------------
@@ -103,8 +113,17 @@ public class TmfCoalescedEventRequest extends TmfEventRequest {
      *            The request to add
      */
     public void addRequest(ITmfEventRequest request) {
-        fRequests.add(request);
-        merge(request);
+        // If it is a coalesced request only add the sub-requests
+        if (request instanceof TmfCoalescedEventRequest) {
+            TmfCoalescedEventRequest otherRequest = (TmfCoalescedEventRequest)request;
+            for (ITmfEventRequest subRequest : otherRequest.fRequests) {
+                fRequests.add(subRequest);
+                merge(subRequest);
+            }
+        } else {
+            fRequests.add(request);
+            merge(request);
+        }
     }
 
     /**
@@ -189,8 +208,25 @@ public class TmfCoalescedEventRequest extends TmfEventRequest {
     @Override
     public void handleData(ITmfEvent data) {
         super.handleData(data);
+
         long index = getIndex() + getNbRead() - 1;
-        for (ITmfEventRequest request : fRequests) {
+
+        String traceName = data.getTrace().getName();
+        Set<ITmfEventRequest> requests = fRequestsCache.get(traceName);
+
+        if (requests == null) {
+            // Populate requests cache
+            requests = new HashSet<>();
+            for (ITmfEventRequest myRequest : fRequests) {
+                if (myRequest.getEventProvider().providesEvent(data)) {
+                    requests.add(myRequest);
+                }
+            }
+            fRequestsCache.put(traceName, requests);
+        }
+
+        // dispatch event to relevant requests
+        for (ITmfEventRequest request : requests) {
             long start = request.getIndex();
             if (!request.isCompleted() && index >= start && request.getNbRead() < request.getNbRequested()) {
                 ITmfTimestamp ts = data.getTimestamp();

diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/component/ITmfEventProvider.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/component/ITmfEventProvider.java
index 4db60e89e6b3f47e16921b51e31fef68f197b3c7..55164b376a79a2b4c4da8046697f1b0c4a8d5e97 100644 (file)
--- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/component/ITmfEventProvider.java
+++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/component/ITmfEventProvider.java
@@ -130,4 +130,15 @@ public interface ITmfEventProvider extends ITmfComponent {
      * @return number of children
      */
     int getNbChildren();
+
+    /**
+     * Returns true if an event was provided by this event provider or one of
+     * its children event providers else false.
+     *
+     * @param event
+     *            the event to check
+     * @return <code>true</code> if event was provided by this provider or one
+     *         of its children else <code>false</code>
+     */
+    boolean providesEvent(ITmfEvent event);
 }

diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/component/TmfEventProvider.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/component/TmfEventProvider.java
index 202e2bde571d1d653b4c673fb0f3e3a4660dfb6a..71f31be36eec16f6bf8399e68b9d7debdb936c36 100644 (file)
--- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/component/TmfEventProvider.java
+++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/component/TmfEventProvider.java
@@ -192,6 +192,10 @@ public abstract class TmfEventProvider extends TmfComponent implements ITmfEvent
                 TmfCoreTracer.traceRequest(request.getRequestId(), "SENT to provider " + getName()); //$NON-NLS-1$
             }
 
+            if (request.getEventProvider() == null) {
+                request.setEventProvider(this);
+            }
+
             if (sendWithParent(request)) {
                 return;
             }
@@ -272,6 +276,7 @@ public abstract class TmfEventProvider extends TmfComponent implements ITmfEvent
                 // fire request if all pending requests are received
                 if (fRequestPendingCounter == 0) {
                     fireRequest(false);
+                    fireRequest(true);
                 }
             }
         }
@@ -298,6 +303,7 @@ public abstract class TmfEventProvider extends TmfComponent implements ITmfEvent
                     request.getNbRequested(),
                     request.getExecType());
             coalescedRequest.addRequest(request);
+            coalescedRequest.setEventProvider(this);
             if (TmfCoreTracer.isRequestTraced()) {
                 TmfCoreTracer.traceRequest(request.getRequestId(), "COALESCED with " + coalescedRequest.getRequestId()); //$NON-NLS-1$
                 TmfCoreTracer.traceRequest(coalescedRequest.getRequestId(), "now contains " + coalescedRequest.getSubRequestIds()); //$NON-NLS-1$
@@ -576,6 +582,24 @@ public abstract class TmfEventProvider extends TmfComponent implements ITmfEvent
         return fChildren.size();
     }
 
+    @Override
+    public boolean providesEvent(ITmfEvent event) {
+        if ((event.getTrace() == this)) {
+            return true;
+        }
+        if (fChildren.size() > 0) {
+            synchronized (fLock) {
+                List <TmfEventProvider> children = getChildren(TmfEventProvider.class);
+                for (TmfEventProvider child : children) {
+                    if (child.providesEvent(event)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
     // ------------------------------------------------------------------------
     // Debug code (will also used in tests using reflection)
     // ------------------------------------------------------------------------

diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/request/ITmfEventRequest.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/request/ITmfEventRequest.java
index 646205231ec6a0f34ff9c111b13537501377ddc6..bc66484d5181f3fc1345db6a3dbf70f04d5cb0be 100644 (file)
--- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/request/ITmfEventRequest.java
+++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/request/ITmfEventRequest.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2009, 2013 Ericsson
+ * Copyright (c) 2009, 2014 Ericsson
  *
  * All rights reserved. This program and the accompanying materials are
  * made available under the terms of the Eclipse Public License v1.0 which
@@ -14,6 +14,7 @@
 package org.eclipse.tracecompass.tmf.core.request;
 
 import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.tmf.core.component.ITmfEventProvider;
 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
 
@@ -85,6 +86,21 @@ public interface ITmfEventRequest {
      */
     TmfTimeRange getRange();
 
+    /**
+     * @return the event provider that the request is sent initially.
+     * @since 3.0
+     */
+    ITmfEventProvider getEventProvider();
+
+    /**
+     * Sets the event provider that the request is sent initially.
+     *
+     * @param provider
+     *            event provider to set
+     * @since 3.0
+     */
+    void setEventProvider(ITmfEventProvider provider);
+
     // ------------------------------------------------------------------------
     // Request state predicates
     // ------------------------------------------------------------------------

diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/request/TmfEventRequest.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/request/TmfEventRequest.java
index 4ef3f88037448b814499e0a0cb0cd2fd62032b96..a01efe483d6f04f2964c780aac9abf4012701520 100644 (file)
--- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/request/TmfEventRequest.java
+++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/request/TmfEventRequest.java
@@ -16,6 +16,7 @@ package org.eclipse.tracecompass.tmf.core.request;
 import java.util.concurrent.CountDownLatch;
 
 import org.eclipse.tracecompass.internal.tmf.core.TmfCoreTracer;
+import org.eclipse.tracecompass.tmf.core.component.ITmfEventProvider;
 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
 
@@ -101,6 +102,8 @@ public abstract class TmfEventRequest implements ITmfEventRequest {
     private boolean fRequestFailed;
     private boolean fRequestCanceled;
 
+    private ITmfEventProvider fEventProvider;
+
     // ------------------------------------------------------------------------
     // Constructors
     // ------------------------------------------------------------------------
@@ -252,6 +255,22 @@ public abstract class TmfEventRequest implements ITmfEventRequest {
         return fRange;
     }
 
+    /**
+     * @since 3.0
+     */
+    @Override
+    public ITmfEventProvider getEventProvider() {
+        return fEventProvider;
+    }
+
+    /**
+     * @since 3.0
+     */
+    @Override
+    public void setEventProvider(ITmfEventProvider provider) {
+        fEventProvider = provider;
+    }
+
     // ------------------------------------------------------------------------
     // Setters
     // ------------------------------------------------------------------------