From: Geneviève Bastien Date: Wed, 27 Apr 2016 16:26:41 +0000 (-0400) Subject: tmf.core: Add a dependency level to analyses X-Git-Url: http://drtracing.org/?a=commitdiff_plain;h=0021a73444e49da55be6ab9cf0ad6167927dbe6e;p=deliverable%2Ftracecompass.git 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 Reviewed-on: https://git.eclipse.org/r/71540 Tested-by: Bernd Hufmann Reviewed-by: Hudson CI Reviewed-by: Bernd Hufmann --- 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 ed725db4da..35001d5e87 100644 --- 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 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 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 0c6a34f79f..c44a8a254e 100644 --- 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 8107f3ddf6..0031c70439 100644 --- 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 fOutputs = new ArrayList<>(); private Set 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 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