From f623a1069a20e8821effc8476d8374a69da9c6b3 Mon Sep 17 00:00:00 2001 From: Matthew Khouzam Date: Fri, 6 Feb 2026 12:53:25 -0500 Subject: [PATCH] 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 --- .../cpuusage/KernelCpuUsageStateProvider.java | 5 ++++ .../KernelMemoryStateProvider.java | 28 ++++++++++++++++--- .../core/tid/ActiveTidStateProvider.java | 8 ++++-- .../core/kernel/KernelStateProvider.java | 18 +++++++++++- .../callstack/CallStackStateProvider.java | 8 +++--- .../memory/UstMemoryStateProvider.java | 8 ++++++ .../statesystem/AbstractTmfStateProvider.java | 20 +++++++++++++ 7 files changed, 83 insertions(+), 12 deletions(-) diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageStateProvider.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageStateProvider.java index 7f9d962f5b..d419433c00 100644 --- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageStateProvider.java +++ b/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) { diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/kernelmemoryusage/KernelMemoryStateProvider.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/kernelmemoryusage/KernelMemoryStateProvider.java index 600943ddbf..688b7b7a27 100644 --- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/kernelmemoryusage/KernelMemoryStateProvider.java +++ b/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 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 { diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/tid/ActiveTidStateProvider.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/tid/ActiveTidStateProvider.java index 34f65791c5..a85cb56831 100644 --- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/tid/ActiveTidStateProvider.java +++ b/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; diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/internal/analysis/os/linux/core/kernel/KernelStateProvider.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/internal/analysis/os/linux/core/kernel/KernelStateProvider.java index 83f8c0c042..57de6aa44a 100644 --- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/internal/analysis/os/linux/core/kernel/KernelStateProvider.java +++ b/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 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) { diff --git a/analysis/org.eclipse.tracecompass.analysis.profiling.core/src/org/eclipse/tracecompass/analysis/profiling/core/callstack/CallStackStateProvider.java b/analysis/org.eclipse.tracecompass.analysis.profiling.core/src/org/eclipse/tracecompass/analysis/profiling/core/callstack/CallStackStateProvider.java index 0b61de4218..d30e0f9aa6 100644 --- a/analysis/org.eclipse.tracecompass.analysis.profiling.core/src/org/eclipse/tracecompass/analysis/profiling/core/callstack/CallStackStateProvider.java +++ b/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. diff --git a/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/internal/lttng2/ust/core/analysis/memory/UstMemoryStateProvider.java b/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/internal/lttng2/ust/core/analysis/memory/UstMemoryStateProvider.java index 5f73b08159..3e0f732ba5 100644 --- a/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/internal/lttng2/ust/core/analysis/memory/UstMemoryStateProvider.java +++ b/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(); diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/AbstractTmfStateProvider.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/AbstractTmfStateProvider.java index 04fa9adca4..a5fc1f324f 100644 --- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/AbstractTmfStateProvider.java +++ b/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.