NEW

Author: KFilipek

.github/workflows/reusable_compatibility.yml

@@ -228,7 +228,7 @@ jobs:
 
     - name: Run disabled tests individually with latest UMF libs (warnings enabled)
       working-directory: ${{github.workspace}}/tag_version/build
-      run: >
+      run: |
         $env:UMF_LOG="level:warning;flush:debug;output:stderr;pid:no"
         cp ${{github.workspace}}/latest_version/build/bin/Debug/umf.dll ${{github.workspace}}/tag_version/build/bin/Debug/umf.dll
         # Run the test_disjoint_pool with the latest UMF libs, excluding disjoint pool internals

include/umf/base.h

@@ -30,6 +30,12 @@ extern "C" {
 /// @brief Current version of the UMF headers
 #define UMF_VERSION_CURRENT UMF_MAKE_VERSION(1, 0)
 
+// Is current version below specified version?
+#define UMF_VERSION_BELOW(_major, _minor)                                      \
+    (UMF_MAJOR_VERSION(UMF_VERSION_CURRENT) < (_major) ||                     \
+     (UMF_MAJOR_VERSION(UMF_VERSION_CURRENT) == (_major) &&                   \
+      UMF_MINOR_VERSION(UMF_VERSION_CURRENT) < (_minor)))                       \
+
 /// @brief Operation results
 typedef enum umf_result_t {
     UMF_RESULT_SUCCESS = 0, ///< Success

include/umf/memory_pool_ops.h

@@ -194,7 +194,8 @@ typedef struct umf_memory_pool_ops_t {
     /// @brief Post-initializes and set up memory pool.
     ///
     /// \details
-    /// * This function must be implemented if the pool/provider supports CTL that overrides defaults
+    /// * This function *must* be implemented if the pool/provider supports CTL that overrides defaults.
+    /// * This function *must* free any resources allocated in the function.
     /// * This function *must* be called after the memory pool has been allocated in initialize function
     ///        and is used to perform any additional setup required by the memory pool.
     /// * This function *may* be used to set up any additional resources required by the memory pool.

include/umf/memory_provider_ops.h

@@ -278,6 +278,8 @@ typedef struct umf_memory_provider_ops_t {
                             const char *name, void *arg, size_t size,
                             umf_ctl_query_type_t queryType, va_list args);
 
+    // The following operations were added in ops version 1.1
+
     ///
     /// @brief Post-initializes memory provider.
     /// @param params provider-specific params, or NULL for defaults

src/memory_pool.c

@@ -265,8 +265,8 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
 
         // Create a new ops compatible structure with the current version
         memset(&compatible_ops, 0, sizeof(compatible_ops));
-        if (UMF_MINOR_VERSION(ops->version) == 0) {
-            LOG_INFO("Detected 1.0 version of Memory Pool ops, "
+        if(UMF_VERSION_BELOW(1, 1)) {
+            LOG_INFO("Detected 1.0 version or below of Memory Pool ops, "
                      "upgrading to current version");
             memcpy(&compatible_ops, ops,
                    offsetof(umf_memory_pool_ops_t, ext_trim_memory));
@@ -344,8 +344,7 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
         }
     }
 
-    ret =
-        pool->ops.ext_post_initialize(pool->pool_priv);
+    ret = pool->ops.ext_post_initialize(pool->pool_priv);
     if (ret != UMF_RESULT_SUCCESS) {
         LOG_ERR("Failed to post-initialize pool");
         goto err_pool_init;

src/pool/pool_disjoint.c

@@ -763,8 +763,7 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
     return UMF_RESULT_SUCCESS;
 }
 
-umf_result_t
-disjoint_pool_post_initialize(void *ppPool) {
+umf_result_t disjoint_pool_post_initialize(void *ppPool) {
     disjoint_pool_t *disjoint_pool = (disjoint_pool_t *)ppPool;
 
     disjoint_pool->known_slabs = critnib_new(free_slab, NULL);

src/pool/pool_jemalloc.c

@@ -446,7 +446,7 @@ static umf_result_t op_initialize(umf_memory_provider_handle_t provider,
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
     memset(pool, 0, sizeof(*pool));
-    
+
     pool->provider = provider;
     if (params) {
         pool->params = *(const umf_jemalloc_pool_params_t *)params;
@@ -455,7 +455,7 @@ static umf_result_t op_initialize(umf_memory_provider_handle_t provider,
         memset(&pool->params, 0, sizeof(pool->params));
         strncpy(pool->params.name, DEFAULT_NAME, sizeof(pool->params.name) - 1);
     }
-    
+
     *out_pool = pool;
 
     return UMF_RESULT_SUCCESS;

src/pool/pool_proxy.c

@@ -39,8 +39,7 @@ proxy_pool_initialize(umf_memory_provider_handle_t hProvider,
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t
-proxy_pool_post_initialize(void *ppPool) {
+static umf_result_t proxy_pool_post_initialize(void *ppPool) {
     (void)ppPool;
     return UMF_RESULT_SUCCESS;
 }

src/pool/pool_scalable.c

@@ -301,24 +301,24 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
 
     memset(pool_data, 0, sizeof(*pool_data));
     pool_data->mem_provider = provider;
-    
+
     if (params) {
         pool_data->params = *(const umf_scalable_pool_params_t *)params;
     } else {
         // Set default values
         memset(&pool_data->params, 0, sizeof(pool_data->params));
         pool_data->params.granularity = DEFAULT_GRANULARITY;
         pool_data->params.keep_all_memory = false;
-        strncpy(pool_data->params.name, DEFAULT_NAME, sizeof(pool_data->params.name) - 1);
+        strncpy(pool_data->params.name, DEFAULT_NAME,
+                sizeof(pool_data->params.name) - 1);
     }
 
     *pool = (void *)pool_data;
 
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t
-tbb_pool_post_initialize(void *pool) {
+static umf_result_t tbb_pool_post_initialize(void *pool) {
     tbb_mem_pool_policy_t policy = {.pAlloc = tbb_raw_alloc_wrapper,
                                     .pFree = tbb_raw_free_wrapper,
                                     .granularity = DEFAULT_GRANULARITY,
@@ -335,7 +335,7 @@ tbb_pool_post_initialize(void *pool) {
 
     const umf_scalable_pool_params_t *scalable_params = &pool_data->params;
     const char *pool_name = scalable_params->name;
-    
+
     // Use stored params
     policy.granularity = scalable_params->granularity;
     policy.keep_all_memory = scalable_params->keep_all_memory;