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

• Show log

  Commit

• Hash : 42c453fe
  Author :
  Date : 2020-03-15T18:23:15
  

  Move perf test common files to a source set.
  
  Similarly to a prior patch this organizes the common perf test sources
  into a single target. This will allow us to more easily support setting
  compiler flags on particular perf test sources.
  
  This also fixes some build errors that popped up when new warnings were
  enabled.
  
  Bug: angleproject:3630
  Change-Id: I866885199f93a5055e8d160e39f72d1f8209bc75
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2103086
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
  

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 "common/third_party/base/anglebase/no_destructor.h"
  
  #include <stdarg.h>
  #include <stdio.h>
  #include <vector>
  
  namespace
  {
  
  std::string FormatString(const char *fmt, va_list vararg)
  {
      static angle::base::NoDestructor<std::vector<char>> buffer(512);
  
      // Attempt to just print to the current buffer
      int len = vsnprintf(buffer->data(), 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->data(), 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