pub_soft/abseil-cpp
3
0
Fork 0
mirror of https://github.com/abseil/abseil-cpp.git synced 2026-06-04 12:07:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add throughput and latency benchmarks for absl::ToDoubleXYZ functions.

Browse Source 
Sample benchmark result on a Skylake machine:
```
name                                       time/op
BM_Duration_ToInt64Nanoseconds             1.506n ± 0%
BM_Duration_ToInt64Microseconds            1.499n ± 1%
BM_Duration_ToInt64Milliseconds            1.502n ± 1%
BM_Duration_ToInt64Seconds                 1.498n ± 1%
BM_Duration_ToInt64Minutes                 1.495n ± 1%
BM_Duration_ToInt64Hours                   1.502n ± 1%
BM_Duration_ToDoubleNanoseconds            1.589n ± 1%
BM_Duration_ToDoubleMicroseconds           1.712n ± 1%
BM_Duration_ToDoubleMilliseconds           1.712n ± 1%
BM_Duration_ToDoubleSeconds                1.715n ± 1%
BM_Duration_ToDoubleMinutes                1.716n ± 1%
BM_Duration_ToDoubleHours                  1.717n ± 1%
BM_Duration_ToDoubleNanoseconds_Latency    9.934n ± 1%
BM_Duration_ToDoubleMicroseconds_Latency   13.08n ± 0%
BM_Duration_ToDoubleMilliseconds_Latency   13.06n ± 0%
BM_Duration_ToDoubleSeconds_Latency        13.06n ± 1%
BM_Duration_ToDoubleMinutes_Latency        13.01n ± 1%
BM_Duration_ToDoubleHours_Latency          13.03n ± 1%
BM_Duration_ToTimespec_AbslTime            1.567n ± 1%
BM_Duration_ToTimespec_Double              1.282n ± 1%
geomean                                    2.920n
```

PiperOrigin-RevId: 822317999
Change-Id: I0055d0780c9039ee30be52bc284599a3bcb24f56
This commit is contained in:
Shahriar Rouf
2025-10-21 16:18:26 -07:00
committed by Copybara-Service
parent f807de027a
commit 215d8a0e75
1 changed files with 144 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
absl/time/duration_benchmark.cc
View File

