1 /*******************************************************************************
2 * Copyright (c) 2014, 2015 É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
.analysis
.os
.linux
.core
.tests
.kernel
;
15 import static org
.eclipse
.tracecompass
.common
.core
.NonNullUtils
.checkNotNull
;
16 import static org
.junit
.Assert
.assertEquals
;
17 import static org
.junit
.Assert
.assertNotNull
;
18 import static org
.junit
.Assert
.assertNull
;
19 import static org
.junit
.Assert
.assertTrue
;
22 import java
.util
.Collection
;
23 import java
.util
.List
;
25 import org
.eclipse
.core
.runtime
.IProgressMonitor
;
26 import org
.eclipse
.core
.runtime
.NullProgressMonitor
;
27 import org
.eclipse
.jdt
.annotation
.NonNull
;
28 import org
.eclipse
.tracecompass
.analysis
.os
.linux
.core
.kernel
.KernelAnalysisModule
;
29 import org
.eclipse
.tracecompass
.analysis
.os
.linux
.core
.kernel
.KernelThreadInformationProvider
;
30 import org
.eclipse
.tracecompass
.analysis
.os
.linux
.core
.kernel
.StateValues
;
31 import org
.eclipse
.tracecompass
.analysis
.os
.linux
.core
.tests
.stubs
.LinuxTestCase
;
32 import org
.eclipse
.tracecompass
.analysis
.os
.linux
.core
.tests
.stubs
.kernel
.KernelAnalysisTestFactory
;
33 import org
.eclipse
.tracecompass
.statesystem
.core
.interval
.ITmfStateInterval
;
34 import org
.eclipse
.tracecompass
.statesystem
.core
.statevalue
.ITmfStateValue
;
35 import org
.eclipse
.tracecompass
.statesystem
.core
.statevalue
.TmfStateValue
;
36 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.IAnalysisModule
;
37 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceOpenedSignal
;
38 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfTrace
;
39 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTrace
;
40 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTraceManager
;
41 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTraceUtils
;
42 import org
.junit
.After
;
43 import org
.junit
.Before
;
44 import org
.junit
.Test
;
46 import com
.google
.common
.collect
.ImmutableSet
;
49 * Test analysis-specific methods for the {@link KernelAnalysisModule} class.
51 * @author Geneviève Bastien
53 public class KernelThreadInformationProviderTest
{
55 private static final @NonNull LinuxTestCase KERNEL_TEST_CASE
= KernelAnalysisTestFactory
.KERNEL_SCHED
;
57 private ITmfTrace fTrace
;
58 private KernelAnalysisModule fModule
;
60 private static void deleteSuppFiles(ITmfTrace trace
) {
61 /* Remove supplementary files */
62 File suppDir
= new File(TmfTraceManager
.getSupplementaryFileDir(trace
));
63 for (File file
: suppDir
.listFiles()) {
69 * Setup the trace for the tests
73 ITmfTrace trace
= KERNEL_TEST_CASE
.getKernelTrace();
74 deleteSuppFiles(trace
);
75 ((TmfTrace
) trace
).traceOpened(new TmfTraceOpenedSignal(this, trace
, null));
76 IAnalysisModule module
= null;
77 for (IAnalysisModule mod
: TmfTraceUtils
.getAnalysisModulesOfClass(trace
, KernelAnalysisModule
.class)) {
80 assertNotNull(module
);
82 module
.waitForCompletion();
83 fModule
= TmfTraceUtils
.getAnalysisModuleOfClass(trace
, KernelAnalysisModule
.class, KernelAnalysisModule
.ID
);
91 public void tearDown() {
92 deleteSuppFiles(fTrace
);
98 * {@link KernelThreadInformationProvider#getThreadIds(KernelAnalysisModule)}
102 public void testGetThreadQuarks() {
103 KernelAnalysisModule module
= checkNotNull(fModule
);
104 Collection
<Integer
> threadIds
= KernelThreadInformationProvider
.getThreadIds(module
);
105 assertEquals(ImmutableSet
.<Integer
>of(10,11,20,21,30,100), threadIds
);
110 * {@link KernelThreadInformationProvider#getThreadOnCpu(KernelAnalysisModule, long, long)}
114 public void testGetThreadOnCpu() {
115 KernelAnalysisModule module
= checkNotNull(fModule
);
117 /* Check with invalid timestamps */
118 Integer tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, 0, -1);
121 tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, 0, 80);
124 /* Check with invalid cpus */
125 tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, 2, 20);
128 tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, -1, 20);
131 /* Check valid values */
132 tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, 0, 4);
135 tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, 0, 15);
138 tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, 1, 15);
139 assertEquals(Integer
.valueOf(11), tid
);
141 tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, 1, 29);
142 assertEquals(Integer
.valueOf(20), tid
);
144 tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, 1, 30);
145 assertEquals(Integer
.valueOf(21), tid
);
147 tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, 0, 59);
148 assertEquals(Integer
.valueOf(11), tid
);
150 tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, 1, 59);
151 assertEquals(Integer
.valueOf(30), tid
);
153 tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, 0, 60);
154 assertEquals(Integer
.valueOf(11), tid
);
156 tid
= KernelThreadInformationProvider
.getThreadOnCpu(module
, 1, 60);
157 assertEquals(Integer
.valueOf(21), tid
);
163 * {@link KernelThreadInformationProvider#getParentPid(KernelAnalysisModule, Integer, long)}
167 public void testGetPpid() {
168 KernelAnalysisModule module
= checkNotNull(fModule
);
170 /* Check with invalid timestamps */
171 Integer ppid
= KernelThreadInformationProvider
.getParentPid(module
, 11, -1);
174 ppid
= KernelThreadInformationProvider
.getParentPid(module
, 11, 80);
177 /* Check with invalid cpus */
178 ppid
= KernelThreadInformationProvider
.getParentPid(module
, -4, 20);
181 ppid
= KernelThreadInformationProvider
.getParentPid(module
, 12, 20);
184 /* Check values with no parent */
185 ppid
= KernelThreadInformationProvider
.getParentPid(module
, 10, 20);
186 assertEquals(Integer
.valueOf(0), ppid
);
188 ppid
= KernelThreadInformationProvider
.getParentPid(module
, 30, 60);
189 assertEquals(Integer
.valueOf(0), ppid
);
191 /* Check parent determined at statedump */
192 ppid
= KernelThreadInformationProvider
.getParentPid(module
, 11, 4);
195 ppid
= KernelThreadInformationProvider
.getParentPid(module
, 11, 5);
196 assertEquals(Integer
.valueOf(10), ppid
);
198 /* Check parent after process fork */
199 ppid
= KernelThreadInformationProvider
.getParentPid(module
, 21, 25);
200 assertEquals(Integer
.valueOf(20), ppid
);
202 ppid
= KernelThreadInformationProvider
.getParentPid(module
, 21, 70);
203 assertEquals(Integer
.valueOf(20), ppid
);
208 * Test the {@link KernelThreadInformationProvider#getExecutableName(KernelAnalysisModule, Integer)} method
211 public void testGetExecutableName() {
212 KernelAnalysisModule module
= checkNotNull(fModule
);
214 /* Check with invalid threads */
215 String execName
= KernelThreadInformationProvider
.getExecutableName(module
, 101);
216 assertNull(execName
);
218 execName
= KernelThreadInformationProvider
.getExecutableName(module
, -2);
219 assertNull(execName
);
221 /* Check valid value */
222 execName
= KernelThreadInformationProvider
.getExecutableName(module
, 20);
223 assertEquals("proc20", execName
);
225 /* Check valid value with process name change in history */
226 execName
= KernelThreadInformationProvider
.getExecutableName(module
, 21);
227 assertEquals("proc21", execName
);
231 private static void testIntervals(String info
, List
<ITmfStateInterval
> intervals
, ITmfStateValue
[] values
) {
232 assertEquals(info
+ " interval count", values
.length
, intervals
.size());
233 for (int i
= 0; i
< values
.length
; i
++) {
234 assertEquals(info
+ " interval " + i
, values
[i
], intervals
.get(i
).getStateValue());
240 * {@link KernelThreadInformationProvider#getStatusIntervalsForThread(KernelAnalysisModule, Integer, long, long, long, IProgressMonitor)}
244 public void testGetStatusIntervalsForThread() {
245 KernelAnalysisModule module
= checkNotNull(fModule
);
247 IProgressMonitor monitor
= new NullProgressMonitor();
248 Integer process21
= 21;
249 Integer process20
= 20;
251 /* Check invalid time ranges */
252 List
<ITmfStateInterval
> intervals
= KernelThreadInformationProvider
.getStatusIntervalsForThread(module
, process21
, -15, -5, 3, monitor
);
253 assertTrue(intervals
.isEmpty());
255 intervals
= KernelThreadInformationProvider
.getStatusIntervalsForThread(module
, process21
, 80, 1500000000L, 50, monitor
);
256 assertTrue(intervals
.isEmpty());
258 /* Check invalid quarks */
259 intervals
= KernelThreadInformationProvider
.getStatusIntervalsForThread(module
, -1, 0, 70L, 3, monitor
);
260 assertTrue(intervals
.isEmpty());
262 intervals
= KernelThreadInformationProvider
.getStatusIntervalsForThread(module
, 0, 0, 70L, 3, monitor
);
263 assertTrue(intervals
.isEmpty());
265 /* Check different time ranges and resolutions */
266 ITmfStateValue
[] values
= { TmfStateValue
.nullValue(), StateValues
.PROCESS_STATUS_WAIT_FOR_CPU_VALUE
,
267 StateValues
.PROCESS_STATUS_RUN_USERMODE_VALUE
, StateValues
.PROCESS_STATUS_WAIT_FOR_CPU_VALUE
,
268 StateValues
.PROCESS_STATUS_RUN_USERMODE_VALUE
};
269 intervals
= KernelThreadInformationProvider
.getStatusIntervalsForThread(module
, process21
, 0, 70L, 3, monitor
);
270 testIntervals("tid 21 [0,70,3]", intervals
, values
);
272 ITmfStateValue
[] values2
= { TmfStateValue
.nullValue(), StateValues
.PROCESS_STATUS_RUN_USERMODE_VALUE
,
273 StateValues
.PROCESS_STATUS_RUN_USERMODE_VALUE
};
274 intervals
= KernelThreadInformationProvider
.getStatusIntervalsForThread(module
, process21
, 1, 70L, 30, monitor
);
275 testIntervals("tid 21 [0,70,30]", intervals
, values2
);
277 ITmfStateValue
[] values3
= { StateValues
.PROCESS_STATUS_WAIT_FOR_CPU_VALUE
,
278 StateValues
.PROCESS_STATUS_RUN_USERMODE_VALUE
};
279 intervals
= KernelThreadInformationProvider
.getStatusIntervalsForThread(module
, process21
, 25, 50L, 3, monitor
);
280 testIntervals("tid 21 [25,50,3]", intervals
, values3
);
282 ITmfStateValue
[] values4
= { TmfStateValue
.nullValue(), StateValues
.PROCESS_STATUS_WAIT_UNKNOWN_VALUE
,
283 StateValues
.PROCESS_STATUS_RUN_USERMODE_VALUE
, StateValues
.PROCESS_STATUS_WAIT_FOR_CPU_VALUE
};
284 intervals
= KernelThreadInformationProvider
.getStatusIntervalsForThread(module
, process20
, 0, 70L, 3, monitor
);
285 testIntervals("tid 20 [0,70,3]", intervals
, values4
);
287 ITmfStateValue
[] values5
= { TmfStateValue
.nullValue(), StateValues
.PROCESS_STATUS_WAIT_FOR_CPU_VALUE
};
288 intervals
= KernelThreadInformationProvider
.getStatusIntervalsForThread(module
, process20
, 1, 70L, 30, monitor
);
289 testIntervals("tid 20 [0,70,30]", intervals
, values5
);
291 ITmfStateValue
[] values6
= { StateValues
.PROCESS_STATUS_RUN_USERMODE_VALUE
,
292 StateValues
.PROCESS_STATUS_WAIT_FOR_CPU_VALUE
};
293 intervals
= KernelThreadInformationProvider
.getStatusIntervalsForThread(module
, process20
, 25, 50L, 3, monitor
);
294 testIntervals("tid 20 [25,50,3]", intervals
, values6
);