Skip to content

Commit 3d53e39

Browse files
bratpiorkabratpiorka
authored
Merge pull request #267 from bratpiorka/rrudnick_scalable_dlopen
close tbb handle on scalable pool finalize
2 parents de4cce7 + 8cade8a commit 3d53e39

File tree

1 file changed

+77
-77
lines changed

1 file changed

+77
-77
lines changed

‎src/pool/pool_scalable.c

Lines changed: 77 additions & 77 deletions
Original file line numberDiff line numberDiff line change
@@ -34,79 +34,78 @@ typedef void (*raw_free_tbb_type)(intptr_t, void *, size_t);
3434
static __TLS umf_result_t TLS_last_allocation_error;
3535
static __TLS umf_result_t TLS_last_free_error;
3636

37-
struct mem_pool_policy_s {
37+
typedef struct tbb_mem_pool_policy_t {
3838
raw_alloc_tbb_type pAlloc;
3939
raw_free_tbb_type pFree;
4040
size_t granularity;
4141
int version;
4242
unsigned fixed_pool : 1, keep_all_memory : 1, reserved : 30;
43-
};
43+
} tbb_mem_pool_policy_t;
4444

45-
struct tbb_callbacks {
45+
typedef struct tbb_callbacks_t {
4646
void *(*pool_malloc)(void *, size_t);
4747
void *(*pool_realloc)(void *, void *, size_t);
4848
void *(*pool_aligned_malloc)(void *, size_t, size_t);
4949
bool (*pool_free)(void *, void *);
50-
int (*pool_create_v1)(intptr_t, const struct mem_pool_policy_s *, void **);
50+
int (*pool_create_v1)(intptr_t, const struct tbb_mem_pool_policy_t *,
51+
void **);
5152
bool (*pool_destroy)(void *);
5253
void *(*pool_identify)(void *object);
5354
size_t (*pool_msize)(void *, void *);
54-
};
55+
void *lib_handle;
56+
} tbb_callbacks_t;
5557

56-
struct tbb_memory_pool {
58+
typedef struct tbb_memory_pool_t {
5759
umf_memory_provider_handle_t mem_provider;
5860
void *tbb_pool;
59-
};
61+
tbb_callbacks_t tbb_callbacks;
62+
} tbb_memory_pool_t;
6063

