tmf.analysis: Pre-filter events to speed up trace parsing

Add a pre-filter activity to reduce queue fill. Only enqueue data that may be read by analyses.

This patch updates:
* ActiveTidStateProvider
* KernelStateProvider
* KernelMemoryStateProvider
* KernelCpuUsageStateProvider
* CallstackStateProvider

[Changed] add filter to event dispatch to speed up trace compass

Change-Id: I51c8cb5594812491c85a2cbafe8d32fd4f6bc0c5
Signed-off-by: Matthew Khouzam <matthew.khouzam@ericsson.com>

Author: MatthewKhouzam

analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageStateProvider.java

@@ -90,6 +90,11 @@ public KernelCpuUsageStateProvider getNewInstance() {
         return new KernelCpuUsageStateProvider(this.getTrace(), this.fLayout);
     }
 
+    @Override
+    protected boolean considerEvent(ITmfEvent event) {
+        return super.considerEvent(event) && event.getName().equals(fLayout.eventSchedSwitch());
+    }
+
     @Override
     protected void eventHandle(@Nullable ITmfEvent event) {
         if (event == null) {

analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/kernelmemoryusage/KernelMemoryStateProvider.java

@@ -12,6 +12,9 @@
 
 import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
 
+import java.util.Set;
+import java.util.TreeSet;
+
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.tracecompass.analysis.os.linux.core.kernel.KernelTidAspect;
@@ -58,6 +61,12 @@ public class KernelMemoryStateProvider extends AbstractTmfStateProvider {
 
     private IKernelAnalysisEventLayout fLayout;
 
+    private final String fEventKmemPageFree;
+
+    private final String fEventKmemPageAlloc;
+
+    private final Set<String> fToConsider = new TreeSet<>();
+
     /**
      * Constructor
      *
@@ -69,6 +78,10 @@ public class KernelMemoryStateProvider extends AbstractTmfStateProvider {
     public KernelMemoryStateProvider(@NonNull ITmfTrace trace, IKernelAnalysisEventLayout layout) {
         super(trace, "Kernel:Memory"); //$NON-NLS-1$
         fLayout = layout;
+        fEventKmemPageAlloc = fLayout.eventKmemPageAlloc();
+        fEventKmemPageFree = fLayout.eventKmemPageFree();
+        fToConsider.add(fEventKmemPageAlloc);
+        fToConsider.add(fEventKmemPageFree);
     }
 
     @Override
@@ -81,17 +94,24 @@ public ITmfStateProvider getNewInstance() {
         return new KernelMemoryStateProvider(getTrace(), fLayout);
     }
 
+    @Override
+    protected boolean considerEvent(ITmfEvent event) {
+        return super.considerEvent(event) && fToConsider.contains(event.getName());
+    }
+
     @Override
     protected void eventHandle(@NonNull ITmfEvent event) {
         String name = event.getName();
 
         long inc;
-        if (name.equals(fLayout.eventKmemPageAlloc())) {
+        if (name.equals(fEventKmemPageAlloc)) {
             inc = PAGE_SIZE;
-        } else if (name.equals(fLayout.eventKmemPageFree())) {
-            inc = -PAGE_SIZE;
         } else {
-            return;
+            if (name.equals(fEventKmemPageFree)) {
+                inc = -PAGE_SIZE;
+            } else {
+                return;
+            }
         }
 
         try {

analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/tid/ActiveTidStateProvider.java

@@ -72,11 +72,13 @@ public int getVersion() {
         return new ActiveTidStateProvider(getTrace(), fLayout);
     }
 
+    @Override
+    protected boolean considerEvent(@NonNull ITmfEvent event) {
+        return super.considerEvent(event) && event.getName().equals(fSchedSwitch);
+    }
+
     @Override
     protected void eventHandle(@NonNull ITmfEvent event) {
-        if (!event.getName().equals(fSchedSwitch)) {
-            return;
-        }
         ITmfStateSystemBuilder ssb = getStateSystemBuilder();
         if (ssb == null) {
             return;

analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/internal/analysis/os/linux/core/kernel/KernelStateProvider.java

@@ -14,7 +14,9 @@
 
 package org.eclipse.tracecompass.internal.analysis.os.linux.core.kernel;
 
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 
 import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelAnalysisEventLayout;
@@ -98,6 +100,7 @@ public class KernelStateProvider extends AbstractTmfStateProvider {
 
     private final KernelEventHandler fSysEntryHandler;
     private final KernelEventHandler fSysExitHandler;
+    private final Set<String> fValidEventNames = new HashSet<>();
 
     // ------------------------------------------------------------------------
     // Constructor
@@ -116,7 +119,7 @@ public KernelStateProvider(ITmfTrace trace, IKernelAnalysisEventLayout layout) {
         super(trace, "Kernel"); //$NON-NLS-1$
         fLayout = layout;
         fEventNames = buildEventNames(layout);
-
+        fValidEventNames.addAll(fEventNames.keySet());
         fSysEntryHandler = new SysEntryHandler(fLayout);
         fSysExitHandler = new SysExitHandler(fLayout);
     }
@@ -175,6 +178,19 @@ public KernelStateProvider getNewInstance() {
         return new KernelStateProvider(this.getTrace(), fLayout);
     }
 
+    @Override
+    protected boolean considerEvent(ITmfEvent event) {
+        boolean considerEvent = super.considerEvent(event);
+        if (!considerEvent) {
+            return false;
+        }
+        String name = event.getName();
+        if (fValidEventNames.contains(name)) {
+            return true;
+        }
+        return isSyscallEntry(name) || isSyscallExit(name);
+    }
+
     @Override
     protected void eventHandle(@Nullable ITmfEvent event) {
         if (event == null) {

analysis/org.eclipse.tracecompass.analysis.profiling.core/src/org/eclipse/tracecompass/analysis/profiling/core/callstack/CallStackStateProvider.java

@@ -114,9 +114,6 @@ public CallStackStateProvider(ITmfTrace trace) {
 
     @Override
     protected void eventHandle(ITmfEvent event) {
-        if (!considerEvent(event)) {
-            return;
-        }
 
         ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder());
 
@@ -204,7 +201,10 @@ public void done() {
      * @return If false, the event will be ignored by the state provider. If
      *         true processing will continue.
      */
-    protected abstract boolean considerEvent(ITmfEvent event);
+    @Override
+    protected boolean considerEvent(ITmfEvent event) {
+        return true;
+    }
 
     /**
      * Check an event if it indicates a function entry.

lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/internal/lttng2/ust/core/analysis/memory/UstMemoryStateProvider.java

@@ -159,6 +159,14 @@ public UstMemoryStateProvider(@NonNull ITmfTrace trace, @Nullable UstMemoryAnaly
         return builder.build();
     }
 
+    @Override
+    protected boolean considerEvent(@NonNull ITmfEvent event) {
+        if (!super.considerEvent(event)) {
+            return false;
+        }
+        return fEventNames.containsKey(event.getName());
+    }
+
     @Override
     protected void eventHandle(ITmfEvent event) {
         String name = event.getName();

tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/AbstractTmfStateProvider.java

@@ -319,6 +319,10 @@ public void run() {
                         event = fEventsQueue.take();
                         continue;
                     }
+                    if (!considerEvent(event)) {
+                        event = fEventsQueue.take();
+                        continue;
+                    }
                     currentEvent = event;
                     long currentTime = event.getTimestamp().toNanos();
                     fSafeTime = currentTime - 1;
@@ -436,6 +440,22 @@ public void addFutureEvent(long time, @Nullable Object futureValue, int attribut
     // Abstract methods
     // ------------------------------------------------------------------------
 
+    /**
+     * Check if this event should be considered for processing by the state
+     * provider. This check is a fast fail filter invoked before
+     * {@link #eventHandle(ITmfEvent)} to allow events to not be processed as
+     * much.
+     *
+     * @param event
+     *            The event to check
+     * @return If false, the event will be ignored by the state provider. If
+     *         true processing will continue.
+     * @since 10.2
+     */
+    protected boolean considerEvent(ITmfEvent event) {
+        return true;
+    }
+
     /**
      * Handle the given event and send the appropriate state transitions into
      * the the state system.