|
6 | 6 | * |
7 | 7 | */ |
8 | 8 |
|
9 | | -#include <benchmark/benchmark.h> |
10 | | -#include <umf/pools/pool_proxy.h> |
11 | | -#ifdef UMF_POOL_SCALABLE_ENABLED |
12 | | -#include <umf/pools/pool_scalable.h> |
13 | | -#endif |
14 | | -#include <umf/providers/provider_os_memory.h> |
15 | | - |
16 | | -#ifdef UMF_POOL_DISJOINT_ENABLED |
17 | | -#include <umf/pools/pool_disjoint.h> |
18 | | -#endif |
19 | | - |
20 | | -#ifdef UMF_POOL_JEMALLOC_ENABLED |
21 | | -#include <umf/pools/pool_jemalloc.h> |
22 | | -#endif |
23 | | - |
24 | 9 | #include "benchmark.hpp" |
25 | 10 |
|
26 | | -struct glibc_malloc : public allocator_interface { |
27 | | - unsigned SetUp([[maybe_unused]] ::benchmark::State &state, |
28 | | - unsigned argPos) override { |
29 | | - return argPos; |
30 | | - } |
31 | | - void TearDown([[maybe_unused]] ::benchmark::State &state) override{}; |
32 | | - void *benchAlloc(size_t size) override { return malloc(size); } |
33 | | - void benchFree(void *ptr, [[maybe_unused]] size_t size) override { |
34 | | - free(ptr); |
| 11 | +#define UMF_BENCHMARK_TEMPLATE_DEFINE(BaseClass, Method, ...) \ |
| 12 | + BENCHMARK_TEMPLATE_DEFINE_F(BaseClass, Method, __VA_ARGS__) \ |
| 13 | + (benchmark::State & state) { \ |
| 14 | + for (auto _ : state) { \ |
| 15 | + bench(state); \ |
| 16 | + } \ |
35 | 17 | } |
36 | | - static std::string name() { return "glibc"; } |
37 | | -}; |
38 | | - |
39 | | -struct os_provider : public provider_interface { |
40 | | - provider_interface::params_ptr |
41 | | - getParams(::benchmark::State &state) override { |
42 | | - umf_os_memory_provider_params_handle_t raw_params = nullptr; |
43 | | - umfOsMemoryProviderParamsCreate(&raw_params); |
44 | | - if (!raw_params) { |
45 | | - state.SkipWithError("Failed to create os provider params"); |
46 | | - return {nullptr, [](void *) {}}; |
47 | | - } |
48 | | - |
49 | | - // Use a lambda as the custom deleter |
50 | | - auto deleter = [](void *p) { |
51 | | - auto handle = |
52 | | - static_cast<umf_os_memory_provider_params_handle_t>(p); |
53 | | - umfOsMemoryProviderParamsDestroy(handle); |
54 | | - }; |
55 | | - |
56 | | - return {static_cast<void *>(raw_params), deleter}; |
57 | | - } |
58 | | - |
59 | | - umf_memory_provider_ops_t * |
60 | | - getOps([[maybe_unused]] ::benchmark::State &state) override { |
61 | | - return umfOsMemoryProviderOps(); |
62 | | - } |
63 | | - static std::string name() { return "os_provider"; } |
64 | | -}; |
65 | | - |
66 | | -template <typename Provider> |
67 | | -struct proxy_pool : public pool_interface<Provider> { |
68 | | - umf_memory_pool_ops_t * |
69 | | - getOps([[maybe_unused]] ::benchmark::State &state) override { |
70 | | - return umfProxyPoolOps(); |
71 | | - } |
72 | | - |
73 | | - static std::string name() { return "proxy_pool<" + Provider::name() + ">"; } |
74 | | -}; |
75 | 18 |
|
76 | | -#ifdef UMF_POOL_DISJOINT_ENABLED |
77 | | -template <typename Provider> |
78 | | -struct disjoint_pool : public pool_interface<Provider> { |
79 | | - umf_memory_pool_ops_t * |
80 | | - getOps([[maybe_unused]] ::benchmark::State &state) override { |
81 | | - return umfDisjointPoolOps(); |
82 | | - } |
83 | | - |
84 | | - typename pool_interface<Provider>::params_ptr |
85 | | - getParams(::benchmark::State &state) override { |
86 | | - umf_disjoint_pool_params_handle_t raw_params = nullptr; |
87 | | - auto ret = umfDisjointPoolParamsCreate(&raw_params); |
88 | | - if (ret != UMF_RESULT_SUCCESS) { |
89 | | - state.SkipWithError("Failed to create disjoint pool params"); |
90 | | - return {nullptr, [](void *) {}}; |
91 | | - } |
92 | | - |
93 | | - typename pool_interface<Provider>::params_ptr params( |
94 | | - raw_params, [](void *p) { |
95 | | - umfDisjointPoolParamsDestroy( |
96 | | - static_cast<umf_disjoint_pool_params_handle_t>(p)); |
97 | | - }); |
98 | | - |
99 | | - ret = umfDisjointPoolParamsSetSlabMinSize(raw_params, 4096); |
100 | | - if (ret != UMF_RESULT_SUCCESS) { |
101 | | - state.SkipWithError("Failed to set slab min size"); |
102 | | - return {nullptr, [](void *) {}}; |
103 | | - } |
104 | | - |
105 | | - ret = umfDisjointPoolParamsSetCapacity(raw_params, 4); |
106 | | - if (ret != UMF_RESULT_SUCCESS) { |
107 | | - state.SkipWithError("Failed to set capacity"); |
108 | | - return {nullptr, [](void *) {}}; |
109 | | - } |
110 | | - |
111 | | - ret = umfDisjointPoolParamsSetMinBucketSize(raw_params, 4096); |
112 | | - if (ret != UMF_RESULT_SUCCESS) { |
113 | | - state.SkipWithError("Failed to set min bucket size"); |
114 | | - return {nullptr, [](void *) {}}; |
115 | | - } |
116 | | - |
117 | | - ret = umfDisjointPoolParamsSetMaxPoolableSize(raw_params, 4096 * 16); |
118 | | - if (ret != UMF_RESULT_SUCCESS) { |
119 | | - state.SkipWithError("Failed to set max poolable size"); |
120 | | - return {nullptr, [](void *) {}}; |
121 | | - } |
122 | | - |
123 | | - return params; |
124 | | - } |
125 | | - |
126 | | - static std::string name() { |
127 | | - return "disjoint_pool<" + Provider::name() + ">"; |
128 | | - } |
129 | | -}; |
130 | | -#endif |
131 | | - |
132 | | -#ifdef UMF_POOL_JEMALLOC_ENABLED |
133 | | -template <typename Provider> |
134 | | -struct jemalloc_pool : public pool_interface<Provider> { |
135 | | - umf_memory_pool_ops_t * |
136 | | - getOps([[maybe_unused]] ::benchmark::State &state) override { |
137 | | - return umfJemallocPoolOps(); |
138 | | - } |
139 | | - |
140 | | - static std::string name() { |
141 | | - return "jemalloc_pool<" + Provider::name() + ">"; |
142 | | - } |
143 | | -}; |
144 | | -#endif |
145 | | - |
146 | | -#ifdef UMF_POOL_SCALABLE_ENABLED |
147 | | -template <typename Provider> |
148 | | -struct scalable_pool : public pool_interface<Provider> { |
149 | | - virtual umf_memory_pool_ops_t * |
150 | | - getOps([[maybe_unused]] ::benchmark::State &state) override { |
151 | | - return umfScalablePoolOps(); |
152 | | - } |
153 | | - |
154 | | - static std::string name() { |
155 | | - return "scalable_pool<" + Provider::name() + ">"; |
156 | | - } |
157 | | -}; |
158 | | -#endif |
159 | | -// Benchmarks scenarios: |
| 19 | +#define UMF_BENCHMARK_REGISTER_F(BaseClass, Method) \ |
| 20 | + BENCHMARK_REGISTER_F(BaseClass, Method) \ |
| 21 | + ->ArgNames( \ |
| 22 | + BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::argsName()) \ |
| 23 | + ->Name(BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::name()) \ |
| 24 | + ->Iterations( \ |
| 25 | + BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::iterations()) |
160 | 26 |
|
161 | 27 | UMF_BENCHMARK_TEMPLATE_DEFINE(alloc_benchmark, glibc_fix, fixed_alloc_size, |
162 | 28 | glibc_malloc); |
163 | 29 |
|
| 30 | +// Benchmarks scenarios: |
| 31 | + |
164 | 32 | // The benchmark arguments specified in Args() are, in order: |
165 | 33 | // benchmark arguments, allocator arguments, size generator arguments. |
166 | 34 | // The exact meaning of each argument depends on the benchmark, allocator, and size components used. |
|
0 commit comments