Update jemalloc pool params implementation

Author: vinser52

examples/dram_and_fsdax/dram_and_fsdax.c

@@ -67,19 +67,35 @@ static umf_memory_pool_handle_t create_fsdax_pool(const char *path) {
     // so it should be used with a pool manager that will take over
     // the managing of the provided memory - for example the jemalloc pool
     // with the `disable_provider_free` parameter set to true.
-    umf_jemalloc_pool_params_t pool_params;
-    pool_params.disable_provider_free = true;
+    umf_jemalloc_pool_params_handle_t pool_params;
+    umf_result = umfJemallocPoolParamsCreate(&pool_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create jemalloc params!\n");
+        umfMemoryProviderDestroy(provider_fsdax);
+        return NULL;
+    }
+    umf_result = umfJemallocPoolParamsSetKeepAllMemory(pool_params, true);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to set KeepAllMemory!\n");
+        umfMemoryProviderDestroy(provider_fsdax);
+        return NULL;
+    }
 
     // Create an FSDAX memory pool
     umf_result =
-        umfPoolCreate(umfJemallocPoolOps(), provider_fsdax, &pool_params,
+        umfPoolCreate(umfJemallocPoolOps(), provider_fsdax, pool_params,
                       UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &pool_fsdax);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "Failed to create an FSDAX memory pool!\n");
         umfMemoryProviderDestroy(provider_fsdax);
         return NULL;
     }
 
+    umf_result = umfJemallocPoolParamsDestroy(pool_params);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to destroy jemalloc params!\n");
+    }
+
     return pool_fsdax;
 }
 

include/umf/pools/pool_jemalloc.h

@@ -17,11 +17,31 @@ extern "C" {
 #include <stdbool.h>
 #include <umf/memory_pool_ops.h>
 
-/// @brief Configuration of Jemalloc Pool
-typedef struct umf_jemalloc_pool_params_t {
-    /// Set to true if umfMemoryProviderFree() should never be called.
-    bool disable_provider_free;
-} umf_jemalloc_pool_params_t;
+struct umf_jemalloc_pool_params_t;
+
+/// @brief handle to the parameters of the jemalloc pool.
+typedef struct umf_jemalloc_pool_params_t *umf_jemalloc_pool_params_handle_t;
+
+/// @brief  Create a struct to store parameters of jemalloc pool.
+/// @param  hParams [out] handle to the newly created parameters struct.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfJemallocPoolParamsCreate(umf_jemalloc_pool_params_handle_t *hParams);
+
+/// @brief  Destroy parameters struct.
+/// @param  hParams handle to the parameters of the jemalloc pool.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfJemallocPoolParamsDestroy(umf_jemalloc_pool_params_handle_t hParams);
+
+/// @brief  Set if \p umfMemoryProviderFree() should never be called..
+/// @param  hParams handle to the parameters of the scalable pool.
+/// @param  keepAllMemory \p true if the jemalloc pool should not call
+/// \p umfMemoryProviderFree, \p false otherwise.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfJemallocPoolParamsSetKeepAllMemory(umf_jemalloc_pool_params_handle_t hParams,
+                                      bool keepAllMemory);
 
 umf_memory_pool_ops_t *umfJemallocPoolOps(void);
 

src/pool/pool_jemalloc.c

@@ -41,6 +41,12 @@ typedef struct jemalloc_memory_pool_t {
     bool disable_provider_free;
 } jemalloc_memory_pool_t;
 
+// Configuration of Jemalloc Pool
+typedef struct umf_jemalloc_pool_params_t {
+    /// Set to true if umfMemoryProviderFree() should never be called.
+    bool disable_provider_free;
+} umf_jemalloc_pool_params_t;
+
 static __TLS umf_result_t TLS_last_allocation_error;
 
 static jemalloc_memory_pool_t *pool_by_arena_index[MALLCTL_ARENAS_ALL];
@@ -53,6 +59,52 @@ static jemalloc_memory_pool_t *get_pool_by_arena_index(unsigned arena_ind) {
     return pool_by_arena_index[arena_ind];
 }
 
+umf_result_t
+umfJemallocPoolParamsCreate(umf_jemalloc_pool_params_handle_t *hParams) {
+    if (!hParams) {
+        LOG_ERR("jemalloc pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_jemalloc_pool_params_t *params_data =
+        umf_ba_global_alloc(sizeof(umf_jemalloc_pool_params_t));
+    if (!params_data) {
+        LOG_ERR("cannot allocate memory for jemalloc poolparams");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    params_data->disable_provider_free = false;
+
+    *hParams = (umf_jemalloc_pool_params_handle_t)params_data;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfJemallocPoolParamsDestroy(umf_jemalloc_pool_params_handle_t hParams) {
+    if (!hParams) {
+        LOG_ERR("jemalloc pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_ba_global_free(hParams);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfJemallocPoolParamsSetKeepAllMemory(umf_jemalloc_pool_params_handle_t hParams,
+                                      bool keepAllMemory) {
+    if (!hParams) {
+        LOG_ERR("jemalloc pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    hParams->disable_provider_free = keepAllMemory;
+
+    return UMF_RESULT_SUCCESS;
+}
+
 // arena_extent_alloc - an extent allocation function conforms to the extent_alloc_t type and upon
 // success returns a pointer to size bytes of mapped memory on behalf of arena arena_ind such that
 // the extent's base address is a multiple of alignment, as well as setting *zero to indicate
@@ -401,8 +453,8 @@ static umf_result_t op_initialize(umf_memory_provider_handle_t provider,
     assert(provider);
     assert(out_pool);
 
-    umf_jemalloc_pool_params_t *je_params =
-        (umf_jemalloc_pool_params_t *)params;
+    umf_jemalloc_pool_params_handle_t je_params =
+        (umf_jemalloc_pool_params_handle_t)params;
 
     extent_hooks_t *pHooks = &arena_extent_hooks;
     size_t unsigned_size = sizeof(unsigned);