Skip to content

Commit 6d5b0c0

Browse files
bratpiorkabratpiorka
committed
implement umfPoolTrimMemory
1 parent e05b3a7 commit 6d5b0c0

17 files changed

+294
-26
lines changed

‎include/umf/memory_pool.h

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -196,6 +196,16 @@ umf_result_t umfPoolSetTag(umf_memory_pool_handle_t hPool, void *tag,
196196
/// @return UMF_RESULT_SUCCESS on success.
197197
umf_result_t umfPoolGetTag(umf_memory_pool_handle_t hPool, void **tag);
198198

199+
///
200+
/// @brief Trims memory of the pool, removing resources that are not needed
201+
/// to keep the pool operational.
202+
/// @param hPool specified memory pool
203+
/// @param minBytesToKeep minimum number of bytes to keep in the pool (if
204+
/// possible)
205+
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
206+
umf_result_t umfPoolTrimMemory(umf_memory_pool_handle_t hPool,
207+
size_t minBytesToKeep);
208+
199209
#ifdef __cplusplus
200210
}
201211
#endif

‎include/umf/memory_pool_ops.h

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ extern "C" {
2222
/// @brief Version of the Memory Pool ops structure.
2323
/// NOTE: This is equal to the latest UMF version, in which the ops structure
2424
/// has been modified.
25-
#define UMF_POOL_OPS_VERSION_CURRENT UMF_MAKE_VERSION(1, 0)
25+
#define UMF_POOL_OPS_VERSION_CURRENT UMF_MAKE_VERSION(1, 1)
2626

2727
///
2828
/// @brief This structure comprises function pointers used by corresponding umfPool*
@@ -166,6 +166,16 @@ typedef struct umf_memory_pool_ops_t {
166166
const char *name, void *arg, size_t size,
167167
umf_ctl_query_type_t queryType, va_list args);
168168

169+
///
170+
/// @brief Trims memory of the pool, removing resources that are not needed
171+
/// to keep the pool operational.
172+
/// @param pool pointer to the memory pool
173+
/// @param minBytesToKeep minimum number of bytes to keep in the pool (if
174+
/// possible)
175+
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on
176+
/// failure.
177+
///
178+
umf_result_t (*ext_trim_memory)(void *pool, size_t minBytesToKeep);
169179
} umf_memory_pool_ops_t;
170180

171181
#ifdef __cplusplus

‎src/libumf.def

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -152,4 +152,5 @@ EXPORTS
152152
umfJemallocPoolParamsSetName
153153
umfLevelZeroMemoryProviderParamsSetName
154154
umfOsMemoryProviderParamsSetName
155+
umfPoolTrimMemory
155156
umfScalablePoolParamsSetName

‎src/libumf.map

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -150,5 +150,6 @@ UMF_1.1 {
150150
umfJemallocPoolParamsSetName;
151151
umfLevelZeroMemoryProviderParamsSetName;
152152
umfOsMemoryProviderParamsSetName;
153+
umfPoolTrimMemory;
153154
umfScalablePoolParamsSetName;
154155
} UMF_1.0;

‎src/memory_pool.c

Lines changed: 22 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -212,6 +212,13 @@ umfDefaultCtlPoolHandle(void *hPool, umf_ctl_query_source_t operationType,
212212
return UMF_RESULT_ERROR_NOT_SUPPORTED;
213213
}
214214

