analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/src/org/eclipse/tracecompass/analysis/os/linux/core/tests/kernelanalysis/KernelThreadInformationProviderTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2014, 2015 École Polytechnique de Montréal
   3  *
   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
   8  *
   9  * Contributors:
  10  *   Geneviève Bastien - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.analysis.os.linux.core.tests.kernelanalysis;
  14
  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;
  20
  21 import java.io.File;
  22 import java.util.Collection;
  23 import java.util.List;
  24
  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.kernelanalysis.KernelAnalysisModule;
  29 import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.KernelThreadInformationProvider;
  30 import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.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;
  45
  46 import com.google.common.collect.ImmutableSet;
  47
  48 /**
  49  * Test analysis-specific methods for the {@link KernelAnalysisModule} class.
  50  *
  51  * @author Geneviève Bastien
  52  */
  53 public class KernelThreadInformationProviderTest {
  54
  55     private static final @NonNull LinuxTestCase KERNEL_TEST_CASE = KernelAnalysisTestFactory.KERNEL_SCHED;
  56
  57     private ITmfTrace fTrace;
  58     private KernelAnalysisModule fModule;
  59
  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()) {
  64             file.delete();
  65         }
  66     }
  67
  68     /**
  69      * Setup the trace for the tests
  70      */
  71     @Before
  72     public void setUp() {
  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)) {
  78             module = mod;
  79         }
  80         assertNotNull(module);
  81         module.schedule();
  82         module.waitForCompletion();
  83         fModule = TmfTraceUtils.getAnalysisModuleOfClass(trace, KernelAnalysisModule.class, KernelAnalysisModule.ID);
  84         fTrace = trace;
  85     }
  86
  87     /**
  88      * Clean up
  89      */
  90     @After
  91     public void tearDown() {
  92         deleteSuppFiles(fTrace);
  93         fTrace.dispose();
  94     }
  95
  96     /**
  97      * Test the
  98      * {@link KernelThreadInformationProvider#getThreadIds(KernelAnalysisModule)}
  99      * method
 100      */
 101     @Test
 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);
 106     }
 107
 108     /**
 109      * Test the
 110      * {@link KernelThreadInformationProvider#getThreadOnCpu(KernelAnalysisModule, long, long)}
 111      * method
 112      */
 113     @Test
 114     public void testGetThreadOnCpu() {
 115         KernelAnalysisModule module = checkNotNull(fModule);
 116
 117         /* Check with invalid timestamps */
 118         Integer tid = KernelThreadInformationProvider.getThreadOnCpu(module, 0, -1);
 119         assertNull(tid);
 120
 121         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 0, 80);
 122         assertNull(tid);
 123
 124         /* Check with invalid cpus */
 125         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 2, 20);
 126         assertNull(tid);
 127
 128         tid = KernelThreadInformationProvider.getThreadOnCpu(module, -1, 20);
 129         assertNull(tid);
 130
 131         /* Check valid values */
 132         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 0, 4);
 133         assertNull(tid);
 134
 135         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 0, 15);
 136         assertNull(tid);
 137
 138         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 1, 15);
 139         assertEquals(Integer.valueOf(11), tid);
 140
 141         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 1, 29);
 142         assertEquals(Integer.valueOf(20), tid);
 143
 144         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 1, 30);
 145         assertEquals(Integer.valueOf(21), tid);
 146
 147         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 0, 59);
 148         assertEquals(Integer.valueOf(11), tid);
 149
 150         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 1, 59);
 151         assertEquals(Integer.valueOf(30), tid);
 152
 153         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 0, 60);
 154         assertEquals(Integer.valueOf(11), tid);
 155
 156         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 1, 60);
 157         assertEquals(Integer.valueOf(21), tid);
 158
 159     }
 160
 161     /**
 162      * Test the
 163      * {@link KernelThreadInformationProvider#getParentPid(KernelAnalysisModule, Integer, long)}
 164      * method
 165      */
 166     @Test
 167     public void testGetPpid() {
 168         KernelAnalysisModule module = checkNotNull(fModule);
 169
 170         /* Check with invalid timestamps */
 171         Integer ppid = KernelThreadInformationProvider.getParentPid(module, 11, -1);
 172         assertNull(ppid);
 173
 174         ppid = KernelThreadInformationProvider.getParentPid(module, 11, 80);
 175         assertNull(ppid);
 176
 177         /* Check with invalid cpus */
 178         ppid = KernelThreadInformationProvider.getParentPid(module, -4, 20);
 179         assertNull(ppid);
 180
 181         ppid = KernelThreadInformationProvider.getParentPid(module, 12, 20);
 182         assertNull(ppid);
 183
 184         /* Check values with no parent */
 185         ppid = KernelThreadInformationProvider.getParentPid(module, 10, 20);
 186         assertEquals(Integer.valueOf(0), ppid);
 187
 188         ppid = KernelThreadInformationProvider.getParentPid(module, 30, 60);
 189         assertEquals(Integer.valueOf(0), ppid);
 190
 191         /* Check parent determined at statedump */
 192         ppid = KernelThreadInformationProvider.getParentPid(module, 11, 4);
 193         assertNull(ppid);
 194
 195         ppid = KernelThreadInformationProvider.getParentPid(module, 11, 5);
 196         assertEquals(Integer.valueOf(10), ppid);
 197
 198         /* Check parent after process fork */
 199         ppid = KernelThreadInformationProvider.getParentPid(module, 21, 25);
 200         assertEquals(Integer.valueOf(20), ppid);
 201
 202         ppid = KernelThreadInformationProvider.getParentPid(module, 21, 70);
 203         assertEquals(Integer.valueOf(20), ppid);
 204
 205     }
 206
 207     /**
 208      * Test the {@link KernelThreadInformationProvider#getExecutableName(KernelAnalysisModule, Integer)} method
 209      */
 210     @Test
 211     public void testGetExecutableName() {
 212         KernelAnalysisModule module = checkNotNull(fModule);
 213
 214         /* Check with invalid threads */
 215         String execName = KernelThreadInformationProvider.getExecutableName(module, 101);
 216         assertNull(execName);
 217
 218         execName = KernelThreadInformationProvider.getExecutableName(module, -2);
 219         assertNull(execName);
 220
 221         /* Check valid value */
 222         execName = KernelThreadInformationProvider.getExecutableName(module, 20);
 223         assertEquals("proc20", execName);
 224
 225         /* Check valid value with process name change in history */
 226         execName = KernelThreadInformationProvider.getExecutableName(module, 21);
 227         assertEquals("proc21", execName);
 228
 229     }
 230
 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());
 235         }
 236     }
 237
 238     /**
 239      * Test the
 240      * {@link KernelThreadInformationProvider#getStatusIntervalsForThread(KernelAnalysisModule, Integer, long, long, long, IProgressMonitor)}
 241      * method
 242      */
 243     @Test
 244     public void testGetStatusIntervalsForThread() {
 245         KernelAnalysisModule module = checkNotNull(fModule);
 246
 247         IProgressMonitor monitor = new NullProgressMonitor();
 248         Integer process21 = 21;
 249         Integer process20 = 20;
 250
 251         /* Check invalid time ranges */
 252         List<ITmfStateInterval> intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process21, -15, -5, 3, monitor);
 253         assertTrue(intervals.isEmpty());
 254
 255         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process21, 80, 1500000000L, 50, monitor);
 256         assertTrue(intervals.isEmpty());
 257
 258         /* Check invalid quarks */
 259         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, -1, 0, 70L, 3, monitor);
 260         assertTrue(intervals.isEmpty());
 261
 262         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, 0, 0, 70L, 3, monitor);
 263         assertTrue(intervals.isEmpty());
 264
 265         /* Check different time ranges and resolutions */
 266         ITmfStateValue[] values = { TmfStateValue.nullValue(), StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE,
 267                 StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE, StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE,
 268                 StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE };
 269         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process21, 0, 70L, 3, monitor);
 270         testIntervals("tid 21 [0,70,3]", intervals, values);
 271
 272         ITmfStateValue[] values2 = { TmfStateValue.nullValue(), StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE,
 273                 StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE };
 274         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process21, 1, 70L, 30, monitor);
 275         testIntervals("tid 21 [0,70,30]", intervals, values2);
 276
 277         ITmfStateValue[] values3 = { StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE,
 278                 StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE };
 279         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process21, 25, 50L, 3, monitor);
 280         testIntervals("tid 21 [25,50,3]", intervals, values3);
 281
 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);
 286
 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);
 290
 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);
 295
 296     }
 297
 298 }