61-
static struct tbb_callbacks g_tbb_ops;
62-
static UTIL_ONCE_FLAG tbb_is_initialized = UTIL_ONCE_FLAG_INIT;
63-
static bool Init_tbb_global_state_failed;
64+
static int init_tbb_callbacks(tbb_callbacks_t *tbb_callbacks) {
65+
assert(tbb_callbacks);
6466

65-
static void init_tbb_global_state(void) {
6667
const char so_name[] = "libtbbmalloc.so.2";
67-
void *tbb_handle = dlopen(so_name, RTLD_LAZY);
68-
if (!tbb_handle) {
68+
tbb_callbacks->lib_handle = dlopen(so_name, RTLD_LAZY);
69+
if (!tbb_callbacks->lib_handle) {
6970
fprintf(stderr, "%s not found.\n", so_name);
70-
Init_tbb_global_state_failed = true;
71-
return;
71+
return -1;
7272
}
7373

74-
struct tbb_callbacks tbb_ops;
75-
76-
*(void **)&tbb_ops.pool_malloc =
77-
dlsym(tbb_handle, "_ZN3rml11pool_mallocEPNS_10MemoryPoolEm");
78-
*(void **)&tbb_ops.pool_realloc =
79-
dlsym(tbb_handle, "_ZN3rml12pool_reallocEPNS_10MemoryPoolEPvm");
80-
*(void **)&tbb_ops.pool_aligned_malloc =
81-
dlsym(tbb_handle, "_ZN3rml19pool_aligned_mallocEPNS_10MemoryPoolEmm");
82-
*(void **)&tbb_ops.pool_free =
83-
dlsym(tbb_handle, "_ZN3rml9pool_freeEPNS_10MemoryPoolEPv");
84-
*(void **)&tbb_ops.pool_create_v1 = dlsym(
85-
tbb_handle,
74+
*(void **)&tbb_callbacks->pool_malloc = dlsym(
75+
tbb_callbacks->lib_handle, "_ZN3rml11pool_mallocEPNS_10MemoryPoolEm");
76+
*(void **)&tbb_callbacks->pool_realloc =
77+
dlsym(tbb_callbacks->lib_handle,
78+
"_ZN3rml12pool_reallocEPNS_10MemoryPoolEPvm");
79+
*(void **)&tbb_callbacks->pool_aligned_malloc =
80+
dlsym(tbb_callbacks->lib_handle,
81+
"_ZN3rml19pool_aligned_mallocEPNS_10MemoryPoolEmm");
82+
*(void **)&tbb_callbacks->pool_free = dlsym(
83+
tbb_callbacks->lib_handle, "_ZN3rml9pool_freeEPNS_10MemoryPoolEPv");
84+
*(void **)&tbb_callbacks->pool_create_v1 = dlsym(
85+
tbb_callbacks->lib_handle,
8686
"_ZN3rml14pool_create_v1ElPKNS_13MemPoolPolicyEPPNS_10MemoryPoolE");
87-
*(void **)&tbb_ops.pool_destroy =
88-
dlsym(tbb_handle, "_ZN3rml12pool_destroyEPNS_10MemoryPoolE");
89-
*(void **)&tbb_ops.pool_identify =
90-
dlsym(tbb_handle, "_ZN3rml13pool_identifyEPv");
91-
*(void **)&tbb_ops.pool_msize =
92-
dlsym(tbb_handle, "_ZN3rml10pool_msizeEPNS_10MemoryPoolEPv");
93-
94-
if (!tbb_ops.pool_malloc || !tbb_ops.pool_realloc ||
95-
!tbb_ops.pool_aligned_malloc || !tbb_ops.pool_free ||
96-
!tbb_ops.pool_create_v1 || !tbb_ops.pool_destroy ||
97-
!tbb_ops.pool_identify) {
87+
*(void **)&tbb_callbacks->pool_destroy = dlsym(
88+
tbb_callbacks->lib_handle, "_ZN3rml12pool_destroyEPNS_10MemoryPoolE");
89+
*(void **)&tbb_callbacks->pool_identify =
90+
dlsym(tbb_callbacks->lib_handle, "_ZN3rml13pool_identifyEPv");
91+
*(void **)&tbb_callbacks->pool_msize = dlsym(
92+
tbb_callbacks->lib_handle, "_ZN3rml10pool_msizeEPNS_10MemoryPoolEPv");
93+
94+
if (!tbb_callbacks->pool_malloc || !tbb_callbacks->pool_realloc ||
95+
!tbb_callbacks->pool_aligned_malloc || !tbb_callbacks->pool_free ||
96+
!tbb_callbacks->pool_create_v1 || !tbb_callbacks->pool_destroy ||
97+
!tbb_callbacks->pool_identify) {
9898
fprintf(stderr, "Could not find symbols in %s.\n", so_name);
99-
dlclose(tbb_handle);
100-
Init_tbb_global_state_failed = true;
101-
return;
99+
dlclose(tbb_callbacks->lib_handle);
100+
return -1;
102101
}
103102

104-
g_tbb_ops = tbb_ops;
103+
return 0;
105104
}
106105

107106
static void *tbb_raw_alloc_wrapper(intptr_t pool_id, size_t *raw_bytes) {
108107
void *resPtr;
109-
struct tbb_memory_pool *pool = (struct tbb_memory_pool *)pool_id;
108+
tbb_memory_pool_t *pool = (tbb_memory_pool_t *)pool_id;
110109
umf_result_t ret =
111110
umfMemoryProviderAlloc(pool->mem_provider, *raw_bytes, 0, &resPtr);
112111
if (ret != UMF_RESULT_SUCCESS) {
@@ -118,7 +117,7 @@ static void *tbb_raw_alloc_wrapper(intptr_t pool_id, size_t *raw_bytes) {
118117
}
119118

120119
static void tbb_raw_free_wrapper(intptr_t pool_id, void *ptr, size_t bytes) {
121-
struct tbb_memory_pool *pool = (struct tbb_memory_pool *)pool_id;
120+
tbb_memory_pool_t *pool = (tbb_memory_pool_t *)pool_id;
122121
umf_result_t ret = umfMemoryProviderFree(pool->mem_provider, ptr, bytes);
123122
if (ret != UMF_RESULT_SUCCESS) {
124123
TLS_last_free_error = ret;
@@ -134,30 +133,30 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
134133
(void)params; // unused
135134

136135
const size_t GRANULARITY = 2 * 1024 * 1024;
137-
struct mem_pool_policy_s policy = {.pAlloc = tbb_raw_alloc_wrapper,
138-
.pFree = tbb_raw_free_wrapper,
139-
.granularity = GRANULARITY,
140-
.version = 1,
141-
.fixed_pool = false,
142-
.keep_all_memory = false,
143-
.reserved = 0};
144-
145-
util_init_once(&tbb_is_initialized, init_tbb_global_state);
146-
if (Init_tbb_global_state_failed) {
147-
fprintf(stderr, "loading TBB symbols failed\n");
148-
return UMF_RESULT_ERROR_UNKNOWN;
149-
}
150-
151-
struct tbb_memory_pool *pool_data =
152-
umf_ba_global_alloc(sizeof(struct tbb_memory_pool));
136+
tbb_mem_pool_policy_t policy = {.pAlloc = tbb_raw_alloc_wrapper,
137+
.pFree = tbb_raw_free_wrapper,
138+
.granularity = GRANULARITY,
139+
.version = 1,
140+
.fixed_pool = false,
141+
.keep_all_memory = false,
142+
.reserved = 0};
143+
144+
tbb_memory_pool_t *pool_data =
145+
umf_ba_global_alloc(sizeof(tbb_memory_pool_t));
153146
if (!pool_data) {
154147
fprintf(stderr, "cannot allocate memory for metadata\n");
155148
return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
156149
}
157150

151+
int ret = init_tbb_callbacks(&pool_data->tbb_callbacks);
152+
if (ret != 0) {
153+
fprintf(stderr, "loading TBB symbols failed\n");
154+
return UMF_RESULT_ERROR_UNKNOWN;
155+
}
156+
158157
pool_data->mem_provider = provider;
159-
int ret = g_tbb_ops.pool_create_v1((intptr_t)pool_data, &policy,
160-
&(pool_data->tbb_pool));
158+
ret = pool_data->tbb_callbacks.pool_create_v1((intptr_t)pool_data, &policy,
159+
&(pool_data->tbb_pool));
161160
if (ret != TBBMALLOC_OK) {
162161
return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
163162
}
@@ -168,16 +167,16 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
168167
}
169168

170169
static void tbb_pool_finalize(void *pool) {
171-
util_init_once(&tbb_is_initialized, init_tbb_global_state);
172-
struct tbb_memory_pool *pool_data = (struct tbb_memory_pool *)pool;
173-
g_tbb_ops.pool_destroy(pool_data->tbb_pool);
174-
umf_ba_global_free(pool_data, sizeof(struct tbb_memory_pool));
170+
tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
171+
pool_data->tbb_callbacks.pool_destroy(pool_data->tbb_pool);
172+
dlclose(pool_data->tbb_callbacks.lib_handle);
173+
umf_ba_global_free(pool_data, sizeof(tbb_memory_pool_t));
175174
}
176175

177176
static void *tbb_malloc(void *pool, size_t size) {
178-
struct tbb_memory_pool *pool_data = (struct tbb_memory_pool *)pool;
177+
tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
179178
TLS_last_allocation_error = UMF_RESULT_SUCCESS;
180-
void *ptr = g_tbb_ops.pool_malloc(pool_data->tbb_pool, size);
179+
void *ptr = pool_data->tbb_callbacks.pool_malloc(pool_data->tbb_pool, size);
181180
if (ptr == NULL) {
182181
if (TLS_last_allocation_error == UMF_RESULT_SUCCESS) {
183182
TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
@@ -202,9 +201,10 @@ static void *tbb_calloc(void *pool, size_t num, size_t size) {
202201
}
203202

204203
static void *tbb_realloc(void *pool, void *ptr, size_t size) {
205-
struct tbb_memory_pool *pool_data = (struct tbb_memory_pool *)pool;
204+
tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
206205
TLS_last_allocation_error = UMF_RESULT_SUCCESS;
207-
void *new_ptr = g_tbb_ops.pool_realloc(pool_data->tbb_pool, ptr, size);
206+
void *new_ptr =
207+
pool_data->tbb_callbacks.pool_realloc(pool_data->tbb_pool, ptr, size);
208208
if (new_ptr == NULL) {
209209
if (TLS_last_allocation_error == UMF_RESULT_SUCCESS) {
210210
TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
@@ -216,10 +216,10 @@ static void *tbb_realloc(void *pool, void *ptr, size_t size) {
216216
}
217217

218218
static void *tbb_aligned_malloc(void *pool, size_t size, size_t alignment) {
219-
struct tbb_memory_pool *pool_data = (struct tbb_memory_pool *)pool;
219+
tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
220220
TLS_last_allocation_error = UMF_RESULT_SUCCESS;
221-
void *ptr =
222-
g_tbb_ops.pool_aligned_malloc(pool_data->tbb_pool, size, alignment);
221+
void *ptr = pool_data->tbb_callbacks.pool_aligned_malloc(
222+
pool_data->tbb_pool, size, alignment);
223223
if (ptr == NULL) {
224224
if (TLS_last_allocation_error == UMF_RESULT_SUCCESS) {
225225
TLS_last_allocation_error = UMF_RESULT_ERROR_UNKNOWN;
@@ -243,8 +243,8 @@ static umf_result_t tbb_free(void *pool, void *ptr) {
243243
// other threads.
244244
utils_annotate_release(pool);
245245

246-
struct tbb_memory_pool *pool_data = (struct tbb_memory_pool *)pool;
247-
if (g_tbb_ops.pool_free(pool_data->tbb_pool, ptr)) {
246+
tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
247+
if (pool_data->tbb_callbacks.pool_free(pool_data->tbb_pool, ptr)) {
248248
return UMF_RESULT_SUCCESS;
249249
}
250250

@@ -256,8 +256,8 @@ static umf_result_t tbb_free(void *pool, void *ptr) {
256256
}
257257

258258
static size_t tbb_malloc_usable_size(void *pool, void *ptr) {
259-
struct tbb_memory_pool *pool_data = (struct tbb_memory_pool *)pool;
260-
return g_tbb_ops.pool_msize(pool_data->tbb_pool, ptr);
259+
tbb_memory_pool_t *pool_data = (tbb_memory_pool_t *)pool;
260+
return pool_data->tbb_callbacks.pool_msize(pool_data->tbb_pool, ptr);
261261
}
262262

263263
static umf_result_t tbb_get_last_allocation_error(void *pool) {

0 commit comments

Comments
 (0)