data-structure-typed 2.4.0 → 2.4.2

package/build/_deps/benchmark-src/src/benchmark_api_internal.cc

@@ -1,118 +0,0 @@
-#include "benchmark_api_internal.h"
-
-#include <cinttypes>
-
-#include "string_util.h"
-
-namespace benchmark {
-namespace internal {
-
-BenchmarkInstance::BenchmarkInstance(Benchmark* benchmark, int family_idx,
-                                     int per_family_instance_idx,
-                                     const std::vector<int64_t>& args,
-                                     int thread_count)
-    : benchmark_(*benchmark),
-      family_index_(family_idx),
-      per_family_instance_index_(per_family_instance_idx),
-      aggregation_report_mode_(benchmark_.aggregation_report_mode_),
-      args_(args),
-      time_unit_(benchmark_.GetTimeUnit()),
-      measure_process_cpu_time_(benchmark_.measure_process_cpu_time_),
-      use_real_time_(benchmark_.use_real_time_),
-      use_manual_time_(benchmark_.use_manual_time_),
-      complexity_(benchmark_.complexity_),
-      complexity_lambda_(benchmark_.complexity_lambda_),
-      statistics_(benchmark_.statistics_),
-      repetitions_(benchmark_.repetitions_),
-      min_time_(benchmark_.min_time_),
-      min_warmup_time_(benchmark_.min_warmup_time_),
-      iterations_(benchmark_.iterations_),
-      threads_(thread_count) {
-  name_.function_name = benchmark_.name_;
-
-  size_t arg_i = 0;
-  for (const auto& arg : args) {
-    if (!name_.args.empty()) {
-      name_.args += '/';
-    }
-
-    if (arg_i < benchmark->arg_names_.size()) {
-      const auto& arg_name = benchmark_.arg_names_[arg_i];
-      if (!arg_name.empty()) {
-        name_.args += StrFormat("%s:", arg_name.c_str());
-      }
-    }
-
-    name_.args += StrFormat("%" PRId64, arg);
-    ++arg_i;
-  }
-
-  if (!IsZero(benchmark->min_time_)) {
-    name_.min_time = StrFormat("min_time:%0.3f", benchmark_.min_time_);
-  }
-
-  if (!IsZero(benchmark->min_warmup_time_)) {
-    name_.min_warmup_time =
-        StrFormat("min_warmup_time:%0.3f", benchmark_.min_warmup_time_);
-  }
-
-  if (benchmark_.iterations_ != 0) {
-    name_.iterations = StrFormat(
-        "iterations:%lu", static_cast<unsigned long>(benchmark_.iterations_));
-  }
-
-  if (benchmark_.repetitions_ != 0) {
-    name_.repetitions = StrFormat("repeats:%d", benchmark_.repetitions_);
-  }
-
-  if (benchmark_.measure_process_cpu_time_) {
-    name_.time_type = "process_time";
-  }
-
-  if (benchmark_.use_manual_time_) {
-    if (!name_.time_type.empty()) {
-      name_.time_type += '/';
-    }
-    name_.time_type += "manual_time";
-  } else if (benchmark_.use_real_time_) {
-    if (!name_.time_type.empty()) {
-      name_.time_type += '/';
-    }
-    name_.time_type += "real_time";
-  }
-
-  if (!benchmark_.thread_counts_.empty()) {
-    name_.threads = StrFormat("threads:%d", threads_);
-  }
-
-  setup_ = benchmark_.setup_;
-  teardown_ = benchmark_.teardown_;
-}
-
-State BenchmarkInstance::Run(
-    IterationCount iters, int thread_id, internal::ThreadTimer* timer,
-    internal::ThreadManager* manager,
-    internal::PerfCountersMeasurement* perf_counters_measurement) const {
-  State st(name_.function_name, iters, args_, thread_id, threads_, timer,
-           manager, perf_counters_measurement);
-  benchmark_.Run(st);
-  return st;
-}
-
-void BenchmarkInstance::Setup() const {
-  if (setup_) {
-    State st(name_.function_name, /*iters*/ 1, args_, /*thread_id*/ 0, threads_,
-             nullptr, nullptr, nullptr);
-    setup_(st);
-  }
-}
-
-void BenchmarkInstance::Teardown() const {
-  if (teardown_) {
-    State st(name_.function_name, /*iters*/ 1, args_, /*thread_id*/ 0, threads_,
-             nullptr, nullptr, nullptr);
-    teardown_(st);
-  }
-}
-}  // namespace internal
-}  // namespace benchmark

package/build/_deps/benchmark-src/src/benchmark_api_internal.h

