data-structure-typed 2.4.1 → 2.4.3

package/build/_deps/benchmark-src/test/perf_counters_gtest.cc

@@ -1,307 +0,0 @@
-#include <random>
-#include <thread>
-
-#include "../src/perf_counters.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-#ifndef GTEST_SKIP
-struct MsgHandler {
-  void operator=(std::ostream&) {}
-};
-#define GTEST_SKIP() return MsgHandler() = std::cout
-#endif
-
-using benchmark::internal::PerfCounters;
-using benchmark::internal::PerfCountersMeasurement;
-using benchmark::internal::PerfCounterValues;
-using ::testing::AllOf;
-using ::testing::Gt;
-using ::testing::Lt;
-
-namespace {
-const char kGenericPerfEvent1[] = "CYCLES";
-const char kGenericPerfEvent2[] = "INSTRUCTIONS";
-
-TEST(PerfCountersTest, Init) {
-  EXPECT_EQ(PerfCounters::Initialize(), PerfCounters::kSupported);
-}
-
-TEST(PerfCountersTest, OneCounter) {
-  if (!PerfCounters::kSupported) {
-    GTEST_SKIP() << "Performance counters not supported.\n";
-  }
-  EXPECT_TRUE(PerfCounters::Initialize());
-  EXPECT_EQ(PerfCounters::Create({kGenericPerfEvent1}).num_counters(), 1);
-}
-
-TEST(PerfCountersTest, NegativeTest) {
-  if (!PerfCounters::kSupported) {
-    EXPECT_FALSE(PerfCounters::Initialize());
-    return;
-  }
-  EXPECT_TRUE(PerfCounters::Initialize());
-  // Sanity checks
-  // Create() will always create a valid object, even if passed no or
-  // wrong arguments as the new behavior is to warn and drop unsupported
-  // counters
-  EXPECT_EQ(PerfCounters::Create({}).num_counters(), 0);
-  EXPECT_EQ(PerfCounters::Create({""}).num_counters(), 0);
-  EXPECT_EQ(PerfCounters::Create({"not a counter name"}).num_counters(), 0);
-  {
-    // Try sneaking in a bad egg to see if it is filtered out. The
-    // number of counters has to be two, not zero
-    auto counter =
-        PerfCounters::Create({kGenericPerfEvent2, "", kGenericPerfEvent1});
-    EXPECT_EQ(counter.num_counters(), 2);
-    EXPECT_EQ(counter.names(), std::vector<std::string>(
-                                   {kGenericPerfEvent2, kGenericPerfEvent1}));
-  }
-  {
-    // Try sneaking in an outrageous counter, like a fat finger mistake
-    auto counter = PerfCounters::Create(
-        {kGenericPerfEvent2, "not a counter name", kGenericPerfEvent1});
-    EXPECT_EQ(counter.num_counters(), 2);
-    EXPECT_EQ(counter.names(), std::vector<std::string>(
-                                   {kGenericPerfEvent2, kGenericPerfEvent1}));
-  }
-  {
-    // Finally try a golden input - it should like both of them
-    EXPECT_EQ(PerfCounters::Create({kGenericPerfEvent1, kGenericPerfEvent2})
-                  .num_counters(),
-              2);
-  }
-  {
-    // Add a bad apple in the end of the chain to check the edges
-    auto counter = PerfCounters::Create(
-        {kGenericPerfEvent1, kGenericPerfEvent2, "bad event name"});
-    EXPECT_EQ(counter.num_counters(), 2);
-    EXPECT_EQ(counter.names(), std::vector<std::string>(
-                                   {kGenericPerfEvent1, kGenericPerfEvent2}));
-  }
-}
-
-TEST(PerfCountersTest, Read1Counter) {
-  if (!PerfCounters::kSupported) {
-    GTEST_SKIP() << "Test skipped because libpfm is not supported.\n";
-  }
-  EXPECT_TRUE(PerfCounters::Initialize());
-  auto counters = PerfCounters::Create({kGenericPerfEvent1});
-  EXPECT_EQ(counters.num_counters(), 1);
-  PerfCounterValues values1(1);
-  EXPECT_TRUE(counters.Snapshot(&values1));
-  EXPECT_GT(values1[0], 0);
-  PerfCounterValues values2(1);
-  EXPECT_TRUE(counters.Snapshot(&values2));
-  EXPECT_GT(values2[0], 0);
-  EXPECT_GT(values2[0], values1[0]);
-}
-
-TEST(PerfCountersTest, Read2Counters) {
-  if (!PerfCounters::kSupported) {
-    GTEST_SKIP() << "Test skipped because libpfm is not supported.\n";
-  }
-  EXPECT_TRUE(PerfCounters::Initialize());
-  auto counters =
-      PerfCounters::Create({kGenericPerfEvent1, kGenericPerfEvent2});
-  EXPECT_EQ(counters.num_counters(), 2);
-  PerfCounterValues values1(2);
-  EXPECT_TRUE(counters.Snapshot(&values1));
-  EXPECT_GT(values1[0], 0);
-  EXPECT_GT(values1[1], 0);
-  PerfCounterValues values2(2);
-  EXPECT_TRUE(counters.Snapshot(&values2));
-  EXPECT_GT(values2[0], 0);
-  EXPECT_GT(values2[1], 0);
-}
-
-TEST(PerfCountersTest, ReopenExistingCounters) {
-  // This test works in recent and old Intel hardware, Pixel 3, and Pixel 6.
-  // However we cannot make assumptions beyond 2 HW counters due to Pixel 6.
-  if (!PerfCounters::kSupported) {
-    GTEST_SKIP() << "Test skipped because libpfm is not supported.\n";
-  }
-  EXPECT_TRUE(PerfCounters::Initialize());
-  std::vector<std::string> kMetrics({kGenericPerfEvent1});
-  std::vector<PerfCounters> counters(2);
-  for (auto& counter : counters) {
-    counter = PerfCounters::Create(kMetrics);
-  }
-  PerfCounterValues values(1);
-  EXPECT_TRUE(counters[0].Snapshot(&values));
-  EXPECT_TRUE(counters[1].Snapshot(&values));
-}
-
-TEST(PerfCountersTest, CreateExistingMeasurements) {
-  // The test works (i.e. causes read to fail) for the assumptions
-  // about hardware capabilities (i.e. small number (2) hardware
-  // counters) at this date,
-  // the same as previous test ReopenExistingCounters.
-  if (!PerfCounters::kSupported) {
-    GTEST_SKIP() << "Test skipped because libpfm is not supported.\n";
-  }
-  EXPECT_TRUE(PerfCounters::Initialize());
-
-  // This means we will try 10 counters but we can only guarantee
-  // for sure at this time that only 3 will work. Perhaps in the future
-  // we could use libpfm to query for the hardware limits on this
-  // particular platform.
-  const int kMaxCounters = 10;
-  const int kMinValidCounters = 2;
-
-  // Let's use a ubiquitous counter that is guaranteed to work
-  // on all platforms
-  const std::vector<std::string> kMetrics{"cycles"};
-
-  // Cannot create a vector of actual objects because the
-  // copy constructor of PerfCounters is deleted - and so is
-  // implicitly deleted on PerfCountersMeasurement too
-  std::vector<std::unique_ptr<PerfCountersMeasurement>>
-      perf_counter_measurements;
-
-  perf_counter_measurements.reserve(kMaxCounters);
-  for (int j = 0; j < kMaxCounters; ++j) {
-    perf_counter_measurements.emplace_back(
-        new PerfCountersMeasurement(kMetrics));
-  }
-
-  std::vector<std::pair<std::string, double>> measurements;
-
-  // Start all counters together to see if they hold
-  size_t max_counters = kMaxCounters;
-  for (size_t i = 0; i < kMaxCounters; ++i) {
-    auto& counter(*perf_counter_measurements[i]);
-    EXPECT_EQ(counter.num_counters(), 1);
-    if (!counter.Start()) {
-      max_counters = i;
-      break;
-    };
-  }
-
-  ASSERT_GE(max_counters, kMinValidCounters);
-
-  // Start all together
-  for (size_t i = 0; i < max_counters; ++i) {
-    auto& counter(*perf_counter_measurements[i]);
-    EXPECT_TRUE(counter.Stop(measurements) || (i >= kMinValidCounters));
-  }
-
-  // Start/stop individually
-  for (size_t i = 0; i < max_counters; ++i) {
-    auto& counter(*perf_counter_measurements[i]);
-    measurements.clear();
-    counter.Start();
-    EXPECT_TRUE(counter.Stop(measurements) || (i >= kMinValidCounters));
-  }
-}
-
-// We try to do some meaningful work here but the compiler
-// insists in optimizing away our loop so we had to add a
-// no-optimize macro. In case it fails, we added some entropy
-// to this pool as well.
-
-BENCHMARK_DONT_OPTIMIZE size_t do_work() {
-  static std::mt19937 rd{std::random_device{}()};
-  static std::uniform_int_distribution<size_t> mrand(0, 10);
-  const size_t kNumLoops = 1000000;
-  size_t sum = 0;
-  for (size_t j = 0; j < kNumLoops; ++j) {
-    sum += mrand(rd);
-  }
-  benchmark::DoNotOptimize(sum);
-  return sum;
-}
-
-void measure(size_t threadcount, PerfCounterValues* before,
-             PerfCounterValues* after) {
-  BM_CHECK_NE(before, nullptr);
-  BM_CHECK_NE(after, nullptr);
-  std::vector<std::thread> threads(threadcount);
-  auto work = [&]() { BM_CHECK(do_work() > 1000); };
-
-  // We need to first set up the counters, then start the threads, so the
-  // threads would inherit the counters. But later, we need to first destroy
-  // the thread pool (so all the work finishes), then measure the counters. So
-  // the scopes overlap, and we need to explicitly control the scope of the
-  // threadpool.
-  auto counters =
-      PerfCounters::Create({kGenericPerfEvent1, kGenericPerfEvent2});
-  for (auto& t : threads) t = std::thread(work);
-  counters.Snapshot(before);
-  for (auto& t : threads) t.join();
-  counters.Snapshot(after);
-}
-
-TEST(PerfCountersTest, MultiThreaded) {
-  if (!PerfCounters::kSupported) {
-    GTEST_SKIP() << "Test skipped because libpfm is not supported.";
-  }
-  EXPECT_TRUE(PerfCounters::Initialize());
-  PerfCounterValues before(2);
-  PerfCounterValues after(2);
-
-  // Notice that this test will work even if we taskset it to a single CPU
-  // In this case the threads will run sequentially
-  // Start two threads and measure the number of combined cycles and
-  // instructions
-  measure(2, &before, &after);
-  std::vector<double> Elapsed2Threads{
-      static_cast<double>(after[0] - before[0]),
-      static_cast<double>(after[1] - before[1])};
-
-  // Start four threads and measure the number of combined cycles and
-  // instructions
-  measure(4, &before, &after);
-  std::vector<double> Elapsed4Threads{
-      static_cast<double>(after[0] - before[0]),
-      static_cast<double>(after[1] - before[1])};
-
-  // The following expectations fail (at least on a beefy workstation with lots
-  // of cpus) - it seems that in some circumstances the runtime of 4 threads
-  // can even be better than with 2.
-  // So instead of expecting 4 threads to be slower, let's just make sure they
-  // do not differ too much in general (one is not more than 10x than the
-  // other).
-  EXPECT_THAT(Elapsed4Threads[0] / Elapsed2Threads[0], AllOf(Gt(0.1), Lt(10)));
-  EXPECT_THAT(Elapsed4Threads[1] / Elapsed2Threads[1], AllOf(Gt(0.1), Lt(10)));
-}
-
-TEST(PerfCountersTest, HardwareLimits) {
-  // The test works (i.e. causes read to fail) for the assumptions
-  // about hardware capabilities (i.e. small number (3-4) hardware
-  // counters) at this date,
-  // the same as previous test ReopenExistingCounters.
-  if (!PerfCounters::kSupported) {
-    GTEST_SKIP() << "Test skipped because libpfm is not supported.\n";
-  }
-  EXPECT_TRUE(PerfCounters::Initialize());
-
-  // Taken from `perf list`, but focusses only on those HW events that actually
-  // were reported when running `sudo perf stat -a sleep 10`, intersected over
-  // several platforms. All HW events listed in the first command not reported
-  // in the second seem to not work. This is sad as we don't really get to test
-  // the grouping here (groups can contain up to 6 members)...
-  std::vector<std::string> counter_names{
-      "cycles",         // leader
-      "instructions",   //
-      "branch-misses",  //
-  };
-
-  // In the off-chance that some of these values are not supported,
-  // we filter them out so the test will complete without failure
-  // albeit it might not actually test the grouping on that platform
-  std::vector<std::string> valid_names;
-  for (const std::string& name : counter_names) {
-    if (PerfCounters::IsCounterSupported(name)) {
-      valid_names.push_back(name);
-    }
-  }
-  PerfCountersMeasurement counter(valid_names);
-
-  std::vector<std::pair<std::string, double>> measurements;
-
-  counter.Start();
-  EXPECT_TRUE(counter.Stop(measurements));
-}
-
-}  // namespace

