Introduce config params for scalable pool

Author: vinser52

include/umf/pools/pool_scalable.h

@@ -14,9 +14,47 @@
 extern "C" {
 #endif
 
+#include <stdbool.h>
+
 #include <umf/memory_pool.h>
 #include <umf/memory_provider.h>
 
+struct umf_scalable_pool_params_t;
+
+/// @brief handle to the parameters of the scalable pool.
+typedef struct umf_scalable_pool_params_t *umf_scalable_pool_params_handle_t;
+
+/// @brief  Create a struct to store parameters of scalable 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
+umfScalablePoolParamsCreate(umf_scalable_pool_params_handle_t *hParams);
+
+/// @brief  Destroy parameters struct.
+/// @param  hParams handle to the parameters of the scalable pool.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfScalablePoolParamsDestroy(umf_scalable_pool_params_handle_t hParams);
+
+/// @brief  Set granularity of allocations that scalable pool requests from a memory provider.
+/// @param  hParams handle to the parameters of the scalable pool.
+/// @param  granularity granularity in bytes.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfScalablePoolParamsSetGranularity(umf_scalable_pool_params_handle_t hParams,
+                                    size_t granularity);
+
+/// @brief  Set if scalable pool should keep all memory allocated from memory provider till destruction.
+/// @param  hParams handle to the parameters of the scalable pool.
+/// @param  keepAllMemory \p true if the scalable pool should not call
+/// \p umfMemoryProviderFree until it is destroyed, \p false otherwise.
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t
+umfScalablePoolParamsSetKeepAllMemory(umf_scalable_pool_params_handle_t hParams,
+                                      bool keepAllMemory);
+
+/// @brief  Return \p ops structure containing pointers to the scalable pool implementation.
+/// @return pointer to the \p umf_memory_pool_ops_t struct.
 umf_memory_pool_ops_t *umfScalablePoolOps(void);
 
 #ifdef __cplusplus

src/libumf.def

@@ -82,3 +82,7 @@ EXPORTS
     umfProxyPoolOps
     umfPutIPCHandle
     umfScalablePoolOps
+    umfScalablePoolParamsCreate
+    umfScalablePoolParamsDestroy
+    umfScalablePoolParamsSetGranularity
+    umfScalablePoolParamsSetKeepAllMemory

src/libumf.map

@@ -76,6 +76,10 @@ UMF_1.0 {
         umfProxyPoolOps;
         umfPutIPCHandle;
         umfScalablePoolOps;
+        umfScalablePoolParamsCreate;
+        umfScalablePoolParamsDestroy;
+        umfScalablePoolParamsSetGranularity;
+        umfScalablePoolParamsSetKeepAllMemory;
     local:
         *;
 };

src/pool/pool_scalable.c

@@ -31,6 +31,7 @@ typedef void (*raw_free_tbb_type)(intptr_t, void *, size_t);
 static __TLS umf_result_t TLS_last_allocation_error;
 static __TLS umf_result_t TLS_last_free_error;
 
+static const size_t DEFAULT_GRANULARITY = 2 * 1024 * 1024; // 2MB
 typedef struct tbb_mem_pool_policy_t {
     raw_alloc_tbb_type pAlloc;
     raw_free_tbb_type pFree;
@@ -39,6 +40,11 @@ typedef struct tbb_mem_pool_policy_t {
     unsigned fixed_pool : 1, keep_all_memory : 1, reserved : 30;
 } tbb_mem_pool_policy_t;
 
+typedef struct umf_scalable_pool_params_t {
+    size_t granularity;
+    bool keep_all_memory;
+} umf_scalable_pool_params_t;
+
 typedef struct tbb_callbacks_t {
     void *(*pool_malloc)(void *, size_t);
     void *(*pool_realloc)(void *, void *, size_t);
@@ -167,19 +173,88 @@ static void tbb_raw_free_wrapper(intptr_t pool_id, void *ptr, size_t bytes) {
     }
 }
 
+umf_result_t
+umfScalablePoolParamsCreate(umf_scalable_pool_params_handle_t *params) {
+    if (!params) {
+        LOG_ERR("scalable pool params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_scalable_pool_params_t *params_data =
+        umf_ba_global_alloc(sizeof(umf_scalable_pool_params_t));
+    if (!params_data) {
+        LOG_ERR("cannot allocate memory for scalable poolparams");
+        return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    params_data->granularity = DEFAULT_GRANULARITY;
+    params_data->keep_all_memory = false;
+
+    *params = (umf_scalable_pool_params_handle_t)params_data;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfScalablePoolParamsDestroy(umf_scalable_pool_params_handle_t params) {
+    if (!params) {
+        LOG_ERR("params is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_ba_global_free(params);
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfScalablePoolParamsSetGranularity(umf_scalable_pool_params_handle_t params,
+                                    size_t granularity) {
+    if (!params) {
+        LOG_ERR("params is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    if (granularity == 0) {
+        LOG_ERR("granularity cannot be 0");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    params->granularity = granularity;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t
+umfScalablePoolParamsSetKeepAllMemory(umf_scalable_pool_params_handle_t params,
+                                      bool keep_all_memory) {
+    if (!params) {
+        LOG_ERR("params is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    params->keep_all_memory = keep_all_memory;
+
+    return UMF_RESULT_SUCCESS;
+}
+
 static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
                                         void *params, void **pool) {
-    (void)params; // unused
-
-    const size_t GRANULARITY = 2 * 1024 * 1024;
     tbb_mem_pool_policy_t policy = {.pAlloc = tbb_raw_alloc_wrapper,
                                     .pFree = tbb_raw_free_wrapper,
-                                    .granularity = GRANULARITY,
+                                    .granularity = DEFAULT_GRANULARITY,
                                     .version = 1,
                                     .fixed_pool = false,
                                     .keep_all_memory = false,
                                     .reserved = 0};
 
+    if (params) {
+        umf_scalable_pool_params_handle_t scalable_params =
+            (umf_scalable_pool_params_handle_t)params;
+        policy.granularity = scalable_params->granularity;
+        policy.keep_all_memory = scalable_params->keep_all_memory;
+    }
+
     tbb_memory_pool_t *pool_data =
         umf_ba_global_alloc(sizeof(tbb_memory_pool_t));
     if (!pool_data) {