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 import static org.junit.Assert.fail;
  21
  22 import java.io.File;
  23 import java.util.Collection;
  24 import java.util.List;
  25
  26 import org.eclipse.core.runtime.IPath;
  27 import org.eclipse.core.runtime.IProgressMonitor;
  28 import org.eclipse.core.runtime.IStatus;
  29 import org.eclipse.core.runtime.NullProgressMonitor;
  30 import org.eclipse.jdt.annotation.NonNull;
  31 import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.KernelAnalysisModule;
  32 import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.KernelThreadInformationProvider;
  33 import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.StateValues;
  34 import org.eclipse.tracecompass.analysis.os.linux.core.tests.Activator;
  35 import org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.trace.TmfXmlKernelTraceStub;
  36 import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
  37 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
  38 import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
  39 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
  40 import org.eclipse.tracecompass.tmf.core.event.TmfEvent;
  41 import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
  42 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
  43 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  44 import org.eclipse.tracecompass.tmf.core.trace.TmfTrace;
  45 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
  46 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
  47 import org.junit.After;
  48 import org.junit.Before;
  49 import org.junit.Test;
  50
  51 import com.google.common.collect.ImmutableSet;
  52
  53 /**
  54  * Test analysis-specific methods for the {@link KernelAnalysisModule} class.
  55  *
  56  * @author Geneviève Bastien
  57  */
  58 public class KernelThreadInformationProviderTest {
  59
  60     private static final @NonNull String LTTNG_KERNEL_FILE = "testfiles/lttng_kernel_analysis.xml";
  61
  62     private ITmfTrace fTrace;
  63     private KernelAnalysisModule fModule;
  64
  65     private static void deleteSuppFiles(ITmfTrace trace) {
  66         /* Remove supplementary files */
  67         File suppDir = new File(TmfTraceManager.getSupplementaryFileDir(trace));
  68         for (File file : suppDir.listFiles()) {
  69             file.delete();
  70         }
  71     }
  72
  73     /**
  74      * Setup the trace for the tests
  75      */
  76     @Before
  77     public void setUp() {
  78         ITmfTrace trace = new TmfXmlKernelTraceStub();
  79         IPath filePath = Activator.getAbsoluteFilePath(LTTNG_KERNEL_FILE);
  80         IStatus status = trace.validate(null, filePath.toOSString());
  81         if (!status.isOK()) {
  82             fail(status.getException().getMessage());
  83         }
  84         try {
  85             trace.initTrace(null, filePath.toOSString(), TmfEvent.class);
  86         } catch (TmfTraceException e) {
  87             fail(e.getMessage());
  88         }
  89         deleteSuppFiles(trace);
  90         ((TmfTrace) trace).traceOpened(new TmfTraceOpenedSignal(this, trace, null));
  91         IAnalysisModule module = null;
  92         for (IAnalysisModule mod : TmfTraceUtils.getAnalysisModulesOfClass(trace, KernelAnalysisModule.class)) {
  93             module = mod;
  94         }
  95         assertNotNull(module);
  96         module.schedule();
  97         module.waitForCompletion();
  98         fModule = TmfTraceUtils.getAnalysisModuleOfClass(trace, KernelAnalysisModule.class, KernelAnalysisModule.ID);
  99         fTrace = trace;
 100     }
 101
 102     /**
 103      * Clean up
 104      */
 105     @After
 106     public void tearDown() {
 107         deleteSuppFiles(fTrace);
 108         fTrace.dispose();
 109     }
 110
 111     /**
 112      * Test the
 113      * {@link KernelThreadInformationProvider#getThreadIds(KernelAnalysisModule)}
 114      * method
 115      */
 116     @Test
 117     public void testGetThreadQuarks() {
 118         KernelAnalysisModule module = checkNotNull(fModule);
 119         Collection<Integer> threadIds = KernelThreadInformationProvider.getThreadIds(module);
 120         assertEquals(ImmutableSet.<Integer>of(10,11,20,21,30,100), threadIds);
 121     }
 122
 123     /**
 124      * Test the
 125      * {@link KernelThreadInformationProvider#getThreadOnCpu(KernelAnalysisModule, long, long)}
 126      * method
 127      */
 128     @Test
 129     public void testGetThreadOnCpu() {
 130         KernelAnalysisModule module = checkNotNull(fModule);
 131
 132         /* Check with invalid timestamps */
 133         Integer tid = KernelThreadInformationProvider.getThreadOnCpu(module, 0, -1);
 134         assertNull(tid);
 135
 136         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 0, 80);
 137         assertNull(tid);
 138
 139         /* Check with invalid cpus */
 140         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 2, 20);
 141         assertNull(tid);
 142
 143         tid = KernelThreadInformationProvider.getThreadOnCpu(module, -1, 20);
 144         assertNull(tid);
 145
 146         /* Check valid values */
 147         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 0, 4);
 148         assertNull(tid);
 149
 150         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 0, 15);
 151         assertNull(tid);
 152
 153         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 1, 15);
 154         assertEquals(Integer.valueOf(11), tid);
 155
 156         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 1, 29);
 157         assertEquals(Integer.valueOf(20), tid);
 158
 159         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 1, 30);
 160         assertEquals(Integer.valueOf(21), tid);
 161
 162         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 0, 59);
 163         assertEquals(Integer.valueOf(11), tid);
 164
 165         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 1, 59);
 166         assertEquals(Integer.valueOf(30), tid);
 167
 168         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 0, 60);
 169         assertEquals(Integer.valueOf(11), tid);
 170
 171         tid = KernelThreadInformationProvider.getThreadOnCpu(module, 1, 60);
 172         assertEquals(Integer.valueOf(21), tid);
 173
 174     }
 175
 176     /**
 177      * Test the
 178      * {@link KernelThreadInformationProvider#getParentPid(KernelAnalysisModule, Integer, long)}
 179      * method
 180      */
 181     @Test
 182     public void testGetPpid() {
 183         KernelAnalysisModule module = checkNotNull(fModule);
 184
 185         /* Check with invalid timestamps */
 186         Integer ppid = KernelThreadInformationProvider.getParentPid(module, 11, -1);
 187         assertNull(ppid);
 188
 189         ppid = KernelThreadInformationProvider.getParentPid(module, 11, 80);
 190         assertNull(ppid);
 191
 192         /* Check with invalid cpus */
 193         ppid = KernelThreadInformationProvider.getParentPid(module, -4, 20);
 194         assertNull(ppid);
 195
 196         ppid = KernelThreadInformationProvider.getParentPid(module, 12, 20);
 197         assertNull(ppid);
 198
 199         /* Check values with no parent */
 200         ppid = KernelThreadInformationProvider.getParentPid(module, 10, 20);
 201         assertEquals(Integer.valueOf(0), ppid);
 202
 203         ppid = KernelThreadInformationProvider.getParentPid(module, 30, 60);
 204         assertEquals(Integer.valueOf(0), ppid);
 205
 206         /* Check parent determined at statedump */
 207         ppid = KernelThreadInformationProvider.getParentPid(module, 11, 4);
 208         assertNull(ppid);
 209
 210         ppid = KernelThreadInformationProvider.getParentPid(module, 11, 5);
 211         assertEquals(Integer.valueOf(10), ppid);
 212
 213         /* Check parent after process fork */
 214         ppid = KernelThreadInformationProvider.getParentPid(module, 21, 25);
 215         assertEquals(Integer.valueOf(20), ppid);
 216
 217         ppid = KernelThreadInformationProvider.getParentPid(module, 21, 70);
 218         assertEquals(Integer.valueOf(20), ppid);
 219
 220     }
 221
 222     /**
 223      * Test the {@link KernelThreadInformationProvider#getExecutableName(KernelAnalysisModule, Integer)} method
 224      */
 225     @Test
 226     public void testGetExecutableName() {
 227         KernelAnalysisModule module = checkNotNull(fModule);
 228
 229         /* Check with invalid threads */
 230         String execName = KernelThreadInformationProvider.getExecutableName(module, 101);
 231         assertNull(execName);
 232
 233         execName = KernelThreadInformationProvider.getExecutableName(module, -2);
 234         assertNull(execName);
 235
 236         /* Check valid value */
 237         execName = KernelThreadInformationProvider.getExecutableName(module, 20);
 238         assertEquals("proc20", execName);
 239
 240         /* Check valid value with process name change in history */
 241         execName = KernelThreadInformationProvider.getExecutableName(module, 21);
 242         assertEquals("proc21", execName);
 243
 244     }
 245
 246     private static void testIntervals(String info, List<ITmfStateInterval> intervals, ITmfStateValue[] values) {
 247         assertEquals(info + " interval count", values.length, intervals.size());
 248         for (int i = 0; i < values.length; i++) {
 249             assertEquals(info + " interval " + i, values[i], intervals.get(i).getStateValue());
 250         }
 251     }
 252
 253     /**
 254      * Test the
 255      * {@link KernelThreadInformationProvider#getStatusIntervalsForThread(KernelAnalysisModule, Integer, long, long, long, IProgressMonitor)}
 256      * method
 257      */
 258     @Test
 259     public void testGetStatusIntervalsForThread() {
 260         KernelAnalysisModule module = checkNotNull(fModule);
 261
 262         IProgressMonitor monitor = new NullProgressMonitor();
 263         Integer process21 = 21;
 264         Integer process20 = 20;
 265
 266         /* Check invalid time ranges */
 267         List<ITmfStateInterval> intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process21, -15, -5, 3, monitor);
 268         assertTrue(intervals.isEmpty());
 269
 270         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process21, 80, 1500000000L, 50, monitor);
 271         assertTrue(intervals.isEmpty());
 272
 273         /* Check invalid quarks */
 274         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, -1, 0, 70L, 3, monitor);
 275         assertTrue(intervals.isEmpty());
 276
 277         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, 0, 0, 70L, 3, monitor);
 278         assertTrue(intervals.isEmpty());
 279
 280         /* Check different time ranges and resolutions */
 281         ITmfStateValue[] values = { TmfStateValue.nullValue(), StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE,
 282                 StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE, StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE,
 283                 StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE };
 284         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process21, 0, 70L, 3, monitor);
 285         testIntervals("tid 21 [0,70,3]", intervals, values);
 286
 287         ITmfStateValue[] values2 = { TmfStateValue.nullValue(), StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE,
 288                 StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE };
 289         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process21, 1, 70L, 30, monitor);
 290         testIntervals("tid 21 [0,70,30]", intervals, values2);
 291
 292         ITmfStateValue[] values3 = { StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE,
 293                 StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE };
 294         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process21, 25, 50L, 3, monitor);
 295         testIntervals("tid 21 [25,50,3]", intervals, values3);
 296
 297         ITmfStateValue[] values4 = { TmfStateValue.nullValue(), StateValues.PROCESS_STATUS_WAIT_UNKNOWN_VALUE,
 298                 StateValues.PROCESS_STATUS_RUN_USERMODE_VALUE, StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE };
 299         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process20, 0, 70L, 3, monitor);
 300         testIntervals("tid 20 [0,70,3]", intervals, values4);
 301
 302         ITmfStateValue[] values5 = { TmfStateValue.nullValue(), StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE };
 303         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process20, 1, 70L, 30, monitor);
 304         testIntervals("tid 20 [0,70,30]", intervals, values5);
 305
 306         ITmfStateValue[] values6 = { StateValues.PROCESS_STATUS_RUN_USERMODE_VALUE,
 307                 StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE };
 308         intervals = KernelThreadInformationProvider.getStatusIntervalsForThread(module, process20, 25, 50L, 3, monitor);
 309         testIntervals("tid 20 [25,50,3]", intervals, values6);
 310
 311     }
 312
 313 }