diff options
author | Abseil Team <absl-team@google.com> | 2018-06-08T15·14-0700 |
---|---|---|
committer | Gennadiy Civil <misterg@google.com> | 2018-06-08T15·24-0400 |
commit | 92020a042c0cd46979db9f6f0cb32783dc07765e (patch) | |
tree | 5f4ebb5a8b0a8c4f0e5e2a061e63665b2071d92f /absl/numeric/int128_benchmark.cc | |
parent | 7aacab8ae05d7115049923da9cfbf584dc1f8338 (diff) |
- abacaab4b11a69dd4db627bd183571d7cabb8def Refinement to previous time.h edit (in this same github p... by Greg Falcon <gfalcon@google.com>
- 64db19b773134c6c8004e3b23c9ca892efbf8bae Move SpinLock's adaptive spin count computation from a st... by Derek Mauro <dmauro@google.com> - 6f9533fb44a52485a7c2bbb9b4efc7bf8d6c359a Import of CCTZ from GitHub. by Abseil Team <absl-team@google.com> - a211d7255c986e8dd4ceada362c0d054a6a1969a Cleanup exception flags by Abseil Team <absl-team@google.com> - babdb29c590126fe9bba5229fe91034b5b5c358a Release time benchmarks. by Alex Strelnikov <strel@google.com> - 5803b32a3ff123d1fb57a0c471d199c818357c9f Release memutil microbenchmarks. by Alex Strelnikov <strel@google.com> - 5357d4890d30e80c53beb05af32500fb20e9402b Add parens around expansion of ABSL_PREDICT_{FALSE,TRUE} ... by Abseil Team <absl-team@google.com> - 32023f61a239a5f6b1c59e577bfe81b179bbcd2d Reformat build rule tag. by Alex Strelnikov <strel@google.com> - 833758ecf2b0cf7a42bbd50b5b127e416425c168 Release uint128 microbenchmarks. by Alex Strelnikov <strel@google.com> - c115a9bca1f944b90fdc78a56b2de176466b124f Disambiguate bitwise-not of size_type by Abseil Team <absl-team@google.com> - f6905f5b5f6e425792de646edafde440548d9346 Updates ConstructorTracker and TrackedObjects with 1) a m... by Abseil Team <absl-team@google.com> - 147c553bdd5d2db20a38f75c4d1ef973d6c709c5 Changes the absl::Duration factory functions to disallow ... by Greg Miller <jgm@google.com> - dba2b96d11b5264546b283ba452f2de1303b0f07 White space fix by Alex Strelnikov <strel@google.com> GitOrigin-RevId: abacaab4b11a69dd4db627bd183571d7cabb8def Change-Id: I6fa34f20d0b2f898e7b5475a603111413bb80a67
Diffstat (limited to 'absl/numeric/int128_benchmark.cc')
-rw-r--r-- | absl/numeric/int128_benchmark.cc | 221 |
1 files changed, 221 insertions, 0 deletions
diff --git a/absl/numeric/int128_benchmark.cc b/absl/numeric/int128_benchmark.cc new file mode 100644 index 000000000000..1cb7d0ed87e0 --- /dev/null +++ b/absl/numeric/int128_benchmark.cc @@ -0,0 +1,221 @@ +// 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 +// +// 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 "absl/numeric/int128.h" + +#include <algorithm> +#include <cstdint> +#include <random> +#include <vector> + +#include "benchmark/benchmark.h" +#include "absl/base/config.h" + +namespace { + +constexpr size_t kSampleSize = 1000000; + +std::mt19937 MakeRandomEngine() { + std::random_device r; + std::seed_seq seed({r(), r(), r(), r(), r(), r(), r(), r()}); + return std::mt19937(seed); +} + +std::vector<std::pair<absl::uint128, absl::uint128>> +GetRandomClass128SampleUniformDivisor() { + std::vector<std::pair<absl::uint128, absl::uint128>> values; + std::mt19937 random = MakeRandomEngine(); + std::uniform_int_distribution<uint64_t> uniform_uint64; + values.reserve(kSampleSize); + for (size_t i = 0; i < kSampleSize; ++i) { + absl::uint128 a = + absl::MakeUint128(uniform_uint64(random), uniform_uint64(random)); + absl::uint128 b = + absl::MakeUint128(uniform_uint64(random), uniform_uint64(random)); + values.emplace_back(std::max(a, b), + std::max(absl::uint128(2), std::min(a, b))); + } + return values; +} + +void BM_DivideClass128UniformDivisor(benchmark::State& state) { + auto values = GetRandomClass128SampleUniformDivisor(); + while (state.KeepRunningBatch(values.size())) { + for (const auto& pair : values) { + benchmark::DoNotOptimize(pair.first / pair.second); + } + } +} +BENCHMARK(BM_DivideClass128UniformDivisor); + +std::vector<std::pair<absl::uint128, uint64_t>> +GetRandomClass128SampleSmallDivisor() { + std::vector<std::pair<absl::uint128, uint64_t>> values; + std::mt19937 random = MakeRandomEngine(); + std::uniform_int_distribution<uint64_t> uniform_uint64; + values.reserve(kSampleSize); + for (size_t i = 0; i < kSampleSize; ++i) { + absl::uint128 a = + absl::MakeUint128(uniform_uint64(random), uniform_uint64(random)); + uint64_t b = std::max(uint64_t{2}, uniform_uint64(random)); + values.emplace_back(std::max(a, absl::uint128(b)), b); + } + return values; +} + +void BM_DivideClass128SmallDivisor(benchmark::State& state) { + auto values = GetRandomClass128SampleSmallDivisor(); + while (state.KeepRunningBatch(values.size())) { + for (const auto& pair : values) { + benchmark::DoNotOptimize(pair.first / pair.second); + } + } +} +BENCHMARK(BM_DivideClass128SmallDivisor); + +std::vector<std::pair<absl::uint128, absl::uint128>> GetRandomClass128Sample() { + std::vector<std::pair<absl::uint128, absl::uint128>> values; + std::mt19937 random = MakeRandomEngine(); + std::uniform_int_distribution<uint64_t> uniform_uint64; + values.reserve(kSampleSize); + for (size_t i = 0; i < kSampleSize; ++i) { + values.emplace_back( + absl::MakeUint128(uniform_uint64(random), uniform_uint64(random)), + absl::MakeUint128(uniform_uint64(random), uniform_uint64(random))); + } + return values; +} + +void BM_MultiplyClass128(benchmark::State& state) { + auto values = GetRandomClass128Sample(); + while (state.KeepRunningBatch(values.size())) { + for (const auto& pair : values) { + benchmark::DoNotOptimize(pair.first * pair.second); + } + } +} +BENCHMARK(BM_MultiplyClass128); + +void BM_AddClass128(benchmark::State& state) { + auto values = GetRandomClass128Sample(); + while (state.KeepRunningBatch(values.size())) { + for (const auto& pair : values) { + benchmark::DoNotOptimize(pair.first + pair.second); + } + } +} +BENCHMARK(BM_AddClass128); + +#ifdef ABSL_HAVE_INTRINSIC_INT128 + +// Some implementations of <random> do not support __int128 when it is +// available, so we make our own uniform_int_distribution-like type. +class UniformIntDistribution128 { + public: + // NOLINTNEXTLINE: mimicking std::uniform_int_distribution API + unsigned __int128 operator()(std::mt19937& generator) { + return (static_cast<unsigned __int128>(dist64_(generator)) << 64) | + dist64_(generator); + } + + private: + std::uniform_int_distribution<uint64_t> dist64_; +}; + +std::vector<std::pair<unsigned __int128, unsigned __int128>> +GetRandomIntrinsic128SampleUniformDivisor() { + std::vector<std::pair<unsigned __int128, unsigned __int128>> values; + std::mt19937 random = MakeRandomEngine(); + UniformIntDistribution128 uniform_uint128; + values.reserve(kSampleSize); + for (size_t i = 0; i < kSampleSize; ++i) { + unsigned __int128 a = uniform_uint128(random); + unsigned __int128 b = uniform_uint128(random); + values.emplace_back( + std::max(a, b), + std::max(static_cast<unsigned __int128>(2), std::min(a, b))); + } + return values; +} + +void BM_DivideIntrinsic128UniformDivisor(benchmark::State& state) { + auto values = GetRandomIntrinsic128SampleUniformDivisor(); + while (state.KeepRunningBatch(values.size())) { + for (const auto& pair : values) { + benchmark::DoNotOptimize(pair.first / pair.second); + } + } +} +BENCHMARK(BM_DivideIntrinsic128UniformDivisor); + +std::vector<std::pair<unsigned __int128, uint64_t>> +GetRandomIntrinsic128SampleSmallDivisor() { + std::vector<std::pair<unsigned __int128, uint64_t>> values; + std::mt19937 random = MakeRandomEngine(); + UniformIntDistribution128 uniform_uint128; + std::uniform_int_distribution<uint64_t> uniform_uint64; + values.reserve(kSampleSize); + for (size_t i = 0; i < kSampleSize; ++i) { + unsigned __int128 a = uniform_uint128(random); + uint64_t b = std::max(uint64_t{2}, uniform_uint64(random)); + values.emplace_back(std::max(a, static_cast<unsigned __int128>(b)), b); + } + return values; +} + +void BM_DivideIntrinsic128SmallDivisor(benchmark::State& state) { + auto values = GetRandomIntrinsic128SampleSmallDivisor(); + while (state.KeepRunningBatch(values.size())) { + for (const auto& pair : values) { + benchmark::DoNotOptimize(pair.first / pair.second); + } + } +} +BENCHMARK(BM_DivideIntrinsic128SmallDivisor); + +std::vector<std::pair<unsigned __int128, unsigned __int128>> + GetRandomIntrinsic128Sample() { + std::vector<std::pair<unsigned __int128, unsigned __int128>> values; + std::mt19937 random = MakeRandomEngine(); + UniformIntDistribution128 uniform_uint128; + values.reserve(kSampleSize); + for (size_t i = 0; i < kSampleSize; ++i) { + values.emplace_back(uniform_uint128(random), uniform_uint128(random)); + } + return values; +} + +void BM_MultiplyIntrinsic128(benchmark::State& state) { + auto values = GetRandomIntrinsic128Sample(); + while (state.KeepRunningBatch(values.size())) { + for (const auto& pair : values) { + benchmark::DoNotOptimize(pair.first * pair.second); + } + } +} +BENCHMARK(BM_MultiplyIntrinsic128); + +void BM_AddIntrinsic128(benchmark::State& state) { + auto values = GetRandomIntrinsic128Sample(); + while (state.KeepRunningBatch(values.size())) { + for (const auto& pair : values) { + benchmark::DoNotOptimize(pair.first + pair.second); + } + } +} +BENCHMARK(BM_AddIntrinsic128); + +#endif // ABSL_HAVE_INTRINSIC_INT128 + +} // namespace |