org.eclipse.linuxtools.tmf.ctf.core.tests/perf/org/eclipse/linuxtools/tmf/ctf/core/tests/perf/experiment/ExperimentBenchmark.java

   1 /*******************************************************************************
   2  * Copyright (c) 2014 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are made
   5  * available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     Matthew Khouzam - Initial API and implementation
  11  *     Geneviève Bastien - Convert to JUnit performance test
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.tmf.ctf.core.tests.perf.experiment;
  15
  16 import java.io.File;
  17 import java.util.Arrays;
  18 import java.util.HashSet;
  19 import java.util.List;
  20 import java.util.Set;
  21
  22 import org.eclipse.linuxtools.ctf.core.tests.shared.CtfTestTrace;
  23 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  24 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
  25 import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
  26 import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest.ExecutionType;
  27 import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
  28 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  29 import org.eclipse.linuxtools.tmf.ctf.core.CtfTmfTrace;
  30 import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfExperimentStub;
  31 import org.eclipse.test.performance.Dimension;
  32 import org.eclipse.test.performance.Performance;
  33 import org.eclipse.test.performance.PerformanceMeter;
  34 import org.junit.Test;
  35
  36 /**
  37  * Coalescing benchmark
  38  *
  39  * @author Matthew Khouzam
  40  */
  41 public class ExperimentBenchmark {
  42
  43     private static final String TEST_ID = "org.eclipse.linuxtools#Experiment benchmark";
  44     private static final int MAX_TRACES = 160;
  45     private static final int BLOCK_SIZE = 100;
  46     private static final String TRACES_ROOT_PATH = CtfTestTrace.TRACE_EXPERIMENT.getPath();
  47     private static final int SAMPLE_SIZE = 5;
  48
  49     private TmfExperimentStub fExperiment;
  50
  51     /**
  52      * Run the benchmark
  53      */
  54     @Test
  55     public void benchmarkExperimentSizeRequest() {
  56         Performance perf = Performance.getDefault();
  57
  58         for (int numTraces = 1; numTraces < MAX_TRACES; numTraces = (int) (1.6 * (numTraces + 1))) {
  59             PerformanceMeter pm = perf.createPerformanceMeter(TEST_ID + '(' + numTraces + ')');
  60             perf.tagAsSummary(pm, "Experiment Benchmark traces:" + numTraces, Dimension.CPU_TIME);
  61             if ((int) (1.6 * (numTraces + 1)) > MAX_TRACES) {
  62                 perf.tagAsGlobalSummary(pm, "Experiment Benchmark traces: " + numTraces, Dimension.CPU_TIME);
  63             }
  64
  65             for (int s = 0; s < SAMPLE_SIZE; s++) {
  66
  67                 InnerEventRequest expReq = new InnerEventRequest(ITmfEvent.class, 0, ITmfEventRequest.ALL_DATA, ExecutionType.BACKGROUND);
  68                 InnerEventRequest traceReq[] = new InnerEventRequest[numTraces];
  69
  70                 init(numTraces);
  71                 fExperiment.sendRequest(expReq);
  72                 ITmfTrace[] traces = fExperiment.getTraces();
  73                 for (int i = 0; i < numTraces; i++) {
  74                     traceReq[i] = new InnerEventRequest(ITmfEvent.class, 0, ITmfEventRequest.ALL_DATA, ExecutionType.BACKGROUND);
  75                     traces[i].sendRequest(traceReq[i]);
  76                 }
  77
  78                 pm.start();
  79                 waitForRequest(expReq, traceReq);
  80                 pm.stop();
  81
  82                 for (int i = 0; i < traces.length; i++) {
  83                     if (!expReq.isTraceHandled(traces[i])) {
  84                         System.err.println("Trace " + i + " not handled!");
  85                     }
  86                 }
  87
  88                 fExperiment.dispose();
  89             }
  90             pm.commit();
  91         }
  92     }
  93
  94     /**
  95      * Initialization
  96      *
  97      * @param maxTraces
  98      *            maximum number of traces to open
  99      */
 100     private void init(int maxTraces) {
 101         try {
 102             File parentDir = new File(TRACES_ROOT_PATH);
 103             File[] traceFiles = parentDir.listFiles();
 104             ITmfTrace[] traces = new CtfTmfTrace[Math.min(maxTraces, traceFiles.length)];
 105             for (int i = 0; i < traces.length; i++) {
 106                 traces[i] = new CtfTmfTrace();
 107             }
 108             fExperiment = new TmfExperimentStub("MegaExperiment", traces, BLOCK_SIZE);
 109             int j = 0;
 110             for (int i = 0; i < (traces.length) && (j < traces.length); i++) {
 111                 String absolutePath = traceFiles[j].getAbsolutePath();
 112                 if (traces[i].validate(null, absolutePath).isOK()) {
 113                     traces[i].initTrace(null, absolutePath, ITmfEvent.class);
 114                 } else {
 115                     i--;
 116                 }
 117                 j++;
 118             }
 119             if (traces[traces.length - 1].getPath() == null) {
 120                 throw new TmfTraceException("Insufficient valid traces in directory");
 121             }
 122         } catch (TmfTraceException e) {
 123             System.out.println(e.getMessage());
 124         }
 125     }
 126
 127     private static void waitForRequest(InnerEventRequest expReq, InnerEventRequest[] traceReqs) {
 128         try {
 129             expReq.waitForCompletion();
 130             List<InnerEventRequest> reqs = Arrays.asList(traceReqs);
 131             for (InnerEventRequest traceReq : reqs) {
 132                 traceReq.waitForCompletion();
 133             }
 134         } catch (InterruptedException e) {
 135         }
 136     }
 137
 138     private static class InnerEventRequest extends TmfEventRequest {
 139         private Set<String> fTraces = new HashSet<>();
 140
 141         public InnerEventRequest(Class<? extends ITmfEvent> dataType, long index, int nbRequested, ExecutionType priority) {
 142             super(dataType, index, nbRequested, priority);
 143         }
 144
 145         @Override
 146         public void handleData(ITmfEvent event) {
 147             super.handleData(event);
 148             if (!fTraces.contains(event.getTrace().getName())) {
 149                 fTraces.add(event.getTrace().getName());
 150             }
 151         }
 152
 153         public boolean isTraceHandled(ITmfTrace trace) {
 154             return fTraces.contains(trace.getName());
 155         }
 156     }
 157 }