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

• Show log

  Commit

• Hash : c991eb22
  Author :
  Date : 2022-12-01T14:05:07
  

  Move the anglebase folder up a level
  
  This code originates from Chromium's base/ directory so it doesn't have
  to be under a third-party folder.
  
  Bug: b/260093525
  Change-Id: I0bf6950095c685f36c5c237093980a64cf6e74f0
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4068339
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Nicolas Capens <nicolascapens@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 "common/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