From d0c7e4bad8c6b5a25501aad876b71f248ddd6677 Mon Sep 17 00:00:00 2001 From: Alexandre Montplaisir Date: Mon, 15 Dec 2014 17:48:44 -0500 Subject: [PATCH] tmf: Null-annotate state system API classes The main culprits here are the createStateProvider() method, that need to pass a @NonNull trace, but simply take the result of getTrace() which is already marked @Nullable. Simply wrapping them in checkNotNull() calls feels lazy, but it's still better than the current situation. Change-Id: Ic1ceb149cbb06e6f91a3351ef757231907a67ae2 Signed-off-by: Alexandre Montplaisir Reviewed-on: https://git.eclipse.org/r/38308 Reviewed-by: Hudson CI Reviewed-by: Matthew Khouzam --- .../btf/core/analysis/BtfStateProvider.java | 6 +- .../build.properties | 2 + .../META-INF/MANIFEST.MF | 1 + .../statesystem/PartialStateSystemTest.java | 3 +- .../StateSystemFullHistoryTest.java | 3 +- .../statesystem/StateSystemInMemoryTest.java | 3 +- .../module/VirtualMachineStateProvider.java | 6 +- .../cpuusage/LttngKernelCpuUsageAnalysis.java | 4 +- .../LttngKernelCpuUsageStateProvider.java | 13 ++- .../analysis/kernel/LttngKernelAnalysis.java | 2 +- .../kernel/LttngKernelStateProvider.java | 85 ++++++++++--------- .../META-INF/MANIFEST.MF | 1 + .../trace/callstack/AbstractProviderTest.java | 3 +- .../memoryusage/MemoryUsageStateProvider.java | 7 +- .../callstack/LttngUstCallStackProvider.java | 3 +- .../memory/UstMemoryAnalysisModule.java | 2 +- .../META-INF/MANIFEST.MF | 1 + .../callstack/LttngUstCallStackAnalysis.java | 4 +- .../core/stateprovider/XmlStateProvider.java | 7 +- .../stateprovider/XmlStateSystemModule.java | 4 +- .../mipmap/TmfMipmapStateProviderStub.java | 12 ++- .../mipmap/TmfMipmapStateProviderTest.java | 5 +- .../TmfMipmapStateProviderWeightedTest.java | 10 ++- .../analysis/TestExperimentAnalysis.java | 9 +- .../stubs/analysis/TestStateSystemModule.java | 4 +- .../analysis/TestStateSystemProvider.java | 8 +- .../AbstractTmfMipmapStateProvider.java | 11 ++- .../callstack/CallStackStateProvider.java | 11 ++- .../statesystem/AbstractTmfStateProvider.java | 29 +++++-- .../ITmfAnalysisModuleWithStateSystems.java | 5 +- .../core/statesystem/ITmfStateProvider.java | 3 +- .../TmfStateSystemAnalysisModule.java | 4 +- .../tmf/core/statesystem/package-info.java | 14 +++ .../TmfStatisticsEventTypesModule.java | 8 +- .../statistics/TmfStatisticsTotalsModule.java | 9 +- 35 files changed, 203 insertions(+), 99 deletions(-) create mode 100644 org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/package-info.java diff --git a/org.eclipse.tracecompass.btf.core/src/org/eclipse/tracecompass/btf/core/analysis/BtfStateProvider.java b/org.eclipse.tracecompass.btf.core/src/org/eclipse/tracecompass/btf/core/analysis/BtfStateProvider.java index f5eb0d8dcf..202ea71022 100644 --- a/org.eclipse.tracecompass.btf.core/src/org/eclipse/tracecompass/btf/core/analysis/BtfStateProvider.java +++ b/org.eclipse.tracecompass.btf.core/src/org/eclipse/tracecompass/btf/core/analysis/BtfStateProvider.java @@ -13,6 +13,8 @@ package org.eclipse.tracecompass.btf.core.analysis; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import org.eclipse.tracecompass.btf.core.event.BtfEvent; import org.eclipse.tracecompass.btf.core.trace.BtfColumnNames; import org.eclipse.tracecompass.btf.core.trace.BtfTrace; @@ -131,7 +133,7 @@ public class BtfStateProvider extends AbstractTmfStateProvider { @Override protected void eventHandle(ITmfEvent ev) { BtfEvent event = (BtfEvent) ev; - final ITmfStateSystemBuilder ssb = this.ss; + final ITmfStateSystemBuilder ssb = checkNotNull(getStateSystemBuilder()); final long ts = event.getTimestamp().getValue(); final String eventType = (String) event.getContent().getField(BtfColumnNames.EVENT.toString()).getValue(); @@ -189,7 +191,7 @@ public class BtfStateProvider extends AbstractTmfStateProvider { quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core); ssb.modifyAttribute(ts, STATE_SUSPENDED.getValue(), quark); quark = ssb.getQuarkRelativeAndAdd(quark, runnable); - ss.modifyAttribute(ts, STATE_SUSPENDED.getValue(), quark); + ssb.modifyAttribute(ts, STATE_SUSPENDED.getValue(), quark); } break; diff --git a/org.eclipse.tracecompass.examples/build.properties b/org.eclipse.tracecompass.examples/build.properties index 308f1048da..53224f3f58 100644 --- a/org.eclipse.tracecompass.examples/build.properties +++ b/org.eclipse.tracecompass.examples/build.properties @@ -17,3 +17,5 @@ bin.includes = META-INF/,\ plugin.properties,\ plugin.xml src.includes = about.html +additional.bundles = org.eclipse.jdt.annotation +jars.extra.classpath = platform:/plugin/org.eclipse.jdt.annotation diff --git a/org.eclipse.tracecompass.lttng2.kernel.core.tests/META-INF/MANIFEST.MF b/org.eclipse.tracecompass.lttng2.kernel.core.tests/META-INF/MANIFEST.MF index 29b29a34e7..1b9679774b 100644 --- a/org.eclipse.tracecompass.lttng2.kernel.core.tests/META-INF/MANIFEST.MF +++ b/org.eclipse.tracecompass.lttng2.kernel.core.tests/META-INF/MANIFEST.MF @@ -10,6 +10,7 @@ Bundle-ActivationPolicy: lazy Bundle-RequiredExecutionEnvironment: JavaSE-1.7 Require-Bundle: org.junit;bundle-version="4.0.0", org.eclipse.core.runtime, + org.eclipse.tracecompass.common.core;bundle-version="0.1.0", org.eclipse.tracecompass.tmf.core;bundle-version="0.1.0", org.eclipse.tracecompass.tmf.core.tests;bundle-version="0.1.0", org.eclipse.tracecompass.tmf.ctf.core, diff --git a/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/statesystem/PartialStateSystemTest.java b/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/statesystem/PartialStateSystemTest.java index 479212c668..b6e09997c3 100644 --- a/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/statesystem/PartialStateSystemTest.java +++ b/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/statesystem/PartialStateSystemTest.java @@ -12,6 +12,7 @@ package org.eclipse.tracecompass.lttng2.kernel.core.tests.analysis.kernel.statesystem; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; @@ -178,7 +179,7 @@ public class PartialStateSystemTest extends StateSystemTest { @Override protected ITmfStateProvider createStateProvider() { - return new LttngKernelStateProvider(getTrace(), LttngEventLayout.getInstance()); + return new LttngKernelStateProvider(checkNotNull(getTrace()), LttngEventLayout.getInstance()); } @Override diff --git a/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/statesystem/StateSystemFullHistoryTest.java b/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/statesystem/StateSystemFullHistoryTest.java index d1188dce07..43180ce5fe 100644 --- a/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/statesystem/StateSystemFullHistoryTest.java +++ b/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/statesystem/StateSystemFullHistoryTest.java @@ -13,6 +13,7 @@ package org.eclipse.tracecompass.lttng2.kernel.core.tests.analysis.kernel.statesystem; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; @@ -175,7 +176,7 @@ public class StateSystemFullHistoryTest extends StateSystemTest { @Override protected ITmfStateProvider createStateProvider() { - return new LttngKernelStateProvider(getTrace(), LttngEventLayout.getInstance()); + return new LttngKernelStateProvider(checkNotNull(getTrace()), LttngEventLayout.getInstance()); } @Override diff --git a/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/statesystem/StateSystemInMemoryTest.java b/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/statesystem/StateSystemInMemoryTest.java index d2d0605b39..37ae6e7103 100644 --- a/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/statesystem/StateSystemInMemoryTest.java +++ b/org.eclipse.tracecompass.lttng2.kernel.core.tests/src/org/eclipse/tracecompass/lttng2/kernel/core/tests/analysis/kernel/statesystem/StateSystemInMemoryTest.java @@ -13,6 +13,7 @@ package org.eclipse.tracecompass.lttng2.kernel.core.tests.analysis.kernel.statesystem; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; @@ -92,7 +93,7 @@ public class StateSystemInMemoryTest extends StateSystemTest { @Override protected ITmfStateProvider createStateProvider() { - return new LttngKernelStateProvider(getTrace(), LttngEventLayout.getInstance()); + return new LttngKernelStateProvider(checkNotNull(getTrace()), LttngEventLayout.getInstance()); } @Override diff --git a/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/internal/lttng2/kernel/core/analysis/vm/module/VirtualMachineStateProvider.java b/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/internal/lttng2/kernel/core/analysis/vm/module/VirtualMachineStateProvider.java index 259ffd8294..c5a5ee9d91 100644 --- a/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/internal/lttng2/kernel/core/analysis/vm/module/VirtualMachineStateProvider.java +++ b/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/internal/lttng2/kernel/core/analysis/vm/module/VirtualMachineStateProvider.java @@ -12,6 +12,8 @@ package org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.module; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import java.util.HashMap; import java.util.Map; @@ -30,6 +32,7 @@ import org.eclipse.tracecompass.internal.lttng2.kernel.core.trace.layout.LttngEv import org.eclipse.tracecompass.lttng2.kernel.core.analysis.kernel.LttngKernelAnalysis; import org.eclipse.tracecompass.lttng2.kernel.core.analysis.kernel.LttngKernelThreadInformationProvider; import org.eclipse.tracecompass.lttng2.kernel.core.trace.LttngKernelTrace; +import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException; import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException; import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException; @@ -157,6 +160,7 @@ public class VirtualMachineStateProvider extends AbstractTmfStateProvider { return; } + ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder()); ITmfStateValue value; final ITmfEventField content = event.getContent(); @@ -345,7 +349,7 @@ public class VirtualMachineStateProvider extends AbstractTmfStateProvider { // ------------------------------------------------------------------------ private int getNodeVirtualMachines() { - return ss.getQuarkAbsoluteAndAdd(VmAttributes.VIRTUAL_MACHINES); + return checkNotNull(getStateSystemBuilder()).getQuarkAbsoluteAndAdd(VmAttributes.VIRTUAL_MACHINES); } private @Nullable HostThread getCurrentHostThread(ITmfEvent event, long ts) { diff --git a/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/cpuusage/LttngKernelCpuUsageAnalysis.java b/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/cpuusage/LttngKernelCpuUsageAnalysis.java index 4786025d01..ae89430f65 100644 --- a/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/cpuusage/LttngKernelCpuUsageAnalysis.java +++ b/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/cpuusage/LttngKernelCpuUsageAnalysis.java @@ -12,6 +12,8 @@ package org.eclipse.tracecompass.lttng2.kernel.core.analysis.cpuusage; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -58,7 +60,7 @@ public class LttngKernelCpuUsageAnalysis extends TmfStateSystemAnalysisModule { @Override protected ITmfStateProvider createStateProvider() { - ITmfTrace trace = getTrace(); + ITmfTrace trace = checkNotNull(getTrace()); IKernelAnalysisEventLayout layout; if (trace instanceof LttngKernelTrace) { diff --git a/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/cpuusage/LttngKernelCpuUsageStateProvider.java b/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/cpuusage/LttngKernelCpuUsageStateProvider.java index 81b044d956..cc5d72c039 100644 --- a/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/cpuusage/LttngKernelCpuUsageStateProvider.java +++ b/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/cpuusage/LttngKernelCpuUsageStateProvider.java @@ -13,6 +13,8 @@ package org.eclipse.tracecompass.lttng2.kernel.core.analysis.cpuusage; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import java.util.HashMap; import java.util.Map; @@ -20,6 +22,7 @@ import org.eclipse.jdt.annotation.NonNull; import org.eclipse.tracecompass.internal.lttng2.kernel.core.Activator; import org.eclipse.tracecompass.internal.lttng2.kernel.core.Attributes; import org.eclipse.tracecompass.internal.lttng2.kernel.core.trace.layout.IKernelAnalysisEventLayout; +import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException; import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue; import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue; @@ -61,7 +64,8 @@ public class LttngKernelCpuUsageStateProvider extends AbstractTmfStateProvider { * @param layout * The event layout to use for this state provider. */ - public LttngKernelCpuUsageStateProvider(ITmfTrace trace, @NonNull IKernelAnalysisEventLayout layout) { + public LttngKernelCpuUsageStateProvider(@NonNull ITmfTrace trace, + @NonNull IKernelAnalysisEventLayout layout) { super(trace, ITmfEvent.class, "LTTng Kernel CPU usage"); //$NON-NLS-1$ fTraceStart = trace.getStartTime().getValue(); fLayout = layout; @@ -83,6 +87,7 @@ public class LttngKernelCpuUsageStateProvider extends AbstractTmfStateProvider { @Override protected void eventHandle(ITmfEvent event) { + final ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder()); final String eventName = event.getType().getName(); if (eventName.equals(fLayout.eventSchedSwitch())) { @@ -109,7 +114,7 @@ public class LttngKernelCpuUsageStateProvider extends AbstractTmfStateProvider { Long prevTid = (Long) content.getField(fLayout.fieldPrevTid()).getValue(); try { - Integer currentCPUNode = ss.getQuarkRelativeAndAdd(getNodeCPUs(), cpu.toString()); + Integer currentCPUNode = ss.getQuarkRelativeAndAdd(getNodeCPUs(ss), cpu.toString()); /* * This quark contains the value of the cumulative time spent on @@ -152,8 +157,8 @@ public class LttngKernelCpuUsageStateProvider extends AbstractTmfStateProvider { } /* Shortcut for the "current CPU" attribute node */ - private int getNodeCPUs() { - return ss.getQuarkAbsoluteAndAdd(Attributes.CPUS); + private static int getNodeCPUs(ITmfStateSystemBuilder ssb) { + return ssb.getQuarkAbsoluteAndAdd(Attributes.CPUS); } } diff --git a/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/kernel/LttngKernelAnalysis.java b/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/kernel/LttngKernelAnalysis.java index 4471a3be78..9e0760f391 100644 --- a/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/kernel/LttngKernelAnalysis.java +++ b/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/kernel/LttngKernelAnalysis.java @@ -90,7 +90,7 @@ public class LttngKernelAnalysis extends TmfStateSystemAnalysisModule { @Override protected @NonNull ITmfStateProvider createStateProvider() { - ITmfTrace trace = getTrace(); + ITmfTrace trace = checkNotNull(getTrace()); IKernelAnalysisEventLayout layout; if (trace instanceof LttngKernelTrace) { diff --git a/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/kernel/LttngKernelStateProvider.java b/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/kernel/LttngKernelStateProvider.java index 58ee3d116d..9d537d40f7 100644 --- a/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/kernel/LttngKernelStateProvider.java +++ b/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/kernel/LttngKernelStateProvider.java @@ -12,6 +12,8 @@ package org.eclipse.tracecompass.lttng2.kernel.core.analysis.kernel; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import java.util.Map; import org.eclipse.jdt.annotation.NonNull; @@ -87,7 +89,7 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { * The event layout to use for this state provider. Usually * depending on the tracer implementation. */ - public LttngKernelStateProvider(ITmfTrace trace, @NonNull IKernelAnalysisEventLayout layout) { + public LttngKernelStateProvider(@NonNull ITmfTrace trace, @NonNull IKernelAnalysisEventLayout layout) { super(trace, ITmfEvent.class, "Kernel"); //$NON-NLS-1$ fLayout = layout; fEventNames = buildEventNames(layout); @@ -143,6 +145,8 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { @Override protected void eventHandle(ITmfEvent event) { + ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder()); + Integer cpu = null; Iterable aspects = TmfTraceUtils.getEventAspectsOfClass(event.getTrace(), TmfCpuAspect.class); for (TmfCpuAspect aspect : aspects) { @@ -161,7 +165,7 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { try { /* Shortcut for the "current CPU" attribute node */ - final int currentCPUNode = ss.getQuarkRelativeAndAdd(getNodeCPUs(), cpu.toString()); + final int currentCPUNode = ss.getQuarkRelativeAndAdd(getNodeCPUs(ss), cpu.toString()); /* * Shortcut for the "current thread" attribute node. It requires @@ -170,7 +174,7 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { int quark = ss.getQuarkRelativeAndAdd(currentCPUNode, Attributes.CURRENT_THREAD); ITmfStateValue value = ss.queryOngoingState(quark); int thread = value.isNull() ? -1 : value.unboxInt(); - final int currentThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(), String.valueOf(thread)); + final int currentThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), String.valueOf(thread)); /* * Feed event to the history system if it's known to cause a state @@ -186,7 +190,7 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { /* Mark this IRQ as active in the resource tree. * The state value = the CPU on which this IRQ is sitting */ - quark = ss.getQuarkRelativeAndAdd(getNodeIRQs(), irqId.toString()); + quark = ss.getQuarkRelativeAndAdd(getNodeIRQs(ss), irqId.toString()); value = TmfStateValue.newValueInt(cpu.intValue()); ss.modifyAttribute(ts, value, quark); @@ -207,15 +211,15 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { Integer irqId = ((Long) event.getContent().getField(fLayout.fieldIrq()).getValue()).intValue(); /* Put this IRQ back to inactive in the resource tree */ - quark = ss.getQuarkRelativeAndAdd(getNodeIRQs(), irqId.toString()); + quark = ss.getQuarkRelativeAndAdd(getNodeIRQs(ss), irqId.toString()); value = TmfStateValue.nullValue(); ss.modifyAttribute(ts, value, quark); /* Set the previous process back to running */ - setProcessToRunning(ts, currentThreadNode); + setProcessToRunning(ss, ts, currentThreadNode); /* Set the CPU status back to running or "idle" */ - cpuExitInterrupt(ts, currentCPUNode, currentThreadNode); + cpuExitInterrupt(ss, ts, currentCPUNode, currentThreadNode); } break; @@ -225,7 +229,7 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { /* Mark this SoftIRQ as active in the resource tree. * The state value = the CPU on which this SoftIRQ is processed */ - quark = ss.getQuarkRelativeAndAdd(getNodeSoftIRQs(), softIrqId.toString()); + quark = ss.getQuarkRelativeAndAdd(getNodeSoftIRQs(ss), softIrqId.toString()); value = TmfStateValue.newValueInt(cpu.intValue()); ss.modifyAttribute(ts, value, quark); @@ -246,15 +250,15 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { Integer softIrqId = ((Long) event.getContent().getField(fLayout.fieldVec()).getValue()).intValue(); /* Put this SoftIRQ back to inactive (= -1) in the resource tree */ - quark = ss.getQuarkRelativeAndAdd(getNodeSoftIRQs(), softIrqId.toString()); + quark = ss.getQuarkRelativeAndAdd(getNodeSoftIRQs(ss), softIrqId.toString()); value = TmfStateValue.nullValue(); ss.modifyAttribute(ts, value, quark); /* Set the previous process back to running */ - setProcessToRunning(ts, currentThreadNode); + setProcessToRunning(ss, ts, currentThreadNode); /* Set the CPU status back to "busy" or "idle" */ - cpuExitInterrupt(ts, currentCPUNode, currentThreadNode); + cpuExitInterrupt(ss, ts, currentCPUNode, currentThreadNode); } break; @@ -265,7 +269,7 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { /* Mark this SoftIRQ as *raised* in the resource tree. * State value = -2 */ - quark = ss.getQuarkRelativeAndAdd(getNodeSoftIRQs(), softIrqId.toString()); + quark = ss.getQuarkRelativeAndAdd(getNodeSoftIRQs(ss), softIrqId.toString()); value = StateValues.SOFT_IRQ_RAISED_VALUE; ss.modifyAttribute(ts, value, quark); } @@ -279,8 +283,8 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { String nextProcessName = (String) content.getField(fLayout.fieldNextComm()).getValue(); Integer nextTid = ((Long) content.getField(fLayout.fieldNextTid()).getValue()).intValue(); - Integer formerThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(), prevTid.toString()); - Integer newCurrentThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(), nextTid.toString()); + Integer formerThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), prevTid.toString()); + Integer newCurrentThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), nextTid.toString()); /* Set the status of the process that got scheduled out. */ quark = ss.getQuarkRelativeAndAdd(formerThreadNode, Attributes.STATUS); @@ -292,7 +296,7 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { ss.modifyAttribute(ts, value, quark); /* Set the status of the new scheduled process */ - setProcessToRunning(ts, newCurrentThreadNode); + setProcessToRunning(ss, ts, newCurrentThreadNode); /* Set the exec name of the new process */ quark = ss.getQuarkRelativeAndAdd(newCurrentThreadNode, Attributes.EXEC_NAME); @@ -335,8 +339,8 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { Integer parentTid = ((Long) content.getField(fLayout.fieldParentTid()).getValue()).intValue(); Integer childTid = ((Long) content.getField(fLayout.fieldChildTid()).getValue()).intValue(); - Integer parentTidNode = ss.getQuarkRelativeAndAdd(getNodeThreads(), parentTid.toString()); - Integer childTidNode = ss.getQuarkRelativeAndAdd(getNodeThreads(), childTid.toString()); + Integer parentTidNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), parentTid.toString()); + Integer childTidNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), childTid.toString()); /* Assign the PPID to the new process */ quark = ss.getQuarkRelativeAndAdd(childTidNode, Attributes.PPID); @@ -378,7 +382,7 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { * Remove the process and all its sub-attributes from the * current state */ - quark = ss.getQuarkRelativeAndAdd(getNodeThreads(), tid.toString()); + quark = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), tid.toString()); ss.removeAttribute(ts, quark); } break; @@ -397,7 +401,7 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { * populated with anything relevant for now. */ - int curThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(), String.valueOf(tid)); + int curThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), String.valueOf(tid)); /* Set the process' name */ quark = ss.getQuarkRelativeAndAdd(curThreadNode, Attributes.EXEC_NAME); @@ -439,7 +443,7 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { case SCHED_WAKEUP_INDEX: { final int tid = ((Long) event.getContent().getField(fLayout.fieldTid()).getValue()).intValue(); - final int threadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(), String.valueOf(tid)); + final int threadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), String.valueOf(tid)); /* * The process indicated in the event's payload is now ready to @@ -529,20 +533,20 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { // Convenience methods for commonly-used attribute tree locations // ------------------------------------------------------------------------ - private int getNodeCPUs() { - return ss.getQuarkAbsoluteAndAdd(Attributes.CPUS); + private static int getNodeCPUs(ITmfStateSystemBuilder ssb) { + return ssb.getQuarkAbsoluteAndAdd(Attributes.CPUS); } - private int getNodeThreads() { - return ss.getQuarkAbsoluteAndAdd(Attributes.THREADS); + private static int getNodeThreads(ITmfStateSystemBuilder ssb) { + return ssb.getQuarkAbsoluteAndAdd(Attributes.THREADS); } - private int getNodeIRQs() { - return ss.getQuarkAbsoluteAndAdd(Attributes.RESOURCES, Attributes.IRQS); + private static int getNodeIRQs(ITmfStateSystemBuilder ssb) { + return ssb.getQuarkAbsoluteAndAdd(Attributes.RESOURCES, Attributes.IRQS); } - private int getNodeSoftIRQs() { - return ss.getQuarkAbsoluteAndAdd(Attributes.RESOURCES, Attributes.SOFT_IRQS); + private static int getNodeSoftIRQs(ITmfStateSystemBuilder ssb) { + return ssb.getQuarkAbsoluteAndAdd(Attributes.RESOURCES, Attributes.SOFT_IRQS); } // ------------------------------------------------------------------------ @@ -555,39 +559,40 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { * put the process back in the syscall state. If not, we put it back in * user mode state. */ - private void setProcessToRunning(long ts, int currentThreadNode) + private static void setProcessToRunning(ITmfStateSystemBuilder ssb, long ts, int currentThreadNode) throws AttributeNotFoundException, TimeRangeException, StateValueTypeException { int quark; ITmfStateValue value; - quark = ss.getQuarkRelativeAndAdd(currentThreadNode, Attributes.SYSTEM_CALL); - if (ss.queryOngoingState(quark).isNull()) { + quark = ssb.getQuarkRelativeAndAdd(currentThreadNode, Attributes.SYSTEM_CALL); + if (ssb.queryOngoingState(quark).isNull()) { /* We were in user mode before the interruption */ value = StateValues.PROCESS_STATUS_RUN_USERMODE_VALUE; } else { /* We were previously in kernel mode */ value = StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE; } - quark = ss.getQuarkRelativeAndAdd(currentThreadNode, Attributes.STATUS); - ss.modifyAttribute(ts, value, quark); + quark = ssb.getQuarkRelativeAndAdd(currentThreadNode, Attributes.STATUS); + ssb.modifyAttribute(ts, value, quark); } /** * Similar logic as above, but to set the CPU's status when it's coming out * of an interruption. */ - private void cpuExitInterrupt(long ts, int currentCpuNode, int currentThreadNode) + private static void cpuExitInterrupt(ITmfStateSystemBuilder ssb, long ts, + int currentCpuNode, int currentThreadNode) throws StateValueTypeException, AttributeNotFoundException, TimeRangeException { int quark; ITmfStateValue value; - quark = ss.getQuarkRelativeAndAdd(currentCpuNode, Attributes.CURRENT_THREAD); - if (ss.queryOngoingState(quark).unboxInt() > 0) { + quark = ssb.getQuarkRelativeAndAdd(currentCpuNode, Attributes.CURRENT_THREAD); + if (ssb.queryOngoingState(quark).unboxInt() > 0) { /* There was a process on the CPU */ - quark = ss.getQuarkRelative(currentThreadNode, Attributes.SYSTEM_CALL); - if (ss.queryOngoingState(quark).isNull()) { + quark = ssb.getQuarkRelative(currentThreadNode, Attributes.SYSTEM_CALL); + if (ssb.queryOngoingState(quark).isNull()) { /* That process was in user mode */ value = StateValues.CPU_STATUS_RUN_USERMODE_VALUE; } else { @@ -598,7 +603,7 @@ public class LttngKernelStateProvider extends AbstractTmfStateProvider { /* There was no real process scheduled, CPU was idle */ value = StateValues.CPU_STATUS_IDLE_VALUE; } - quark = ss.getQuarkRelativeAndAdd(currentCpuNode, Attributes.STATUS); - ss.modifyAttribute(ts, value, quark); + quark = ssb.getQuarkRelativeAndAdd(currentCpuNode, Attributes.STATUS); + ssb.modifyAttribute(ts, value, quark); } } diff --git a/org.eclipse.tracecompass.lttng2.ust.core.tests/META-INF/MANIFEST.MF b/org.eclipse.tracecompass.lttng2.ust.core.tests/META-INF/MANIFEST.MF index d788b5e15d..fdb4500771 100644 --- a/org.eclipse.tracecompass.lttng2.ust.core.tests/META-INF/MANIFEST.MF +++ b/org.eclipse.tracecompass.lttng2.ust.core.tests/META-INF/MANIFEST.MF @@ -10,6 +10,7 @@ Bundle-RequiredExecutionEnvironment: JavaSE-1.7 Require-Bundle: org.junit;bundle-version="4.0.0", org.eclipse.core.resources, org.eclipse.core.runtime, + org.eclipse.tracecompass.common.core;bundle-version="0.1.0", org.eclipse.tracecompass.tmf.core, org.eclipse.tracecompass.tmf.core.tests;bundle-version="0.1.0", org.eclipse.tracecompass.tmf.ctf.core, diff --git a/org.eclipse.tracecompass.lttng2.ust.core.tests/src/org/eclipse/tracecompass/lttng2/ust/core/tests/trace/callstack/AbstractProviderTest.java b/org.eclipse.tracecompass.lttng2.ust.core.tests/src/org/eclipse/tracecompass/lttng2/ust/core/tests/trace/callstack/AbstractProviderTest.java index 5383b2a52f..942690322a 100644 --- a/org.eclipse.tracecompass.lttng2.ust.core.tests/src/org/eclipse/tracecompass/lttng2/ust/core/tests/trace/callstack/AbstractProviderTest.java +++ b/org.eclipse.tracecompass.lttng2.ust.core.tests/src/org/eclipse/tracecompass/lttng2/ust/core/tests/trace/callstack/AbstractProviderTest.java @@ -12,6 +12,7 @@ package org.eclipse.tracecompass.lttng2.ust.core.tests.trace.callstack; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; @@ -285,7 +286,7 @@ public abstract class AbstractProviderTest { @Override protected ITmfStateProvider createStateProvider() { - return new LttngUstCallStackProvider(getTrace()); + return new LttngUstCallStackProvider(checkNotNull(getTrace())); } } } diff --git a/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/internal/lttng2/ust/core/memoryusage/MemoryUsageStateProvider.java b/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/internal/lttng2/ust/core/memoryusage/MemoryUsageStateProvider.java index 81e8c57da7..479d528201 100644 --- a/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/internal/lttng2/ust/core/memoryusage/MemoryUsageStateProvider.java +++ b/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/internal/lttng2/ust/core/memoryusage/MemoryUsageStateProvider.java @@ -13,10 +13,14 @@ package org.eclipse.tracecompass.internal.lttng2.ust.core.memoryusage; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import java.util.HashMap; import java.util.Map; +import org.eclipse.jdt.annotation.NonNull; import org.eclipse.tracecompass.lttng2.ust.core.trace.LttngUstTrace; +import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException; import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException; import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException; @@ -53,7 +57,7 @@ public class MemoryUsageStateProvider extends AbstractTmfStateProvider { * @param trace * trace */ - public MemoryUsageStateProvider(LttngUstTrace trace) { + public MemoryUsageStateProvider(@NonNull LttngUstTrace trace) { super(trace, CtfTmfEvent.class, "Ust:Memory"); //$NON-NLS-1$ } @@ -155,6 +159,7 @@ public class MemoryUsageStateProvider extends AbstractTmfStateProvider { } private void setMem(ITmfEvent event, Long ptr, Long size) { + ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder()); long ts = event.getTimestamp().getValue(); Long tid = getVtid(event); diff --git a/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/internal/lttng2/ust/core/trace/callstack/LttngUstCallStackProvider.java b/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/internal/lttng2/ust/core/trace/callstack/LttngUstCallStackProvider.java index ed0f6e8a6f..2c58384f13 100644 --- a/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/internal/lttng2/ust/core/trace/callstack/LttngUstCallStackProvider.java +++ b/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/internal/lttng2/ust/core/trace/callstack/LttngUstCallStackProvider.java @@ -16,6 +16,7 @@ package org.eclipse.tracecompass.internal.lttng2.ust.core.trace.callstack; import java.util.HashSet; import java.util.Set; +import org.eclipse.jdt.annotation.NonNull; import org.eclipse.tracecompass.tmf.core.callstack.CallStackStateProvider; import org.eclipse.tracecompass.tmf.core.event.ITmfEvent; import org.eclipse.tracecompass.tmf.core.event.ITmfEventField; @@ -81,7 +82,7 @@ public class LttngUstCallStackProvider extends CallStackStateProvider { * @param trace * The UST trace */ - public LttngUstCallStackProvider(ITmfTrace trace) { + public LttngUstCallStackProvider(@NonNull ITmfTrace trace) { super(trace); } diff --git a/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/memory/UstMemoryAnalysisModule.java b/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/memory/UstMemoryAnalysisModule.java index e6ec22e504..e48ad20557 100644 --- a/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/memory/UstMemoryAnalysisModule.java +++ b/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/memory/UstMemoryAnalysisModule.java @@ -76,7 +76,7 @@ public class UstMemoryAnalysisModule extends TmfStateSystemAnalysisModule { @Override protected ITmfStateProvider createStateProvider() { - return new MemoryUsageStateProvider(getTrace()); + return new MemoryUsageStateProvider(checkNotNull(getTrace())); } @Override diff --git a/org.eclipse.tracecompass.lttng2.ust.ui/META-INF/MANIFEST.MF b/org.eclipse.tracecompass.lttng2.ust.ui/META-INF/MANIFEST.MF index ed55587269..dda6e4fc88 100644 --- a/org.eclipse.tracecompass.lttng2.ust.ui/META-INF/MANIFEST.MF +++ b/org.eclipse.tracecompass.lttng2.ust.ui/META-INF/MANIFEST.MF @@ -11,6 +11,7 @@ Bundle-RequiredExecutionEnvironment: JavaSE-1.7 Require-Bundle: org.eclipse.core.resources, org.eclipse.core.runtime, org.eclipse.ui, + org.eclipse.tracecompass.common.core;bundle-version="0.1.0", org.eclipse.tracecompass.lttng2.ust.core;bundle-version="0.1.0", org.eclipse.tracecompass.tmf.core;bundle-version="0.1.0", org.eclipse.tracecompass.tmf.ui;bundle-version="0.1.0", diff --git a/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysis.java b/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysis.java index 53543d589d..c675af9cb0 100644 --- a/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysis.java +++ b/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysis.java @@ -12,6 +12,8 @@ package org.eclipse.tracecompass.lttng2.ust.ui.analysis.callstack; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import org.eclipse.tracecompass.internal.lttng2.ust.core.trace.callstack.LttngUstCallStackProvider; import org.eclipse.tracecompass.lttng2.ust.core.trace.LttngUstTrace; import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException; @@ -43,7 +45,7 @@ public class LttngUstCallStackAnalysis extends AbstractCallStackAnalysis { @Override protected ITmfStateProvider createStateProvider() { - return new LttngUstCallStackProvider(getTrace()); + return new LttngUstCallStackProvider(checkNotNull(getTrace())); } } diff --git a/org.eclipse.tracecompass.tmf.analysis.xml.core/src/org/eclipse/tracecompass/tmf/analysis/xml/core/stateprovider/XmlStateProvider.java b/org.eclipse.tracecompass.tmf.analysis.xml.core/src/org/eclipse/tracecompass/tmf/analysis/xml/core/stateprovider/XmlStateProvider.java index ca31f205f6..52b814fba1 100644 --- a/org.eclipse.tracecompass.tmf.analysis.xml.core/src/org/eclipse/tracecompass/tmf/analysis/xml/core/stateprovider/XmlStateProvider.java +++ b/org.eclipse.tracecompass.tmf.analysis.xml.core/src/org/eclipse/tracecompass/tmf/analysis/xml/core/stateprovider/XmlStateProvider.java @@ -69,7 +69,7 @@ public class XmlStateProvider extends AbstractTmfStateProvider implements IXmlSt * @param file * Path to the XML file containing the state provider definition */ - public XmlStateProvider(ITmfTrace trace, @NonNull String stateid, IPath file) { + public XmlStateProvider(@NonNull ITmfTrace trace, @NonNull String stateid, IPath file) { super(trace, ITmfEvent.class, stateid); fStateId = stateid; fFilePath = file; @@ -144,9 +144,6 @@ public class XmlStateProvider extends AbstractTmfStateProvider implements IXmlSt @Override protected void eventHandle(ITmfEvent event) { - if (event == null) { - return; - } for (TmfXmlEventHandler eventHandler : fEventHandlers) { eventHandler.handleEvent(event); } @@ -154,7 +151,7 @@ public class XmlStateProvider extends AbstractTmfStateProvider implements IXmlSt @Override public ITmfStateSystem getStateSystem() { - return ss; + return getStateSystemBuilder(); } // ------------------------------------------------------------------------ diff --git a/org.eclipse.tracecompass.tmf.analysis.xml.core/src/org/eclipse/tracecompass/tmf/analysis/xml/core/stateprovider/XmlStateSystemModule.java b/org.eclipse.tracecompass.tmf.analysis.xml.core/src/org/eclipse/tracecompass/tmf/analysis/xml/core/stateprovider/XmlStateSystemModule.java index 0bb3327481..8e72f9ffd0 100644 --- a/org.eclipse.tracecompass.tmf.analysis.xml.core/src/org/eclipse/tracecompass/tmf/analysis/xml/core/stateprovider/XmlStateSystemModule.java +++ b/org.eclipse.tracecompass.tmf.analysis.xml.core/src/org/eclipse/tracecompass/tmf/analysis/xml/core/stateprovider/XmlStateSystemModule.java @@ -12,6 +12,8 @@ package org.eclipse.tracecompass.tmf.analysis.xml.core.stateprovider; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import java.util.List; import org.eclipse.core.runtime.IPath; @@ -40,7 +42,7 @@ public class XmlStateSystemModule extends TmfStateSystemAnalysisModule { @Override @NonNull protected ITmfStateProvider createStateProvider() { - return new XmlStateProvider(getTrace(), getId(), fXmlFile); + return new XmlStateProvider(checkNotNull(getTrace()), getId(), fXmlFile); } @Override diff --git a/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderStub.java b/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderStub.java index a12480304c..722a0130c7 100644 --- a/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderStub.java +++ b/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderStub.java @@ -13,8 +13,12 @@ package org.eclipse.tracecompass.tmf.core.tests.statesystem.mipmap; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + +import org.eclipse.jdt.annotation.NonNull; import org.eclipse.tracecompass.internal.tmf.core.Activator; import org.eclipse.tracecompass.internal.tmf.core.statesystem.mipmap.AbstractTmfMipmapStateProvider; +import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException; import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException; import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException; @@ -29,6 +33,7 @@ import org.eclipse.tracecompass.tmf.core.event.TmfEventType; import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp; import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp; import org.eclipse.tracecompass.tmf.core.trace.ITmfContext; +import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub; /** * A mipmap state provider for test @@ -42,7 +47,7 @@ class TmfMipmapStateProviderStub extends AbstractTmfMipmapStateProvider { private int resolution; private ITmfStateValue.Type type; - private final static String MIPMAP_ID = "MIPMAP_ID"; //$NON-NLS-1$ + private static final @NonNull String MIPMAP_ID = "MIPMAP_ID"; //$NON-NLS-1$ private final String ERROR_ATTRIBUTE_NOT_FOUND = "Error : Impossible to find the attribute"; //$NON-NLS-1$ private final String ERROR_INVALID_STATE_VALUE = "Error : Invalid state value"; //$NON-NLS-1$ @@ -57,13 +62,14 @@ class TmfMipmapStateProviderStub extends AbstractTmfMipmapStateProvider { * the type of value to use */ public TmfMipmapStateProviderStub(int resolution, ITmfStateValue.Type type) { - super(null, TmfEvent.class, MIPMAP_ID); + super(new TmfTraceStub(), TmfEvent.class, MIPMAP_ID); this.resolution = resolution; this.type = type; } @Override protected void eventHandle(ITmfEvent ev) { + ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder()); final long ts = ev.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue(); try { int quark = ss.getQuarkAbsoluteAndAdd(TEST_ATTRIBUTE_NAME); @@ -95,7 +101,7 @@ class TmfMipmapStateProviderStub extends AbstractTmfMipmapStateProvider { * The event value or null * @return A new TmfEvent */ - public ITmfEvent createEvent(long time, Long longVal) { + public @NonNull ITmfEvent createEvent(long time, Long longVal) { ITmfStateValue value; if (longVal == null) { value = TmfStateValue.nullValue(); diff --git a/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderTest.java b/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderTest.java index 42cac462be..b4c3bd0eb4 100644 --- a/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderTest.java +++ b/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderTest.java @@ -63,8 +63,9 @@ public class TmfMipmapStateProviderTest { public static void init() { TmfMipmapStateProviderStub mmp = new TmfMipmapStateProviderStub(RESOLUTION, Type.LONG); IStateHistoryBackend be = new InMemoryBackend(0); - ssq = StateSystemFactory.newStateSystem(SSID, be); - mmp.assignTargetStateSystem(ssq); + ITmfStateSystemBuilder ssb = StateSystemFactory.newStateSystem(SSID, be); + mmp.assignTargetStateSystem(ssb); + ssq = ssb; for (long time = START_TIME; time <= END_TIME; time += INTERVAL) { long value = time / INTERVAL; diff --git a/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderWeightedTest.java b/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderWeightedTest.java index 26ddcc7f18..250c918bc6 100644 --- a/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderWeightedTest.java +++ b/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderWeightedTest.java @@ -53,13 +53,15 @@ public class TmfMipmapStateProviderWeightedTest { /* setup for INTEGER test */ TmfMipmapStateProviderStub mmpi = new TmfMipmapStateProviderStub(RESOLUTION, Type.INTEGER); IStateHistoryBackend bei = new InMemoryBackend(0); - ssqi = StateSystemFactory.newStateSystem(SSID, bei); - mmpi.assignTargetStateSystem(ssqi); + ITmfStateSystemBuilder ssbi = StateSystemFactory.newStateSystem(SSID, bei); + mmpi.assignTargetStateSystem(ssbi); + ssqi = ssbi; /* setup for DOUBLE test */ TmfMipmapStateProviderStub mmpd = new TmfMipmapStateProviderStub(RESOLUTION, Type.DOUBLE); IStateHistoryBackend bed = new InMemoryBackend(0); - ssqd = StateSystemFactory.newStateSystem(SSID, bed); - mmpd.assignTargetStateSystem(ssqd); + ITmfStateSystemBuilder ssbd = StateSystemFactory.newStateSystem(SSID, bed); + mmpd.assignTargetStateSystem(ssbd); + ssqd = ssbd; /* * Every 10,000 ns chunk contains the following states: * diff --git a/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestExperimentAnalysis.java b/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestExperimentAnalysis.java index 29df80586d..3448c6396c 100644 --- a/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestExperimentAnalysis.java +++ b/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestExperimentAnalysis.java @@ -12,9 +12,13 @@ package org.eclipse.tracecompass.tmf.tests.stubs.analysis; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import java.util.HashSet; import java.util.Set; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException; import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException; import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException; @@ -43,7 +47,7 @@ public class TestExperimentAnalysis extends TmfStateSystemAnalysisModule { @Override protected ITmfStateProvider createStateProvider() { - return new TestExpStateSystemProvider(getTrace()); + return new TestExpStateSystemProvider(checkNotNull(getTrace())); } @Override @@ -63,7 +67,7 @@ public class TestExperimentAnalysis extends TmfStateSystemAnalysisModule { * @param trace * The LTTng 2.0 kernel trace directory */ - public TestExpStateSystemProvider(ITmfTrace trace) { + public TestExpStateSystemProvider(@NonNull ITmfTrace trace) { super(trace, TmfEvent.class, "Stub State System for Experiment"); } @@ -79,6 +83,7 @@ public class TestExperimentAnalysis extends TmfStateSystemAnalysisModule { @Override protected void eventHandle(ITmfEvent event) { + ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder()); if (!fTraces.contains(event.getTrace())) { try { int quarkId = ss.getQuarkAbsoluteAndAdd(TRACE_QUARK_NAME); diff --git a/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestStateSystemModule.java b/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestStateSystemModule.java index 7174b1f027..2d8e9a8dfc 100644 --- a/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestStateSystemModule.java +++ b/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestStateSystemModule.java @@ -12,6 +12,8 @@ package org.eclipse.tracecompass.tmf.tests.stubs.analysis; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import org.eclipse.jdt.annotation.NonNullByDefault; import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider; import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule; @@ -26,7 +28,7 @@ public class TestStateSystemModule extends TmfStateSystemAnalysisModule { @Override protected ITmfStateProvider createStateProvider() { - return new TestStateSystemProvider(getTrace()); + return new TestStateSystemProvider(checkNotNull(getTrace())); } @Override diff --git a/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestStateSystemProvider.java b/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestStateSystemProvider.java index c61434e7f4..7af1d92313 100644 --- a/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestStateSystemProvider.java +++ b/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestStateSystemProvider.java @@ -12,6 +12,10 @@ package org.eclipse.tracecompass.tmf.tests.stubs.analysis; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException; import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException; import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException; @@ -39,7 +43,7 @@ public class TestStateSystemProvider extends AbstractTmfStateProvider { * @param trace * The LTTng 2.0 kernel trace directory */ - public TestStateSystemProvider(ITmfTrace trace) { + public TestStateSystemProvider(@NonNull ITmfTrace trace) { super(trace, TmfEvent.class, "Stub State System"); } @@ -55,6 +59,8 @@ public class TestStateSystemProvider extends AbstractTmfStateProvider { @Override protected void eventHandle(ITmfEvent event) { + ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder()); + /* Just need something to fill the state system */ if (fString.equals(event.getContent().getValue())) { try { diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/internal/tmf/core/statesystem/mipmap/AbstractTmfMipmapStateProvider.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/internal/tmf/core/statesystem/mipmap/AbstractTmfMipmapStateProvider.java index 4de3159888..ea32edb000 100644 --- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/internal/tmf/core/statesystem/mipmap/AbstractTmfMipmapStateProvider.java +++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/internal/tmf/core/statesystem/mipmap/AbstractTmfMipmapStateProvider.java @@ -13,11 +13,15 @@ package org.eclipse.tracecompass.internal.tmf.core.statesystem.mipmap; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import java.util.HashMap; import java.util.LinkedHashSet; import java.util.Map; import java.util.Set; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException; import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException; import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException; @@ -92,7 +96,9 @@ public abstract class AbstractTmfMipmapStateProvider extends AbstractTmfStatePro * The name given to this state change input. Only used * internally. */ - public AbstractTmfMipmapStateProvider(ITmfTrace trace, Class eventType, String id) { + public AbstractTmfMipmapStateProvider(@NonNull ITmfTrace trace, + @NonNull Class eventType, + @NonNull String id) { super(trace, eventType, id); } @@ -143,6 +149,7 @@ public abstract class AbstractTmfMipmapStateProvider extends AbstractTmfStatePro */ public void modifyMipmapAttribute(long ts, ITmfStateValue value, int baseQuark, int mipmapFeatureBits, int resolution) throws TimeRangeException, AttributeNotFoundException, StateValueTypeException { + ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder()); ss.modifyAttribute(ts, value, baseQuark); if (value.getType() == Type.LONG || value.getType() == Type.INTEGER || value.getType() == Type.DOUBLE || value.isNull()) { Set features = getFeatureSet(baseQuark, ts, value, mipmapFeatureBits, resolution); @@ -157,6 +164,8 @@ public abstract class AbstractTmfMipmapStateProvider extends AbstractTmfStatePro // ------------------------------------------------------------------------ private Set getFeatureSet(int baseQuark, long ts, ITmfStateValue value, int mipmapFeatureBits, int resolution) { + ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder()); + Set features = featureMap.get(baseQuark); if (features != null) { return features; diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/callstack/CallStackStateProvider.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/callstack/CallStackStateProvider.java index c0ff03c8d2..9307b11118 100644 --- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/callstack/CallStackStateProvider.java +++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/callstack/CallStackStateProvider.java @@ -12,8 +12,12 @@ package org.eclipse.tracecompass.tmf.core.callstack; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + +import org.eclipse.jdt.annotation.NonNull; import org.eclipse.osgi.util.NLS; import org.eclipse.tracecompass.internal.tmf.core.Activator; +import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException; import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException; import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException; @@ -73,7 +77,7 @@ public abstract class CallStackStateProvider extends AbstractTmfStateProvider { public static final String UNDEFINED = "UNDEFINED"; //$NON-NLS-1$ /** CallStack state system ID */ - private static final String ID = "org.eclipse.linuxtools.tmf.callstack"; //$NON-NLS-1$ + private static final @NonNull String ID = "org.eclipse.linuxtools.tmf.callstack"; //$NON-NLS-1$ /** Dummy function name for when no function is expected */ private static final String NO_FUNCTION = "no function"; //$NON-NLS-1$ @@ -83,7 +87,7 @@ public abstract class CallStackStateProvider extends AbstractTmfStateProvider { * @param trace * The trace for which we build this state system */ - public CallStackStateProvider(ITmfTrace trace) { + public CallStackStateProvider(@NonNull ITmfTrace trace) { super(trace, ITmfEvent.class, ID); } @@ -92,6 +96,9 @@ public abstract class CallStackStateProvider extends AbstractTmfStateProvider { if (!considerEvent(event)) { return; } + + ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder()); + try { /* Check if the event is a function entry */ String functionEntryName = functionEntry(event); diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/AbstractTmfStateProvider.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/AbstractTmfStateProvider.java index 599d5fa3c2..bd7b96ec7b 100644 --- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/AbstractTmfStateProvider.java +++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/AbstractTmfStateProvider.java @@ -15,6 +15,7 @@ package org.eclipse.tracecompass.tmf.core.statesystem; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; +import org.eclipse.jdt.annotation.Nullable; import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem; import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; import org.eclipse.tracecompass.tmf.core.event.ITmfEvent; @@ -48,7 +49,7 @@ public abstract class AbstractTmfStateProvider implements ITmfStateProvider { private boolean ssAssigned; /** State system in which to insert the state changes */ - protected ITmfStateSystemBuilder ss = null; + private @Nullable ITmfStateSystemBuilder ss = null; /** * Instantiate a new state provider plugin. @@ -68,8 +69,16 @@ public abstract class AbstractTmfStateProvider implements ITmfStateProvider { eventsQueue = new ArrayBlockingQueue<>(DEFAULT_EVENTS_QUEUE_SIZE); ssAssigned = false; - String id2 = (id == null ? "Unamed" : id); //$NON-NLS-1$ - eventHandlerThread = new Thread(new EventProcessor(), id2 + " Event Handler"); //$NON-NLS-1$ + eventHandlerThread = new Thread(new EventProcessor(), id + " Event Handler"); //$NON-NLS-1$ + } + + /** + * Get the state system builder of this provider (to insert states in). + * + * @return The state system object to be filled + */ + protected @Nullable ITmfStateSystemBuilder getStateSystemBuilder() { + return ss; } @Override @@ -99,7 +108,7 @@ public abstract class AbstractTmfStateProvider implements ITmfStateProvider { * @since 3.0 */ @Override - public ITmfStateSystem getAssignedStateSystem() { + public @Nullable ITmfStateSystem getAssignedStateSystem() { return ss; } @@ -188,7 +197,7 @@ public abstract class AbstractTmfStateProvider implements ITmfStateProvider { */ private class EventProcessor implements Runnable { - private ITmfEvent currentEvent; + private @Nullable ITmfEvent currentEvent; @Override public void run() { @@ -226,9 +235,13 @@ public abstract class AbstractTmfStateProvider implements ITmfStateProvider { } private void closeStateSystem() { - final long endTime = (currentEvent == null) ? 0 : - currentEvent.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue(); - ss.closeHistory(endTime); + ITmfEvent event = currentEvent; + final long endTime = (event == null) ? 0 : + event.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue(); + + if (ss != null) { + ss.closeHistory(endTime); + } } } diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/ITmfAnalysisModuleWithStateSystems.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/ITmfAnalysisModuleWithStateSystems.java index 1d8ec286ed..18b93365c4 100644 --- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/ITmfAnalysisModuleWithStateSystems.java +++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/ITmfAnalysisModuleWithStateSystems.java @@ -12,7 +12,6 @@ package org.eclipse.tracecompass.tmf.core.statesystem; -import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem; import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule; @@ -33,8 +32,7 @@ public interface ITmfAnalysisModuleWithStateSystems extends IAnalysisModule { * @return The state system corresponding to the given ID, null if there is * no match. */ - @Nullable - ITmfStateSystem getStateSystem(@NonNull String id); + @Nullable ITmfStateSystem getStateSystem(String id); /** * Return all the state systems provided by this analysis module, in @@ -42,7 +40,6 @@ public interface ITmfAnalysisModuleWithStateSystems extends IAnalysisModule { * * @return The state systems */ - @NonNull Iterable getStateSystems(); } diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/ITmfStateProvider.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/ITmfStateProvider.java index c355b470f6..1441c6012b 100644 --- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/ITmfStateProvider.java +++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/ITmfStateProvider.java @@ -12,6 +12,7 @@ package org.eclipse.tracecompass.tmf.core.statesystem; +import org.eclipse.jdt.annotation.Nullable; import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem; import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; import org.eclipse.tracecompass.tmf.core.event.ITmfEvent; @@ -88,7 +89,7 @@ public interface ITmfStateProvider { * SS is assigned yet * @since 3.0 */ - ITmfStateSystem getAssignedStateSystem(); + @Nullable ITmfStateSystem getAssignedStateSystem(); /** * Send an event to this input plugin for processing. The implementation diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/TmfStateSystemAnalysisModule.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/TmfStateSystemAnalysisModule.java index 9a087a341f..cde3bd9fc2 100644 --- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/TmfStateSystemAnalysisModule.java +++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/TmfStateSystemAnalysisModule.java @@ -23,7 +23,6 @@ import java.util.concurrent.CountDownLatch; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.NullProgressMonitor; -import org.eclipse.jdt.annotation.NonNullByDefault; import org.eclipse.jdt.annotation.Nullable; import org.eclipse.tracecompass.internal.tmf.core.statesystem.backends.partial.PartialHistoryBackend; import org.eclipse.tracecompass.internal.tmf.core.statesystem.backends.partial.PartialStateSystem; @@ -61,7 +60,6 @@ import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment; * @author Geneviève Bastien * @since 3.0 */ -@NonNullByDefault public abstract class TmfStateSystemAnalysisModule extends TmfAbstractAnalysisModule implements ITmfAnalysisModuleWithStateSystems { @@ -442,7 +440,7 @@ public abstract class TmfStateSystemAnalysisModule extends TmfAbstractAnalysisMo fTimeRange = TmfTimeRange.ETERNITY; final ITmfTrace trace = provider.getTrace(); - if (trace != null && !isCompleteTrace(trace)) { + if (!isCompleteTrace(trace)) { TmfTimeRange traceTimeRange = trace.getTimeRange(); if (traceTimeRange != null) { fTimeRange = traceTimeRange; diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/package-info.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/package-info.java new file mode 100644 index 0000000000..a626ba31f0 --- /dev/null +++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statesystem/package-info.java @@ -0,0 +1,14 @@ +/******************************************************************************* + * Copyright (c) 2014 Ericsson + * + * 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 + * + * Contributors: + * Ericsson - Initial API and implementation + *******************************************************************************/ + +@org.eclipse.jdt.annotation.NonNullByDefault +package org.eclipse.tracecompass.tmf.core.statesystem; diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statistics/TmfStatisticsEventTypesModule.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statistics/TmfStatisticsEventTypesModule.java index 70f998fb88..708d520d82 100644 --- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statistics/TmfStatisticsEventTypesModule.java +++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statistics/TmfStatisticsEventTypesModule.java @@ -12,7 +12,10 @@ package org.eclipse.tracecompass.tmf.core.statistics; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException; import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException; import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException; @@ -55,7 +58,7 @@ public class TmfStatisticsEventTypesModule extends TmfStateSystemAnalysisModule @Override protected ITmfStateProvider createStateProvider() { - return new StatsProviderEventTypes(getTrace()); + return new StatsProviderEventTypes(checkNotNull(getTrace())); } @Override @@ -100,7 +103,7 @@ public class TmfStatisticsEventTypesModule extends TmfStateSystemAnalysisModule * @param trace * The trace for which we build this state system */ - public StatsProviderEventTypes(ITmfTrace trace) { + public StatsProviderEventTypes(@NonNull ITmfTrace trace) { super(trace, ITmfEvent.class ,"TMF Statistics, events per type"); //$NON-NLS-1$ } @@ -116,6 +119,7 @@ public class TmfStatisticsEventTypesModule extends TmfStateSystemAnalysisModule @Override protected void eventHandle(ITmfEvent event) { + ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder()); int quark; /* Since this can be used for any trace types, normalize all the diff --git a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statistics/TmfStatisticsTotalsModule.java b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statistics/TmfStatisticsTotalsModule.java index f72bf38fc6..cd8e889a1b 100644 --- a/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statistics/TmfStatisticsTotalsModule.java +++ b/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/statistics/TmfStatisticsTotalsModule.java @@ -12,7 +12,10 @@ package org.eclipse.tracecompass.tmf.core.statistics; +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException; import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException; import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException; @@ -54,7 +57,7 @@ public class TmfStatisticsTotalsModule extends TmfStateSystemAnalysisModule { @Override protected ITmfStateProvider createStateProvider() { - return new StatsProviderTotals(getTrace()); + return new StatsProviderTotals(checkNotNull(getTrace())); } @Override @@ -92,7 +95,7 @@ public class TmfStatisticsTotalsModule extends TmfStateSystemAnalysisModule { * @param trace * The trace for which we build this state system */ - public StatsProviderTotals(ITmfTrace trace) { + public StatsProviderTotals(@NonNull ITmfTrace trace) { super(trace, ITmfEvent.class , NAME); } @@ -113,6 +116,8 @@ public class TmfStatisticsTotalsModule extends TmfStateSystemAnalysisModule { return; } + ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder()); + /* Since this can be used for any trace types, normalize all the * timestamp values to nanoseconds. */ final long ts = event.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue(); -- 2.34.1