| /******************************************************************************* |
| * Copyright (c) 2018 É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 2.0 which |
| * accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| *******************************************************************************/ |
| |
| package org.eclipse.tracecompass.lttng2.kernel.core.tests.analysis.graph; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.jdt.annotation.NonNull; |
| import org.eclipse.tracecompass.analysis.graph.core.base.IGraphWorker; |
| import org.eclipse.tracecompass.analysis.graph.core.base.TmfEdge; |
| import org.eclipse.tracecompass.analysis.graph.core.base.TmfEdge.EdgeType; |
| import org.eclipse.tracecompass.analysis.graph.core.base.TmfGraph; |
| import org.eclipse.tracecompass.analysis.graph.core.base.TmfVertex; |
| import org.eclipse.tracecompass.analysis.graph.core.building.TmfGraphBuilderModule; |
| import org.eclipse.tracecompass.analysis.graph.core.criticalpath.CriticalPathModule; |
| import org.eclipse.tracecompass.analysis.graph.core.tests.stubs.GraphOps; |
| import org.eclipse.tracecompass.analysis.os.linux.core.execution.graph.OsExecutionGraph; |
| import org.eclipse.tracecompass.analysis.os.linux.core.execution.graph.OsWorker; |
| import org.eclipse.tracecompass.analysis.os.linux.core.tests.stubs.trace.TmfXmlKernelTraceStub; |
| import org.eclipse.tracecompass.lttng2.kernel.core.tests.Activator; |
| import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule; |
| import org.eclipse.tracecompass.tmf.core.event.ITmfEvent; |
| import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException; |
| 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.TmfTraceUtils; |
| import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment; |
| import org.junit.Test; |
| |
| /** |
| * Test the distributed critical path, when traced machines communicate with one |
| * another through the network |
| * |
| * @author Geneviève Bastien |
| */ |
| public class DistributedCriticalPathTest { |
| |
| private static final String EXPERIMENT = "CritPathExperiment"; |
| private static int BLOCK_SIZE = 1000; |
| private static final @NonNull String TEST_ANALYSIS_ID = OsExecutionGraph.ANALYSIS_ID; |
| |
| /** |
| * Setup the experiment for the tests |
| * |
| * @param traceFiles |
| * File names relative to this plugin for the trace files to load |
| * @return The experiment with its graph module executed |
| * @throws TmfTraceException |
| */ |
| private ITmfTrace setUpExperiment(String... traceFiles) throws TmfTraceException { |
| ITmfTrace[] traces = new ITmfTrace[traceFiles.length]; |
| int i = 0; |
| for (String traceFile : traceFiles) { |
| TmfXmlKernelTraceStub trace = new TmfXmlKernelTraceStub(); |
| IPath filePath = Activator.getAbsoluteFilePath(traceFile); |
| IStatus status = trace.validate(null, filePath.toOSString()); |
| if (!status.isOK()) { |
| fail(status.getException().getMessage()); |
| } |
| trace.initTrace(null, filePath.toOSString(), ITmfEvent.class); |
| traces[i++] = trace; |
| } |
| |
| TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, EXPERIMENT, traces, BLOCK_SIZE, null); |
| experiment.traceOpened(new TmfTraceOpenedSignal(this, experiment, null)); |
| |
| IAnalysisModule module = null; |
| for (IAnalysisModule mod : TmfTraceUtils.getAnalysisModulesOfClass(experiment, TmfGraphBuilderModule.class)) { |
| module = mod; |
| } |
| assertNotNull(module); |
| module.schedule(); |
| assertTrue(module.waitForCompletion()); |
| return experiment; |
| } |
| |
| /** |
| * Test the graph building of a network exchange where one machine receives |
| * in a softirq and the other receives in a threaded IRQ, with new network |
| * reception events. The 2 traces include events to wrap IRQ and packet |
| * reception contexts |
| * |
| * @throws TmfTraceException |
| * Exception thrown by opening experiment |
| * @throws TmfAnalysisException |
| * Exception thrown by analyses |
| */ |
| @Test |
| public void testNetworkExchangeWithWifi() throws TmfTraceException, TmfAnalysisException { |
| ITmfTrace experiment = setUpExperiment("testfiles/graph/network_exchange_eth.xml", "testfiles/graph/network_exchange_wifi.xml"); |
| assertNotNull(experiment); |
| try { |
| internalTestNetworkExchangeWithWifi(experiment); |
| } finally { |
| experiment.dispose(); |
| } |
| } |
| |
| private static void internalTestNetworkExchangeWithWifi(@NonNull ITmfTrace experiment) throws TmfAnalysisException { |
| TmfGraphBuilderModule module = TmfTraceUtils.getAnalysisModuleOfClass(experiment, TmfGraphBuilderModule.class, TEST_ANALYSIS_ID); |
| assertNotNull(module); |
| |
| TmfGraph graph = module.getGraph(); |
| assertNotNull(graph); |
| |
| Set<IGraphWorker> workers = graph.getWorkers(); |
| assertEquals(6, workers.size()); |
| |
| // Prepare a worker map |
| final int irqThread = 50; |
| final int clientThread = 200; |
| final int otherClient = 201; |
| final int serverThread = 100; |
| final int otherServer = 101; |
| final int kernelThread = -1; |
| Map<Integer, IGraphWorker> workerMap = new HashMap<>(); |
| for (IGraphWorker worker : workers) { |
| workerMap.put(((OsWorker) worker).getHostThread().getTid(), worker); |
| } |
| // Build the expected graph |
| TmfGraph expected = new TmfGraph(); |
| |
| // other thread on client side |
| IGraphWorker worker = workerMap.get(otherClient); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(10)); |
| expected.append(worker, new TmfVertex(15), EdgeType.PREEMPTED); |
| expected.append(worker, new TmfVertex(60), EdgeType.RUNNING); |
| |
| // client thread |
| worker = workerMap.get(clientThread); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(10)); |
| TmfVertex packet1Sent = new TmfVertex(13); |
| expected.append(worker, packet1Sent, EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(15), EdgeType.RUNNING); |
| TmfVertex packet2Received = new TmfVertex(70); |
| expected.append(worker, packet2Received, EdgeType.NETWORK, "irq/30-handler"); |
| expected.append(worker, new TmfVertex(75), EdgeType.PREEMPTED); |
| |
| // irq thread |
| worker = workerMap.get(irqThread); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(55)); |
| expected.append(worker, new TmfVertex(60), EdgeType.PREEMPTED); |
| expected.append(worker, new TmfVertex(65), EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(75), EdgeType.RUNNING); |
| |
| // Other thread on server side |
| worker = workerMap.get(otherServer); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(5)); |
| expected.append(worker, new TmfVertex(40), EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(55), EdgeType.PREEMPTED); |
| |
| // Server thread |
| worker = workerMap.get(serverThread); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(5)); |
| TmfVertex packet1Received = new TmfVertex(35); |
| expected.append(worker, packet1Received, EdgeType.NETWORK); |
| expected.append(worker, new TmfVertex(40), EdgeType.PREEMPTED); |
| TmfVertex packet2Sent = new TmfVertex(45); |
| expected.append(worker, packet2Sent, EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(55), EdgeType.RUNNING); |
| |
| // Create the vertical links |
| TmfEdge link = packet1Sent.linkVertical(packet1Received); |
| link.setType(EdgeType.NETWORK); |
| link = packet2Sent.linkVertical(packet2Received); |
| link.setType(EdgeType.NETWORK); |
| |
| // kernel worker on server side |
| worker = workerMap.get(kernelThread); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(30)); |
| expected.append(worker, new TmfVertex(33), EdgeType.RUNNING); |
| |
| GraphOps.checkEquality(expected, graph); |
| |
| /* Test the critical path */ |
| |
| // Build the expected critical path |
| expected = new TmfGraph(); |
| // Client worker |
| worker = workerMap.get(clientThread); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(10)); |
| expected.append(worker, new TmfVertex(13), EdgeType.RUNNING); |
| packet1Sent = new TmfVertex(15); |
| expected.append(worker, packet1Sent, EdgeType.RUNNING); |
| packet2Received = new TmfVertex(70); |
| expected.add(worker, packet2Received); |
| expected.append(worker, new TmfVertex(75), EdgeType.PREEMPTED); |
| |
| // Server worker |
| worker = workerMap.get(serverThread); |
| assertNotNull(worker); |
| packet1Received = new TmfVertex(35); |
| expected.add(worker, packet1Received); |
| expected.append(worker, new TmfVertex(40), EdgeType.PREEMPTED); |
| packet2Sent = new TmfVertex(45); |
| expected.append(worker, packet2Sent, EdgeType.RUNNING); |
| |
| link = packet1Sent.linkVertical(packet1Received); |
| link.setType(EdgeType.NETWORK); |
| link = packet2Sent.linkVertical(packet2Received); |
| link.setType(EdgeType.NETWORK); |
| |
| // Execute the critical path module and compare equality |
| CriticalPathModule critPathModule = new CriticalPathModule(module); |
| try { |
| critPathModule.setTrace(experiment); |
| critPathModule.setParameter(CriticalPathModule.PARAM_WORKER, workerMap.get(clientThread)); |
| critPathModule.schedule(); |
| assertTrue(critPathModule.waitForCompletion()); |
| |
| TmfGraph criticalPath = critPathModule.getCriticalPath(); |
| assertNotNull(criticalPath); |
| |
| GraphOps.checkEquality(expected, criticalPath); |
| } finally { |
| critPathModule.dispose(); |
| } |
| } |
| |
| /** |
| * Test the graph building of a simple network exchange where both machines |
| * receive in softirqs, without packet reception and complete IRQ contexts |
| * |
| * @throws TmfTraceException |
| * Exception thrown by opening experiment |
| * @throws TmfAnalysisException |
| * Exception thrown by analyses |
| */ |
| @Test |
| public void testNetworkExchange() throws TmfTraceException, TmfAnalysisException { |
| ITmfTrace experiment = setUpExperiment("testfiles/graph/simple_network_server.xml", "testfiles/graph/simple_network_client.xml"); |
| assertNotNull(experiment); |
| try { |
| internalTestNetworkExchange(experiment); |
| } finally { |
| experiment.dispose(); |
| } |
| } |
| |
| private static void internalTestNetworkExchange(@NonNull ITmfTrace experiment) throws TmfAnalysisException { |
| TmfGraphBuilderModule module = TmfTraceUtils.getAnalysisModuleOfClass(experiment, TmfGraphBuilderModule.class, TEST_ANALYSIS_ID); |
| assertNotNull(module); |
| |
| TmfGraph graph = module.getGraph(); |
| assertNotNull(graph); |
| |
| Set<IGraphWorker> workers = graph.getWorkers(); |
| assertEquals(7, workers.size()); |
| |
| // Prepare a worker map |
| final int clientThread = 200; |
| final int otherClient = 201; |
| final int depClient = 202; |
| final int serverThread = 100; |
| final int otherServer = 101; |
| OsWorker clientWorker = null; |
| OsWorker serverWorker = null; |
| Map<Integer, IGraphWorker> workerMap = new HashMap<>(); |
| for (IGraphWorker worker : workers) { |
| OsWorker osWorker = (OsWorker) worker; |
| if (osWorker.getHostThread().getTid() < 0) { |
| if (osWorker.getHostId().equals("simple_network_server.xml")) { |
| serverWorker = osWorker; |
| } else { |
| clientWorker = osWorker; |
| } |
| } |
| workerMap.put(osWorker.getHostThread().getTid(), worker); |
| } |
| // Make the expected graph |
| TmfGraph expected = new TmfGraph(); |
| |
| // other thread on client side |
| IGraphWorker worker = workerMap.get(otherClient); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(7)); |
| expected.append(worker, new TmfVertex(10), EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(15), EdgeType.PREEMPTED); |
| expected.append(worker, new TmfVertex(75), EdgeType.RUNNING); |
| |
| // client thread |
| worker = workerMap.get(clientThread); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(10)); |
| TmfVertex packet1Sent = new TmfVertex(13); |
| expected.append(worker, packet1Sent, EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(15), EdgeType.RUNNING); |
| TmfVertex packet2Received = new TmfVertex(70); |
| expected.append(worker, packet2Received, EdgeType.NETWORK); |
| expected.append(worker, new TmfVertex(75), EdgeType.PREEMPTED); |
| TmfVertex wakeupSource = new TmfVertex(90); |
| expected.append(worker, wakeupSource, EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(95), EdgeType.RUNNING); |
| |
| // client kernel worker |
| worker = clientWorker; |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(60)); |
| expected.append(worker, new TmfVertex(65), EdgeType.RUNNING); |
| |
| // thread on client waiting for client process |
| worker = workerMap.get(depClient); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(7)); |
| TmfVertex wakeupTarget = new TmfVertex(90); |
| expected.append(worker, wakeupTarget, EdgeType.BLOCKED); |
| expected.append(worker, new TmfVertex(95), EdgeType.PREEMPTED); |
| wakeupSource.linkVertical(wakeupTarget); |
| |
| // Other thread on server side |
| worker = workerMap.get(otherServer); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(5)); |
| expected.append(worker, new TmfVertex(40), EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(55), EdgeType.PREEMPTED); |
| |
| // Server thread |
| worker = workerMap.get(serverThread); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(5)); |
| TmfVertex packet1Received = new TmfVertex(35); |
| expected.append(worker, packet1Received, EdgeType.NETWORK); |
| expected.append(worker, new TmfVertex(40), EdgeType.PREEMPTED); |
| TmfVertex packet2Sent = new TmfVertex(45); |
| expected.append(worker, packet2Sent, EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(55), EdgeType.RUNNING); |
| |
| // Create the vertical links |
| TmfEdge link = packet1Sent.linkVertical(packet1Received); |
| link.setType(EdgeType.NETWORK); |
| link = packet2Sent.linkVertical(packet2Received); |
| link.setType(EdgeType.NETWORK); |
| |
| // kernel worker on server side |
| worker = serverWorker; |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(30)); |
| expected.append(worker, new TmfVertex(33), EdgeType.RUNNING); |
| |
| GraphOps.checkEquality(expected, graph); |
| |
| /* Test the critical path */ |
| |
| // Build the expected critical path |
| expected = new TmfGraph(); |
| |
| // Client worker |
| worker = workerMap.get(clientThread); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(10)); |
| expected.append(worker, new TmfVertex(13), EdgeType.RUNNING); |
| packet1Sent = new TmfVertex(15); |
| expected.append(worker, packet1Sent, EdgeType.RUNNING); |
| packet2Received = new TmfVertex(70); |
| expected.add(worker, packet2Received); |
| expected.append(worker, new TmfVertex(75), EdgeType.PREEMPTED); |
| expected.append(worker, new TmfVertex(90), EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(95), EdgeType.RUNNING); |
| |
| // Server worker |
| worker = workerMap.get(serverThread); |
| assertNotNull(worker); |
| packet1Received = new TmfVertex(35); |
| expected.add(worker, packet1Received); |
| expected.append(worker, new TmfVertex(40), EdgeType.PREEMPTED); |
| packet2Sent = new TmfVertex(45); |
| expected.append(worker, packet2Sent, EdgeType.RUNNING); |
| |
| link = packet1Sent.linkVertical(packet1Received); |
| link.setType(EdgeType.NETWORK); |
| link = packet2Sent.linkVertical(packet2Received); |
| link.setType(EdgeType.NETWORK); |
| |
| // Execute the critical path module and compare equality |
| CriticalPathModule critPathModule = new CriticalPathModule(module); |
| try { |
| critPathModule.setTrace(experiment); |
| critPathModule.setParameter(CriticalPathModule.PARAM_WORKER, workerMap.get(clientThread)); |
| critPathModule.schedule(); |
| assertTrue(critPathModule.waitForCompletion()); |
| |
| TmfGraph criticalPath = critPathModule.getCriticalPath(); |
| assertNotNull(criticalPath); |
| |
| GraphOps.checkEquality(expected, criticalPath); |
| } finally { |
| critPathModule.dispose(); |
| } |
| } |
| |
| /** |
| * Test the graph building of a simple network exchange but without the |
| * other machine's trace. The process should be blocked by network |
| * |
| * @throws TmfTraceException |
| * Exception thrown by opening experiment |
| * @throws TmfAnalysisException |
| * Exception thrown by analyses |
| */ |
| @Test |
| public void testNetworkExchangeOneTrace() throws TmfTraceException, TmfAnalysisException { |
| ITmfTrace experiment = setUpExperiment("testfiles/graph/network_exchange_wifi.xml"); |
| assertNotNull(experiment); |
| try { |
| internalTestNetworkExchangeOneTrace(experiment); |
| } finally { |
| experiment.dispose(); |
| } |
| } |
| |
| private static void internalTestNetworkExchangeOneTrace(@NonNull ITmfTrace experiment) throws TmfAnalysisException { |
| TmfGraphBuilderModule module = TmfTraceUtils.getAnalysisModuleOfClass(experiment, TmfGraphBuilderModule.class, TEST_ANALYSIS_ID); |
| assertNotNull(module); |
| |
| TmfGraph graph = module.getGraph(); |
| assertNotNull(graph); |
| |
| Set<IGraphWorker> workers = graph.getWorkers(); |
| assertEquals(3, workers.size()); |
| |
| // Prepare a worker map |
| final int irqThread = 50; |
| final int clientThread = 200; |
| final int otherClient = 201; |
| Map<Integer, IGraphWorker> workerMap = new HashMap<>(); |
| for (IGraphWorker worker : workers) { |
| workerMap.put(((OsWorker) worker).getHostThread().getTid(), worker); |
| } |
| // Make the expected graph |
| TmfGraph expected = new TmfGraph(); |
| |
| // other thread on client side |
| IGraphWorker worker = workerMap.get(otherClient); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(10)); |
| expected.append(worker, new TmfVertex(15), EdgeType.PREEMPTED); |
| expected.append(worker, new TmfVertex(60), EdgeType.RUNNING); |
| |
| // client thread |
| worker = workerMap.get(clientThread); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(10)); |
| TmfVertex packet1Sent = new TmfVertex(13); |
| expected.append(worker, packet1Sent, EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(15), EdgeType.RUNNING); |
| TmfVertex packet2Received = new TmfVertex(70); |
| expected.append(worker, packet2Received, EdgeType.NETWORK, "irq/30-handler"); |
| expected.append(worker, new TmfVertex(75), EdgeType.PREEMPTED); |
| |
| // irq thread |
| worker = workerMap.get(irqThread); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(55)); |
| expected.append(worker, new TmfVertex(60), EdgeType.PREEMPTED); |
| expected.append(worker, new TmfVertex(65), EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(75), EdgeType.RUNNING); |
| |
| GraphOps.checkEquality(expected, graph); |
| |
| /* Test the critical path */ |
| // Build the expected graph: it should be the client thread only |
| expected = new TmfGraph(); |
| |
| worker = workerMap.get(clientThread); |
| assertNotNull(worker); |
| |
| for (TmfVertex vertex : graph.getNodesOf(worker)) { |
| expected.add(worker, vertex); |
| } |
| |
| // Execute the critical path module and compare equality |
| CriticalPathModule critPathModule = new CriticalPathModule(module); |
| try { |
| critPathModule.setTrace(experiment); |
| critPathModule.setParameter(CriticalPathModule.PARAM_WORKER, workerMap.get(clientThread)); |
| critPathModule.schedule(); |
| assertTrue(critPathModule.waitForCompletion()); |
| |
| TmfGraph criticalPath = critPathModule.getCriticalPath(); |
| assertNotNull(criticalPath); |
| |
| GraphOps.checkEquality(expected, criticalPath); |
| } finally { |
| critPathModule.dispose(); |
| } |
| } |
| |
| /** |
| * Test the graph building of a simple network exchange but without the |
| * other machine's trace. The process should be blocked by network |
| * |
| * @throws TmfTraceException |
| * Exception thrown by opening experiment |
| * @throws TmfAnalysisException |
| * Exception thrown by analyses |
| */ |
| @Test |
| public void testNetworkExchangeOneTraceSoftirq() throws TmfTraceException, TmfAnalysisException { |
| ITmfTrace experiment = setUpExperiment("testfiles/graph/simple_network_client.xml"); |
| assertNotNull(experiment); |
| try { |
| internalTestNetworkExchangeOneTraceSoftirq(experiment); |
| } finally { |
| experiment.dispose(); |
| } |
| } |
| |
| private static void internalTestNetworkExchangeOneTraceSoftirq(@NonNull ITmfTrace experiment) throws TmfAnalysisException { |
| TmfGraphBuilderModule module = TmfTraceUtils.getAnalysisModuleOfClass(experiment, TmfGraphBuilderModule.class, TEST_ANALYSIS_ID); |
| assertNotNull(module); |
| |
| TmfGraph graph = module.getGraph(); |
| assertNotNull(graph); |
| |
| Set<IGraphWorker> workers = graph.getWorkers(); |
| assertEquals(4, workers.size()); |
| |
| // Prepare a worker map |
| final int clientThread = 200; |
| final int otherClient = 201; |
| final int depClient = 202; |
| OsWorker clientWorker = null; |
| Map<Integer, IGraphWorker> workerMap = new HashMap<>(); |
| for (IGraphWorker worker : workers) { |
| OsWorker osWorker = (OsWorker) worker; |
| if (osWorker.getHostThread().getTid() < 0) { |
| clientWorker = osWorker; |
| } |
| workerMap.put(osWorker.getHostThread().getTid(), worker); |
| } |
| // Make the expected graph |
| TmfGraph expected = new TmfGraph(); |
| |
| // other thread on client side |
| IGraphWorker worker = workerMap.get(otherClient); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(7)); |
| expected.append(worker, new TmfVertex(10), EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(15), EdgeType.PREEMPTED); |
| expected.append(worker, new TmfVertex(75), EdgeType.RUNNING); |
| |
| // client thread |
| worker = workerMap.get(clientThread); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(10)); |
| TmfVertex packet1Sent = new TmfVertex(13); |
| expected.append(worker, packet1Sent, EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(15), EdgeType.RUNNING); |
| TmfVertex packet2Received = new TmfVertex(70); |
| expected.append(worker, packet2Received, EdgeType.NETWORK); |
| expected.append(worker, new TmfVertex(75), EdgeType.PREEMPTED); |
| TmfVertex wakeupSource = new TmfVertex(90); |
| expected.append(worker, wakeupSource, EdgeType.RUNNING); |
| expected.append(worker, new TmfVertex(95), EdgeType.RUNNING); |
| |
| // client kernel worker |
| worker = clientWorker; |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(60)); |
| expected.append(worker, new TmfVertex(65), EdgeType.RUNNING); |
| |
| // thread on client waiting for client process |
| worker = workerMap.get(depClient); |
| assertNotNull(worker); |
| expected.add(worker, new TmfVertex(7)); |
| TmfVertex wakeupTarget = new TmfVertex(90); |
| expected.append(worker, wakeupTarget, EdgeType.BLOCKED); |
| expected.append(worker, new TmfVertex(95), EdgeType.PREEMPTED); |
| wakeupSource.linkVertical(wakeupTarget); |
| |
| GraphOps.checkEquality(expected, graph); |
| |
| /* Test the critical path */ |
| |
| // Build the expected critical path |
| expected = new TmfGraph(); |
| |
| // Client worker |
| IGraphWorker cWorker = workerMap.get(clientThread); |
| assertNotNull(cWorker); |
| expected.add(cWorker, new TmfVertex(10)); |
| expected.append(cWorker, new TmfVertex(13), EdgeType.RUNNING); |
| packet1Sent = new TmfVertex(15); |
| expected.append(cWorker, packet1Sent, EdgeType.RUNNING); |
| packet2Received = new TmfVertex(70); |
| expected.append(cWorker, packet2Received, EdgeType.NETWORK); |
| expected.append(cWorker, new TmfVertex(75), EdgeType.PREEMPTED); |
| wakeupSource = new TmfVertex(90); |
| expected.append(cWorker, wakeupSource, EdgeType.RUNNING); |
| expected.append(cWorker, new TmfVertex(95), EdgeType.RUNNING); |
| |
| // Execute the critical path module and compare equality |
| CriticalPathModule critPathModule = new CriticalPathModule(module); |
| try { |
| critPathModule.setTrace(experiment); |
| critPathModule.setParameter(CriticalPathModule.PARAM_WORKER, cWorker); |
| critPathModule.schedule(); |
| assertTrue(critPathModule.waitForCompletion()); |
| |
| TmfGraph criticalPath = critPathModule.getCriticalPath(); |
| assertNotNull(criticalPath); |
| |
| GraphOps.checkEquality(expected, criticalPath); |
| |
| // Test the critical path for the dependent thread |
| // Critical path for the dependent worker |
| expected = new TmfGraph(); |
| worker = workerMap.get(depClient); |
| assertNotNull(worker); |
| TmfVertex begin = new TmfVertex(7); |
| expected.add(worker, begin); |
| wakeupTarget = new TmfVertex(90); |
| expected.add(worker, wakeupTarget); |
| expected.append(worker, new TmfVertex(95), EdgeType.PREEMPTED); |
| |
| // Copy the critical path of the client worker |
| TmfVertex start = new TmfVertex(7); |
| expected.add(cWorker, start); |
| expected.append(cWorker, new TmfVertex(10), EdgeType.UNKNOWN); |
| expected.append(cWorker, new TmfVertex(13), EdgeType.RUNNING); |
| packet1Sent = new TmfVertex(15); |
| expected.append(cWorker, packet1Sent, EdgeType.RUNNING); |
| packet2Received = new TmfVertex(70); |
| expected.append(cWorker, packet2Received, EdgeType.NETWORK); |
| expected.append(cWorker, new TmfVertex(75), EdgeType.PREEMPTED); |
| wakeupSource = new TmfVertex(90); |
| expected.append(cWorker, wakeupSource, EdgeType.RUNNING); |
| |
| // Add the links |
| begin.linkVertical(start); |
| wakeupSource.linkVertical(wakeupTarget); |
| |
| critPathModule.setParameter(CriticalPathModule.PARAM_WORKER, worker); |
| critPathModule.schedule(); |
| assertTrue(critPathModule.waitForCompletion()); |
| |
| criticalPath = critPathModule.getCriticalPath(); |
| assertNotNull(criticalPath); |
| |
| GraphOps.checkEquality(expected, criticalPath); |
| } finally { |
| critPathModule.dispose(); |
| } |
| } |
| |
| } |
