analysis.io: Unit tests for the I/O analysis

It uses a few XML kernel stub traces to cover the various cases and events
of the IO analysis, then the content of the state system is verified at certain
times and for certain attributes.

Change-Id: I33f8deb62d9df6958fe88012ada3db5f077d0c09
Signed-off-by: Geneviève Bastien <gbastien+lttng@versatic.net>
Reviewed-on: https://git.eclipse.org/r/69668
Reviewed-by: Hudson CI
Reviewed-by: Matthew Khouzam <matthew.khouzam@ericsson.com>
Tested-by: Matthew Khouzam <matthew.khouzam@ericsson.com>

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/META-INF/MANIFEST.MF b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/META-INF/MANIFEST.MF
index 1372c27c12c808b8c1fecba8ae1b1baf8100bf03..e83bfc38b03362dff9a9bf8289c1a9c5a937ae32 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/META-INF/MANIFEST.MF
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/META-INF/MANIFEST.MF
@@ -17,11 +17,12 @@ Require-Bundle: org.junit;bundle-version="4.0.0",
  org.eclipse.tracecompass.tmf.ctf.core,
  org.eclipse.tracecompass.tmf.ctf.core.tests,
  org.eclipse.core.resources,
- org.eclipse.tracecompass.analysis.timing.core;bundle-version="1.0.0",
+ org.eclipse.tracecompass.analysis.timing.core,
  org.eclipse.tracecompass.statesystem.core.tests
 Import-Package: com.google.common.collect,
- org.apache.commons.io;version="2.2.0",
- org.eclipse.tracecompass.testtraces.ctf;version="1.0.0"
+ org.apache.commons.io,
+ org.eclipse.tracecompass.statesystem.core.tests.shared.utils,
+ org.eclipse.tracecompass.testtraces.ctf
 Export-Package: org.eclipse.tracecompass.analysis.os.linux.core.tests,
  org.eclipse.tracecompass.analysis.os.linux.core.tests.cpuusage,
  org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.trace

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/plugin.xml b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/plugin.xml
index ec3944bc1b43dd2dc550f67e7724409df7b02856..fcd34f775542275dd4464f9fa4bb1e35f36ce0ff 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/plugin.xml
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/plugin.xml
@@ -39,7 +39,16 @@
             name="Kernel Memory Usage Test Analysis">
          <tracetype
                applies="true"