@@ -358,6 +358,150 @@ void BM_Duration_ToInt64Hours(benchmark::State& state) {
}
BENCHMARK(BM_Duration_ToInt64Hours);
//
// ToDoubleXYZ
//
void BM_Duration_ToDoubleNanoseconds(benchmark::State& state) {
absl::Duration d = absl::Seconds(100000);
while (state.KeepRunning()) {
benchmark::DoNotOptimize(d);
double result = absl::ToDoubleNanoseconds(d);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(BM_Duration_ToDoubleNanoseconds);
void BM_Duration_ToDoubleMicroseconds(benchmark::State& state) {
absl::Duration d = absl::Seconds(100000);
while (state.KeepRunning()) {
benchmark::DoNotOptimize(d);
double result = absl::ToDoubleMicroseconds(d);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(BM_Duration_ToDoubleMicroseconds);
void BM_Duration_ToDoubleMilliseconds(benchmark::State& state) {
absl::Duration d = absl::Seconds(100000);
while (state.KeepRunning()) {
benchmark::DoNotOptimize(d);
double result = absl::ToDoubleMilliseconds(d);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(BM_Duration_ToDoubleMilliseconds);
void BM_Duration_ToDoubleSeconds(benchmark::State& state) {
absl::Duration d = absl::Seconds(100000);
while (state.KeepRunning()) {
benchmark::DoNotOptimize(d);
double result = absl::ToDoubleSeconds(d);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(BM_Duration_ToDoubleSeconds);
void BM_Duration_ToDoubleMinutes(benchmark::State& state) {
absl::Duration d = absl::Seconds(100000);
while (state.KeepRunning()) {
benchmark::DoNotOptimize(d);
double result = absl::ToDoubleMinutes(d);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(BM_Duration_ToDoubleMinutes);
void BM_Duration_ToDoubleHours(benchmark::State& state) {
absl::Duration d = absl::Seconds(100000);
while (state.KeepRunning()) {
benchmark::DoNotOptimize(d);
double result = absl::ToDoubleHours(d);
benchmark::DoNotOptimize(result);
}
}
BENCHMARK(BM_Duration_ToDoubleHours);
//
// ToDoubleXYZ Latency
//
void BM_Duration_ToDoubleNanoseconds_Latency(benchmark::State& state) {
absl::Duration d1 = absl::Seconds(100000);
absl::Duration d2 = absl::Seconds(100000);
double result = 1;
while (state.KeepRunning()) {
benchmark::DoNotOptimize(d1);
benchmark::DoNotOptimize(d2);
benchmark::DoNotOptimize(result);
result = absl::ToDoubleNanoseconds(result < 0 ? d1 : d2);
}
}
BENCHMARK(BM_Duration_ToDoubleNanoseconds_Latency);
void BM_Duration_ToDoubleMicroseconds_Latency(benchmark::State& state) {
absl::Duration d1 = absl::Seconds(100000);
absl::Duration d2 = absl::Seconds(100000);
double result = 1;
while (state.KeepRunning()) {
benchmark::DoNotOptimize(d1);
benchmark::DoNotOptimize(d2);
benchmark::DoNotOptimize(result);
result = absl::ToDoubleMicroseconds(result < 0 ? d1 : d2);
}
}
BENCHMARK(BM_Duration_ToDoubleMicroseconds_Latency);
void BM_Duration_ToDoubleMilliseconds_Latency(benchmark::State& state) {
absl::Duration d1 = absl::Seconds(100000);
absl::Duration d2 = absl::Seconds(100000);
double result = 1;
while (state.KeepRunning()) {
benchmark::DoNotOptimize(d1);
benchmark::DoNotOptimize(d2);
benchmark::DoNotOptimize(result);
result = absl::ToDoubleMilliseconds(result < 0 ? d1 : d2);
}
}
BENCHMARK(BM_Duration_ToDoubleMilliseconds_Latency);
void BM_Duration_ToDoubleSeconds_Latency(benchmark::State& state) {
absl::Duration d1 = absl::Seconds(100000);
absl::Duration d2 = absl::Seconds(100000);
double result = 1;
while (state.KeepRunning()) {
benchmark::DoNotOptimize(d1);
benchmark::DoNotOptimize(d2);
benchmark::DoNotOptimize(result);
result = absl::ToDoubleSeconds(result < 0 ? d1 : d2);
}
}
BENCHMARK(BM_Duration_ToDoubleSeconds_Latency);
void BM_Duration_ToDoubleMinutes_Latency(benchmark::State& state) {
absl::Duration d1 = absl::Seconds(100000);
absl::Duration d2 = absl::Seconds(100000);
double result = 1;
while (state.KeepRunning()) {
benchmark::DoNotOptimize(d1);
benchmark::DoNotOptimize(d2);
benchmark::DoNotOptimize(result);
result = absl::ToDoubleMinutes(result < 0 ? d1 : d2);
}
}
BENCHMARK(BM_Duration_ToDoubleMinutes_Latency);
void BM_Duration_ToDoubleHours_Latency(benchmark::State& state) {
absl::Duration d1 = absl::Seconds(100000);
absl::Duration d2 = absl::Seconds(100000);
double result = 1;
while (state.KeepRunning()) {
benchmark::DoNotOptimize(d1);
benchmark::DoNotOptimize(d2);
benchmark::DoNotOptimize(result);
result = absl::ToDoubleHours(result < 0 ? d1 : d2);
}
}
BENCHMARK(BM_Duration_ToDoubleHours_Latency);
//
// To/FromTimespec
//