kc3-lang/angle/src/tests/perf_tests/third_party/perf/perf_test.cc

• Show log

  Commit

• Hash : 2f4a7518
  Author :
  Date : 2019-08-16T14:09:13
  

  Refactor perf tests to fix metric/story swapping
  
  Refactors the perf tests to fix the issue of metric and story being
  swapped, which causes issues when trying to convert to histograms.
  
  Specifically, does the following:
  1. Rolls the version of src/tests/perf_tests/third_party/perf/ to
     Chromium 476dae823269c8d05b544271af97ad1adb0db8ee
  2. Switch to using PerfResultReporter instead of PrintResult directly.
  3. Split RenderTestParams::suffix into backend and story; backend is
     used as part of the metric, while story is used as the story.
  4. Remove the "average" metric that was being automatically reported
     by ANGLEPerfTest, as reported results are automatically averaged.
  5. Update the reported metric to more clearly distinguish between
     test, backend, and metric. It is now name_backend.metric. e.g.
     DrawCallPerf_vulkan.wall_time.
  
  Bug: chromium:923564,chromium:924618
  Change-Id: I00cc191407052f23df57dbfa53b6fb088fc26960
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1762360
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Jonah Ryan-Davis <jonahr@google.com>
  

Download

• src/tests/perf_tests/third_party/perf/perf_test.cc

• // Copyright 2013 The Chromium Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  
  #include "perf_test.h"
  
  #include <stdarg.h>
  #include <stdio.h>
  #include <vector>
  
  namespace {
  
  std::string FormatString(const char *fmt, va_list vararg) {
    static std::vector<char> buffer(512);
  
    // Attempt to just print to the current buffer
    int len = vsnprintf(&buffer[0], buffer.size(), fmt, vararg);
    if (len < 0 || static_cast<size_t>(len) >= buffer.size()) {
      // Buffer was not large enough, calculate the required size and resize the buffer
      len = vsnprintf(NULL, 0, fmt, vararg);
      buffer.resize(len + 1);
  
      // Print again
      vsnprintf(&buffer[0], buffer.size(), fmt, vararg);
    }
  
    return std::string(buffer.data(), len);
  }
  
  std::string StringPrintf(const char *fmt, ...) {
    va_list vararg;
    va_start(vararg, fmt);
    std::string result = FormatString(fmt, vararg);
    va_end(vararg);
    return result;
  }
  
  std::string NumberToString(size_t value)
  {
      return StringPrintf("%u", value);
  }
  
  std::string NumberToString(double value)
  {
      return StringPrintf("%.10lf", value);
  }
  
  std::string ResultsToString(const std::string& measurement,
                              const std::string& modifier,
                              const std::string& trace,
                              const std::string& values,
                              const std::string& prefix,
                              const std::string& suffix,
                              const std::string& units,
                              bool important) {
    // <*>RESULT <graph_name>: <trace_name>= <value> <units>
    // <*>RESULT <graph_name>: <trace_name>= {<mean>, <std deviation>} <units>
    // <*>RESULT <graph_name>: <trace_name>= [<value>,value,value,...,] <units>
    return StringPrintf("%sRESULT %s%s: %s= %s%s%s %s\n", important ? "*" : "", measurement.c_str(),
                        modifier.c_str(), trace.c_str(), prefix.c_str(), values.c_str(),
                        suffix.c_str(), units.c_str());
  }
  
  void PrintResultsImpl(const std::string& measurement,
                        const std::string& modifier,
                        const std::string& trace,
                        const std::string& values,
                        const std::string& prefix,
                        const std::string& suffix,
                        const std::string& units,
                        bool important) {
    fflush(stdout);
    printf("%s", ResultsToString(measurement, modifier, trace, values,
                                 prefix, suffix, units, important).c_str());
    fflush(stdout);
  }
  
  }  // namespace
  
  namespace perf_test {
  
  void PrintResult(const std::string& measurement,
                   const std::string& modifier,
                   const std::string& trace,
                   size_t value,
                   const std::string& units,
                   bool important) {
      PrintResultsImpl(measurement, modifier, trace, NumberToString(value), std::string(),
                       std::string(), units, important);
  }
  
  void PrintResult(const std::string& measurement,
                   const std::string& modifier,
                   const std::string& trace,
                   double value,
                   const std::string& units,
                   bool important) {
      PrintResultsImpl(measurement, modifier, trace, NumberToString(value), std::string(),
                       std::string(), units, important);
  }
  
  void AppendResult(std::string& output,
                    const std::string& measurement,
                    const std::string& modifier,
                    const std::string& trace,
                    size_t value,
                    const std::string& units,
                    bool important) {
      output += ResultsToString(measurement, modifier, trace, NumberToString(value), std::string(),
                                std::string(), units, important);
  }
  
  void PrintResult(const std::string& measurement,
                   const std::string& modifier,
                   const std::string& trace,
                   const std::string& value,
                   const std::string& units,
                   bool important) {
    PrintResultsImpl(measurement,
                     modifier,
                     trace,
                     value,
                     std::string(),
                     std::string(),
                     units,
                     important);
  }
  
  void AppendResult(std::string& output,
                    const std::string& measurement,
                    const std::string& modifier,
                    const std::string& trace,
                    const std::string& value,
                    const std::string& units,
                    bool important) {
    output += ResultsToString(measurement,
                              modifier,
                              trace,
                              value,
                              std::string(),
                              std::string(),
                              units,
                              important);
  }
  
  void PrintResultMeanAndError(const std::string& measurement,
                               const std::string& modifier,
                               const std::string& trace,
                               const std::string& mean_and_error,
                               const std::string& units,
                               bool important) {
    PrintResultsImpl(measurement, modifier, trace, mean_and_error,
                     "{", "}", units, important);
  }
  
  void AppendResultMeanAndError(std::string& output,
                                const std::string& measurement,
                                const std::string& modifier,
                                const std::string& trace,
                                const std::string& mean_and_error,
                                const std::string& units,
                                bool important) {
    output += ResultsToString(measurement, modifier, trace, mean_and_error,
                              "{", "}", units, important);
  }
  
  void PrintResultList(const std::string& measurement,
                       const std::string& modifier,
                       const std::string& trace,
                       const std::string& values,
                       const std::string& units,
                       bool important) {
    PrintResultsImpl(measurement, modifier, trace, values,
                     "[", "]", units, important);
  }
  
  void AppendResultList(std::string& output,
                        const std::string& measurement,
                        const std::string& modifier,
                        const std::string& trace,
                        const std::string& values,
                        const std::string& units,
                        bool important) {
    output += ResultsToString(measurement, modifier, trace, values,
                              "[", "]", units, important);
  }
  
  void PrintSystemCommitCharge(const std::string& test_name,
                               size_t charge,
                               bool important) {
    PrintSystemCommitCharge(stdout, test_name, charge, important);
  }
  
  void PrintSystemCommitCharge(FILE* target,
                               const std::string& test_name,
                               size_t charge,
                               bool important) {
    fprintf(target, "%s", SystemCommitChargeToString(test_name, charge,
                                                     important).c_str());
  }
  
  std::string SystemCommitChargeToString(const std::string& test_name,
                                         size_t charge,
                                         bool important) {
    std::string trace_name(test_name);
    std::string output;
    AppendResult(output,
                 "commit_charge",
                 std::string(),
                 "cc" + trace_name,
                 charge,
                 "kb",
                 important);
    return output;
  }
  
  }  // namespace perf_test
  

Download