-               class="org.eclipse.tracecompass.tmf.tests.stubs.trace.xml.TmfXmlTraceStub">
+               class="org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.trace.TmfXmlKernelTraceStub">
+         </tracetype>
+      </module>
+      <module
+            analysis_module="org.eclipse.tracecompass.analysis.os.linux.core.inputoutput.InputOutputAnalysisModule"
+            automatic="false"
+            id="org.eclipse.tracecompass.analysis.os.linux.inputoutput"
+            name="IO Test Analysis">
+         <tracetype
+               class="org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.trace.TmfXmlKernelTraceStub">
          </tracetype>
       </module>
    </extension>

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/src/org/eclipse/tracecompass/analysis/os/linux/core/tests/inputoutput/AbstractTestInputOutput.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/src/org/eclipse/tracecompass/analysis/os/linux/core/tests/inputoutput/AbstractTestInputOutput.java
new file mode 100644 (file)
index 0000000..63d4f5d
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/src/org/eclipse/tracecompass/analysis/os/linux/core/tests/inputoutput/AbstractTestInputOutput.java
@@ -0,0 +1,145 @@
+/*******************************************************************************
+ * Copyright (c) 2016 École Polytechnique de Montréal
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.analysis.os.linux.core.tests.inputoutput;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.tracecompass.analysis.os.linux.core.inputoutput.InputOutputAnalysisModule;
+import org.eclipse.tracecompass.analysis.os.linux.core.kernel.KernelAnalysisModule;
+import org.eclipse.tracecompass.analysis.os.linux.core.kernel.KernelTidAspect;
+import org.eclipse.tracecompass.analysis.os.linux.core.tests.Activator;
+import org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.trace.KernelEventLayoutStub;
+import org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.trace.TmfXmlKernelTraceStub;
+import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelAnalysisEventLayout;
+import org.eclipse.tracecompass.tmf.core.event.TmfEvent;
+import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
+import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
+import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
+
+/**
+ * Abstract for InputOuput test classes with utility methods to setup and tear
+ * down the tests
+ *
+ * @author Geneviève Bastien
+ */
+public class AbstractTestInputOutput {
+
+    private static final String IO_FILE_PATH = "testfiles/io_analysis/";
+
+    private static class IOKernelEventLayout extends KernelEventLayoutStub {
+        @Override
+        public @NonNull String eventBlockRqMerge() {
+            return "addons_elv_merge_requests";
+        }
+
+        @Override
+        public @Nullable String eventStatedumpBlockDevice() {
+            return "statedump_block_device";
+        }
+
+        @Override
+        public @NonNull String eventSyscallEntryPrefix() {
+            return "syscall_entry";
+        }
+
+        @Override
+        public @NonNull String eventCompatSyscallEntryPrefix() {
+            return "syscall_compat_entry";
+        }
+
+        @Override
+        public @NonNull String eventSyscallExitPrefix() {
+            return "syscall_exit";
+        }
+
+        @Override
+        public @NonNull String eventCompatSyscallExitPrefix() {
+            return "syscall_compat_exit";
+        }
+    }
+
+    private static final @NonNull IKernelAnalysisEventLayout EVENT_LAYOUT = new IOKernelEventLayout();
+
+    private ITmfTrace fTrace;
+
+    private static void deleteSuppFiles(ITmfTrace trace) {
+        /* Remove supplementary files */
+        File suppDir = new File(TmfTraceManager.getSupplementaryFileDir(trace));
+        for (File file : suppDir.listFiles()) {
+            file.delete();
+        }
+    }
+
+    /**
+     * Constructor
+     */
+    public AbstractTestInputOutput() {
+
+    }
+
+    /**
+     * Clean up
+     */
+    protected void deleteTrace() {
+        ITmfTrace trace = fTrace;
+        if (trace != null) {
+            deleteSuppFiles(fTrace);
+            fTrace.dispose();
+        }
+    }
+
+    /**
+     * Setup the trace for the tests and return the InputOutputAnalysisModule,
+     * not executed.
+     *
+     * @param fileName
+     *            The file name of the trace to open
+     * @return The input output analysis module
+     */
+    protected @NonNull InputOutputAnalysisModule setUp(String fileName) {
+        TmfXmlKernelTraceStub trace = new TmfXmlKernelTraceStub();
+        trace.addEventAspect(KernelTidAspect.INSTANCE);
+        trace.setKernelEventLayout(EVENT_LAYOUT);
+        IPath filePath = Activator.getAbsoluteFilePath(IO_FILE_PATH + fileName);
+        IStatus status = trace.validate(null, filePath.toOSString());
+        if (!status.isOK()) {
+            fail(status.getException().getMessage());
+        }
+        try {
+            trace.initTrace(null, filePath.toOSString(), TmfEvent.class);
+        } catch (TmfTraceException e) {
+            fail(e.getMessage());
+        }
+
+        deleteSuppFiles(trace);
+        ((TmfTrace) trace).traceOpened(new TmfTraceOpenedSignal(this, trace, null));
+        fTrace = trace;
+
+        /* Start the kernel analysis module */
+        KernelAnalysisModule kernelMod = TmfTraceUtils.getAnalysisModuleOfClass(trace, KernelAnalysisModule.class, KernelAnalysisModule.ID);
+        assertNotNull(kernelMod);
+        kernelMod.schedule();
+        kernelMod.waitForCompletion();
+
+        InputOutputAnalysisModule module = TmfTraceUtils.getAnalysisModuleOfClass(trace, InputOutputAnalysisModule.class, InputOutputAnalysisModule.ID);
+        assertNotNull(module);
+        return module;
+    }
+}

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/src/org/eclipse/tracecompass/analysis/os/linux/core/tests/inputoutput/InputOutputStateProviderTest.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/src/org/eclipse/tracecompass/analysis/os/linux/core/tests/inputoutput/InputOutputStateProviderTest.java
new file mode 100644 (file)
index 0000000..980b7d9
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/src/org/eclipse/tracecompass/analysis/os/linux/core/tests/inputoutput/InputOutputStateProviderTest.java
@@ -0,0 +1,129 @@
+/*******************************************************************************
+ * Copyright (c) 2016 École Polytechnique de Montréal
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.analysis.os.linux.core.tests.inputoutput;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.analysis.os.linux.core.inputoutput.InputOutputAnalysisModule;
+import org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.LinuxTestCase;
+import org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.LinuxTestCase.IntervalInfo;
+import org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.LinuxTestCase.PunctualInfo;
+import org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.inputoutput.IoTestFactory;
+import org.eclipse.tracecompass.internal.analysis.os.linux.core.inputoutput.InputOutputStateProvider;
+import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
+import org.eclipse.tracecompass.statesystem.core.tests.shared.utils.StateSystemTestUtils;
+import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestHelper;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+/**
+ * Test suite for the {@link InputOutputStateProvider} class
+ *
+ * @author Geneviève Bastien
+ */
+@RunWith(Parameterized.class)
+public class InputOutputStateProviderTest extends AbstractTestInputOutput {
+
+    private final LinuxTestCase fTestCase;
+
+    /**
+     * Constructor
+     *
+     * @param testName
+     *            A name for the test, to display in the header
+     * @param test
+     *            A test case parameter for this test
+     */
+    public InputOutputStateProviderTest(String testName, LinuxTestCase test) {
+        super();
+        fTestCase = test;
+    }
+
+    /**
+     * Clean up
+     */
+    @After
+    public void tearDown() {
+        super.deleteTrace();
+    }
+
+    /**
+     * @return The arrays of parameters
+     */
+    @Parameters(name = "{index}: {0}")
+    public static Iterable<Object[]> getParameters() {
+        return Arrays.asList(new Object[][] {
+                { IoTestFactory.SIMPLE_REQUESTS.getTraceFileName(), IoTestFactory.SIMPLE_REQUESTS },
+                { IoTestFactory.SIMPLE_NO_STATEDUMP.getTraceFileName(), IoTestFactory.SIMPLE_NO_STATEDUMP },
+                { IoTestFactory.REQUESTS_MERGE.getTraceFileName(), IoTestFactory.REQUESTS_MERGE },
+                { IoTestFactory.REQUESTS_MISSING.getTraceFileName(), IoTestFactory.REQUESTS_MISSING },
+                { IoTestFactory.TWO_DEVICES.getTraceFileName(), IoTestFactory.TWO_DEVICES },
+                { IoTestFactory.SYSCALL_READ.getTraceFileName(), IoTestFactory.SYSCALL_READ },
+                { IoTestFactory.SYSCALL_WRITE.getTraceFileName(), IoTestFactory.SYSCALL_WRITE },
+                { IoTestFactory.SYSCALLS_KERNEL.getTraceFileName(), IoTestFactory.SYSCALLS_KERNEL }
+        });
+    }
+
+    /**
+     * Test that the analysis executes without problems
+     */
+    @Test
+    public void testAnalysisExecution() {
+        InputOutputAnalysisModule module = setUp(fTestCase.getTraceFileName());
+        /* Make sure the analysis hasn't run yet */
+        assertNull(module.getStateSystem());
+
+        /* Execute the analysis */
+        assertTrue(TmfTestHelper.executeAnalysis(module));
+        assertNotNull(module.getStateSystem());
+    }
+
+    /**
+     * Test the intervals built by the state provider
+     */
+    @Test
+    public void testStateProviderIntervalData() {
+        InputOutputAnalysisModule module = setUp(fTestCase.getTraceFileName());
+        assertNotNull(module);
+        TmfTestHelper.executeAnalysis(module);
+
+        ITmfStateSystem ss = module.getStateSystem();
+        assertNotNull(ss);
+
+        for (@NonNull IntervalInfo info : fTestCase.getTestIntervals()) {
+            StateSystemTestUtils.testIntervalForAttributes(ss, info.getIntervals(), info.getAttributePath());
+        }
+    }
+
+    /**
+     * Test the data of attributes at punctual times
+     */
+    @Test
+    public void testStateProviderPunctualData() {
+        InputOutputAnalysisModule module = setUp(fTestCase.getTraceFileName());
+        assertNotNull(module);
+        TmfTestHelper.executeAnalysis(module);
+
+        ITmfStateSystem ss = module.getStateSystem();
+        assertNotNull(ss);
+
+        for (@NonNull PunctualInfo info : fTestCase.getPunctualTestData()) {
+            StateSystemTestUtils.testValuesAtTime(ss, info.getTimestamp(), info.getValues());
+        }
+    }
+}

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/stubs/org/eclipse/tracecompass/analysis/os/linux/core/tests/stubs/LinuxTestCase.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/stubs/org/eclipse/tracecompass/analysis/os/linux/core/tests/stubs/LinuxTestCase.java
index c762c52d1d52be0b56100aebd9c04f83717d4acf..5bd2e82abf21ee6d814922b3320e99e32c48ce76 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/stubs/org/eclipse/tracecompass/analysis/os/linux/core/tests/stubs/LinuxTestCase.java
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/stubs/org/eclipse/tracecompass/analysis/os/linux/core/tests/stubs/LinuxTestCase.java
@@ -45,7 +45,16 @@ public class LinuxTestCase {
         private final String[] fAttributePath;
         private final List<ITmfStateInterval> fIntervals;
 
-        IntervalInfo(List<ITmfStateInterval> intervals, String... attributePath) {
+        /**
+         * Constructor
+         *
+         * @param intervals
+         *            The list of intervals for the full time range of the
+         *            attribute
+         * @param attributePath
+         *            The attribute path
+         */
+        public IntervalInfo(List<ITmfStateInterval> intervals, String... attributePath) {
             fAttributePath = attributePath;
             fIntervals = intervals;
         }

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/stubs/org/eclipse/tracecompass/analysis/os/linux/core/tests/stubs/inputoutput/IoTestFactory.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/stubs/org/eclipse/tracecompass/analysis/os/linux/core/tests/stubs/inputoutput/IoTestFactory.java
new file mode 100644 (file)
index 0000000..0f72d90
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/stubs/org/eclipse/tracecompass/analysis/os/linux/core/tests/stubs/inputoutput/IoTestFactory.java
@@ -0,0 +1,717 @@
+/*******************************************************************************
+ * Copyright (c) 2016 École Polytechnique de Montréal
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.inputoutput;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.tracecompass.analysis.os.linux.core.inputoutput.Attributes;
+import org.eclipse.tracecompass.analysis.os.linux.core.inputoutput.StateValues;
+import org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.LinuxTestCase;
+import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
+import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
+import org.eclipse.tracecompass.statesystem.core.tests.shared.utils.StateSystemTestUtils;
+
+import com.google.common.collect.ImmutableList;
+
+import org.eclipse.tracecompass.statesystem.core.tests.shared.utils.StateIntervalStub;
+
+/**
+ * Factory of test for the input output analysis
+ *
+ * @author Geneviève Bastien
+ */
+public final class IoTestFactory {
+
+    private static final String DEVICE_ID = "8388624";
+    private static final String DEVICE_NAME = "sda";
+    private static final String SECOND_DEVICE_ID = "8388608";
+
+    private IoTestFactory() {
+
+    }
+
+    /**
+     * This test case covers cases of simple requests to disk, insert, issue and
+     * completion:
+     *
+     * <pre>
+     * - Write Request inserted at 5L, issued at 10L and completed at 20L
+     * - Two write requests are issued at 25L, one issued at 27L and completed at 30L, the other issued at 29L and completed at 35L
+     * - Read request inserted at 40L, issued at 50L and completed at 60L
+     * </pre>
+     */
+    public final static LinuxTestCase SIMPLE_REQUESTS = new LinuxTestCase("io_analysis.xml") {
+
+        @Override
+        public Set<IntervalInfo> getTestIntervals() {
+            Set<IntervalInfo> info = new HashSet<>();
+
+            /* Driver and waiting queue length */
+            ImmutableList<ITmfStateInterval> intervals = ImmutableList.of(new StateIntervalStub(1, 4, TmfStateValue.nullValue()),
+                    new StateIntervalStub(5, 9, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(10, 24, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(25, 26, TmfStateValue.newValueInt(2)),
+                    new StateIntervalStub(27, 28, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(29, 39, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(40, 49, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(50, 60, TmfStateValue.newValueInt(0)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE_LENGTH));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 4, TmfStateValue.nullValue()),
+                    new StateIntervalStub(5, 9, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(10, 19, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(20, 26, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(27, 28, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(29, 29, TmfStateValue.newValueInt(2)),
+                    new StateIntervalStub(30, 34, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(35, 49, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(50, 59, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(60, 60, TmfStateValue.newValueInt(0)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE_LENGTH));
+
+            /* Bytes read and written */
+            intervals = ImmutableList.of(new StateIntervalStub(1, 59, TmfStateValue.nullValue()),
+                    new StateIntervalStub(60, 60, TmfStateValue.newValueInt(256)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.SECTORS_READ));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 19, TmfStateValue.nullValue()),
+                    new StateIntervalStub(20, 29, TmfStateValue.newValueInt(8)),
+                    new StateIntervalStub(30, 34, TmfStateValue.newValueInt(16)),
+                    new StateIntervalStub(35, 60, TmfStateValue.newValueInt(24)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.SECTORS_WRITTEN));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 60, TmfStateValue.newValueString(DEVICE_NAME)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID));
+            return info;
+        }
+
+        @Override
+        public Set<PunctualInfo> getPunctualTestData() {
+            Set<PunctualInfo> info = new HashSet<>();
+
+            PunctualInfo oneInfo = new PunctualInfo(5L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(444L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(10L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(444L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.ISSUED_FROM), TmfStateValue.newValueInt(0));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(20L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.ISSUED_FROM), TmfStateValue.nullValue());
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(25L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(111L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(222L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(27L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(222L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(111L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.ISSUED_FROM), TmfStateValue.newValueInt(0));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(29L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(111L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.ISSUED_FROM), TmfStateValue.newValueInt(0));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "1"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(222L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "1", Attributes.ISSUED_FROM), TmfStateValue.newValueInt(1));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(30L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.ISSUED_FROM), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "1"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(222L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "1", Attributes.ISSUED_FROM), TmfStateValue.newValueInt(1));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(35L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.ISSUED_FROM), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "1"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "1", Attributes.ISSUED_FROM), TmfStateValue.nullValue());
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(40L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(444L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(256));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(50L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(444L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(256));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.ISSUED_FROM), TmfStateValue.newValueInt(0));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(60L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.ISSUED_FROM), TmfStateValue.nullValue());
+            info.add(oneInfo);
+
+            return info;
+        }
+
+    };
+
+    /**
+     * This test case tests the behavior of a simple request without the device
+     * statedump
+     *
+     * <pre>
+     * - Write Request inserted at 5L, issued at 10L and completed at 20L
+     * </pre>
+     */
+    public final static LinuxTestCase SIMPLE_NO_STATEDUMP = new LinuxTestCase("io_nostatedump.xml") {
+
+        @Override
+        public Set<IntervalInfo> getTestIntervals() {
+            Set<IntervalInfo> info = new HashSet<>();
+
+            /* Driver and waiting queue length */
+            ImmutableList<ITmfStateInterval> intervals = ImmutableList.of(new StateIntervalStub(5, 9, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(10, 20, TmfStateValue.newValueInt(0)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE_LENGTH));
+
+            intervals = ImmutableList.of(new StateIntervalStub(5, 9, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(10, 19, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(20, 20, TmfStateValue.newValueInt(0)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE_LENGTH));
+
+            return info;
+        }
+
+        @Override
+        public Set<PunctualInfo> getPunctualTestData() {
+            return new HashSet<>();
+        }
+    };
+
+    /**
+     * This test case contains system call read events
+     */
+    public final static LinuxTestCase SYSCALL_READ = new LinuxTestCase("io_syscall_read.xml") {
+
+        @Override
+        public Set<IntervalInfo> getTestIntervals() {
+            Set<IntervalInfo> info = new HashSet<>();
+
+            /* Bytes read for a given process */
+            ImmutableList<ITmfStateInterval> intervals = ImmutableList.of(new StateIntervalStub(1, 9, TmfStateValue.nullValue()),
+                    new StateIntervalStub(10, 24, TmfStateValue.newValueInt(8)),
+                    new StateIntervalStub(25, 50, TmfStateValue.newValueInt(44)));
+            info.add(new IntervalInfo(intervals, Attributes.THREADS, "2", Attributes.BYTES_READ));
+
+            /* Bytes read for a given process */
+            intervals = ImmutableList.of(new StateIntervalStub(1, 49, TmfStateValue.nullValue()),
+                    new StateIntervalStub(50, 50, TmfStateValue.newValueInt(8)));
+            info.add(new IntervalInfo(intervals, Attributes.THREADS, "5", Attributes.BYTES_READ));
+
+            return info;
+        }
+
+        @Override
+        public Set<PunctualInfo> getPunctualTestData() {
+            return new HashSet<>();
+        }
+    };
+
+    /**
+     * This test case contains system call write events
+     */
+    public final static LinuxTestCase SYSCALL_WRITE = new LinuxTestCase("io_syscall_write.xml") {
+
+        @Override
+        public Set<IntervalInfo> getTestIntervals() {
+            Set<IntervalInfo> info = new HashSet<>();
+
+            /* Bytes read for a given process */
+            ImmutableList<ITmfStateInterval> intervals = ImmutableList.of(new StateIntervalStub(1, 9, TmfStateValue.nullValue()),
+                    new StateIntervalStub(10, 29, TmfStateValue.newValueInt(16)),
+                    new StateIntervalStub(30, 39, TmfStateValue.newValueInt(26)),
+                    new StateIntervalStub(40, 50, TmfStateValue.newValueInt(36)));
+            info.add(new IntervalInfo(intervals, Attributes.THREADS, "2", Attributes.BYTES_WRITTEN));
+
+            /* Bytes read for a given process */
+            intervals = ImmutableList.of(new StateIntervalStub(1, 29, TmfStateValue.nullValue()),
+                    new StateIntervalStub(30, 49, TmfStateValue.newValueInt(32)),
+                    new StateIntervalStub(50, 50, TmfStateValue.newValueInt(96)));
+            info.add(new IntervalInfo(intervals, Attributes.THREADS, "5", Attributes.BYTES_WRITTEN));
+
+            return info;
+        }
+
+        @Override
+        public Set<PunctualInfo> getPunctualTestData() {
+            return new HashSet<>();
+        }
+    };
+
+    /**
+     * This test case contains requests merges with different events
+     *
+     * <pre>
+     * - Write request inserted at 5L, frontmerged at 7L, issued at 10L and completed 20L
+     * - 4 reqd requests inserted at 15L, 35L, 40L and 50L, merged at 42L, 45L and 55L, issued at 60L and completed at 65L
+     * </pre>
+     */
+    public final static LinuxTestCase REQUESTS_MERGE = new LinuxTestCase("io_req_merge.xml") {
+
+        @Override
+        public Set<IntervalInfo> getTestIntervals() {
+            Set<IntervalInfo> info = new HashSet<>();
+
+            /* Driver and waiting queue length */
+            ImmutableList<ITmfStateInterval> intervals = ImmutableList.of(new StateIntervalStub(1, 4, TmfStateValue.nullValue()),
+                    new StateIntervalStub(5, 9, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(10, 14, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(15, 34, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(35, 39, TmfStateValue.newValueInt(2)),
+                    new StateIntervalStub(40, 41, TmfStateValue.newValueInt(3)),
+                    new StateIntervalStub(42, 44, TmfStateValue.newValueInt(2)),
+                    new StateIntervalStub(45, 49, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(50, 54, TmfStateValue.newValueInt(2)),
+                    new StateIntervalStub(55, 59, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(60, 65, TmfStateValue.newValueInt(0)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE_LENGTH));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 4, TmfStateValue.nullValue()),
+                    new StateIntervalStub(5, 9, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(10, 19, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(20, 59, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(60, 64, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(65, 65, TmfStateValue.newValueInt(0)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE_LENGTH));
+
+            /* Bytes read and written */
+            intervals = ImmutableList.of(new StateIntervalStub(1, 64, TmfStateValue.nullValue()),
+                    new StateIntervalStub(65, 65, TmfStateValue.newValueInt(40)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.SECTORS_READ));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 19, TmfStateValue.nullValue()),
+                    new StateIntervalStub(20, 65, TmfStateValue.newValueInt(16)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.SECTORS_WRITTEN));
+
+            return info;
+        }
+
+        @Override
+        public Set<PunctualInfo> getPunctualTestData() {
+            Set<PunctualInfo> info = new HashSet<>();
+
+            PunctualInfo oneInfo = new PunctualInfo(5L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(444L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(7L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(436L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(16));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(10L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(436L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(16));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(15L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(292L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), StateValues.WRITING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(436L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(16));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(20L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(35L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(292L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(284L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(40L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(292L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(284L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(300L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(16));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(42L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(292L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(24));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.MERGED_IN), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(284L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.MERGED_IN), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.MERGED_IN), TmfStateValue.newValueInt(0));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(45L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.MERGED_IN), TmfStateValue.newValueInt(1));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(284L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(32));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.MERGED_IN), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.MERGED_IN), TmfStateValue.newValueInt(0));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(50L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(316L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(8));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.MERGED_IN), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(284L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(32));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.MERGED_IN), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.MERGED_IN), TmfStateValue.newValueInt(0));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(55L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.MERGED_IN), TmfStateValue.newValueInt(1));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(284L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(40));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.MERGED_IN), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.MERGED_IN), TmfStateValue.newValueInt(0));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(60L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "1", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE, "2", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), StateValues.READING_REQUEST_VALUE);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.newValueLong(284L));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.newValueInt(40));
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.ISSUED_FROM), TmfStateValue.newValueInt(1));
+            info.add(oneInfo);
+
+            oneInfo = new PunctualInfo(65L);
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0"), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.CURRENT_REQUEST), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.REQUEST_SIZE), TmfStateValue.nullValue());
+            oneInfo.addValue(StateSystemTestUtils.makeAttribute(Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE, "0", Attributes.ISSUED_FROM), TmfStateValue.nullValue());
+            info.add(oneInfo);
+
+            return info;
+        }
+    };
+
+    /**
+     * This test case contains special cases when some events are missed (no
+     * insert, no issue, merge without prior insertion)
+     *
+     * <pre>
+     * - write request issued at 5L and completed at 10L
+     *     * expected: See the request in the issue queue
+     * - frontmerge with a request that was not inserted at 15L, issued 20L, completed 25L
+     *     * expected: See only that one request with the right sector, issued and completed normally
+     * - read request completed at 30L, never insert or issued
+     *     * expected: Sectors added to the total of read sectors
+     * - elv_merge after a request not inserted: insert at 35, merge at 38, issued at 40, completed at 45
+     *     * expected: See only one request with the right sector, issued and completed normally
+     * - elv merge before a request not inserted: insert at 50, merge at 55, issued at 60 and completed at 65
+     *     * expected: See only one request with the right sector, issued and completed normally
+     * - request that does not complete: insert at 80, issued at 100
+     *     * expected: have an open request in the driving queue until the end
+     * - request that is not issued: insert at 120, completed at 140
+     *     * expected: have an open request in the waiting queue until the end, written sectors at completion are counted
+     * </pre>
+     */
+    public final static LinuxTestCase REQUESTS_MISSING = new LinuxTestCase("io_missing.xml") {
+
+        @Override
+        public Set<IntervalInfo> getTestIntervals() {
+            Set<IntervalInfo> info = new HashSet<>();
+
+            /* Driver and waiting queue length */
+            ImmutableList<ITmfStateInterval> intervals = ImmutableList.of(new StateIntervalStub(1, 4, TmfStateValue.nullValue()),
+                    new StateIntervalStub(5, 14, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(15, 19, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(20, 34, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(35, 39, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(40, 49, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(50, 59, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(60, 79, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(80, 99, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(100, 119, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(120, 140, TmfStateValue.newValueInt(1)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE_LENGTH));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 4, TmfStateValue.nullValue()),
+                    new StateIntervalStub(5, 9, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(10, 19, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(20, 24, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(25, 39, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(40, 44, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(45, 59, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(60, 64, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(65, 99, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(100, 140, TmfStateValue.newValueInt(1)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE_LENGTH));
+
+            /* Bytes read and written */
+            intervals = ImmutableList.of(new StateIntervalStub(1, 29, TmfStateValue.nullValue()),
+                    new StateIntervalStub(30, 44, TmfStateValue.newValueInt(16)),
+                    new StateIntervalStub(45, 64, TmfStateValue.newValueInt(56)),
+                    new StateIntervalStub(65, 140, TmfStateValue.newValueInt(96)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.SECTORS_READ));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 9, TmfStateValue.nullValue()),
+                    new StateIntervalStub(10, 24, TmfStateValue.newValueInt(8)),
+                    new StateIntervalStub(25, 139, TmfStateValue.newValueInt(24)),
+                    new StateIntervalStub(140, 140, TmfStateValue.newValueInt(32)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.SECTORS_WRITTEN));
+
+            return info;
+        }
+
+        @Override
+        public Set<PunctualInfo> getPunctualTestData() {
+            return new HashSet<>();
+        }
+    };
+
+    /**
+     * This test case tests that requests are associated with the right device
+     *
+     * <pre>
+     * - write request on sda inserted at 5L, issued at 10L and completed at 20L
+     * - read request on sdb inserted at 8L (before statedump), issued at 12L and completed at 18L
+     * </pre>
+     */
+    public final static LinuxTestCase TWO_DEVICES = new LinuxTestCase("io_two_devices.xml") {
+
+        @Override
+        public Set<IntervalInfo> getTestIntervals() {
+            Set<IntervalInfo> info = new HashSet<>();
+
+            /* Driver and waiting queue length */
+            ImmutableList<ITmfStateInterval> intervals = ImmutableList.of(new StateIntervalStub(1, 4, TmfStateValue.nullValue()),
+                    new StateIntervalStub(5, 9, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(10, 20, TmfStateValue.newValueInt(0)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.WAITING_QUEUE_LENGTH));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 4, TmfStateValue.nullValue()),
+                    new StateIntervalStub(5, 9, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(10, 19, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(20, 20, TmfStateValue.newValueInt(0)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.DRIVER_QUEUE_LENGTH));
+
+            /* Bytes read and written */
+            intervals = ImmutableList.of(new StateIntervalStub(1, 20, TmfStateValue.nullValue()));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.SECTORS_READ));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 19, TmfStateValue.nullValue()),
+                    new StateIntervalStub(20, 20, TmfStateValue.newValueInt(8)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, DEVICE_ID, Attributes.SECTORS_WRITTEN));
+
+            /* Driver and waiting queue length */
+            intervals = ImmutableList.of(new StateIntervalStub(1, 7, TmfStateValue.nullValue()),
+                    new StateIntervalStub(8, 11, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(12, 20, TmfStateValue.newValueInt(0)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, SECOND_DEVICE_ID, Attributes.WAITING_QUEUE_LENGTH));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 7, TmfStateValue.nullValue()),
+                    new StateIntervalStub(8, 11, TmfStateValue.newValueInt(0)),
+                    new StateIntervalStub(12, 17, TmfStateValue.newValueInt(1)),
+                    new StateIntervalStub(18, 20, TmfStateValue.newValueInt(0)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, SECOND_DEVICE_ID, Attributes.DRIVER_QUEUE_LENGTH));
+
+            /* Bytes read and written */
+            intervals = ImmutableList.of(new StateIntervalStub(1, 17, TmfStateValue.nullValue()),
+                    new StateIntervalStub(18, 20, TmfStateValue.newValueInt(16)));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, SECOND_DEVICE_ID, Attributes.SECTORS_READ));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 20, TmfStateValue.nullValue()));
+            info.add(new IntervalInfo(intervals, Attributes.DISKS, SECOND_DEVICE_ID, Attributes.SECTORS_WRITTEN));
+
+            return info;
+        }
+
+        @Override
+        public Set<PunctualInfo> getPunctualTestData() {
+            return new HashSet<>();
+        }
+    };
+
+    /**
+     * This test case contains system call read and write events but instead of
+     * context with the event, it has sched_switches so that the kernel analysis
+     * has to be used to get the running threads
+     */
+    public final static LinuxTestCase SYSCALLS_KERNEL = new LinuxTestCase("io_full_kernel.xml") {
+
+        @Override
+        public Set<IntervalInfo> getTestIntervals() {
+            Set<IntervalInfo> info = new HashSet<>();
+
+            /* Bytes read and written for thread 1 */
+            ImmutableList<ITmfStateInterval> intervals = ImmutableList.of(new StateIntervalStub(1, 29, TmfStateValue.nullValue()),
+                    new StateIntervalStub(30, 45, TmfStateValue.newValueInt(20)));
+            info.add(new IntervalInfo(intervals, Attributes.THREADS, "1", Attributes.BYTES_READ));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 45, TmfStateValue.nullValue()));
+            info.add(new IntervalInfo(intervals, Attributes.THREADS, "1", Attributes.BYTES_WRITTEN));
+
+            /* Bytes read and written for thread 2 */
+            intervals = ImmutableList.of(new StateIntervalStub(1, 9, TmfStateValue.nullValue()),
+                    new StateIntervalStub(10, 45, TmfStateValue.newValueInt(8)));
+            info.add(new IntervalInfo(intervals, Attributes.THREADS, "2", Attributes.BYTES_READ));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 45, TmfStateValue.nullValue()));
+            info.add(new IntervalInfo(intervals, Attributes.THREADS, "2", Attributes.BYTES_WRITTEN));
+
+            /* Bytes read and written for thread 3 */
+            intervals = ImmutableList.of(new StateIntervalStub(1, 34, TmfStateValue.nullValue()),
+                    new StateIntervalStub(35, 45, TmfStateValue.newValueInt(36)));
+            info.add(new IntervalInfo(intervals, Attributes.THREADS, "3", Attributes.BYTES_READ));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 39, TmfStateValue.nullValue()),
+                    new StateIntervalStub(40, 45, TmfStateValue.newValueInt(64)));
+            info.add(new IntervalInfo(intervals, Attributes.THREADS, "3", Attributes.BYTES_WRITTEN));
+
+            /* Bytes read and written for thread 4 */
+            intervals = ImmutableList.of(new StateIntervalStub(1, 45, TmfStateValue.nullValue()));
+            info.add(new IntervalInfo(intervals, Attributes.THREADS, "4", Attributes.BYTES_READ));
+
+            intervals = ImmutableList.of(new StateIntervalStub(1, 9, TmfStateValue.nullValue()),
+                    new StateIntervalStub(10, 45, TmfStateValue.newValueInt(16)));
+            info.add(new IntervalInfo(intervals, Attributes.THREADS, "4", Attributes.BYTES_WRITTEN));
+
+            return info;
+        }
+
+        @Override
+        public Set<PunctualInfo> getPunctualTestData() {
+            return new HashSet<>();
+        }
+    };
+}

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/stubs/org/eclipse/tracecompass/analysis/os/linux/core/tests/stubs/inputoutput/package-info.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/stubs/org/eclipse/tracecompass/analysis/os/linux/core/tests/stubs/inputoutput/package-info.java
new file mode 100644 (file)
index 0000000..7328d24
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/stubs/org/eclipse/tracecompass/analysis/os/linux/core/tests/stubs/inputoutput/package-info.java
@@ -0,0 +1,11 @@
+/*******************************************************************************
+ * Copyright (c) 2016 École Polytechnique de Montréal
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+
+@org.eclipse.jdt.annotation.NonNullByDefault
+package org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.inputoutput;
\ No newline at end of file

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_analysis.xml b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_analysis.xml
new file mode 100644 (file)
index 0000000..93cd92c
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_analysis.xml
@@ -0,0 +1,114 @@
+<trace>
+<set_aspects>
+<field name="cpu" value="1" type="int" />
+</set_aspects>
+<event timestamp="1" name="statedump_block_device">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="diskname" value="sda" type="string" />
+</event>
+<event timestamp="5" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="10" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="20" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="25" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="111" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="25" name="block_rq_insert">
+<field name="cpu" value="1" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="222" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="2" type="long" />
+<field name="rwbs" value="289" type="long" />
+</event>
+<event timestamp="27" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="111" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="29" name="block_rq_issue">
+<field name="cpu" value="1" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="222" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="2" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="30" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="111" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="35" name="block_rq_complete">
+<field name="cpu" value="1" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="222" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="40" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="256" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="50" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="256" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="60" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="256" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+</trace>
\ No newline at end of file

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_full_kernel.xml b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_full_kernel.xml
new file mode 100644 (file)
index 0000000..9dc15ba
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_full_kernel.xml
@@ -0,0 +1,173 @@
+<trace>
+<set_aspects>
+<field name="cpu" value="1" type="int" />
+</set_aspects>
+<event timestamp="1" name="statedump_block_device">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="diskname" value="sda" type="string" />
+</event>
+<event timestamp="3" name="sched_switch">
+<field name="cpu" value="0" type="int" />
+<field name="prev_comm" value="proc4" type="string" />
+<field name="prev_tid" value="4" type="long" />
+<field name="prev_prio" value="20" type="long" />
+<field name="prev_state" value="0" type="long" />
+<field name="next_comm" value="proc2" type="string" />
+<field name="next_tid" value="2" type="long" />
+<field name="next_prio" value="20" type="long" />
+</event>
+<event timestamp="4" name="sched_switch">
+<field name="cpu" value="1" type="int" />
+<field name="prev_comm" value="proc1" type="string" />
+<field name="prev_tid" value="1" type="long" />
+<field name="prev_prio" value="20" type="long" />
+<field name="prev_state" value="0" type="long" />
+<field name="next_comm" value="proc4" type="string" />
+<field name="next_tid" value="4" type="long" />
+<field name="next_prio" value="20" type="long" />
+</event>
+<event timestamp="5" name="syscall_entry_read">
+<field name="cpu" value="0" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="count" value="16" type="long" />
+</event>
+<event timestamp="5" name="syscall_entry_write">
+<field name="cpu" value="1" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="buf" value="654654" type="long" />
+<field name="count" value="16" type="long" />
+</event>
+<event timestamp="10" name="syscall_exit_write">
+<field name="cpu" value="1" type="int" />
+<field name="ret" value="16" type="long" />
+</event>
+<event timestamp="10" name="syscall_exit_read">
+<field name="cpu" value="0" type="int" />
+<field name="ret" value="8" type="long" />
+<field name="buf" value="123456" type="long" />
+</event>
+<event timestamp="15" name="sched_switch">
+<field name="cpu" value="0" type="int" />
+<field name="prev_comm" value="proc2" type="string" />
+<field name="prev_tid" value="2" type="long" />
+<field name="prev_prio" value="20" type="long" />
+<field name="prev_state" value="0" type="long" />
+<field name="next_comm" value="proc3" type="string" />
+<field name="next_tid" value="3" type="long" />
+<field name="next_prio" value="20" type="long" />
+</event>
+<event timestamp="20" name="syscall_entry_pread64">
+<field name="cpu" value="0" type="int" />
+<field name="fd" value="13" type="long" />
+<field name="count" value="36" type="long" />
+<field name="pos" value="64" type="long" />
+</event>
+<event timestamp="22" name="sched_switch">
+<field name="cpu" value="0" type="int" />
+<field name="prev_comm" value="proc3" type="string" />
+<field name="prev_tid" value="3" type="long" />
+<field name="prev_prio" value="20" type="long" />
+<field name="prev_state" value="1" type="long" />
+<field name="next_comm" value="proc1" type="string" />
+<field name="next_tid" value="1" type="long" />
+<field name="next_prio" value="20" type="long" />
+</event>
+<event timestamp="22" name="sched_switch">
+<field name="cpu" value="1" type="int" />
+<field name="prev_comm" value="proc5" type="string" />
+<field name="prev_tid" value="5" type="long" />
+<field name="prev_prio" value="20" type="long" />
+<field name="prev_state" value="0" type="long" />
+<field name="next_comm" value="sdb10" type="string" />
+<field name="next_tid" value="10" type="long" />
+<field name="next_prio" value="20" type="long" />
+</event>
+<event timestamp="24" name="block_rq_insert">
+<field name="cpu" value="1" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="256" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="25" name="syscall_entry_read">
+<field name="cpu" value="0" type="int" />
+<field name="fd" value="10" type="long" />
+<field name="count" value="19" type="long" />
+</event>
+<event timestamp="27" name="block_rq_issue">
+<field name="cpu" value="1" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="256" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="29" name="block_rq_complete">
+<field name="cpu" value="1" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="256" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="30" name="syscall_exit_read">
+<field name="cpu" value="0" type="int" />
+<field name="ret" value="20" type="long" />
+<field name="buf" value="123456" type="long" />
+</event>
+<event timestamp="32" name="sched_switch">
+<field name="cpu" value="0" type="int" />
+<field name="prev_comm" value="proc1" type="string" />
+<field name="prev_tid" value="1" type="long" />
+<field name="prev_prio" value="20" type="long" />
+<field name="prev_state" value="0" type="long" />
+<field name="next_comm" value="proc3" type="string" />
+<field name="next_tid" value="3" type="long" />
+<field name="next_prio" value="20" type="long" />
+</event>
+<event timestamp="35" name="syscall_exit_pread64">
+<field name="cpu" value="0" type="int" />
+<field name="ret" value="36" type="long" />
+<field name="buf" value="123456" type="long" />
+</event>
+<event timestamp="35" name="block_rq_insert">
+<field name="cpu" value="1" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="35" name="syscall_entry_write">
+<field name="cpu" value="0" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="buf" value="654654" type="long" />
+<field name="count" value="64" type="long" />
+</event>
+<event timestamp="40" name="syscall_exit_write">
+<field name="cpu" value="0" type="int" />
+<field name="ret" value="64" type="long" />
+</event>
+<event timestamp="40" name="block_rq_issue">
+<field name="cpu" value="1" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="45" name="block_rq_complete">
+<field name="cpu" value="1" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+</trace>
\ No newline at end of file

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_missing.xml b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_missing.xml
new file mode 100644 (file)
index 0000000..f13caa5
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_missing.xml
@@ -0,0 +1,166 @@
+<trace>
+<set_aspects>
+<field name="cpu" value="1" type="int" />
+</set_aspects>
+<event timestamp="1" name="statedump_block_device">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="diskname" value="sda" type="string" />
+</event>
+<!-- missing the insert event -->
+<event timestamp="5" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="10" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<!-- frontmerging with a request that was not inserted -->
+<event timestamp="15" name="block_bio_frontmerge">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="rq_sector" value="444" type="long" />
+<field name="sector" value="436" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="20" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="436" type="long" />
+<field name="nr_sector" value="16" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="25" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="436" type="long" />
+<field name="nr_sector" value="16" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<!-- missing insert and issue events -->
+<event timestamp="30" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="333" type="long" />
+<field name="nr_sector" value="16" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<!-- elv_merge after a request not inserted -->
+<event timestamp="35" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="292" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="38" name="addons_elv_merge_requests">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="rq_sector" value="284" type="long" />
+<field name="nextrq_sector" value="292" type="long" />
+</event>
+<event timestamp="40" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="284" type="long" />
+<field name="nr_sector" value="40" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="45" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="284" type="long" />
+<field name="nr_sector" value="40" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<!-- elv_merge before a request not inserted -->
+<event timestamp="50" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="284" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="55" name="addons_elv_merge_requests">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="rq_sector" value="284" type="long" />
+<field name="nextrq_sector" value="292" type="long" />
+</event>
+<event timestamp="60" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="284" type="long" />
+<field name="nr_sector" value="40" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="65" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="284" type="long" />
+<field name="nr_sector" value="40" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<!-- request never completed -->
+<event timestamp="80" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="100" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<!-- request not issued -->
+<event timestamp="120" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="333" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="140" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="333" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+</trace>
\ No newline at end of file

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_nostatedump.xml b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_nostatedump.xml
new file mode 100644 (file)
index 0000000..b468971
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_nostatedump.xml
@@ -0,0 +1,31 @@
+<trace>
+<set_aspects>
+<field name="cpu" value="1" type="int" />
+</set_aspects>
+<event timestamp="5" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="10" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="20" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+</trace>
\ No newline at end of file

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_req_merge.xml b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_req_merge.xml
new file mode 100644 (file)
index 0000000..3a9844a
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_req_merge.xml
@@ -0,0 +1,115 @@
+<trace>
+<set_aspects>
+<field name="cpu" value="1" type="int" />
+</set_aspects>
+<event timestamp="1" name="statedump_block_device">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="diskname" value="sda" type="string" />
+</event>
+<event timestamp="5" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="7" name="block_bio_frontmerge">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="rq_sector" value="444" type="long" />
+<field name="sector" value="436" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="10" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="436" type="long" />
+<field name="nr_sector" value="16" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="15" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="292" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="20" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="436" type="long" />
+<field name="nr_sector" value="16" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="35" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="284" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="40" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="300" type="long" />
+<field name="nr_sector" value="16" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="42" name="addons_elv_merge_requests">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="rq_sector" value="292" type="long" />
+<field name="nextrq_sector" value="300" type="long" />
+</event>
+<event timestamp="45" name="addons_elv_merge_requests">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="rq_sector" value="284" type="long" />
+<field name="nextrq_sector" value="292" type="long" />
+</event>
+<event timestamp="50" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="316" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="55" name="addons_elv_merge_requests">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="rq_sector" value="284" type="long" />
+<field name="nextrq_sector" value="316" type="long" />
+</event>
+<event timestamp="60" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="284" type="long" />
+<field name="nr_sector" value="40" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="65" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="284" type="long" />
+<field name="nr_sector" value="40" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+</trace>
\ No newline at end of file

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_syscall_read.xml b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_syscall_read.xml
new file mode 100644 (file)
index 0000000..b6c061c
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_syscall_read.xml
@@ -0,0 +1,74 @@
+<trace>
+<set_aspects>
+<field name="cpu" value="1" type="int" />
+</set_aspects>
+<event timestamp="1" name="statedump_block_device">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="diskname" value="sda" type="string" />
+</event>
+<event timestamp="3" name="sched_switch">
+<field name="cpu" value="0" type="int" />
+<field name="prev_comm" value="proc4" type="string" />
+<field name="prev_tid" value="4" type="long" />
+<field name="prev_prio" value="20" type="long" />
+<field name="prev_state" value="0" type="long" />
+<field name="next_comm" value="proc2" type="string" />
+<field name="next_tid" value="2" type="long" />
+<field name="next_prio" value="20" type="long" />
+</event>
+<event timestamp="5" name="syscall_entry_read">
+<field name="cpu" value="0" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="count" value="16" type="long" />
+</event>
+<event timestamp="10" name="syscall_exit_read">
+<field name="cpu" value="0" type="int" />
+<field name="ret" value="8" type="long" />
+<field name="buf" value="123456" type="long" />
+</event>
+<event timestamp="20" name="syscall_entry_pread64">
+<field name="cpu" value="0" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="count" value="36" type="long" />
+<field name="pos" value="64" type="long" />
+</event>
+<event timestamp="25" name="syscall_exit_pread64">
+<field name="cpu" value="0" type="int" />
+<field name="ret" value="36" type="long" />
+<field name="buf" value="123456" type="long" />
+</event>
+<event timestamp="30" name="sched_switch">
+<field name="cpu" value="0" type="int" />
+<field name="prev_comm" value="proc2" type="string" />
+<field name="prev_tid" value="2" type="long" />
+<field name="prev_prio" value="20" type="long" />
+<field name="prev_state" value="0" type="long" />
+<field name="next_comm" value="proc5" type="string" />
+<field name="next_tid" value="5" type="long" />
+<field name="next_prio" value="20" type="long" />
+</event>
+<event timestamp="35" name="syscall_entry_readv">
+<field name="cpu" value="0" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="vec" value="123123" type="long" />
+<field name="vlen" value="1" type="long" />
+</event>
+<event timestamp="40" name="syscall_exit_readv">
+<field name="cpu" value="0" type="int" />
+<field name="ret" value="-11" type="long" />
+<field name="buf" value="123456" type="long" />
+</event>
+<event timestamp="45" name="syscall_entry_preadv">
+<field name="cpu" value="0" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="pos" value="64" type="long" />
+<field name="vec" value="123123" type="long" />
+<field name="vlen" value="3" type="long" />
+</event>
+<event timestamp="50" name="syscall_exit_preadv">
+<field name="cpu" value="0" type="int" />
+<field name="ret" value="8" type="long" />
+<field name="buf" value="123456" type="long" />
+</event>
+</trace>
\ No newline at end of file

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_syscall_write.xml b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_syscall_write.xml
new file mode 100644 (file)
index 0000000..76c711c
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_syscall_write.xml
@@ -0,0 +1,95 @@
+<trace>
+<set_aspects>
+<field name="cpu" value="1" type="int" />
+</set_aspects>
+<event timestamp="1" name="statedump_block_device">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="diskname" value="sda" type="string" />
+</event>
+<event timestamp="3" name="sched_switch">
+<field name="cpu" value="0" type="int" />
+<field name="prev_comm" value="proc4" type="string" />
+<field name="prev_tid" value="4" type="long" />
+<field name="prev_prio" value="20" type="long" />
+<field name="prev_state" value="0" type="long" />
+<field name="next_comm" value="proc2" type="string" />
+<field name="next_tid" value="2" type="long" />
+<field name="next_prio" value="20" type="long" />
+</event>
+<event timestamp="3" name="sched_switch">
+<field name="cpu" value="1" type="int" />
+<field name="prev_comm" value="proc3" type="string" />
+<field name="prev_tid" value="3" type="long" />
+<field name="prev_prio" value="20" type="long" />
+<field name="prev_state" value="0" type="long" />
+<field name="next_comm" value="proc5" type="string" />
+<field name="next_tid" value="5" type="long" />
+<field name="next_prio" value="20" type="long" />
+</event>
+<event timestamp="5" name="syscall_entry_write">
+<field name="cpu" value="0" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="buf" value="654654" type="long" />
+<field name="count" value="16" type="long" />
+</event>
+<event timestamp="10" name="syscall_exit_write">
+<field name="cpu" value="0" type="int" />
+<field name="ret" value="16" type="long" />
+</event>
+<event timestamp="15" name="syscall_entry_writev">
+<field name="cpu" value="1" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="vec" value="123123" type="long" />
+<field name="vlen" value="1" type="long" />
+</event>
+<event timestamp="20" name="syscall_exit_writev">
+<field name="cpu" value="1" type="int" />
+<field name="ret" value="-11" type="long" />
+</event>
+<event timestamp="25" name="syscall_entry_writev">
+<field name="cpu" value="1" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="vec" value="123123" type="long" />
+<field name="vlen" value="1" type="long" />
+</event>
+<event timestamp="26" name="syscall_entry_pwrite">
+<field name="cpu" value="0" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="buf" value="654654" type="long" />
+<field name="count" value="10" type="long" />
+<field name="pos" value="10" type="long" />
+</event>
+<event timestamp="30" name="syscall_exit_writev">
+<field name="cpu" value="1" type="int" />
+<field name="ret" value="32" type="long" />
+<field name="vec" value="123123" type="long" />
+</event>
+<event timestamp="30" name="syscall_exit_pwrite">
+<field name="cpu" value="0" type="int" />
+<field name="ret" value="10" type="long" />
+</event>
+<event timestamp="35" name="syscall_entry_pwrite64">
+<field name="cpu" value="0" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="buf" value="654654" type="long" />
+<field name="count" value="10" type="long" />
+<field name="pos" value="10" type="long" />
+</event>
+<event timestamp="40" name="syscall_exit_pwrite64">
+<field name="cpu" value="0" type="int" />
+<field name="ret" value="10" type="long" />
+</event>
+<event timestamp="45" name="syscall_entry_pwritev">
+<field name="cpu" value="1" type="int" />
+<field name="fd" value="11" type="long" />
+<field name="vec" value="123123" type="long" />
+<field name="vlen" value="3" type="long" />
+<field name="pos" value="15" type="long" />
+</event>
+<event timestamp="50" name="syscall_exit_pwritev">
+<field name="cpu" value="1" type="int" />
+<field name="ret" value="64" type="long" />
+<field name="vec" value="123123" type="long" />
+</event>
+</trace>
\ No newline at end of file

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_two_devices.xml b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_two_devices.xml
new file mode 100644 (file)
index 0000000..4da42ce
--- /dev/null
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core.tests/testfiles/io_analysis/io_two_devices.xml
@@ -0,0 +1,67 @@
+<trace>
+<set_aspects>
+<field name="cpu" value="1" type="int" />
+</set_aspects>
+<event timestamp="1" name="statedump_block_device">
+<field name="cpu" value="1" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="diskname" value="sda" type="string" />
+</event>
+<event timestamp="5" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="8" name="block_rq_insert">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388608" type="long" />
+<field name="sector" value="111" type="long" />
+<field name="nr_sector" value="16" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="9" name="statedump_block_device">
+<field name="cpu" value="1" type="int" />
+<field name="dev" value="8388608" type="long" />
+<field name="diskname" value="sdb" type="string" />
+</event>
+<event timestamp="10" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+<event timestamp="12" name="block_rq_issue">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388608" type="long" />
+<field name="sector" value="111" type="long" />
+<field name="nr_sector" value="16" type="long" />
+<field name="bytes" value="0" type="long" />
+<field name="tid" value="1" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="18" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388608" type="long" />
+<field name="sector" value="111" type="long" />
+<field name="nr_sector" value="16" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="4" type="long" />
+</event>
+<event timestamp="20" name="block_rq_complete">
+<field name="cpu" value="0" type="int" />
+<field name="dev" value="8388624" type="long" />
+<field name="sector" value="444" type="long" />
+<field name="nr_sector" value="8" type="long" />
+<field name="errors" value="0" type="long" />
+<field name="rwbs" value="33" type="long" />
+</event>
+</trace>
\ No newline at end of file