From 5aa5d282eac56a21e74611c1cdbaa97bb5db2dca Mon Sep 17 00:00:00 2001 From: Vincent Ambo Date: Tue, 8 Feb 2022 02:05:36 +0300 Subject: chore(3p/abseil_cpp): unvendor abseil_cpp we weren't actually using these sources anymore, okay? Change-Id: If701571d9716de308d3512e1eb22c35db0877a66 Reviewed-on: https://cl.tvl.fyi/c/depot/+/5248 Tested-by: BuildkiteCI Reviewed-by: grfn Autosubmit: tazjin --- third_party/abseil_cpp/absl/random/benchmarks.cc | 383 ----------------------- 1 file changed, 383 deletions(-) delete mode 100644 third_party/abseil_cpp/absl/random/benchmarks.cc (limited to 'third_party/abseil_cpp/absl/random/benchmarks.cc') diff --git a/third_party/abseil_cpp/absl/random/benchmarks.cc b/third_party/abseil_cpp/absl/random/benchmarks.cc deleted file mode 100644 index 87bbb9810a77..000000000000 --- a/third_party/abseil_cpp/absl/random/benchmarks.cc +++ /dev/null @@ -1,383 +0,0 @@ -// Copyright 2017 The Abseil Authors. -// -// 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 -// -// https://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. - -// Benchmarks for absl random distributions as well as a selection of the -// C++ standard library random distributions. - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "absl/base/macros.h" -#include "absl/meta/type_traits.h" -#include "absl/random/bernoulli_distribution.h" -#include "absl/random/beta_distribution.h" -#include "absl/random/exponential_distribution.h" -#include "absl/random/gaussian_distribution.h" -#include "absl/random/internal/fast_uniform_bits.h" -#include "absl/random/internal/randen_engine.h" -#include "absl/random/log_uniform_int_distribution.h" -#include "absl/random/poisson_distribution.h" -#include "absl/random/random.h" -#include "absl/random/uniform_int_distribution.h" -#include "absl/random/uniform_real_distribution.h" -#include "absl/random/zipf_distribution.h" -#include "benchmark/benchmark.h" - -namespace { - -// Seed data to avoid reading random_device() for benchmarks. -uint32_t kSeedData[] = { - 0x1B510052, 0x9A532915, 0xD60F573F, 0xBC9BC6E4, 0x2B60A476, 0x81E67400, - 0x08BA6FB5, 0x571BE91F, 0xF296EC6B, 0x2A0DD915, 0xB6636521, 0xE7B9F9B6, - 0xFF34052E, 0xC5855664, 0x53B02D5D, 0xA99F8FA1, 0x08BA4799, 0x6E85076A, - 0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623, 0xAD6EA6B0, 0x49A7DF7D, - 0x9CEE60B8, 0x8FEDB266, 0xECAA8C71, 0x699A18FF, 0x5664526C, 0xC2B19EE1, - 0x193602A5, 0x75094C29, 0xA0591340, 0xE4183A3E, 0x3F54989A, 0x5B429D65, - 0x6B8FE4D6, 0x99F73FD6, 0xA1D29C07, 0xEFE830F5, 0x4D2D38E6, 0xF0255DC1, - 0x4CDD2086, 0x8470EB26, 0x6382E9C6, 0x021ECC5E, 0x09686B3F, 0x3EBAEFC9, - 0x3C971814, 0x6B6A70A1, 0x687F3584, 0x52A0E286, 0x13198A2E, 0x03707344, -}; - -// PrecompiledSeedSeq provides kSeedData to a conforming -// random engine to speed initialization in the benchmarks. -class PrecompiledSeedSeq { - public: - using result_type = uint32_t; - - PrecompiledSeedSeq() {} - - template - PrecompiledSeedSeq(Iterator begin, Iterator end) {} - - template - PrecompiledSeedSeq(std::initializer_list il) {} - - template - void generate(OutIterator begin, OutIterator end) { - static size_t idx = 0; - for (; begin != end; begin++) { - *begin = kSeedData[idx++]; - if (idx >= ABSL_ARRAYSIZE(kSeedData)) { - idx = 0; - } - } - } - - size_t size() const { return ABSL_ARRAYSIZE(kSeedData); } - - template - void param(OutIterator out) const { - std::copy(std::begin(kSeedData), std::end(kSeedData), out); - } -}; - -// use_default_initialization indicates whether the random engine -// T must be default initialized, or whether we may initialize it using -// a seed sequence. This is used because some engines do not accept seed -// sequence-based initialization. -template -using use_default_initialization = std::false_type; - -// make_engine returns a random_engine which is initialized, -// either via the default constructor, when use_default_initialization -// is true, or via the indicated seed sequence, SSeq. -template -typename absl::enable_if_t::value, Engine> -make_engine() { - // Initialize the random engine using the seed sequence SSeq, which - // is constructed from the precompiled seed data. - SSeq seq(std::begin(kSeedData), std::end(kSeedData)); - return Engine(seq); -} - -template -typename absl::enable_if_t::value, Engine> -make_engine() { - // Initialize the random engine using the default constructor. - return Engine(); -} - -template -void BM_Construct(benchmark::State& state) { - for (auto _ : state) { - auto rng = make_engine(); - benchmark::DoNotOptimize(rng()); - } -} - -template -void BM_Direct(benchmark::State& state) { - using value_type = typename Engine::result_type; - // Direct use of the URBG. - auto rng = make_engine(); - for (auto _ : state) { - benchmark::DoNotOptimize(rng()); - } - state.SetBytesProcessed(sizeof(value_type) * state.iterations()); -} - -template -void BM_Generate(benchmark::State& state) { - // std::generate makes a copy of the RNG; thus this tests the - // copy-constructor efficiency. - using value_type = typename Engine::result_type; - std::vector v(64); - auto rng = make_engine(); - while (state.KeepRunningBatch(64)) { - std::generate(std::begin(v), std::end(v), rng); - } -} - -template -void BM_Shuffle(benchmark::State& state) { - // Direct use of the Engine. - std::vector v(elems); - while (state.KeepRunningBatch(elems)) { - auto rng = make_engine(); - std::shuffle(std::begin(v), std::end(v), rng); - } -} - -template -void BM_ShuffleReuse(benchmark::State& state) { - // Direct use of the Engine. - std::vector v(elems); - auto rng = make_engine(); - while (state.KeepRunningBatch(elems)) { - std::shuffle(std::begin(v), std::end(v), rng); - } -} - -template -void BM_Dist(benchmark::State& state, Args&&... args) { - using value_type = typename Dist::result_type; - auto rng = make_engine(); - Dist dis{std::forward(args)...}; - // Compare the following loop performance: - for (auto _ : state) { - benchmark::DoNotOptimize(dis(rng)); - } - state.SetBytesProcessed(sizeof(value_type) * state.iterations()); -} - -template -void BM_Large(benchmark::State& state) { - using value_type = typename Dist::result_type; - volatile value_type kMin = 0; - volatile value_type kMax = std::numeric_limits::max() / 2 + 1; - BM_Dist(state, kMin, kMax); -} - -template -void BM_Small(benchmark::State& state) { - using value_type = typename Dist::result_type; - volatile value_type kMin = 0; - volatile value_type kMax = std::numeric_limits::max() / 64 + 1; - BM_Dist(state, kMin, kMax); -} - -template -void BM_Bernoulli(benchmark::State& state) { - volatile double a = static_cast(A) / 1000000; - BM_Dist(state, a); -} - -template -void BM_Beta(benchmark::State& state) { - using value_type = typename Dist::result_type; - volatile value_type a = static_cast(A) / 100; - volatile value_type b = static_cast(B) / 100; - BM_Dist(state, a, b); -} - -template -void BM_Gamma(benchmark::State& state) { - using value_type = typename Dist::result_type; - volatile value_type a = static_cast(A) / 100; - BM_Dist(state, a); -} - -template -void BM_Poisson(benchmark::State& state) { - volatile double a = static_cast(A) / 100; - BM_Dist(state, a); -} - -template -void BM_Zipf(benchmark::State& state) { - using value_type = typename Dist::result_type; - volatile double q = Q; - volatile double v = V; - BM_Dist(state, std::numeric_limits::max(), q, v); -} - -template -void BM_Thread(benchmark::State& state) { - using value_type = typename Dist::result_type; - auto rng = make_engine(); - Dist dis{}; - for (auto _ : state) { - benchmark::DoNotOptimize(dis(rng)); - } - state.SetBytesProcessed(sizeof(value_type) * state.iterations()); -} - -// NOTES: -// -// std::geometric_distribution is similar to the zipf distributions. -// The algorithm for the geometric_distribution is, basically, -// floor(log(1-X) / log(1-p)) - -// Normal benchmark suite -#define BM_BASIC(Engine) \ - BENCHMARK_TEMPLATE(BM_Construct, Engine, PrecompiledSeedSeq); \ - BENCHMARK_TEMPLATE(BM_Construct, Engine, std::seed_seq); \ - BENCHMARK_TEMPLATE(BM_Direct, Engine); \ - BENCHMARK_TEMPLATE(BM_Shuffle, Engine, 10); \ - BENCHMARK_TEMPLATE(BM_Shuffle, Engine, 100); \ - BENCHMARK_TEMPLATE(BM_Shuffle, Engine, 1000); \ - BENCHMARK_TEMPLATE(BM_ShuffleReuse, Engine, 100); \ - BENCHMARK_TEMPLATE(BM_ShuffleReuse, Engine, 1000); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, \ - absl::random_internal::FastUniformBits); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, \ - absl::random_internal::FastUniformBits); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, std::uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, std::uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, \ - absl::uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, \ - absl::uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Large, Engine, \ - std::uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Large, Engine, \ - std::uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Large, Engine, \ - absl::uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Large, Engine, \ - absl::uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, std::uniform_real_distribution); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, std::uniform_real_distribution); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, absl::uniform_real_distribution); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, absl::uniform_real_distribution) - -#define BM_COPY(Engine) BENCHMARK_TEMPLATE(BM_Generate, Engine) - -#define BM_THREAD(Engine) \ - BENCHMARK_TEMPLATE(BM_Thread, Engine, \ - absl::uniform_int_distribution) \ - ->ThreadPerCpu(); \ - BENCHMARK_TEMPLATE(BM_Thread, Engine, \ - absl::uniform_real_distribution) \ - ->ThreadPerCpu(); \ - BENCHMARK_TEMPLATE(BM_Shuffle, Engine, 100)->ThreadPerCpu(); \ - BENCHMARK_TEMPLATE(BM_Shuffle, Engine, 1000)->ThreadPerCpu(); \ - BENCHMARK_TEMPLATE(BM_ShuffleReuse, Engine, 100)->ThreadPerCpu(); \ - BENCHMARK_TEMPLATE(BM_ShuffleReuse, Engine, 1000)->ThreadPerCpu(); - -#define BM_EXTENDED(Engine) \ - /* -------------- Extended Uniform -----------------------*/ \ - BENCHMARK_TEMPLATE(BM_Small, Engine, \ - std::uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Small, Engine, \ - std::uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Small, Engine, \ - absl::uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Small, Engine, \ - absl::uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Small, Engine, std::uniform_real_distribution); \ - BENCHMARK_TEMPLATE(BM_Small, Engine, \ - std::uniform_real_distribution); \ - BENCHMARK_TEMPLATE(BM_Small, Engine, \ - absl::uniform_real_distribution); \ - BENCHMARK_TEMPLATE(BM_Small, Engine, \ - absl::uniform_real_distribution); \ - /* -------------- Other -----------------------*/ \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, std::normal_distribution); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, absl::gaussian_distribution); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, std::exponential_distribution); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, absl::exponential_distribution); \ - BENCHMARK_TEMPLATE(BM_Poisson, Engine, std::poisson_distribution, \ - 100); \ - BENCHMARK_TEMPLATE(BM_Poisson, Engine, absl::poisson_distribution, \ - 100); \ - BENCHMARK_TEMPLATE(BM_Poisson, Engine, std::poisson_distribution, \ - 10 * 100); \ - BENCHMARK_TEMPLATE(BM_Poisson, Engine, absl::poisson_distribution, \ - 10 * 100); \ - BENCHMARK_TEMPLATE(BM_Poisson, Engine, std::poisson_distribution, \ - 13 * 100); \ - BENCHMARK_TEMPLATE(BM_Poisson, Engine, absl::poisson_distribution, \ - 13 * 100); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, \ - absl::log_uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, \ - absl::log_uniform_int_distribution); \ - BENCHMARK_TEMPLATE(BM_Dist, Engine, std::geometric_distribution); \ - BENCHMARK_TEMPLATE(BM_Zipf, Engine, absl::zipf_distribution); \ - BENCHMARK_TEMPLATE(BM_Zipf, Engine, absl::zipf_distribution, 2, \ - 3); \ - BENCHMARK_TEMPLATE(BM_Bernoulli, Engine, std::bernoulli_distribution, \ - 257305); \ - BENCHMARK_TEMPLATE(BM_Bernoulli, Engine, absl::bernoulli_distribution, \ - 257305); \ - BENCHMARK_TEMPLATE(BM_Beta, Engine, absl::beta_distribution, 65, \ - 41); \ - BENCHMARK_TEMPLATE(BM_Beta, Engine, absl::beta_distribution, 99, \ - 330); \ - BENCHMARK_TEMPLATE(BM_Beta, Engine, absl::beta_distribution, 150, \ - 150); \ - BENCHMARK_TEMPLATE(BM_Beta, Engine, absl::beta_distribution, 410, \ - 580); \ - BENCHMARK_TEMPLATE(BM_Beta, Engine, absl::beta_distribution, 65, 41); \ - BENCHMARK_TEMPLATE(BM_Beta, Engine, absl::beta_distribution, 99, \ - 330); \ - BENCHMARK_TEMPLATE(BM_Beta, Engine, absl::beta_distribution, 150, \ - 150); \ - BENCHMARK_TEMPLATE(BM_Beta, Engine, absl::beta_distribution, 410, \ - 580); \ - BENCHMARK_TEMPLATE(BM_Gamma, Engine, std::gamma_distribution, 199); \ - BENCHMARK_TEMPLATE(BM_Gamma, Engine, std::gamma_distribution, 199); - -// ABSL Recommended interfaces. -BM_BASIC(absl::InsecureBitGen); // === pcg64_2018_engine -BM_BASIC(absl::BitGen); // === randen_engine. -BM_THREAD(absl::BitGen); -BM_EXTENDED(absl::BitGen); - -// Instantiate benchmarks for multiple engines. -using randen_engine_64 = absl::random_internal::randen_engine; -using randen_engine_32 = absl::random_internal::randen_engine; - -// Comparison interfaces. -BM_BASIC(std::mt19937_64); -BM_COPY(std::mt19937_64); -BM_EXTENDED(std::mt19937_64); -BM_BASIC(randen_engine_64); -BM_COPY(randen_engine_64); -BM_EXTENDED(randen_engine_64); - -BM_BASIC(std::mt19937); -BM_COPY(std::mt19937); -BM_BASIC(randen_engine_32); -BM_COPY(randen_engine_32); - -} // namespace -- cgit 1.4.1