package/build/_deps/benchmark-src/test/perf_counters_test.cc

@@ -1,92 +0,0 @@
-#include <cstdarg>
-#undef NDEBUG
-
-#include "../src/commandlineflags.h"
-#include "../src/perf_counters.h"
-#include "benchmark/benchmark.h"
-#include "output_test.h"
-
-namespace benchmark {
-
-BM_DECLARE_string(benchmark_perf_counters);
-
-}  // namespace benchmark
-
-static void BM_Simple(benchmark::State& state) {
-  for (auto _ : state) {
-    auto iterations = state.iterations();
-    benchmark::DoNotOptimize(iterations);
-  }
-}
-BENCHMARK(BM_Simple);
-ADD_CASES(TC_JSONOut, {{"\"name\": \"BM_Simple\",$"}});
-
-const int kIters = 1000000;
-
-void BM_WithoutPauseResume(benchmark::State& state) {
-  int n = 0;
-
-  for (auto _ : state) {
-    for (auto i = 0; i < kIters; ++i) {
-      n = 1 - n;
-      benchmark::DoNotOptimize(n);
-    }
-  }
-}
-
-BENCHMARK(BM_WithoutPauseResume);
-ADD_CASES(TC_JSONOut, {{"\"name\": \"BM_WithoutPauseResume\",$"}});
-
-void BM_WithPauseResume(benchmark::State& state) {
-  int m = 0, n = 0;
-
-  for (auto _ : state) {
-    for (auto i = 0; i < kIters; ++i) {
-      n = 1 - n;
-      benchmark::DoNotOptimize(n);
-    }
-
-    state.PauseTiming();
-    for (auto j = 0; j < kIters; ++j) {
-      m = 1 - m;
-      benchmark::DoNotOptimize(m);
-    }
-    state.ResumeTiming();
-  }
-}
-
-BENCHMARK(BM_WithPauseResume);
-
-ADD_CASES(TC_JSONOut, {{"\"name\": \"BM_WithPauseResume\",$"}});
-
-static void CheckSimple(Results const& e) {
-  CHECK_COUNTER_VALUE(e, double, "CYCLES", GT, 0);
-}
-
-double withoutPauseResumeInstrCount = 0.0;
-double withPauseResumeInstrCount = 0.0;
-
-static void SaveInstrCountWithoutResume(Results const& e) {
-  withoutPauseResumeInstrCount = e.GetAs<double>("INSTRUCTIONS");
-}
-
-static void SaveInstrCountWithResume(Results const& e) {
-  withPauseResumeInstrCount = e.GetAs<double>("INSTRUCTIONS");
-}
-
-CHECK_BENCHMARK_RESULTS("BM_Simple", &CheckSimple);
-CHECK_BENCHMARK_RESULTS("BM_WithoutPauseResume", &SaveInstrCountWithoutResume);
-CHECK_BENCHMARK_RESULTS("BM_WithPauseResume", &SaveInstrCountWithResume);
-
-int main(int argc, char* argv[]) {
-  if (!benchmark::internal::PerfCounters::kSupported) {
-    return 0;
-  }
-  benchmark::FLAGS_benchmark_perf_counters = "CYCLES,INSTRUCTIONS";
-  benchmark::internal::PerfCounters::Initialize();
-  RunOutputTests(argc, argv);
-
-  BM_CHECK_GT(withPauseResumeInstrCount, kIters);
-  BM_CHECK_GT(withoutPauseResumeInstrCount, kIters);
-  BM_CHECK_LT(withPauseResumeInstrCount, 1.5 * withoutPauseResumeInstrCount);
-}

