X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=org.eclipse.linuxtools.lttng2.kernel.core.tests%2Fsrc%2Forg%2Feclipse%2Flinuxtools%2Flttng2%2Fkernel%2Fcore%2Ftests%2Fstateprovider%2FStateSystemFullHistoryTest.java;h=f3919ff60835e93ab07cd08fcf7e54842eaf8616;hb=f1f86dfb492c7e41eb81a62c651b26e7b4fdb406;hp=41e9a1dc4c9e399eb28bfaf5c9f7a8a957d36d69;hpb=6b78e55bae3827497518c2533167390228f920ef;p=deliverable%2Ftracecompass.git diff --git a/org.eclipse.linuxtools.lttng2.kernel.core.tests/src/org/eclipse/linuxtools/lttng2/kernel/core/tests/stateprovider/StateSystemFullHistoryTest.java b/org.eclipse.linuxtools.lttng2.kernel.core.tests/src/org/eclipse/linuxtools/lttng2/kernel/core/tests/stateprovider/StateSystemFullHistoryTest.java index 41e9a1dc4c..f3919ff608 100644 --- a/org.eclipse.linuxtools.lttng2.kernel.core.tests/src/org/eclipse/linuxtools/lttng2/kernel/core/tests/stateprovider/StateSystemFullHistoryTest.java +++ b/org.eclipse.linuxtools.lttng2.kernel.core.tests/src/org/eclipse/linuxtools/lttng2/kernel/core/tests/stateprovider/StateSystemFullHistoryTest.java @@ -2,54 +2,52 @@ * Copyright (c) 2012 Ericsson * Copyright (c) 2010, 2011 École Polytechnique de Montréal * Copyright (c) 2010, 2011 Alexandre Montplaisir - * + * * 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.linuxtools.lttng2.kernel.core.tests.stateprovider; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; import java.io.File; -import java.io.FileNotFoundException; -import java.io.IOException; -import java.io.PrintWriter; import java.util.List; -import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval; -import org.eclipse.linuxtools.tmf.core.statesystem.AttributeNotFoundException; -import org.eclipse.linuxtools.tmf.core.statesystem.StateHistorySystem; -import org.eclipse.linuxtools.tmf.core.statesystem.TimeRangeException; -import org.eclipse.linuxtools.tmf.core.statesystem.backend.historytree.HistoryTreeBackend; -import org.eclipse.linuxtools.tmf.core.statesystem.helpers.HistoryBuilder; -import org.eclipse.linuxtools.tmf.core.statesystem.helpers.IStateChangeInput; -import org.eclipse.linuxtools.tmf.core.statesystem.helpers.IStateHistoryBackend; -import org.eclipse.linuxtools.tmf.core.statevalue.StateValueTypeException; +import org.eclipse.linuxtools.internal.lttng2.kernel.core.Attributes; import org.eclipse.linuxtools.internal.lttng2.kernel.core.stateprovider.CtfKernelStateInput; -import org.eclipse.linuxtools.lttng2.kernel.core.trace.Attributes; -import org.junit.*; +import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException; +import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException; +import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException; +import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException; +import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval; +import org.eclipse.linuxtools.tmf.core.statesystem.IStateChangeInput; +import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystem; +import org.eclipse.linuxtools.tmf.core.statesystem.StateSystemManager; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; /** * Unit tests for the StateHistorySystem, which uses a full (non-partial) * history and the non-threaded CTF kernel handler. - * + * * @author alexmont - * + * */ -@SuppressWarnings("nls") +@SuppressWarnings({"nls", "javadoc"}) public class StateSystemFullHistoryTest { static File stateFile; static File stateFileBenchmark; - static HistoryBuilder builder; static IStateChangeInput input; - static IStateHistoryBackend hp; - static StateHistorySystem shs; + static ITmfStateSystem ssq; /* Offset in the trace + start time of the trace */ private final static long interestingTimestamp1 = 18670067372290L + 1331649577946812237L; @@ -64,14 +62,10 @@ public class StateSystemFullHistoryTest { stateFileBenchmark = new File(getTestFileName() + ".benchmark"); //$NON-NLS-1$ try { input = new CtfKernelStateInput(CtfTestFiles.getTestTrace()); - hp = new HistoryTreeBackend(stateFile, input.getStartTime()); - builder = new HistoryBuilder(input, hp); + ssq = StateSystemManager.loadStateHistory(stateFile, input, true); } catch (Exception e) { e.printStackTrace(); } - builder.run(); - shs = (StateHistorySystem) builder.getSS(); - builder.close(); /* Waits for the construction to finish */ } @AfterClass @@ -88,36 +82,32 @@ public class StateSystemFullHistoryTest { /** * Rebuild independently so we can benchmark it. Too bad JUnit doesn't allow * us to @Test the @BeforeClass... + * + * @throws IOException + * @throws TmfTraceException */ @Test - public void testBuild() { - HistoryBuilder zebuilder; - IStateChangeInput zeinput; - IStateHistoryBackend zehp; + public void testBuild() throws TmfTraceException { + IStateChangeInput input2; + ITmfStateSystem ssb2; - try { - zeinput = new CtfKernelStateInput(CtfTestFiles.getTestTrace()); - zehp = new HistoryTreeBackend(stateFileBenchmark, - zeinput.getStartTime()); - zebuilder = new HistoryBuilder(zeinput, zehp); - zebuilder.run(); - } catch (Exception e) { - e.printStackTrace(); - } + input2 = new CtfKernelStateInput(CtfTestFiles.getTestTrace()); + ssb2 = StateSystemManager.loadStateHistory(stateFileBenchmark, input2, true); + + assertEquals(CtfTestFiles.startTime, ssb2.getStartTime()); + assertEquals(CtfTestFiles.endTime, ssb2.getCurrentEndTime()); } @Test - public void testOpenExistingStateFile() { - IStateHistoryBackend hp2 = null; - StateHistorySystem shs2 = null; - try { - /* 'newStateFile' should have already been created */ - hp2 = new HistoryTreeBackend(stateFile); - shs2 = new StateHistorySystem(hp2, false); - } catch (IOException e) { - e.printStackTrace(); - } - assertTrue(shs2 != null); + public void testOpenExistingStateFile() throws TmfTraceException { + ITmfStateSystem ssb2; + + /* 'newStateFile' should have already been created */ + ssb2 = StateSystemManager.loadStateHistory(stateFile, null, true); + + assertNotNull(ssb2); + assertEquals(CtfTestFiles.startTime, ssb2.getStartTime()); + assertEquals(CtfTestFiles.endTime, ssb2.getCurrentEndTime()); } @Test @@ -126,27 +116,23 @@ public class StateSystemFullHistoryTest { List list; ITmfStateInterval interval; - int quark, quark2, valueInt; + int quark, valueInt; String valueStr; - list = shs.loadStateAtTime(interestingTimestamp1); + list = ssq.queryFullState(interestingTimestamp1); - quark = shs.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); + quark = ssq.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); interval = list.get(quark); valueInt = interval.getStateValue().unboxInt(); assertEquals(1397, valueInt); - quark = shs.getQuarkAbsolute(Attributes.THREADS, "1432", Attributes.EXEC_NAME); + quark = ssq.getQuarkAbsolute(Attributes.THREADS, "1432", Attributes.EXEC_NAME); interval = list.get(quark); valueStr = interval.getStateValue().unboxStr(); assertEquals("gdbus", valueStr); - /* Query a stack attribute, has to be done in two passes */ - quark = shs.getQuarkAbsolute(Attributes.THREADS, "1432", Attributes.EXEC_MODE_STACK); + quark = ssq.getQuarkAbsolute(Attributes.THREADS, "1432", Attributes.SYSTEM_CALL); interval = list.get(quark); - valueInt = interval.getStateValue().unboxInt(); /* The stack depth */ - quark2 = shs.getQuarkRelative(quark, Integer.toString(valueInt)); - interval = list.get(quark2); valueStr = interval.getStateValue().unboxStr(); assertTrue(valueStr.equals("sys_poll")); } @@ -170,8 +156,8 @@ public class StateSystemFullHistoryTest { ITmfStateInterval interval; String valueStr; - quark = shs.getQuarkAbsolute(Attributes.THREADS, "1432", Attributes.EXEC_NAME); - interval = shs.querySingleState(timestamp, quark); + quark = ssq.getQuarkAbsolute(Attributes.THREADS, "1432", Attributes.EXEC_NAME); + interval = ssq.querySingleState(timestamp, quark); valueStr = interval.getStateValue().unboxStr(); assertEquals("gdbus", valueStr); } @@ -198,8 +184,8 @@ public class StateSystemFullHistoryTest { int quark; List intervals; - quark = shs.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); - intervals = shs.queryHistoryRange(quark, time1, time2); + quark = ssq.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); + intervals = ssq.queryHistoryRange(quark, time1, time2); assertEquals(487, intervals.size()); /* Number of context switches! */ assertEquals(1685, intervals.get(100).getStateValue().unboxInt()); assertEquals(1331668248427681372L, intervals.get(205).getEndTime()); @@ -214,15 +200,15 @@ public class StateSystemFullHistoryTest { AttributeNotFoundException { List intervals; - - int quark = shs.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.IRQ_STACK); - long ts1 = shs.getHistoryBackend().getStartTime(); /* start of the trace */ + + int quark = ssq.getQuarkAbsolute(Attributes.RESOURCES, Attributes.IRQS, "1"); + long ts1 = ssq.getStartTime(); /* start of the trace */ long ts2 = CtfTestFiles.startTime + 20L * CtfTestFiles.NANOSECS_PER_SEC; /* invalid, but ignored */ - intervals = shs.queryHistoryRange(quark, ts1, ts2); + intervals = ssq.queryHistoryRange(quark, ts1, ts2); - /* Nb of IRQs on CPU 0 during the whole trace */ - assertEquals(1653, intervals.size()); + /* Activity of IRQ 1 over the whole trace */ + assertEquals(65, intervals.size()); } /** @@ -238,29 +224,29 @@ public class StateSystemFullHistoryTest { int quark; List intervals; - quark = shs.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); - intervals = shs.queryHistoryRange(quark, time1, time2, resolution); - assertEquals(129, intervals.size()); /* Number of context switches! */ + quark = ssq.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); + intervals = ssq.queryHistoryRange(quark, time1, time2, resolution, null); + assertEquals(126, intervals.size()); /* Number of context switches! */ assertEquals(1452, intervals.get(50).getStateValue().unboxInt()); - assertEquals(1331668248784789238L, intervals.get(100).getEndTime()); + assertEquals(1331668248815698779L, intervals.get(100).getEndTime()); } /** * Ask for a time range outside of the trace's range - * + * * @throws TimeRangeException */ @Test(expected = TimeRangeException.class) public void testFullQueryInvalidTime1() throws TimeRangeException { long ts = CtfTestFiles.startTime + 20L * CtfTestFiles.NANOSECS_PER_SEC; - shs.loadStateAtTime(ts); + ssq.queryFullState(ts); } @Test(expected = TimeRangeException.class) public void testFullQueryInvalidTime2() throws TimeRangeException { long ts = CtfTestFiles.startTime - 20L * CtfTestFiles.NANOSECS_PER_SEC; - shs.loadStateAtTime(ts); + ssq.queryFullState(ts); } @@ -268,56 +254,56 @@ public class StateSystemFullHistoryTest { public void testSingleQueryInvalidTime1() throws AttributeNotFoundException, TimeRangeException { - int quark = shs.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); + int quark = ssq.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); long ts = CtfTestFiles.startTime + 20L * CtfTestFiles.NANOSECS_PER_SEC; - shs.querySingleState(ts, quark); + ssq.querySingleState(ts, quark); } @Test(expected = TimeRangeException.class) public void testSingleQueryInvalidTime2() throws AttributeNotFoundException, TimeRangeException { - int quark = shs.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); + int quark = ssq.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); long ts = CtfTestFiles.startTime - 20L * CtfTestFiles.NANOSECS_PER_SEC; - shs.querySingleState(ts, quark); + ssq.querySingleState(ts, quark); } @Test(expected = TimeRangeException.class) public void testRangeQueryInvalidTime1() throws AttributeNotFoundException, TimeRangeException { - int quark = shs.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); + int quark = ssq.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); long ts1 = CtfTestFiles.startTime - 20L * CtfTestFiles.NANOSECS_PER_SEC; /* invalid */ long ts2 = CtfTestFiles.startTime + 1L * CtfTestFiles.NANOSECS_PER_SEC; /* valid */ - shs.queryHistoryRange(quark, ts1, ts2); + ssq.queryHistoryRange(quark, ts1, ts2); } @Test(expected = TimeRangeException.class) public void testRangeQueryInvalidTime2() throws TimeRangeException, AttributeNotFoundException { - int quark = shs.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); + int quark = ssq.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); long ts1 = CtfTestFiles.startTime - 1L * CtfTestFiles.NANOSECS_PER_SEC; /* invalid */ long ts2 = CtfTestFiles.startTime + 20L * CtfTestFiles.NANOSECS_PER_SEC; /* invalid */ - shs.queryHistoryRange(quark, ts1, ts2); + ssq.queryHistoryRange(quark, ts1, ts2); } /** * Ask for a non-existing attribute - * + * * @throws AttributeNotFoundException */ @Test(expected = AttributeNotFoundException.class) public void testQueryInvalidAttribute() throws AttributeNotFoundException { - shs.getQuarkAbsolute("There", "is", "no", "cow", "level"); + ssq.getQuarkAbsolute("There", "is", "no", "cow", "level"); } /** * Query but with the wrong State Value type - * + * * @throws StateValueTypeException * @throws AttributeNotFoundException * @throws TimeRangeException @@ -329,8 +315,8 @@ public class StateSystemFullHistoryTest { ITmfStateInterval interval; int quark; - list = shs.loadStateAtTime(interestingTimestamp1); - quark = shs.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); + list = ssq.queryFullState(interestingTimestamp1); + quark = ssq.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); interval = list.get(quark); /* This is supposed to be an int value */ @@ -344,8 +330,8 @@ public class StateSystemFullHistoryTest { ITmfStateInterval interval; int quark; - list = shs.loadStateAtTime(interestingTimestamp1); - quark = shs.getQuarkAbsolute(Attributes.THREADS, "1432", Attributes.EXEC_NAME); + list = ssq.queryFullState(interestingTimestamp1); + quark = ssq.getQuarkAbsolute(Attributes.THREADS, "1432", Attributes.EXEC_NAME); interval = list.get(quark); /* This is supposed to be a String value */ @@ -354,40 +340,31 @@ public class StateSystemFullHistoryTest { @Test public void testFullAttributeName() throws AttributeNotFoundException { - int quark = shs.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); - String name = shs.getFullAttributePath(quark); + int quark = ssq.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); + String name = ssq.getFullAttributePath(quark); assertEquals(name, "CPUs/0/Current_thread"); } @Test public void testGetQuarks_begin() { - List list = shs.getQuarks("*", "1577", Attributes.EXEC_NAME); + List list = ssq.getQuarks("*", "1577", Attributes.EXEC_NAME); assertEquals(1, list.size()); - assertEquals(Integer.valueOf(398), list.get(0)); } @Test public void testGetQuarks_middle() { - List list = shs.getQuarks(Attributes.THREADS, "*", Attributes.EXEC_NAME); + List list = ssq.getQuarks(Attributes.THREADS, "*", Attributes.EXEC_NAME); - assertEquals(Integer.valueOf(18), list.get(4)); - assertEquals(Integer.valueOf(54), list.get(10)); - assertEquals(Integer.valueOf(64), list.get(12)); + /* Number of different kernel threads in the trace */ + assertEquals(168, list.size()); } @Test public void testGetQuarks_end() { - List list = shs.getQuarks(Attributes.THREADS, "1577", "*"); - - assertEquals(3, list.size()); - assertEquals(Integer.valueOf(398), list.get(1)); - } + List list = ssq.getQuarks(Attributes.THREADS, "1577", "*"); - @Test - public void testDebugPrinting() throws FileNotFoundException { - PrintWriter pw = new PrintWriter(new File("/dev/null")); - shs.debugPrint(pw); - pw.close(); + /* There should be 4 sub-attributes for each Thread node */ + assertEquals(4, list.size()); } }