Add profile agent reporting to MasterBench

pr-link: #11460
change-id: cid-f75488ea9ce04f61ad1660f121a0f848886770e4

stress/common/src/main/java/alluxio/stress/master/MasterBenchParameters.java

@@ -80,6 +80,11 @@ public final class MasterBenchParameters extends Parameters {
           + "directory with exactly 1000 paths.")
   public int mFixedCount = 100;
 
+  @Parameter(names = {"--profile-agent"},
+      description = "The path to the profile agent if one is available. "
+          + "Providing this will enable a more detailed output.")
+  public String mProfileAgent = "";
+
   @DynamicParameter(names = "--conf", description = "HDFS client configuration. Can be repeated.")
   public Map<String, String> mConf = new HashMap<>();
 }

stress/common/src/main/java/alluxio/stress/master/MasterBenchSummary.java

@@ -18,35 +18,29 @@
 import alluxio.stress.graph.LineGraph;
 
 import com.google.common.base.Splitter;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 
 import java.text.DateFormat;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
+import java.util.zip.DataFormatException;
 
 /**
  * The summary for the master stress tests.
  */
 public final class MasterBenchSummary implements Summary {
   private long mDurationMs;
-  private long mNumSuccess;
-  private float mThroughput;
   private long mEndTimeMs;
   private MasterBenchParameters mParameters;
   private List<String> mNodes;
   private Map<String, List<String>> mErrors;
 
-  /** response times for all percentiles from 0 -> 100 (101 values). */
-  @SuppressFBWarnings(value = "EI_EXPOSE_REP2")
-  private float[] mResponseTimePercentileMs;
-  /** percentiles of just 99.x%. first entry is 99%, second is 99.9%, etc. */
-  @SuppressFBWarnings(value = "EI_EXPOSE_REP2")
-  private float[] mResponseTime99PercentileMs;
-  /** max response time over time, over the duration of the test. */
-  @SuppressFBWarnings(value = "EI_EXPOSE_REP2")
-  private float[] mMaxResponseTimeMs;
+  private float mThroughput;
+  private MasterBenchSummaryStatistics mStatistics;
+
+  private Map<String, MasterBenchSummaryStatistics> mStatisticsPerMethod;
 
   /**
    * Creates an instance.
@@ -58,44 +52,29 @@ public MasterBenchSummary() {
   /**
    * Creates an instance.
    *
-   * @param durationMs the duration (in ms)
-   * @param numSuccess the number of success
-   * @param endTimeMs the end time (in ms)
-   * @param responseTimePercentileMs the response times (in ms), for all percentiles
-   * @param responseTime99PercentileMs the response times (in ms), for the 99.x percentiles
-   * @param maxResponseTimeMs the max response times (in ms) over time
-   * @param parameters the parameters
+   * @param mergedTaskResults the merged task result
    * @param nodes the list of nodes
    * @param errors the list of errors
    */
-  public MasterBenchSummary(long durationMs, long numSuccess, long endTimeMs,
-      float[] responseTimePercentileMs, float[] responseTime99PercentileMs,
-      float[] maxResponseTimeMs, MasterBenchParameters parameters, List<String> nodes,
-      Map<String, List<String>> errors) {
-    mDurationMs = durationMs;
-    mNumSuccess = numSuccess;
-    mEndTimeMs = endTimeMs;
-    mResponseTimePercentileMs = responseTimePercentileMs;
-    mResponseTime99PercentileMs = responseTime99PercentileMs;
-    mThroughput = ((float) mNumSuccess / mDurationMs) * 1000.0f;
-    mMaxResponseTimeMs = maxResponseTimeMs;
-    mParameters = parameters;
-    mNodes = nodes;
-    mErrors = errors;
-  }
+  public MasterBenchSummary(MasterBenchTaskResult mergedTaskResults, List<String> nodes,
+      Map<String, List<String>> errors) throws DataFormatException {
+    mStatistics = mergedTaskResults.getStatistics().toMasterBenchSummaryStatistics();
 
-  /**
-   * @return the duration (in ms)
-   */
-  public long getDurationMs() {
-    return mDurationMs;
-  }
+    mStatisticsPerMethod = new HashMap<>();
+    for (Map.Entry<String, MasterBenchTaskResultStatistics> entry :
+        mergedTaskResults.getStatisticsPerMethod().entrySet()) {
+      final String key = entry.getKey();
+      final MasterBenchTaskResultStatistics value = entry.getValue();
 
-  /**
-   * @return the number of successes
-   */
-  public long getNumSuccess() {
-    return mNumSuccess;
+      mStatisticsPerMethod.put(key, value.toMasterBenchSummaryStatistics());
+    }
+
+    mDurationMs = mergedTaskResults.getEndMs() - mergedTaskResults.getRecordStartMs();
+    mEndTimeMs = mergedTaskResults.getEndMs();
+    mThroughput = ((float) mStatistics.mNumSuccess / mDurationMs) * 1000.0f;
+    mParameters = mergedTaskResults.getParameters();
+    mNodes = nodes;
+    mErrors = errors;
   }
 
   /**
@@ -105,41 +84,6 @@ public float getThroughput() {
     return mThroughput;
   }
 
-  /**
-   * @return the response times (in ms) for all percentiles
-   */
-  public float[] getResponseTimePercentileMs() {
-    return mResponseTimePercentileMs;
-  }
-
-  /**
-   * @return the response times (in ms) for 99.x%. first entry is 99%, second is 99.9%, etc
-   */
-  public float[] getResponseTime99PercentileMs() {
-    return mResponseTime99PercentileMs;
-  }
-
-  /**
-   * @return the list of max response times throughout the duration of the run
-   */
-  public float[] getMaxResponseTimeMs() {
-    return mMaxResponseTimeMs;
-  }
-
-  /**
-   * @param durationMs the duration (in ms)
-   */
-  public void setDurationMs(long durationMs) {
-    mDurationMs = durationMs;
-  }
-
-  /**
-   * @param numSuccess the number of successes
-   */
-  public void setNumSuccess(long numSuccess) {
-    mNumSuccess = numSuccess;
-  }
-
   /**
    * @param throughput the throughput
    */
@@ -148,24 +92,17 @@ public void setThroughput(float throughput) {
   }
 
   /**
-   * @param responseTimePercentileMs the response times (in ms) for all percentiles
-   */
-  public void setResponseTimePercentileMs(float[] responseTimePercentileMs) {
-    mResponseTimePercentileMs = responseTimePercentileMs;
-  }
-
-  /**
-   * @param responseTime99PercentileMs the response times (in ms) for 99.x%
+   * @return the duration (in ms)
    */
-  public void setResponseTime99PercentileMs(float[] responseTime99PercentileMs) {
-    mResponseTime99PercentileMs = responseTime99PercentileMs;
+  public long getDurationMs() {
+    return mDurationMs;
   }
 
   /**
-   * @param maxResponseTimeMs the list of max response times throughout the duration of the run
+   * @param durationMs the duration (in ms)
    */
-  public void setMaxResponseTimeMs(float[] maxResponseTimeMs) {
-    mMaxResponseTimeMs = maxResponseTimeMs;
+  public void setDurationMs(long durationMs) {
+    mDurationMs = durationMs;
   }
 
   /**
@@ -224,21 +161,37 @@ public void setEndTimeMs(long endTimeMs) {
     mEndTimeMs = endTimeMs;
   }
 
-  private LineGraph.Data getResponseTimeData() {
-    LineGraph.Data data = new LineGraph.Data();
-    data.addData(50, mResponseTimePercentileMs[50]);
-    data.addData(75, mResponseTimePercentileMs[75]);
-    data.addData(90, mResponseTimePercentileMs[90]);
-    data.addData(95, mResponseTimePercentileMs[95]);
-
-    int counter = 0;
-    for (float ms : mResponseTime99PercentileMs) {
-      float percentile = (float) (100.0 - 1.0 / (Math.pow(10.0, counter)));
-      data.addData(percentile, ms);
-      counter++;
-    }
+  /**
+   * @return the statistics
+   */
+  public MasterBenchSummaryStatistics getStatistics() {
+    return mStatistics;
+  }
+
+  /**
+   * @param statistics the statistics
+   */
+  public void setStatistics(MasterBenchSummaryStatistics statistics) {
+    mStatistics = statistics;
+  }
 
-    return data;
+  /**
+   * @return statistics per method map
+   */
+  public Map<String, MasterBenchSummaryStatistics> getStatisticsPerMethod() {
+    return mStatisticsPerMethod;
+  }
+
+  /**
+   * @param statisticsPerMethod the statistics per method map
+   */
+  public void setStatisticsPerMethod(Map<String, MasterBenchSummaryStatistics>
+                                         statisticsPerMethod) {
+    mStatisticsPerMethod = statisticsPerMethod;
+  }
+
+  private LineGraph.Data computeResponseTimeData() {
+    return mStatistics.computeResponseTimeData();
   }
 
   private List<String> collectErrors() {
@@ -292,13 +245,31 @@ public List<Graph> generate(List<? extends Summary> results) {
               new LineGraph(operation + " - Response Time (ms)", subTitle, "Percentile",
                   "Response Time (ms)");
 
+          Map<String, LineGraph> responseTimeGraphPerMethod = new HashMap<>();
+
           for (MasterBenchSummary summary : opSummaries) {
             String series = summary.mParameters.getDescription(fieldNames.getSecond());
-            responseTimeGraph.addDataSeries(series, summary.getResponseTimeData());
+            responseTimeGraph.addDataSeries(series, summary.computeResponseTimeData());
             responseTimeGraph.setErrors(series, summary.collectErrors());
+
+            for (Map.Entry<String, MasterBenchSummaryStatistics> entry :
+                summary.getStatisticsPerMethod().entrySet()) {
+              final String method = entry.getKey();
+              final LineGraph.Data responseTimeData = entry.getValue().computeResponseTimeData();
+
+              if (!responseTimeGraphPerMethod.containsKey(method)) {
+                responseTimeGraphPerMethod.put(method,
+                    new LineGraph(operation + " - Response Time (ms) " + method, subTitle,
+                        "Percentile", "Response Time (ms)"));
+              }
+              responseTimeGraphPerMethod.get(method).addDataSeries(series, responseTimeData);
+            }
           }
 
           graphs.add(responseTimeGraph);
+          for (LineGraph graph : responseTimeGraphPerMethod.values()) {
+            graphs.add(graph);
+          }
         }
       }
 

stress/common/src/main/java/alluxio/stress/master/MasterBenchSummaryStatistics.java

@@ -0,0 +1,79 @@
+/*
+ * The Alluxio Open Foundation licenses this work under the Apache License, version 2.0
+ * (the "License"). You may not use this work except in compliance with the License, which is
+ * available at www.apache.org/licenses/LICENSE-2.0
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied, as more fully set forth in the License.
+ *
+ * See the NOTICE file distributed with this work for information regarding copyright ownership.
+ */
+
+package alluxio.stress.master;
+
+import alluxio.stress.graph.LineGraph;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
+/**
+ * Statistics class for {@link MasterBenchSummary}.
+ */
+public class MasterBenchSummaryStatistics {
+  /** number of successes. */
+  public long mNumSuccess;
+
+  /** response times for all percentiles from 0 -> 100 (101 values). */
+  @SuppressFBWarnings(value = "EI_EXPOSE_REP2")
+  public float[] mResponseTimePercentileMs;
+  /** percentiles of just 99.x%. first entry is 99%, second is 99.9%, etc. */
+  @SuppressFBWarnings(value = "EI_EXPOSE_REP2")
+  public float[] mResponseTime99PercentileMs;
+  /** max response time over time, over the duration of the test. */
+  @SuppressFBWarnings(value = "EI_EXPOSE_REP2")
+  public float[] mMaxResponseTimeMs;
+
+  /**
+   * Creates an instance.
+   */
+  public MasterBenchSummaryStatistics() {
+    // Default constructor required for json deserialization
+  }
+
+  /**
+   * Creates an instance.
+   *
+   * @param numSuccess the number of success
+   * @param responseTimePercentileMs the response times (in ms), for all percentiles
+   * @param responseTime99PercentileMs the response times (in ms), for the 99.x percentiles
+   * @param maxResponseTimeMs the max response times (in ms) over time
+   */
+  public MasterBenchSummaryStatistics(long numSuccess, float[] responseTimePercentileMs,
+                                      float[] responseTime99PercentileMs,
+                                      float[] maxResponseTimeMs) {
+    mNumSuccess = numSuccess;
+    mResponseTimePercentileMs = responseTimePercentileMs;
+    mResponseTime99PercentileMs = responseTime99PercentileMs;
+    mMaxResponseTimeMs = maxResponseTimeMs;
+  }
+
+  /**
+   * @return the response time linegraph data
+   */
+  public LineGraph.Data computeResponseTimeData() {
+    LineGraph.Data data = new LineGraph.Data();
+
+    data.addData(50, mResponseTimePercentileMs[50]);
+    data.addData(75, mResponseTimePercentileMs[75]);
+    data.addData(90, mResponseTimePercentileMs[90]);
+    data.addData(95, mResponseTimePercentileMs[95]);
+
+    int counter = 0;
+    for (float ms : mResponseTime99PercentileMs) {
+      float percentile = (float) (100.0 - 1.0 / (Math.pow(10.0, counter)));
+      data.addData(percentile, ms);
+      counter++;
+    }
+
+    return data;
+  }
+}