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=6ef8494114179d6413f96e2d16c1f7a1beffdb4b;hpb=2359eccaefc1e6e1f3bff054fcc047be1d17deb9;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 6ef8494114..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,55 +2,55 @@ * 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.internal.lttng2.kernel.core.Attributes; +import org.eclipse.linuxtools.internal.lttng2.kernel.core.stateprovider.CtfKernelStateInput; +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.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.stateprovider.CTFKernelStateInput; -import org.junit.*; +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 { - protected static File stateFile; - protected static File stateFileBenchmark; + static File stateFile; + static File stateFileBenchmark; - protected static HistoryBuilder builder; - protected static IStateChangeInput input; - protected static IStateHistoryBackend hp; - protected static StateHistorySystem shs; + static IStateChangeInput input; + static ITmfStateSystem ssq; - private final static long interestingTimestamp1 = 18670067372290L; + /* Offset in the trace + start time of the trace */ + private final static long interestingTimestamp1 = 18670067372290L + 1331649577946812237L; protected static String getTestFileName() { return "/tmp/statefile.ht"; //$NON-NLS-1$ @@ -61,83 +61,80 @@ public class StateSystemFullHistoryTest { stateFile = new File(getTestFileName()); 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); + input = new CtfKernelStateInput(CtfTestFiles.getTestTrace()); + ssq = StateSystemManager.loadStateHistory(stateFile, input, true); } catch (Exception e) { e.printStackTrace(); } - builder.run(); - shs = (StateHistorySystem) builder.getSS(); } @AfterClass public static void cleanup() { - stateFile.delete(); - stateFileBenchmark.delete(); + boolean ret1, ret2; + ret1 = stateFile.delete(); + ret2 = stateFileBenchmark.delete(); + if ( !(ret1 && ret2) ) { + System.err.println("Error cleaning up during unit testing, " + //$NON-NLS-1$ + "you might have leftovers state history files in /tmp"); //$NON-NLS-1$ + } } /** * 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 public void testFullQuery1() throws StateValueTypeException, AttributeNotFoundException, TimeRangeException { + List list; ITmfStateInterval interval; int quark, valueInt; String valueStr; - shs.loadStateAtTime(interestingTimestamp1); + list = ssq.queryFullState(interestingTimestamp1); - quark = shs.getQuarkAbsolute("CPUs", "0", "Current_thread"); - interval = shs.queryState(quark); + quark = ssq.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); + interval = list.get(quark); valueInt = interval.getStateValue().unboxInt(); assertEquals(1397, valueInt); - quark = shs.getQuarkAbsolute("Threads", "1432", "Exec_name"); - interval = shs.queryState(quark); + quark = ssq.getQuarkAbsolute(Attributes.THREADS, "1432", Attributes.EXEC_NAME); + interval = list.get(quark); valueStr = interval.getStateValue().unboxStr(); assertEquals("gdbus", valueStr); - // FIXME fails at the moment (attribute type is int, and = 3129??), I'll - // figure it out later - // quark = shs.getQuarkAbsolute("Threads", "3109", "Exec_mode_stack"); - // interval = shs.getState(quark); - // valueStr = interval.getStateValue().unboxStr(); - // assertTrue( valueStr.equals("bloup") ); + quark = ssq.getQuarkAbsolute(Attributes.THREADS, "1432", Attributes.SYSTEM_CALL); + interval = list.get(quark); + valueStr = interval.getStateValue().unboxStr(); + assertTrue(valueStr.equals("sys_poll")); } @Test @@ -159,8 +156,8 @@ public class StateSystemFullHistoryTest { ITmfStateInterval interval; String valueStr; - quark = shs.getQuarkAbsolute("Threads", "1432", "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); } @@ -175,38 +172,81 @@ public class StateSystemFullHistoryTest { // } + /** + * Test a range query (with no resolution parameter, so all intervals) + */ @Test public void testRangeQuery1() throws AttributeNotFoundException, TimeRangeException, StateValueTypeException { long time1 = interestingTimestamp1; - long time2 = time1 + 1L * CTFTestFiles.NANOSECS_PER_SEC; + long time2 = time1 + 1L * CtfTestFiles.NANOSECS_PER_SEC; int quark; List intervals; - quark = shs.getQuarkAbsolute("CPUs", "0", "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(18670480869135L, intervals.get(205).getEndTime()); + assertEquals(1331668248427681372L, intervals.get(205).getEndTime()); + } + + /** + * Range query, but with a t2 far off the end of the trace. + * The result should still be valid. + */ + @Test + public void testRangeQuery2() throws TimeRangeException, + AttributeNotFoundException { + + List intervals; + + 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 = ssq.queryHistoryRange(quark, ts1, ts2); + + /* Activity of IRQ 1 over the whole trace */ + assertEquals(65, intervals.size()); + } + + /** + * Test a range query with a resolution + */ + @Test + public void testRangeQuery3() throws AttributeNotFoundException, + TimeRangeException, StateValueTypeException { + + long time1 = interestingTimestamp1; + long time2 = time1 + 1L * CtfTestFiles.NANOSECS_PER_SEC; + long resolution = 1000000; /* One query every millisecond */ + int quark; + List intervals; + + 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(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); + long ts = CtfTestFiles.startTime + 20L * CtfTestFiles.NANOSECS_PER_SEC; + ssq.queryFullState(ts); } @Test(expected = TimeRangeException.class) public void testFullQueryInvalidTime2() throws TimeRangeException { - long ts = CTFTestFiles.startTime - 20L * CTFTestFiles.NANOSECS_PER_SEC; - shs.loadStateAtTime(ts); + long ts = CtfTestFiles.startTime - 20L * CtfTestFiles.NANOSECS_PER_SEC; + ssq.queryFullState(ts); } @@ -214,67 +254,56 @@ public class StateSystemFullHistoryTest { public void testSingleQueryInvalidTime1() throws AttributeNotFoundException, TimeRangeException { - int quark = shs.getQuarkAbsolute("CPUs", "0", "Current_thread"); - long ts = CTFTestFiles.startTime + 20L * CTFTestFiles.NANOSECS_PER_SEC; - shs.querySingleState(ts, quark); + int quark = ssq.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); + long ts = CtfTestFiles.startTime + 20L * CtfTestFiles.NANOSECS_PER_SEC; + ssq.querySingleState(ts, quark); } @Test(expected = TimeRangeException.class) public void testSingleQueryInvalidTime2() throws AttributeNotFoundException, TimeRangeException { - int quark = shs.getQuarkAbsolute("CPUs", "0", "Current_thread"); - long ts = CTFTestFiles.startTime - 20L * CTFTestFiles.NANOSECS_PER_SEC; - shs.querySingleState(ts, quark); + int quark = ssq.getQuarkAbsolute(Attributes.CPUS, "0", Attributes.CURRENT_THREAD); + long ts = CtfTestFiles.startTime - 20L * CtfTestFiles.NANOSECS_PER_SEC; + ssq.querySingleState(ts, quark); } @Test(expected = TimeRangeException.class) public void testRangeQueryInvalidTime1() throws AttributeNotFoundException, TimeRangeException { - int quark = shs.getQuarkAbsolute("CPUs", "0", "Current_thread"); - long ts1 = CTFTestFiles.startTime - 20L * CTFTestFiles.NANOSECS_PER_SEC; /* invalid */ - long ts2 = CTFTestFiles.startTime + 1L * CTFTestFiles.NANOSECS_PER_SEC; /* valid */ + 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("CPUs", "0", "Current_thread"); - long ts1 = CTFTestFiles.startTime + 1L * CTFTestFiles.NANOSECS_PER_SEC; /* valid */ - long ts2 = CTFTestFiles.startTime + 20L * CTFTestFiles.NANOSECS_PER_SEC; /* invalid */ + 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); - } - - @Test(expected = TimeRangeException.class) - public void testRangeQueryInvalidTime3() throws TimeRangeException, - AttributeNotFoundException { - - int quark = shs.getQuarkAbsolute("CPUs", "0", "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 @@ -282,12 +311,13 @@ public class StateSystemFullHistoryTest { @Test(expected = StateValueTypeException.class) public void testQueryInvalidValuetype1() throws StateValueTypeException, AttributeNotFoundException, TimeRangeException { + List list; ITmfStateInterval interval; int quark; - shs.loadStateAtTime(interestingTimestamp1); - quark = shs.getQuarkAbsolute("CPUs", "0", "Current_thread"); - interval = shs.queryState(quark); + 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 */ interval.getStateValue().unboxStr(); @@ -296,12 +326,13 @@ public class StateSystemFullHistoryTest { @Test(expected = StateValueTypeException.class) public void testQueryInvalidValuetype2() throws StateValueTypeException, AttributeNotFoundException, TimeRangeException { + List list; ITmfStateInterval interval; int quark; - shs.loadStateAtTime(interestingTimestamp1); - quark = shs.getQuarkAbsolute("Threads", "1432", "Exec_name"); - interval = shs.queryState(quark); + 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 */ interval.getStateValue().unboxInt(); @@ -309,13 +340,31 @@ public class StateSystemFullHistoryTest { @Test public void testFullAttributeName() throws AttributeNotFoundException { - int quark = shs.getQuarkAbsolute("CPUs", "0", "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 testDebugPrinting() throws FileNotFoundException { - shs.debugPrint(new PrintWriter(new File("/dev/null"))); + public void testGetQuarks_begin() { + List list = ssq.getQuarks("*", "1577", Attributes.EXEC_NAME); + + assertEquals(1, list.size()); + } + + @Test + public void testGetQuarks_middle() { + List list = ssq.getQuarks(Attributes.THREADS, "*", Attributes.EXEC_NAME); + + /* Number of different kernel threads in the trace */ + assertEquals(168, list.size()); + } + + @Test + public void testGetQuarks_end() { + List list = ssq.getQuarks(Attributes.THREADS, "1577", "*"); + + /* There should be 4 sub-attributes for each Thread node */ + assertEquals(4, list.size()); } }