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