1 // Copyright 2023 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/big_endian.h"
6
7 #include <stdint.h>
8
9 #include "base/check.h"
10 #include "base/containers/span.h"
11 #include "base/numerics/byte_conversions.h"
12 #include "testing/gtest/include/gtest/gtest.h"
13 #include "third_party/google_benchmark/src/include/benchmark/benchmark.h"
14
15 namespace base {
16 namespace {
17
18 constexpr size_t kSize = 128 * 1024 * 1024;
19 int64_t aligned_bytes[kSize / sizeof(int64_t)];
20 struct {
21 int64_t aligment;
22 char padding_to_cause_misalignment;
23 char bytes[kSize];
24 } misaligned_bytes;
25
DoNotOptimizeSpan(span<const uint8_t> range)26 void DoNotOptimizeSpan(span<const uint8_t> range) {
27 // ::benchmark::DoNotOptimize() generates quite large code, so instead of
28 // calling it for every byte in the range, calculate `sum` which depends on
29 // every byte in the range and then call DoNotOptimise() on that.
30 int sum = 0;
31 for (char c : range) {
32 sum += c;
33 }
34 ::benchmark::DoNotOptimize(sum);
35 }
36
37 template <typename T>
WriteBigEndianCommon(::benchmark::State & state,span<uint8_t,kSize> buffer)38 inline void WriteBigEndianCommon(::benchmark::State& state,
39 span<uint8_t, kSize> buffer) {
40 size_t offset = 0u;
41 auto value = T{0};
42 for (auto _ : state) {
43 if constexpr (sizeof(T) == 1) {
44 buffer.subspan(offset).first<sizeof(T)>().copy_from(U8ToBigEndian(value));
45 } else if constexpr (sizeof(T) == 2) {
46 buffer.subspan(offset).first<sizeof(T)>().copy_from(
47 U16ToBigEndian(value));
48 } else if constexpr (sizeof(T) == 4) {
49 buffer.subspan(offset).first<sizeof(T)>().copy_from(
50 U32ToBigEndian(value));
51 } else {
52 static_assert(sizeof(T) == 8);
53 buffer.subspan(offset).first<sizeof(T)>().copy_from(
54 U64ToBigEndian(value));
55 }
56 offset += sizeof(T);
57 static_assert(kSize % sizeof(T) == 0u);
58 if (offset == kSize) {
59 offset = 0;
60 }
61 ++value;
62 }
63 DoNotOptimizeSpan(buffer);
64 }
65
66 template <typename T>
BM_WriteBigEndianAligned(::benchmark::State & state)67 void BM_WriteBigEndianAligned(::benchmark::State& state) {
68 span<uint8_t, kSize> buffer = as_writable_byte_span(aligned_bytes);
69 CHECK(reinterpret_cast<uintptr_t>(buffer.data()) % alignof(T) == 0u);
70 WriteBigEndianCommon<T>(state, buffer);
71 }
72
73 template <typename T>
BM_WriteBigEndianMisaligned(::benchmark::State & state)74 void BM_WriteBigEndianMisaligned(::benchmark::State& state) {
75 span<uint8_t, kSize> buffer = as_writable_byte_span(misaligned_bytes.bytes);
76 CHECK(reinterpret_cast<uintptr_t>(buffer.data()) % alignof(T) != 0u);
77 WriteBigEndianCommon<T>(state, buffer);
78 }
79
80 template <typename T>
ReadBigEndianCommon(::benchmark::State & state,span<const uint8_t,kSize> buffer)81 inline void ReadBigEndianCommon(::benchmark::State& state,
82 span<const uint8_t, kSize> buffer) {
83 size_t offset = 0;
84 for (auto _ : state) {
85 T value;
86 if constexpr (sizeof(T) == 1) {
87 value = U8FromBigEndian(buffer.subspan(offset).first<sizeof(T)>());
88 } else if constexpr (sizeof(T) == 2) {
89 value = U16FromBigEndian(buffer.subspan(offset).first<sizeof(T)>());
90 } else if constexpr (sizeof(T) == 4) {
91 value = U32FromBigEndian(buffer.subspan(offset).first<sizeof(T)>());
92 } else {
93 static_assert(sizeof(T) == 8);
94 value = U64FromBigEndian(buffer.subspan(offset).first<sizeof(T)>());
95 }
96 ::benchmark::DoNotOptimize(value);
97 offset += sizeof(T);
98 static_assert(kSize % sizeof(T) == 0);
99 if (offset == kSize) {
100 offset = 0;
101 }
102 }
103 }
104
105 template <typename T>
BM_ReadBigEndianAligned(::benchmark::State & state)106 void BM_ReadBigEndianAligned(::benchmark::State& state) {
107 span<const uint8_t, kSize> buffer = as_byte_span(aligned_bytes);
108 CHECK(reinterpret_cast<uintptr_t>(buffer.data()) % alignof(T) == 0);
109 ReadBigEndianCommon<T>(state, buffer);
110 }
111
112 template <typename T>
BM_ReadBigEndianMisaligned(::benchmark::State & state)113 void BM_ReadBigEndianMisaligned(::benchmark::State& state) {
114 span<const uint8_t, kSize> buffer = as_byte_span(misaligned_bytes.bytes);
115 CHECK(reinterpret_cast<uintptr_t>(buffer.data()) % alignof(T) != 0);
116 ReadBigEndianCommon<T>(state, buffer);
117 }
118
119 #define BENCHMARK_FOR_INT_TYPES(function) \
120 BENCHMARK(function<int16_t>)->MinWarmUpTime(1.0); \
121 BENCHMARK(function<uint16_t>)->MinWarmUpTime(1.0); \
122 BENCHMARK(function<int32_t>)->MinWarmUpTime(1.0); \
123 BENCHMARK(function<uint32_t>)->MinWarmUpTime(1.0); \
124 BENCHMARK(function<int64_t>)->MinWarmUpTime(1.0); \
125 BENCHMARK(function<uint64_t>)->MinWarmUpTime(1.0);
126
127 // Register the benchmarks as a GTest test. This allows using legacy
128 // --gtest_filter and --gtest_list_tests.
129 // TODO(https://crbug.com/40251982): Clean this up after transitioning to
130 // --benchmark_filter and --benchmark_list_tests.
TEST(BigEndianPerfTest,All)131 TEST(BigEndianPerfTest, All) {
132 BENCHMARK_FOR_INT_TYPES(BM_WriteBigEndianAligned);
133 BENCHMARK_FOR_INT_TYPES(BM_WriteBigEndianMisaligned);
134 BENCHMARK_FOR_INT_TYPES(BM_ReadBigEndianAligned);
135 BENCHMARK_FOR_INT_TYPES(BM_ReadBigEndianMisaligned);
136 }
137
138 #undef BENCHMARK_FOR_INT_TYPES
139
140 } // namespace
141 } // namespace base
142