package/build/_deps/benchmark-src/test/register_benchmark_test.cc

@@ -1,196 +0,0 @@
-
-#undef NDEBUG
-#include <cassert>
-#include <vector>
-
-#include "../src/check.h"  // NOTE: check.h is for internal use only!
-#include "benchmark/benchmark.h"
-
-namespace {
-
-class TestReporter : public benchmark::ConsoleReporter {
- public:
-  void ReportRuns(const std::vector<Run>& report) override {
-    all_runs_.insert(all_runs_.end(), begin(report), end(report));
-    ConsoleReporter::ReportRuns(report);
-  }
-
-  std::vector<Run> all_runs_;
-};
-
-struct TestCase {
-  const std::string name;
-  const std::string label;
-  // Note: not explicit as we rely on it being converted through ADD_CASES.
-  TestCase(const std::string& xname) : TestCase(xname, "") {}
-  TestCase(const std::string& xname, const std::string& xlabel)
-      : name(xname), label(xlabel) {}
-
-  typedef benchmark::BenchmarkReporter::Run Run;
-
-  void CheckRun(Run const& run) const {
-    // clang-format off
-    BM_CHECK(name == run.benchmark_name()) << "expected " << name << " got "
-                                      << run.benchmark_name();
-    if (!label.empty()) {
-      BM_CHECK(run.report_label == label) << "expected " << label << " got "
-                                       << run.report_label;
-    } else {
-      BM_CHECK(run.report_label.empty());
-    }
-    // clang-format on
-  }
-};
-
-std::vector<TestCase> ExpectedResults;
-
-int AddCases(std::initializer_list<TestCase> const& v) {
-  for (const auto& N : v) {
-    ExpectedResults.push_back(N);
-  }
-  return 0;
-}
-
-#define CONCAT(x, y) CONCAT2(x, y)
-#define CONCAT2(x, y) x##y
-#define ADD_CASES(...) int CONCAT(dummy, __LINE__) = AddCases({__VA_ARGS__})
-
-}  // end namespace
-
-typedef benchmark::internal::Benchmark* ReturnVal;
-
-//----------------------------------------------------------------------------//
-// Test RegisterBenchmark with no additional arguments
-//----------------------------------------------------------------------------//
-void BM_function(benchmark::State& state) {
-  for (auto _ : state) {
-  }
-}
-BENCHMARK(BM_function);
-ReturnVal dummy = benchmark::RegisterBenchmark(
-    "BM_function_manual_registration", BM_function);
-ADD_CASES({"BM_function"}, {"BM_function_manual_registration"});
-
-//----------------------------------------------------------------------------//
-// Test RegisterBenchmark with additional arguments
-// Note: GCC <= 4.8 do not support this form of RegisterBenchmark because they
-//       reject the variadic pack expansion of lambda captures.
-//----------------------------------------------------------------------------//
-#ifndef BENCHMARK_HAS_NO_VARIADIC_REGISTER_BENCHMARK
-
-void BM_extra_args(benchmark::State& st, const char* label) {
-  for (auto _ : st) {
-  }
-  st.SetLabel(label);
-}
-int RegisterFromFunction() {
-  std::pair<const char*, const char*> cases[] = {
-      {"test1", "One"}, {"test2", "Two"}, {"test3", "Three"}};
-  for (auto const& c : cases)
-    benchmark::RegisterBenchmark(c.first, &BM_extra_args, c.second);
-  return 0;
-}
-int dummy2 = RegisterFromFunction();
-ADD_CASES({"test1", "One"}, {"test2", "Two"}, {"test3", "Three"});
-
-#endif  // BENCHMARK_HAS_NO_VARIADIC_REGISTER_BENCHMARK
-
-//----------------------------------------------------------------------------//
-// Test RegisterBenchmark with DISABLED_ benchmark
-//----------------------------------------------------------------------------//
-void DISABLED_BM_function(benchmark::State& state) {
-  for (auto _ : state) {
-  }
-}
-BENCHMARK(DISABLED_BM_function);
-ReturnVal dummy3 = benchmark::RegisterBenchmark("DISABLED_BM_function_manual",
-                                                DISABLED_BM_function);
-// No need to add cases because we don't expect them to run.
-
-//----------------------------------------------------------------------------//
-// Test RegisterBenchmark with different callable types
-//----------------------------------------------------------------------------//
-
-struct CustomFixture {
-  void operator()(benchmark::State& st) {
-    for (auto _ : st) {
-    }
-  }
-};
-
-void TestRegistrationAtRuntime() {
-#ifdef BENCHMARK_HAS_CXX11
-  {
-    CustomFixture fx;
-    benchmark::RegisterBenchmark("custom_fixture", fx);
-    AddCases({std::string("custom_fixture")});
-  }
-#endif
-#ifndef BENCHMARK_HAS_NO_VARIADIC_REGISTER_BENCHMARK
-  {
-    const char* x = "42";
-    auto capturing_lam = [=](benchmark::State& st) {
-      for (auto _ : st) {
-      }
-      st.SetLabel(x);
-    };
-    benchmark::RegisterBenchmark("lambda_benchmark", capturing_lam);
-    AddCases({{"lambda_benchmark", x}});
-  }
-#endif
-}
-
-// Test that all benchmarks, registered at either during static init or runtime,
-// are run and the results are passed to the reported.
-void RunTestOne() {
-  TestRegistrationAtRuntime();
-
-  TestReporter test_reporter;
-  benchmark::RunSpecifiedBenchmarks(&test_reporter);
-
-  typedef benchmark::BenchmarkReporter::Run Run;
-  auto EB = ExpectedResults.begin();
-
-  for (Run const& run : test_reporter.all_runs_) {
-    assert(EB != ExpectedResults.end());
-    EB->CheckRun(run);
-    ++EB;
-  }
-  assert(EB == ExpectedResults.end());
-}
-
-// Test that ClearRegisteredBenchmarks() clears all previously registered
-// benchmarks.
-// Also test that new benchmarks can be registered and ran afterwards.
-void RunTestTwo() {
-  assert(ExpectedResults.size() != 0 &&
-         "must have at least one registered benchmark");
-  ExpectedResults.clear();
-  benchmark::ClearRegisteredBenchmarks();
-
-  TestReporter test_reporter;
-  size_t num_ran = benchmark::RunSpecifiedBenchmarks(&test_reporter);
-  assert(num_ran == 0);
-  assert(test_reporter.all_runs_.begin() == test_reporter.all_runs_.end());
-
-  TestRegistrationAtRuntime();
-  num_ran = benchmark::RunSpecifiedBenchmarks(&test_reporter);
-  assert(num_ran == ExpectedResults.size());
-
-  typedef benchmark::BenchmarkReporter::Run Run;
-  auto EB = ExpectedResults.begin();
-
-  for (Run const& run : test_reporter.all_runs_) {
-    assert(EB != ExpectedResults.end());
-    EB->CheckRun(run);
-    ++EB;
-  }
-  assert(EB == ExpectedResults.end());
-}
-
-int main(int argc, char* argv[]) {
-  benchmark::Initialize(&argc, argv);
-
-  RunTestOne();
-  RunTestTwo();
-}