Skip to content

Commit 062a362

Browse files
lplewalplewa
committed
use unique_ptr instead of constructor/destructor in benchmarks
On Windows static builds, destructors are invoked after the UMF destructor, causing parameter structures to be unable to be destroyed. By switching to std::unique_ptr, we ensure that parameters are properly cleaned up and the destruction order issue is resolved.
1 parent 625a9d4 commit 062a362

File tree

3 files changed

+81
-66
lines changed

3 files changed

+81
-66
lines changed

‎benchmark/benchmark.cpp‎

Lines changed: 52 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -37,20 +37,27 @@ struct glibc_malloc : public allocator_interface {
3737
};
3838

3939
struct os_provider : public provider_interface {
40-
umf_os_memory_provider_params_handle_t params = NULL;
41-
os_provider() {
42-
umfOsMemoryProviderParamsCreate(&params);
43-
return;
44-
}
45-
46-
~os_provider() {
47-
if (params != NULL) {
48-
umfOsMemoryProviderParamsDestroy(params);
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 *) {}};
4947
}
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};
5057
}
5158

52-
void *getParams() override { return params; }
53-
umf_memory_provider_ops_t *getOps() override {
59+
umf_memory_provider_ops_t *
60+
getOps([[maybe_unused]] ::benchmark::State &state) override {
5461
return umfOsMemoryProviderOps();
5562
}
5663
static std::string name() { return "os_provider"; }
@@ -62,73 +69,63 @@ struct proxy_pool : public pool_interface<Provider> {
6269
getOps([[maybe_unused]] ::benchmark::State &state) override {
6370
return umfProxyPoolOps();
6471
}
65-
void *getParams([[maybe_unused]] ::benchmark::State &state) override {
66-
return nullptr;
67-
}
72+
6873
static std::string name() { return "proxy_pool<" + Provider::name() + ">"; }
6974
};
7075

7176
#ifdef UMF_POOL_DISJOINT_ENABLED
7277
template <typename Provider>
7378
struct disjoint_pool : public pool_interface<Provider> {
74-
umf_disjoint_pool_params_handle_t disjoint_memory_pool_params;
79+
umf_memory_pool_ops_t *
80+
getOps([[maybe_unused]] ::benchmark::State &state) override {
81+
return umfDisjointPoolOps();
82+
}
7583

76-
disjoint_pool() {
77-
disjoint_memory_pool_params = NULL;
78-
auto ret = umfDisjointPoolParamsCreate(&disjoint_memory_pool_params);
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);
7988
if (ret != UMF_RESULT_SUCCESS) {
80-
return;
89+
state.SkipWithError("Failed to create disjoint pool params");
90+
return {nullptr, [](void *) {}};
8191
}
8292

83-
// those function should never fail, so error handling is minimal.
84-
ret = umfDisjointPoolParamsSetSlabMinSize(disjoint_memory_pool_params,
85-
4096);
93+
ret = umfDisjointPoolParamsSetSlabMinSize(raw_params, 4096);
8694
if (ret != UMF_RESULT_SUCCESS) {
87-
goto err;
95+
state.SkipWithError("Failed to set slab min size");
96+
umfDisjointPoolParamsDestroy(raw_params);
97+
return {nullptr, [](void *) {}};
8898
}
8999

90-
ret = umfDisjointPoolParamsSetCapacity(disjoint_memory_pool_params, 4);
100+
ret = umfDisjointPoolParamsSetCapacity(raw_params, 4);
91101
if (ret != UMF_RESULT_SUCCESS) {
92-
goto err;
102+
state.SkipWithError("Failed to set capacity");
103+
umfDisjointPoolParamsDestroy(raw_params);
104+
return {nullptr, [](void *) {}};
93105
}
94106

95-
ret = umfDisjointPoolParamsSetMinBucketSize(disjoint_memory_pool_params,
96-
4096);
107+
ret = umfDisjointPoolParamsSetMinBucketSize(raw_params, 4096);
97108
if (ret != UMF_RESULT_SUCCESS) {
98-
goto err;
109+
state.SkipWithError("Failed to set min bucket size");
110+
umfDisjointPoolParamsDestroy(raw_params);
111+
return {nullptr, [](void *) {}};
99112
}
100113

101-
ret = umfDisjointPoolParamsSetMaxPoolableSize(
102-
disjoint_memory_pool_params, 4096 * 16);
103-
114+
ret = umfDisjointPoolParamsSetMaxPoolableSize(raw_params, 4096 * 16);
104115
if (ret != UMF_RESULT_SUCCESS) {
105-
goto err;
116+
state.SkipWithError("Failed to set max poolable size");
117+
umfDisjointPoolParamsDestroy(raw_params);
118+
return {nullptr, [](void *) {}};
106119
}
107-
return;
108-
err:
109-
110-
umfDisjointPoolParamsDestroy(disjoint_memory_pool_params);
111-
disjoint_memory_pool_params = NULL;
112-
}
113120

114-
~disjoint_pool() {
115-
if (disjoint_memory_pool_params != NULL) {
116-
umfDisjointPoolParamsDestroy(disjoint_memory_pool_params);
117-
}
118-
}
121+
auto deleter = [](void *p) {
122+
umfDisjointPoolParamsDestroy(
123+
static_cast<umf_disjoint_pool_params_handle_t>(p));
124+
};
119125

120-
umf_memory_pool_ops_t *
121-
getOps([[maybe_unused]] ::benchmark::State &state) override {
122-
return umfDisjointPoolOps();
126+
return {static_cast<void *>(raw_params), deleter};
123127
}
124-
void *getParams([[maybe_unused]] ::benchmark::State &state) override {
125-
126-
if (disjoint_memory_pool_params == NULL) {
127-
state.SkipWithError("Failed to create disjoint pool params");
128-
}
129128

130-
return disjoint_memory_pool_params;
131-
}
132129
static std::string name() {
133130
return "disjoint_pool<" + Provider::name() + ">";
134131
}
@@ -142,9 +139,7 @@ struct jemalloc_pool : public pool_interface<Provider> {
142139
getOps([[maybe_unused]] ::benchmark::State &state) override {
143140
return umfJemallocPoolOps();
144141
}
145-
void *getParams([[maybe_unused]] ::benchmark::State &state) override {
146-
return NULL;
147-
}
142+
148143
static std::string name() {
149144
return "jemalloc_pool<" + Provider::name() + ">";
150145
}
@@ -158,10 +153,7 @@ struct scalable_pool : public pool_interface<Provider> {
158153
getOps([[maybe_unused]] ::benchmark::State &state) override {
159154
return umfScalablePoolOps();
160155
}
161-
virtual void *
162-
getParams([[maybe_unused]] ::benchmark::State &state) override {
163-
return NULL;
164-
}
156+
165157
static std::string name() {
166158
return "scalable_pool<" + Provider::name() + ">";
167159
}

‎benchmark/benchmark.hpp‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -232,12 +232,14 @@ class alloc_benchmark : public benchmark_interface<Size, Alloc> {
232232
state.ResumeTiming();
233233
}
234234
}
235+
235236
static std::vector<std::string> argsName() {
236237
auto n = benchmark_interface<Size, Alloc>::argsName();
237238
std::vector<std::string> res = {"max_allocs", "pre_allocs"};
238239
res.insert(res.end(), n.begin(), n.end());
239240
return res;
240241
}
242+
241243
static std::string name() { return base::name() + "/alloc"; }
242244
static int64_t iterations() { return 200000; }
243245

@@ -320,13 +322,16 @@ class multiple_malloc_free_benchmark : public alloc_benchmark<Size, Alloc> {
320322
static std::string name() {
321323
return base::base::name() + "/multiple_malloc_free";
322324
}
325+
323326
static std::vector<std::string> argsName() {
324327
auto n = benchmark_interface<Size, Alloc>::argsName();
325328
std::vector<std::string> res = {"max_allocs"};
326329
res.insert(res.end(), n.begin(), n.end());
327330
return res;
328331
}
332+
329333
static int64_t iterations() { return 2000; }
334+
330335
std::default_random_engine generator;
331336
distribution dist;
332337
};
@@ -352,9 +357,11 @@ class provider_allocator : public allocator_interface {
352357
}
353358
return ptr;
354359
}
360+
355361
void benchFree(void *ptr, size_t size) override {
356362
umfMemoryProviderFree(provider.provider, ptr, size);
357363
}
364+
358365
static std::string name() { return Provider::name(); }
359366

360367
private:
@@ -374,6 +381,7 @@ template <typename Pool> class pool_allocator : public allocator_interface {
374381
virtual void *benchAlloc(size_t size) override {
375382
return umfPoolMalloc(pool.pool, size);
376383
}
384+
377385
virtual void benchFree(void *ptr, [[maybe_unused]] size_t size) override {
378386
umfPoolFree(pool.pool, ptr);
379387
}

‎benchmark/benchmark_interfaces.hpp‎

Lines changed: 21 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
*
77
*/
88

9+
#include <memory>
910
#include <string>
1011
#include <thread>
1112
#include <vector>
@@ -39,6 +40,7 @@ struct benchmark_interface : public benchmark::Fixture {
3940
int argPos = alloc_size.SetUp(state, 0);
4041
allocator.SetUp(state, argPos);
4142
}
43+
4244
void TearDown(::benchmark::State &state) {
4345
alloc_size.TearDown(state);
4446
allocator.TearDown(state);
@@ -54,20 +56,24 @@ struct benchmark_interface : public benchmark::Fixture {
5456
res.insert(res.end(), a.begin(), a.end());
5557
return res;
5658
}
59+
5760
static std::string name() { return Allocator::name(); }
5861
static int64_t iterations() { return 10000; }
5962
Size alloc_size;
6063
Allocator allocator;
6164
};
6265

6366
struct provider_interface {
67+
using params_ptr = std::unique_ptr<void, void (*)(void *)>;
68+
6469
umf_memory_provider_handle_t provider = NULL;
6570
virtual void SetUp(::benchmark::State &state) {
6671
if (state.thread_index() != 0) {
6772
return;
6873
}
74+
auto params = getParams(state);
6975
auto umf_result =
70-
umfMemoryProviderCreate(getOps(), getParams(), &provider);
76+
umfMemoryProviderCreate(getOps(state), params.get(), &provider);
7177
if (umf_result != UMF_RESULT_SUCCESS) {
7278
state.SkipWithError("umfMemoryProviderCreate() failed");
7379
}
@@ -83,21 +89,30 @@ struct provider_interface {
8389
}
8490
}
8591

86-
virtual umf_memory_provider_ops_t *getOps() { return nullptr; }
87-
virtual void *getParams() { return nullptr; }
92+
virtual umf_memory_provider_ops_t *
93+
getOps([[maybe_unused]] ::benchmark::State &state) {
94+
return nullptr;
95+
}
96+
97+
virtual params_ptr getParams([[maybe_unused]] ::benchmark::State &state) {
98+
return {nullptr, [](void *) {}};
99+
}
88100
};
89101

90102
template <typename T,
91103
typename =
92104
std::enable_if_t<std::is_base_of<provider_interface, T>::value>>
93105
struct pool_interface {
106+
using params_ptr = std::unique_ptr<void, void (*)(void *)>;
107+
94108
virtual void SetUp(::benchmark::State &state) {
95109
provider.SetUp(state);
96110
if (state.thread_index() != 0) {
97111
return;
98112
}
113+
auto params = getParams(state);
99114
auto umf_result = umfPoolCreate(getOps(state), provider.provider,
100-
getParams(state), 0, &pool);
115+
params.get(), 0, &pool);
101116
if (umf_result != UMF_RESULT_SUCCESS) {
102117
state.SkipWithError("umfPoolCreate() failed");
103118
}
@@ -121,8 +136,8 @@ struct pool_interface {
121136
getOps([[maybe_unused]] ::benchmark::State &state) {
122137
return nullptr;
123138
}
124-
virtual void *getParams([[maybe_unused]] ::benchmark::State &state) {
125-
return nullptr;
139+
virtual params_ptr getParams([[maybe_unused]] ::benchmark::State &state) {
140+
return {nullptr, [](void *) {}};
126141
}
127142
T provider;
128143
umf_memory_pool_handle_t pool;

0 commit comments

Comments
 (0)