tmf.core: Add a dependency level to analyses

This dependency level can then be used by event requests

Change-Id: Ia359fe367b03e99d84b6cf9e213dba6f019981df
Signed-off-by: Geneviève Bastien <gbastien+lttng@versatic.net>
Reviewed-on: https://git.eclipse.org/r/71540
Tested-by: Bernd Hufmann <bernd.hufmann@ericsson.com>
Reviewed-by: Hudson CI
Reviewed-by: Bernd Hufmann <bernd.hufmann@ericsson.com>

diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleTest.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleTest.java
index ed725db4dacb131b284f66099c128806580ab11a..35001d5e87e2ca2b5935860a6fddd8c365148f0a 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleTest.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleTest.java
@@ -43,6 +43,8 @@ import org.junit.Test;
 import org.junit.rules.TestRule;
 import org.junit.rules.Timeout;
 
+import com.google.common.collect.ImmutableSet;
+
 /**
  * Test suite for the {@link TmfAbstractAnalysisModule} class
  */
@@ -84,6 +86,8 @@ public class AnalysisModuleTest {
         module.setParameter(TestAnalysis.PARAM_TEST, 1);
         assertEquals(1, module.getParameter(TestAnalysis.PARAM_TEST));
 
+        assertEquals(0, module.getDependencyLevel());
+
         /* Try to set and get wrong parameter */
         String wrongParam = "abc";
         Exception exception = null;
@@ -365,9 +369,82 @@ public class AnalysisModuleTest {
         /* Make sure the dependent analysis has run and completed */
         assertEquals(paramAndResult, depModule.getAnalysisOutput());
 
+        /* Check the dependency level of both analyses */
+        assertEquals(0, depModule.getDependencyLevel());
+        assertEquals(1, module.getDependencyLevel());
+
         module.dispose();
         depModule.dispose();
         trace.dispose();
 
     }
+
+    /**
+     * Test that the dependency level is consistent with a case where
+     * B depends on A, and C depends on A and B
+     */
+    @Test
+    public void testMultipleDependencies() {
+
+        ITmfTrace trace = TmfTestTrace.A_TEST_10K.getTrace();
+
+        /* Prepare module A with no dependency */
+        IAnalysisModule moduleA = new TestAnalysis();
+        moduleA.setName(MODULE_GENERIC_NAME);
+        moduleA.setId(MODULE_GENERIC_ID);
+        moduleA.addParameter(TestAnalysis.PARAM_TEST);
+        moduleA.setParameter(TestAnalysis.PARAM_TEST, 1);
+
+        /* Prepare module B depending on A */
+        String suffix = " B";
+        IAnalysisModule moduleB = new TestAnalysis() {
+
+            @Override
+            protected Iterable<IAnalysisModule> getDependentAnalyses() {
+                return ImmutableSet.of(moduleA);
+            }
+
+        };
+        moduleB.setName(MODULE_GENERIC_NAME + suffix);
+        moduleB.setId(MODULE_GENERIC_ID + suffix);
+        moduleB.addParameter(TestAnalysis.PARAM_TEST);
+        moduleB.setParameter(TestAnalysis.PARAM_TEST, 1);
+
+        /* Prepare module C depending on A and B */
+        suffix = " C";
+        IAnalysisModule moduleC = new TestAnalysis() {
+
+            @Override
+            protected Iterable<IAnalysisModule> getDependentAnalyses() {
+                return ImmutableSet.of(moduleA, moduleB);
+            }
+
+        };
+        moduleC.setName(MODULE_GENERIC_NAME + suffix);
+        moduleC.setId(MODULE_GENERIC_ID + suffix);
+        moduleC.addParameter(TestAnalysis.PARAM_TEST);
+        moduleC.setParameter(TestAnalysis.PARAM_TEST, 1);
+
+        try {
+            assertTrue(moduleA.setTrace(trace));
+            assertTrue(moduleB.setTrace(trace));
+            assertTrue(moduleC.setTrace(trace));
+        } catch (TmfAnalysisException e) {
+            fail(e.getMessage());
+        }
+
+        moduleC.schedule();
+        assertTrue(moduleC.waitForCompletion());
+
+        /* Check the dependency level of the analyses */
+        assertEquals(0, moduleA.getDependencyLevel());
+        assertEquals(1, moduleB.getDependencyLevel());
+        assertEquals(3, moduleC.getDependencyLevel());
+
+        moduleA.dispose();
+        moduleB.dispose();
+        moduleC.dispose();
+        trace.dispose();
+
+    }
 }

diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/IAnalysisModule.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/IAnalysisModule.java
index 0c6a34f79f11cb4e14865c74777b650190d65b9c..c44a8a254ee2ef72348b958d0bce5956f4cf645f 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/IAnalysisModule.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/IAnalysisModule.java
@@ -136,6 +136,19 @@ public interface IAnalysisModule extends ITmfComponent, IAnalysisRequirementProv
      */
     @Nullable Object getParameter(@NonNull String name);
 
+    /**
+     * Get the level of dependencies on other analyses that this analysis has.
+     * Typically, it would be equal to the number of dependent analyses. An
+     * analysis with no dependence would have a level of 0. This value can be
+     * used for the dependency level of event requests.
+     *
+     * @return The dependency level of this analysis
+     * @since 2.0
+     */
+    default int getDependencyLevel() {
+        return 0;
+    }
+
     // -----------------------------------------------------
     // Functionalities
     // -----------------------------------------------------

diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAbstractAnalysisModule.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAbstractAnalysisModule.java
index 8107f3ddf657400507942652a3ed72ab2da632a1..0031c70439b5b2660ad4e8ec0396b31b5af895a1 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAbstractAnalysisModule.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAbstractAnalysisModule.java
@@ -66,6 +66,7 @@ public abstract class TmfAbstractAnalysisModule extends TmfComponent
     private final List<IAnalysisOutput> fOutputs = new ArrayList<>();
     private Set<IAnalysisParameterProvider> fParameterProviders = new HashSet<>();
     private @Nullable Job fJob = null;
+    private int fDependencyLevel = 0;
 
     private final Object syncObj = new Object();
 
@@ -292,6 +293,14 @@ public abstract class TmfAbstractAnalysisModule extends TmfComponent
         return Collections.EMPTY_LIST;
     }
 
+    /**
+     * @since 2.0
+     */
+    @Override
+    public int getDependencyLevel() {
+        return fDependencyLevel;
+    }
+
     private void execute(final ITmfTrace trace) {
         /*
          * TODO: The analysis in a job should be done at the analysis manager
@@ -316,9 +325,14 @@ public abstract class TmfAbstractAnalysisModule extends TmfComponent
 
         /* Execute dependent analyses before creating the job for this one */
         final Iterable<IAnalysisModule> dependentAnalyses = getDependentAnalyses();
+        int depLevel = 0;
         for (IAnalysisModule module : dependentAnalyses) {
             module.schedule();
+            // Add the dependency level of the analysis + 1 to make sure that if
+            // an analysis already depends on another, it is taken into account
+            depLevel += module.getDependencyLevel() + 1;
         }
+        fDependencyLevel = depLevel;
 
         /*
          * Actual analysis will be run on a separate thread