analysis.os: Add layouted requirements to the CPU analysis

That patch attempts to bring back the concept of requirements to linux kernel
analyses. The requirements were disabled since the event layouts appeared.

Change-Id: I12b4befa69c94ca7205ea0db7670ee126788dc42
Signed-off-by: Geneviève Bastien <gbastien+lttng@versatic.net>
Reviewed-on: https://git.eclipse.org/r/68015
Reviewed-by: Matthew Khouzam <matthew.khouzam@ericsson.com>
Tested-by: Matthew Khouzam <matthew.khouzam@ericsson.com>
Reviewed-by: Hudson CI

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/src/org/eclipse/tracecompass/analysis/os/linux/core/tests/cpuusage/CpuUsageStateProviderTest.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/src/org/eclipse/tracecompass/analysis/os/linux/core/tests/cpuusage/CpuUsageStateProviderTest.java
index d8da22d13352b2c324ae8f0fa0d1ad2d1b9a9d09..6d7cd5d4fc5fedff3b48dff58a6b00dceff6ec0e 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/src/org/eclipse/tracecompass/analysis/os/linux/core/tests/cpuusage/CpuUsageStateProviderTest.java
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/src/org/eclipse/tracecompass/analysis/os/linux/core/tests/cpuusage/CpuUsageStateProviderTest.java
@@ -24,6 +24,9 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
 
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IStatus;
@@ -32,6 +35,8 @@ import org.eclipse.tracecompass.analysis.os.linux.core.cpuusage.KernelCpuUsageAn
 import org.eclipse.tracecompass.analysis.os.linux.core.kernel.KernelAnalysisModule;
 import org.eclipse.tracecompass.analysis.os.linux.core.tests.Activator;
 import org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.trace.TmfXmlKernelTraceStub;
+import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelAnalysisEventLayout;
+import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelTrace;
 import org.eclipse.tracecompass.internal.analysis.os.linux.core.kernel.Attributes;
 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
 import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