215+
static umf_result_t umfDefaultTrimMemory(void *provider,
216+
size_t minBytesToKeep) {
217+
(void)provider;
218+
(void)minBytesToKeep;
219+
return UMF_RESULT_ERROR_NOT_SUPPORTED;
220+
}
221+
215222
// logical sum (OR) of all umf_pool_create_flags_t flags
216223
static const umf_pool_create_flags_t UMF_POOL_CREATE_FLAG_ALL =
217224
UMF_POOL_CREATE_FLAG_OWN_PROVIDER | UMF_POOL_CREATE_FLAG_DISABLE_TRACKING;
@@ -233,9 +240,9 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
233240
const void *params,
234241
umf_pool_create_flags_t flags,
235242
umf_memory_pool_handle_t *hPool) {
236-
if (!ops || !provider || !hPool) {
237-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
238-
}
243+
UMF_CHECK((ops != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
244+
UMF_CHECK((provider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
245+
UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
239246

240247
// validate flags
241248
if (flags & ~UMF_POOL_CREATE_FLAG_ALL) {
@@ -278,6 +285,10 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
278285
pool->ops.ext_ctl = umfDefaultCtlPoolHandle;
279286
}
280287

288+
if (NULL == pool->ops.ext_trim_memory) {
289+
pool->ops.ext_trim_memory = umfDefaultTrimMemory;
290+
}
291+
281292
if (NULL == utils_mutex_init(&pool->lock)) {
282293
LOG_ERR("Failed to initialize mutex for pool");
283294
ret = UMF_RESULT_ERROR_UNKNOWN;
@@ -326,10 +337,7 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
326337
}
327338

328339
umf_result_t umfPoolDestroy(umf_memory_pool_handle_t hPool) {
329-
if (hPool == NULL) {
330-
LOG_ERR("memory pool handle is NULL");
331-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
332-
}
340+
UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
333341

334342
if (umf_ba_global_is_destroyed()) {
335343
return UMF_RESULT_ERROR_UNKNOWN;
@@ -509,6 +517,13 @@ umf_result_t umfPoolGetTag(umf_memory_pool_handle_t hPool, void **tag) {
509517
return UMF_RESULT_SUCCESS;
510518
}
511519

520+
umf_result_t umfPoolTrimMemory(umf_memory_pool_handle_t hPool,
521+
size_t minBytesToKeep) {
522+
UMF_CHECK((hPool != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
523+
524+
return hPool->ops.ext_trim_memory(hPool->pool_priv, minBytesToKeep);
525+
}
526+
512527
void umfPoolCtlDefaultsDestroy(void) {
513528
utils_init_once(&mem_pool_ctl_initialized, pool_ctl_init);
514529

‎src/pool/pool_disjoint.c

Lines changed: 40 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -444,11 +444,11 @@ static void bucket_free_chunk(bucket_t *bucket, void *ptr, slab_t *slab,
444444
// remove slab
445445
slab_list_item_t *slab_it = &slab->iter;
446446
assert(slab_it->val != NULL);
447-
pool_unregister_slab(bucket->pool, slab_it->val);
447+
destroy_slab(slab_it->val);
448448
DL_DELETE(bucket->available_slabs, slab_it);
449449
assert(bucket->available_slabs_num > 0);
450450
bucket->available_slabs_num--;
451-
destroy_slab(slab_it->val);
451+
pool_unregister_slab(bucket->pool, slab_it->val);
452452
}
453453
} else {
454454
// return this chunk to the pool
@@ -1133,6 +1133,43 @@ static umf_result_t disjoint_pool_get_name(void *pool, const char **name) {
11331133
return UMF_RESULT_SUCCESS;
11341134
}
11351135

1136+
umf_result_t disjoint_pool_trim_memory(void *pool, size_t minBytesToKeep) {
1137+
assert(pool != NULL);
1138+
disjoint_pool_t *hPool = (disjoint_pool_t *)pool;
1139+
1140+
for (size_t i = 0; i < hPool->buckets_num; i++) {
1141+
bucket_t *bucket = hPool->buckets[i];
1142+
utils_mutex_lock(&bucket->bucket_lock);
1143+
1144+
// remove empty slabs from the pool
1145+
slab_list_item_t *it = NULL, *tmp = NULL;
1146+
LL_FOREACH_SAFE(bucket->available_slabs, it, tmp) {
1147+
slab_t *slab = it->val;
1148+
if (slab->num_chunks_allocated == 0) {
1149+
if (minBytesToKeep >= slab->slab_size) {
1150+
// if we still have bytes to keep, do not remove slab
1151+
minBytesToKeep -= slab->slab_size;
1152+
continue;
1153+
}
1154+
1155+
// remove slab
1156+
destroy_slab(slab);
1157+
DL_DELETE(bucket->available_slabs, it);
1158+
assert(bucket->available_slabs_num > 0);
1159+
bucket->available_slabs_num--;
1160+
pool_unregister_slab(hPool, slab);
1161+
1162+
// update stats
1163+
bucket_update_stats(bucket, 0, -1);
1164+
}
1165+
}
1166+
1167+
utils_mutex_unlock(&bucket->bucket_lock);
1168+
}
1169+
1170+
return UMF_RESULT_SUCCESS;
1171+
}
1172+
11361173
static umf_memory_pool_ops_t UMF_DISJOINT_POOL_OPS = {
11371174
.version = UMF_POOL_OPS_VERSION_CURRENT,
11381175
.initialize = disjoint_pool_initialize,
@@ -1146,6 +1183,7 @@ static umf_memory_pool_ops_t UMF_DISJOINT_POOL_OPS = {
11461183
.get_last_allocation_error = disjoint_pool_get_last_allocation_error,
11471184
.get_name = disjoint_pool_get_name,
11481185
.ext_ctl = disjoint_pool_ctl,
1186+
.ext_trim_memory = disjoint_pool_trim_memory,
11491187
};
11501188

11511189
const umf_memory_pool_ops_t *umfDisjointPoolOps(void) {

‎src/pool/pool_jemalloc.c

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -588,6 +588,28 @@ static umf_result_t op_get_name(void *pool, const char **name) {
588588
return UMF_RESULT_SUCCESS;
589589
}
590590

591+
static umf_result_t op_trim_memory(void *pool, size_t minBytesToKeep) {
592+
// there is no way to tell jemalloc to keep a minimum number of bytes
593+
// so we just purge all arenas
594+
if (minBytesToKeep > 0) {
595+
LOG_WARN("Ignoring minBytesToKeep (%zu) in jemalloc pool",
596+
minBytesToKeep);
597+
}
598+
599+
jemalloc_memory_pool_t *je_pool = (jemalloc_memory_pool_t *)pool;
600+
for (size_t i = 0; i < je_pool->n_arenas; i++) {
601+
char cmd[64];
602+
unsigned arena = je_pool->arena_index[i];
603+
snprintf(cmd, sizeof(cmd), "arena.%u.purge", arena);
604+
if (je_mallctl(cmd, NULL, NULL, NULL, 0)) {
605+
LOG_ERR("Could not purge jemalloc arena %u", arena);
606+
return UMF_RESULT_ERROR_UNKNOWN;
607+
}
608+
}
609+
610+
return UMF_RESULT_SUCCESS;
611+
}
612+
591613
static umf_memory_pool_ops_t UMF_JEMALLOC_POOL_OPS = {
592614
.version = UMF_POOL_OPS_VERSION_CURRENT,
593615
.initialize = op_initialize,
@@ -600,6 +622,7 @@ static umf_memory_pool_ops_t UMF_JEMALLOC_POOL_OPS = {
600622
.free = op_free,
601623
.get_last_allocation_error = op_get_last_allocation_error,
602624
.get_name = op_get_name,
625+
.ext_trim_memory = op_trim_memory,
603626
};
604627

605628
const umf_memory_pool_ops_t *umfJemallocPoolOps(void) {

‎src/pool/pool_proxy.c

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -147,7 +147,9 @@ static umf_memory_pool_ops_t UMF_PROXY_POOL_OPS = {
147147
.malloc_usable_size = proxy_malloc_usable_size,
148148
.free = proxy_free,
149149
.get_last_allocation_error = proxy_get_last_allocation_error,
150-
.get_name = proxy_get_name};
150+
.get_name = proxy_get_name,
151+
.ext_trim_memory = NULL, // not supported
152+
};
151153

152154
const umf_memory_pool_ops_t *umfProxyPoolOps(void) {
153155
return &UMF_PROXY_POOL_OPS;

‎src/pool/pool_scalable.c

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -450,12 +450,14 @@ static umf_result_t tbb_get_last_allocation_error(void *pool) {
450450
return TLS_last_allocation_error;
451451
}
452452

453+
static void initialize_pool_ctl(void) {}
454+
453455
static umf_result_t pool_ctl(void *hPool, umf_ctl_query_source_t operationType,
454456
const char *name, void *arg, size_t size,
455457
umf_ctl_query_type_t query_type, va_list args) {
456458
(void)operationType; // unused
457459
umf_memory_pool_handle_t pool_provider = (umf_memory_pool_handle_t)hPool;
458-
utils_init_once(&ctl_initialized, NULL);
460+
utils_init_once(&ctl_initialized, initialize_pool_ctl);
459461
return ctl_query(&pool_scallable_ctl_root, pool_provider->pool_priv,
460462
CTL_QUERY_PROGRAMMATIC, name, query_type, arg, size, args);
461463
}
@@ -486,6 +488,7 @@ static umf_memory_pool_ops_t UMF_SCALABLE_POOL_OPS = {
486488
.get_last_allocation_error = tbb_get_last_allocation_error,
487489
.ext_ctl = pool_ctl,
488490
.get_name = scalable_get_name,
491+
.ext_trim_memory = NULL, // not supported
489492
};
490493

491494
const umf_memory_pool_ops_t *umfScalablePoolOps(void) {

‎src/utils/utils_posix_concurrency.c

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,11 @@ int utils_mutex_unlock(utils_mutex_t *m) {
3838
}
3939

4040
void utils_init_once(UTIL_ONCE_FLAG *flag, void (*oneCb)(void)) {
41+
if (oneCb == NULL) {
42+
LOG_FATAL("utils_init_once: callback is NULL");
43+
return;
44+
}
45+
4146
pthread_once(flag, oneCb);
4247
}
4348

0 commit comments

Comments
 (0)