1 /*******************************************************************************
2 * Copyright (c) 2014 École Polytechnique de Montréal
4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * Geneviève Bastien - Initial API and implementation
11 *******************************************************************************/
13 package org
.eclipse
.tracecompass
.lttng2
.kernel
.core
.tests
.analysis
.kernel
;
15 import static org
.junit
.Assert
.assertEquals
;
16 import static org
.junit
.Assert
.assertNotNull
;
17 import static org
.junit
.Assert
.assertNull
;
18 import static org
.junit
.Assert
.assertTrue
;
19 import static org
.junit
.Assert
.fail
;
22 import java
.util
.Collection
;
23 import java
.util
.List
;
25 import org
.eclipse
.core
.runtime
.IPath
;
26 import org
.eclipse
.core
.runtime
.IProgressMonitor
;
27 import org
.eclipse
.core
.runtime
.IStatus
;
28 import org
.eclipse
.core
.runtime
.NullProgressMonitor
;
29 import org
.eclipse
.jdt
.annotation
.NonNull
;
30 import org
.eclipse
.tracecompass
.internal
.lttng2
.kernel
.core
.StateValues
;
31 import org
.eclipse
.tracecompass
.lttng2
.kernel
.core
.analysis
.kernel
.LttngKernelAnalysis
;
32 import org
.eclipse
.tracecompass
.lttng2
.kernel
.core
.analysis
.kernel
.LttngKernelThreadInformationProvider
;
33 import org
.eclipse
.tracecompass
.lttng2
.kernel
.core
.tests
.Activator
;
34 import org
.eclipse
.tracecompass
.statesystem
.core
.interval
.ITmfStateInterval
;
35 import org
.eclipse
.tracecompass
.statesystem
.core
.statevalue
.ITmfStateValue
;
36 import org
.eclipse
.tracecompass
.statesystem
.core
.statevalue
.TmfStateValue
;
37 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.IAnalysisModule
;
38 import org
.eclipse
.tracecompass
.tmf
.core
.event
.TmfEvent
;
39 import org
.eclipse
.tracecompass
.tmf
.core
.exceptions
.TmfTraceException
;
40 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceOpenedSignal
;
41 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfTrace
;
42 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTrace
;
43 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTraceManager
;
44 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTraceUtils
;
45 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.trace
.xml
.TmfXmlTraceStub
;
46 import org
.junit
.After
;
47 import org
.junit
.Before
;
48 import org
.junit
.Test
;
51 * Test analysis-specific methods for the {@link LttngKernelAnalysis} class.
53 * @author Geneviève Bastien
55 public class LttngKernelThreadInformationProviderTest
{
57 private static final @NonNull String LTTNG_KERNEL_FILE
= "testfiles/lttng_kernel_analysis.xml";
59 * The ID of the cpu usage analysis module for development traces
61 public static final String LTTNG_KERNEL_ANALYSIS_ID
= "lttng2.kernel.core.tests.kernel.analysis";
63 private ITmfTrace fTrace
;
64 private LttngKernelAnalysis fModule
;
66 private static void deleteSuppFiles(ITmfTrace trace
) {
67 /* Remove supplementary files */
68 File suppDir
= new File(TmfTraceManager
.getSupplementaryFileDir(trace
));
69 for (File file
: suppDir
.listFiles()) {
75 * Setup the trace for the tests
79 fTrace
= new TmfXmlTraceStub();
80 IPath filePath
= Activator
.getAbsoluteFilePath(LTTNG_KERNEL_FILE
);
81 IStatus status
= fTrace
.validate(null, filePath
.toOSString());
83 fail(status
.getException().getMessage());
86 fTrace
.initTrace(null, filePath
.toOSString(), TmfEvent
.class);
87 } catch (TmfTraceException e
) {
90 deleteSuppFiles(fTrace
);
91 ((TmfTrace
) fTrace
).traceOpened(new TmfTraceOpenedSignal(this, fTrace
, null));
92 IAnalysisModule module
= null;
93 for (IAnalysisModule mod
: TmfTraceUtils
.getAnalysisModulesOfClass(fTrace
, LttngKernelAnalysis
.class)) {
96 assertNotNull(module
);
98 module
.waitForCompletion();
99 fModule
= TmfTraceUtils
.getAnalysisModuleOfClass(fTrace
, LttngKernelAnalysis
.class, LTTNG_KERNEL_ANALYSIS_ID
);
100 assertNotNull(fModule
);
107 public void tearDown() {
108 deleteSuppFiles(fTrace
);
114 * {@link LttngKernelThreadInformationProvider#getThreadIds(LttngKernelAnalysis)}
118 public void testGetThreadQuarks() {
119 Collection
<Integer
> threadIds
= LttngKernelThreadInformationProvider
.getThreadIds(fModule
);
120 assertEquals(7, threadIds
.size());
125 * {@link LttngKernelThreadInformationProvider#getThreadOnCpu(LttngKernelAnalysis, long, long)}
129 public void testGetThreadOnCpu() {
131 /* Check with invalid timestamps */
132 Integer tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, 0, -1);
135 tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, 0, 80);
138 /* Check with invalid cpus */
139 tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, 2, 20);
142 tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, -1, 20);
145 /* Check valid values */
146 tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, 0, 4);
149 tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, 0, 15);
152 tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, 1, 15);
153 assertEquals(Integer
.valueOf(11), tid
);
155 tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, 1, 29);
156 assertEquals(Integer
.valueOf(20), tid
);
158 tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, 1, 30);
159 assertEquals(Integer
.valueOf(21), tid
);
161 tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, 0, 59);
162 assertEquals(Integer
.valueOf(11), tid
);
164 tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, 1, 59);
165 assertEquals(Integer
.valueOf(30), tid
);
167 tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, 0, 60);
168 assertEquals(Integer
.valueOf(11), tid
);
170 tid
= LttngKernelThreadInformationProvider
.getThreadOnCpu(fModule
, 1, 60);
171 assertEquals(Integer
.valueOf(21), tid
);
177 * {@link LttngKernelThreadInformationProvider#getParentPid(LttngKernelAnalysis, Integer, long)}
181 public void testGetPpid() {
183 /* Check with invalid timestamps */
184 Integer ppid
= LttngKernelThreadInformationProvider
.getParentPid(fModule
, 11, -1);
187 ppid
= LttngKernelThreadInformationProvider
.getParentPid(fModule
, 11, 80);
190 /* Check with invalid cpus */
191 ppid
= LttngKernelThreadInformationProvider
.getParentPid(fModule
, -4, 20);
194 ppid
= LttngKernelThreadInformationProvider
.getParentPid(fModule
, 12, 20);
197 /* Check values with no parent */
198 ppid
= LttngKernelThreadInformationProvider
.getParentPid(fModule
, 10, 20);
199 assertEquals(Integer
.valueOf(0), ppid
);
201 ppid
= LttngKernelThreadInformationProvider
.getParentPid(fModule
, 30, 60);
202 assertEquals(Integer
.valueOf(0), ppid
);
204 /* Check parent determined at statedump */
205 ppid
= LttngKernelThreadInformationProvider
.getParentPid(fModule
, 11, 4);
208 ppid
= LttngKernelThreadInformationProvider
.getParentPid(fModule
, 11, 5);
209 assertEquals(Integer
.valueOf(10), ppid
);
211 /* Check parent after process fork */
212 ppid
= LttngKernelThreadInformationProvider
.getParentPid(fModule
, 21, 25);
213 assertEquals(Integer
.valueOf(20), ppid
);
215 ppid
= LttngKernelThreadInformationProvider
.getParentPid(fModule
, 21, 70);
216 assertEquals(Integer
.valueOf(20), ppid
);
221 * Test the {@link LttngKernelThreadInformationProvider#getExecutableName(LttngKernelAnalysis, Integer)} method
224 public void testGetExecutableName() {
225 /* Check with invalid threads */
226 String execName
= LttngKernelThreadInformationProvider
.getExecutableName(fModule
, 101);
227 assertNull(execName
);
229 execName
= LttngKernelThreadInformationProvider
.getExecutableName(fModule
, -2);
230 assertNull(execName
);
232 /* Check valid value */
233 execName
= LttngKernelThreadInformationProvider
.getExecutableName(fModule
, 20);
234 assertEquals("proc20", execName
);
236 /* Check valid value with process name change in history */
237 execName
= LttngKernelThreadInformationProvider
.getExecutableName(fModule
, 21);
238 assertEquals("proc21", execName
);
242 private static void testIntervals(String info
, List
<ITmfStateInterval
> intervals
, ITmfStateValue
[] values
) {
243 assertEquals(info
+ " interval count", values
.length
, intervals
.size());
244 for (int i
= 0; i
< values
.length
; i
++) {
245 assertEquals(info
+ " interval " + i
, values
[i
], intervals
.get(i
).getStateValue());
251 * {@link LttngKernelThreadInformationProvider#getStatusIntervalsForThread(LttngKernelAnalysis, Integer, long, long, long, IProgressMonitor)}
255 public void testGetStatusIntervalsForThread() {
257 IProgressMonitor monitor
= new NullProgressMonitor();
258 Integer process21
= 21;
259 Integer process20
= 20;
261 /* Check invalid time ranges */
262 List
<ITmfStateInterval
> intervals
= LttngKernelThreadInformationProvider
.getStatusIntervalsForThread(fModule
, process21
, -15, -5, 3, monitor
);
263 assertTrue(intervals
.isEmpty());
265 intervals
= LttngKernelThreadInformationProvider
.getStatusIntervalsForThread(fModule
, process21
, 80, 1500000000L, 50, monitor
);
266 assertTrue(intervals
.isEmpty());
268 /* Check invalid quarks */
269 intervals
= LttngKernelThreadInformationProvider
.getStatusIntervalsForThread(fModule
, -1, 0, 70L, 3, monitor
);
270 assertTrue(intervals
.isEmpty());
272 intervals
= LttngKernelThreadInformationProvider
.getStatusIntervalsForThread(fModule
, 0, 0, 70L, 3, monitor
);
273 assertTrue(intervals
.isEmpty());
275 /* Check different time ranges and resolutions */
276 ITmfStateValue
[] values
= { TmfStateValue
.nullValue(), StateValues
.PROCESS_STATUS_WAIT_FOR_CPU_VALUE
,
277 StateValues
.PROCESS_STATUS_RUN_SYSCALL_VALUE
, StateValues
.PROCESS_STATUS_WAIT_FOR_CPU_VALUE
,
278 StateValues
.PROCESS_STATUS_RUN_SYSCALL_VALUE
};
279 intervals
= LttngKernelThreadInformationProvider
.getStatusIntervalsForThread(fModule
, process21
, 0, 70L, 3, monitor
);
280 testIntervals("tid 21 [0,70,3]", intervals
, values
);
282 ITmfStateValue
[] values2
= { TmfStateValue
.nullValue(), StateValues
.PROCESS_STATUS_RUN_SYSCALL_VALUE
,
283 StateValues
.PROCESS_STATUS_RUN_SYSCALL_VALUE
};
284 intervals
= LttngKernelThreadInformationProvider
.getStatusIntervalsForThread(fModule
, process21
, 1, 70L, 30, monitor
);
285 testIntervals("tid 21 [0,70,30]", intervals
, values2
);
287 ITmfStateValue
[] values3
= { StateValues
.PROCESS_STATUS_WAIT_FOR_CPU_VALUE
,
288 StateValues
.PROCESS_STATUS_RUN_SYSCALL_VALUE
};
289 intervals
= LttngKernelThreadInformationProvider
.getStatusIntervalsForThread(fModule
, process21
, 25, 50L, 3, monitor
);
290 testIntervals("tid 21 [25,50,3]", intervals
, values3
);
292 ITmfStateValue
[] values4
= { TmfStateValue
.nullValue(), StateValues
.PROCESS_STATUS_WAIT_BLOCKED_VALUE
,
293 StateValues
.PROCESS_STATUS_RUN_USERMODE_VALUE
, StateValues
.PROCESS_STATUS_WAIT_FOR_CPU_VALUE
};
294 intervals
= LttngKernelThreadInformationProvider
.getStatusIntervalsForThread(fModule
, process20
, 0, 70L, 3, monitor
);
295 testIntervals("tid 20 [0,70,3]", intervals
, values4
);
297 ITmfStateValue
[] values5
= { TmfStateValue
.nullValue(), StateValues
.PROCESS_STATUS_WAIT_FOR_CPU_VALUE
};
298 intervals
= LttngKernelThreadInformationProvider
.getStatusIntervalsForThread(fModule
, process20
, 1, 70L, 30, monitor
);
299 testIntervals("tid 20 [0,70,30]", intervals
, values5
);
301 ITmfStateValue
[] values6
= { StateValues
.PROCESS_STATUS_RUN_USERMODE_VALUE
,
302 StateValues
.PROCESS_STATUS_WAIT_FOR_CPU_VALUE
};
303 intervals
= LttngKernelThreadInformationProvider
.getStatusIntervalsForThread(fModule
, process20
, 25, 50L, 3, monitor
);
304 testIntervals("tid 20 [25,50,3]", intervals
, values6
);