Call check_if_tracker_is_empty() conditionally

Call check_if_tracker_is_empty() inside trackingFinalize()
only if the provider supports the free() operation.

Signed-off-by: Lukasz Dorau <[email protected]>

Author: ldorau

src/memory_pool.c

@@ -41,8 +41,12 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
     assert(ops->version == UMF_VERSION_CURRENT);
 
     if (!(flags & UMF_POOL_CREATE_FLAG_DISABLE_TRACKING)) {
-        // wrap provider with memory tracking provider
-        ret = umfTrackingMemoryProviderCreate(provider, pool, &pool->provider);
+        // Wrap provider with memory tracking provider.
+        // Check if the provider supports the free() operation.
+        bool upstreamFrees = (umfMemoryProviderFree(provider, NULL, 0) !=
+                              UMF_RESULT_ERROR_NOT_SUPPORTED);
+        ret = umfTrackingMemoryProviderCreate(provider, pool, &pool->provider,
+                                              upstreamFrees);
         if (ret != UMF_RESULT_SUCCESS) {
             goto err_provider_create;
         }

src/provider/provider_tracking.c

@@ -141,6 +141,8 @@ typedef struct umf_tracking_memory_provider_t {
     umf_memory_tracker_handle_t hTracker;
     umf_memory_pool_handle_t pool;
     critnib *ipcCache;
+    // the upstream provider supports the free() operation
+    bool upstreamFrees;
 } umf_tracking_memory_provider_t;
 
 typedef struct umf_tracking_memory_provider_t umf_tracking_memory_provider_t;
@@ -434,7 +436,9 @@ static void trackingFinalize(void *provider) {
         (umf_tracking_memory_provider_t *)provider;
     critnib_delete(p->ipcCache);
 #ifndef NDEBUG
-    check_if_tracker_is_empty(p->hTracker, p->pool);
+    if (p->upstreamFrees) {
+        check_if_tracker_is_empty(p->hTracker, p->pool);
+    }
 #endif /* NDEBUG */
 
     umf_ba_global_free(provider);
@@ -661,10 +665,11 @@ umf_memory_provider_ops_t UMF_TRACKING_MEMORY_PROVIDER_OPS = {
 
 umf_result_t umfTrackingMemoryProviderCreate(
     umf_memory_provider_handle_t hUpstream, umf_memory_pool_handle_t hPool,
-    umf_memory_provider_handle_t *hTrackingProvider) {
+    umf_memory_provider_handle_t *hTrackingProvider, bool upstreamFrees) {
 
     umf_tracking_memory_provider_t params;
     params.hUpstream = hUpstream;
+    params.upstreamFrees = upstreamFrees;
     params.hTracker = TRACKER;
     if (!params.hTracker) {
         LOG_ERR("failed, TRACKER is NULL");

src/provider/provider_tracking.h

@@ -11,6 +11,7 @@
 #define UMF_MEMORY_TRACKER_INTERNAL_H 1
 
 #include <assert.h>
+#include <stdbool.h>
 #include <stdlib.h>
 
 #include <umf/base.h>
@@ -53,7 +54,7 @@ umf_result_t umfMemoryTrackerGetAllocInfo(const void *ptr,
 // forwards all requests to hUpstream memory Provider. hUpstream lifetime should be managed by the user of this function.
 umf_result_t umfTrackingMemoryProviderCreate(
     umf_memory_provider_handle_t hUpstream, umf_memory_pool_handle_t hPool,
-    umf_memory_provider_handle_t *hTrackingProvider);
+    umf_memory_provider_handle_t *hTrackingProvider, bool upstreamFrees);
 
 void umfTrackingMemoryProviderGetUpstreamProvider(
     umf_memory_provider_handle_t hTrackingProvider,

test/memoryPoolAPI.cpp

@@ -139,7 +139,8 @@ TEST_P(umfPoolWithCreateFlagsTest, memoryPoolWithCustomProvider) {
 }
 
 TEST_F(test, retrieveMemoryProvider) {
-    umf_memory_provider_handle_t provider = (umf_memory_provider_handle_t)0x1;
+    auto nullProvider = umf_test::wrapProviderUnique(nullProviderCreate());
+    umf_memory_provider_handle_t provider = nullProvider.get();
 
     auto pool =
         wrapPoolUnique(createPoolChecked(umfProxyPoolOps(), provider, nullptr));
@@ -258,7 +259,8 @@ TEST_P(poolInitializeTest, errorPropagation) {
 }
 
 TEST_F(test, retrieveMemoryProvidersError) {
-    umf_memory_provider_handle_t provider = (umf_memory_provider_handle_t)0x1;
+    auto nullProvider = umf_test::wrapProviderUnique(nullProviderCreate());
+    umf_memory_provider_handle_t provider = nullProvider.get();
 
     auto pool =
         wrapPoolUnique(createPoolChecked(umfProxyPoolOps(), provider, nullptr));

test/pools/disjoint_pool.cpp

@@ -82,7 +82,10 @@ TEST_F(test, sharedLimits) {
         }
         umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
             ::free(ptr);
-            numFrees++;
+            // umfMemoryProviderFree(provider, NULL, 0) is called inside umfPoolCreateInternal()
+            if (ptr != NULL && size != 0) {
+                numFrees++;
+            }
             return UMF_RESULT_SUCCESS;
         }
     };