@@ -64,7 +69,7 @@ public class CpuUsageStateProviderTest {
 
     private static final String CPU_USAGE_FILE = "testfiles/cpu_analysis.xml";
 
-    private ITmfTrace fTrace;
+    private IKernelTrace fTrace;
     private KernelCpuUsageAnalysis fModule;
 
     private static void deleteSuppFiles(ITmfTrace trace) {
@@ -80,7 +85,7 @@ public class CpuUsageStateProviderTest {
      */
     @Before
     public void setUp() {
-        ITmfTrace trace = new TmfXmlKernelTraceStub();
+        IKernelTrace trace = new TmfXmlKernelTraceStub();
         IPath filePath = Activator.getAbsoluteFilePath(CPU_USAGE_FILE);
         IStatus status = trace.validate(null, filePath.toOSString());
         if (!status.isOK()) {
@@ -319,8 +324,25 @@ public class CpuUsageStateProviderTest {
         expected.put("total/4", 4L);
         expected.put("1", 9L);
         expected.put("total", 9L);
-        resultMap = fModule.getCpuUsageInRange(ImmutableSet.of(1,2), 4L, 13L);
+        resultMap = fModule.getCpuUsageInRange(ImmutableSet.of(1, 2), 4L, 13L);
         assertEquals(expected, resultMap);
 
     }
+
+    /**
+     * Test the requirements of the analysis module
+     */
+    @Test
+    public void testRequirements() {
+        IKernelTrace trace = fTrace;
+        assertNotNull(trace);
+        IKernelAnalysisEventLayout layout = trace.getKernelEventLayout();
+        Set<String> expected = ImmutableSet.of(layout.eventSchedSwitch());
+
+        Set<String> actual = StreamSupport.stream(fModule.getAnalysisRequirements().spliterator(), false)
+            .flatMap(req -> req.getValues().stream())
+            .collect(Collectors.toSet());
+
+        assertEquals(expected, actual);
+    }
 }

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageAnalysis.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageAnalysis.java
index 71a6b22b19d00473c977d134a5538a19aa9606c0..b67a110d121f4fb28e59cbc7f79baa6e9e95c7f7 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageAnalysis.java
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageAnalysis.java
@@ -22,10 +22,13 @@ import java.util.Map.Entry;
 import java.util.Set;
 
 import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.tracecompass.analysis.os.linux.core.kernel.KernelAnalysisModule;
 import org.eclipse.tracecompass.analysis.os.linux.core.trace.DefaultEventLayout;
 import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelAnalysisEventLayout;
 import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelTrace;
+import org.eclipse.tracecompass.analysis.os.linux.core.trace.KernelEventLayoutRequirement;
+import org.eclipse.tracecompass.common.core.NonNullUtils;
 import org.eclipse.tracecompass.internal.analysis.os.linux.core.Activator;
 import org.eclipse.tracecompass.internal.analysis.os.linux.core.kernel.Attributes;
 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
@@ -35,11 +38,17 @@ import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeExcept
 import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
 import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
 import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
 import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
 
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.SetMultimap;
+
 /**
  * This analysis module computes the CPU usage of a system from a kernel trace.
  * It requires the LTTng Kernel analysis module to have accurate CPU usage data.
@@ -58,9 +67,15 @@ public class KernelCpuUsageAnalysis extends TmfStateSystemAnalysisModule {
     /** Idle process thread ID */
     public static final String TID_ZERO = "0"; //$NON-NLS-1$
 
-    @Override
-    protected ITmfStateProvider createStateProvider() {
-        ITmfTrace trace = checkNotNull(getTrace());
+    /** The requirements as an immutable set */
+    private static final KernelEventLayoutRequirement LAYOUT_REQUIREMENT;
+    private static final SetMultimap<IKernelAnalysisEventLayout, TmfAnalysisRequirement> LAYOUT_REQ_MAP = NonNullUtils.checkNotNull(HashMultimap.create());
+
+    static {
+        LAYOUT_REQUIREMENT = new KernelEventLayoutRequirement(ImmutableSet.of((l) -> l.eventSchedSwitch()), ValuePriorityLevel.MANDATORY);
+    }
+
+    private static IKernelAnalysisEventLayout getLayout(@Nullable ITmfTrace trace) {
         IKernelAnalysisEventLayout layout;
 
         if (trace instanceof IKernelTrace) {
@@ -69,6 +84,13 @@ public class KernelCpuUsageAnalysis extends TmfStateSystemAnalysisModule {
             /* Fall-back to the base LttngEventLayout */
             layout = DefaultEventLayout.getInstance();
         }
+        return layout;
+    }
+
+    @Override
+    protected ITmfStateProvider createStateProvider() {
+        ITmfTrace trace = checkNotNull(getTrace());
+        IKernelAnalysisEventLayout layout = getLayout(trace);
 
         return new KernelCpuUsageStateProvider(trace, layout);
     }
@@ -310,4 +332,16 @@ public class KernelCpuUsageAnalysis extends TmfStateSystemAnalysisModule {
         }
     }
 
+    @Override
+    public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
+        ITmfTrace trace = getTrace();
+        IKernelAnalysisEventLayout layout = getLayout(trace);
+        Set<TmfAnalysisRequirement> reqs = LAYOUT_REQ_MAP.get(layout);
+        if (reqs.isEmpty()) {
+            reqs= ImmutableSet.of(LAYOUT_REQUIREMENT.instanciateRequirements(layout));
+            LAYOUT_REQ_MAP.putAll(layout, reqs);
+        }
+        return reqs;
+    }
+
 }

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/trace/KernelEventLayoutRequirement.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/trace/KernelEventLayoutRequirement.java
new file mode 100644 (file)
index 0000000..6e0ec58
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/trace/KernelEventLayoutRequirement.java
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (c) 2016 École Polytechnique de Montréal
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.analysis.os.linux.core.trace;
+
+import java.util.Set;
+
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisEventRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
+
+import com.google.common.collect.ImmutableList.Builder;
+
+/**
+ * This class is a pre-requirement class who will instanciate at runtime the
+ * actual requirements depending on a trace's event layout
+ *
+ * @author Geneviève Bastien
+ * @since 2.0
+ */
+public class KernelEventLayoutRequirement {
+
+    /**
+     * Functional interface that maps a layout to an event name
+     */
+    @FunctionalInterface
+    public interface ILayoutToEventName {
+        /**
+         * This method will return the event name mapped by this requirement
+         * from the layout. The returned event name may be <code>null</code> in
+         * some layouts.
+         *
+         * @param layout
+         *            The event layout of the trace
+         * @return The event name
+         */
+        @Nullable String getEventName(IKernelAnalysisEventLayout layout);
+    }
+
+    private final Set<ILayoutToEventName> fEventNames;
+    private final ValuePriorityLevel fLevel;
+
+    /**
+     * Constructor
+     *
+     * @param layoutReqs
+     *            The layout mappings this requirement represents
+     * @param level
+     *            Whether the requirement represented by these mapping is
+     *            mandatory or optional
+     */
+    public KernelEventLayoutRequirement(Set<ILayoutToEventName> layoutReqs, ValuePriorityLevel level) {
+        fEventNames = layoutReqs;
+        fLevel = level;
+    }
+
+    /**
+     * Build a real requirement from the layout mapping to be matched with a
+     * real trace's layout
+     *
+     * @param layout
+     *            The event layout from which to build the requirements.
+     * @return The real requirement
+     */
+    public TmfAnalysisRequirement instanciateRequirements(IKernelAnalysisEventLayout layout) {
+        Builder<String> events = new Builder<>();
+        for (ILayoutToEventName eventNameLayout : fEventNames) {
+            String eventName = eventNameLayout.getEventName(layout);
+            if (eventName != null) {
+                events.add(eventName);
+            }
+        }
+        return new TmfAnalysisEventRequirement(events.build(), fLevel);
+    }
+
+}