@@ -1,87 +0,0 @@
-#ifndef BENCHMARK_API_INTERNAL_H
-#define BENCHMARK_API_INTERNAL_H
-
-#include <cmath>
-#include <iosfwd>
-#include <limits>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "benchmark/benchmark.h"
-#include "commandlineflags.h"
-
-namespace benchmark {
-namespace internal {
-
-// Information kept per benchmark we may want to run
-class BenchmarkInstance {
- public:
-  BenchmarkInstance(Benchmark* benchmark, int family_index,
-                    int per_family_instance_index,
-                    const std::vector<int64_t>& args, int threads);
-
-  const BenchmarkName& name() const { return name_; }
-  int family_index() const { return family_index_; }
-  int per_family_instance_index() const { return per_family_instance_index_; }
-  AggregationReportMode aggregation_report_mode() const {
-    return aggregation_report_mode_;
-  }
-  TimeUnit time_unit() const { return time_unit_; }
-  bool measure_process_cpu_time() const { return measure_process_cpu_time_; }
-  bool use_real_time() const { return use_real_time_; }
-  bool use_manual_time() const { return use_manual_time_; }
-  BigO complexity() const { return complexity_; }
-  BigOFunc* complexity_lambda() const { return complexity_lambda_; }
-  const std::vector<Statistics>& statistics() const { return statistics_; }
-  int repetitions() const { return repetitions_; }
-  double min_time() const { return min_time_; }
-  double min_warmup_time() const { return min_warmup_time_; }
-  IterationCount iterations() const { return iterations_; }
-  int threads() const { return threads_; }
-  void Setup() const;
-  void Teardown() const;
-
-  State Run(IterationCount iters, int thread_id, internal::ThreadTimer* timer,
-            internal::ThreadManager* manager,
-            internal::PerfCountersMeasurement* perf_counters_measurement) const;
-
- private:
-  BenchmarkName name_;
-  Benchmark& benchmark_;
-  const int family_index_;
-  const int per_family_instance_index_;
-  AggregationReportMode aggregation_report_mode_;
-  const std::vector<int64_t>& args_;
-  TimeUnit time_unit_;
-  bool measure_process_cpu_time_;
-  bool use_real_time_;
-  bool use_manual_time_;
-  BigO complexity_;
-  BigOFunc* complexity_lambda_;
-  UserCounters counters_;
-  const std::vector<Statistics>& statistics_;
-  int repetitions_;
-  double min_time_;
-  double min_warmup_time_;
-  IterationCount iterations_;
-  int threads_;  // Number of concurrent threads to us
-
-  typedef void (*callback_function)(const benchmark::State&);
-  callback_function setup_ = nullptr;
-  callback_function teardown_ = nullptr;
-};
-
-bool FindBenchmarksInternal(const std::string& re,
-                            std::vector<BenchmarkInstance>* benchmarks,
-                            std::ostream* Err);
-
-bool IsZero(double n);
-
-BENCHMARK_EXPORT
-ConsoleReporter::OutputOptions GetOutputOptions(bool force_no_color = false);
-
-}  // end namespace internal
-}  // end namespace benchmark
-
-#endif  // BENCHMARK_API_INTERNAL_H

package/build/_deps/benchmark-src/src/benchmark_main.cc

@@ -1,18 +0,0 @@
-// Copyright 2018 Google Inc. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "benchmark/benchmark.h"
-
-BENCHMARK_EXPORT int main(int, char**);
-BENCHMARK_MAIN();

package/build/_deps/benchmark-src/src/benchmark_name.cc

@@ -1,59 +0,0 @@
-// Copyright 2015 Google Inc. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <benchmark/benchmark.h>
-
-namespace benchmark {
-
-namespace {
-
-// Compute the total size of a pack of std::strings
-size_t size_impl() { return 0; }
-
-template <typename Head, typename... Tail>
-size_t size_impl(const Head& head, const Tail&... tail) {
-  return head.size() + size_impl(tail...);
-}
-
-// Join a pack of std::strings using a delimiter
-// TODO: use absl::StrJoin
-void join_impl(std::string&, char) {}
-
-template <typename Head, typename... Tail>
-void join_impl(std::string& s, const char delimiter, const Head& head,
-               const Tail&... tail) {
-  if (!s.empty() && !head.empty()) {
-    s += delimiter;
-  }
-
-  s += head;
-
-  join_impl(s, delimiter, tail...);
-}
-
-template <typename... Ts>
-std::string join(char delimiter, const Ts&... ts) {
-  std::string s;
-  s.reserve(sizeof...(Ts) + size_impl(ts...));
-  join_impl(s, delimiter, ts...);
-  return s;
-}
-}  // namespace
-
-BENCHMARK_EXPORT
-std::string BenchmarkName::str() const {
-  return join('/', function_name, args, min_time, min_warmup_time, iterations,
-              repetitions, time_type, threads);
-}
-}  // namespace benchmark