Replace trackerShrinkEntry() with trackerRemoveEntry()

ldorau · ldorau · commit 7e4d37ac38c2 · 2025-02-21T14:46:58.000+01:00
Replace trackerShrinkEntry() with trackerRemoveEntry()
and trackerGrowEntry() with trackerAddEntry().

Signed-off-by: Lukasz Dorau &lt;lukasz.dorau@intel.com&gt;
diff --git a/src/provider/provider_fixed_memory.c b/src/provider/provider_fixed_memory.c
@@ -35,7 +35,6 @@ typedef struct fixed_memory_provider_t {
     coarse_t *coarse;   // coarse library handle
 
     // used only when the UMF_FIXED_FLAG_CREATE_FROM_POOL_PTR flag is set
-    size_t ptr_orig_size; // original size of the memory region in the tracker
     umf_memory_provider_handle_t
         trackingProvider; // tracking provider of the original memory pool
 } fixed_memory_provider_t;
@@ -92,7 +91,6 @@ static umf_result_t fixed_allocation_merge_cb(void *provider, void *lowPtr,
 
 static umf_result_t fixed_initialize(void *params, void **provider) {
     umf_result_t ret;
-    size_t ptr_orig_size = 0;
     umf_memory_provider_handle_t trackingProvider = NULL;
 
     if (params == NULL) {
@@ -116,12 +114,11 @@ static umf_result_t fixed_initialize(void *params, void **provider) {
             return ret;
         }
 
-        ret = trackerShrinkEntry(trackingProvider, in_params->ptr,
-                                 in_params->size, &ptr_orig_size);
+        ret = trackerRemoveEntry(trackingProvider, in_params->ptr,
+                                 in_params->size);
         if (ret != UMF_RESULT_SUCCESS) {
-            LOG_ERR(
-                "cannot shrink the allocation %p in the tracker to size %zu",
-                in_params->ptr, in_params->size);
+            LOG_ERR("cannot remove the allocation %p from the tracker",
+                    in_params->ptr);
             return ret;
         }
     }
@@ -158,7 +155,6 @@ static umf_result_t fixed_initialize(void *params, void **provider) {
     fixed_provider->base = in_params->ptr;
     fixed_provider->size = in_params->size;
     fixed_provider->flags = in_params->flags;
-    fixed_provider->ptr_orig_size = ptr_orig_size;
     fixed_provider->trackingProvider = trackingProvider;
 
     // add the entire memory as a single block
@@ -184,16 +180,13 @@ static void fixed_finalize(void *provider) {
     fixed_memory_provider_t *fixed_provider = provider;
     coarse_delete(fixed_provider->coarse);
 
-    if (fixed_provider->trackingProvider &&
-        (fixed_provider->ptr_orig_size >= fixed_provider->size)) {
-        umf_result_t ret = trackerGrowEntry(
-            fixed_provider->trackingProvider, fixed_provider->base,
-            fixed_provider->size, fixed_provider->ptr_orig_size);
+    if (fixed_provider->trackingProvider) {
+        umf_result_t ret =
+            trackerAddEntry(fixed_provider->trackingProvider,
+                            fixed_provider->base, fixed_provider->size);
         if (ret != UMF_RESULT_SUCCESS) {
-            LOG_ERR("cannot grow the allocation %p in the tracker (from size "
-                    "%zu to size %zu)",
-                    fixed_provider->base, fixed_provider->size,
-                    fixed_provider->ptr_orig_size);
+            LOG_ERR("cannot add the allocation %p to the tracker",
+                    fixed_provider->base);
         }
     }
 
diff --git a/src/provider/provider_tracking.c b/src/provider/provider_tracking.c
@@ -267,58 +267,6 @@ static umf_result_t trackingAllocationSplit(void *hProvider, void *ptr,
     return ret;
 }
 
-// shrink (or remove) an entry in the tracker and return the totalSize of the original entry
-umf_result_t trackerShrinkEntry(void *hProvider, void *ptr, size_t shrinkSize,
-                                size_t *totalSize) {
-    umf_result_t ret = UMF_RESULT_SUCCESS;
-    umf_tracking_memory_provider_t *provider =
-        (umf_tracking_memory_provider_t *)hProvider;
-
-    int r = utils_mutex_lock(&provider->hTracker->splitMergeMutex);
-    if (r) {
-        return UMF_RESULT_ERROR_UNKNOWN;
-    }
-
-    tracker_alloc_info_t *value = (tracker_alloc_info_t *)critnib_get(
-        provider->hTracker->alloc_segments_map, (uintptr_t)ptr);
-    if (!value) {
-        LOG_ERR("region for shrinking is not found in the tracker");
-        ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err;
-    }
-    if (shrinkSize > value->size) {
-        LOG_ERR("requested size %zu to shrink exceeds the tracked size %zu",
-                shrinkSize, value->size);
-        ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err;
-    }
-
-    if (shrinkSize < value->size) {
-        void *highPtr = (void *)(((uintptr_t)ptr) + shrinkSize);
-        size_t secondSize = value->size - shrinkSize;
-        ret = umfMemoryTrackerAdd(provider->hTracker, provider->pool, highPtr,
-                                  secondSize);
-        if (ret != UMF_RESULT_SUCCESS) {
-            LOG_ERR("failed to add the new shrunk region to the tracker, ptr = "
-                    "%p, size = %zu, ret = %d",
-                    highPtr, secondSize, ret);
-            goto err;
-        }
-    }
-
-    *totalSize = value->size;
-
-    void *erasedValue =
-        critnib_remove(provider->hTracker->alloc_segments_map, (uintptr_t)ptr);
-    assert(erasedValue == value);
-    umf_ba_free(provider->hTracker->alloc_info_allocator, erasedValue);
-
-err:
-    utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
-
-    return ret;
-}
-
 static umf_result_t trackingAllocationMerge(void *hProvider, void *lowPtr,
                                             void *highPtr, size_t totalSize) {
     umf_result_t ret = UMF_RESULT_ERROR_UNKNOWN;
@@ -405,65 +353,6 @@ static umf_result_t trackingAllocationMerge(void *hProvider, void *lowPtr,
     return ret;
 }
 
-// grow (or add) an entry in the tracker to its original size
-umf_result_t trackerGrowEntry(void *hProvider, void *ptr, size_t growSize,
-                              size_t origSize) {
-    umf_result_t ret = UMF_RESULT_SUCCESS;
-    umf_tracking_memory_provider_t *provider =
-        (umf_tracking_memory_provider_t *)hProvider;
-
-    if (growSize > origSize) {
-        LOG_ERR("Invalid grow size %zu (larger than the original size %zu)",
-                growSize, origSize);
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    int r = utils_mutex_lock(&provider->hTracker->splitMergeMutex);
-    if (r) {
-        return UMF_RESULT_ERROR_UNKNOWN;
-    }
-
-    void *highPtr = (void *)(((uintptr_t)ptr) + growSize);
-    tracker_alloc_info_t *highValue = NULL;
-
-    if (growSize < origSize) {
-        highValue = (tracker_alloc_info_t *)critnib_get(
-            provider->hTracker->alloc_segments_map, (uintptr_t)highPtr);
-        if (!highValue) {
-            LOG_ERR("cannot find the tracker entry to grow %p", highPtr);
-            ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-            goto err;
-        }
-        if (growSize + highValue->size != origSize) {
-            LOG_ERR("Grow size plus the current size does not equal the "
-                    "original size");
-            ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-            goto err;
-        }
-    }
-
-    ret =
-        umfMemoryTrackerAdd(provider->hTracker, provider->pool, ptr, origSize);
-    if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR("failed to add the new grown region to the tracker, ptr = %p, "
-                "size = %zu, ret = %d",
-                ptr, origSize, ret);
-        goto err;
-    }
-
-    if (growSize < origSize) {
-        void *erasedhighValue = critnib_remove(
-            provider->hTracker->alloc_segments_map, (uintptr_t)highPtr);
-        assert(erasedhighValue == highValue);
-        umf_ba_free(provider->hTracker->alloc_info_allocator, erasedhighValue);
-    }
-
-err:
-    utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
-
-    return ret;
-}
-
 static umf_result_t trackingFree(void *hProvider, void *ptr, size_t size) {
     umf_result_t ret;
     umf_result_t ret_remove = UMF_RESULT_ERROR_UNKNOWN;
@@ -980,3 +869,47 @@ void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) {
     handle->alloc_info_allocator = NULL;
     umf_ba_global_free(handle);
 }
+
+// add an entry to the tracker
+umf_result_t trackerAddEntry(void *hProvider, void *ptr, size_t size) {
+    umf_tracking_memory_provider_t *provider =
+        (umf_tracking_memory_provider_t *)hProvider;
+    return umfMemoryTrackerAdd(provider->hTracker, provider->pool, ptr, size);
+}
+
+// remove an entry from the tracker
+umf_result_t trackerRemoveEntry(void *hProvider, void *ptr, size_t size) {
+    umf_result_t ret = UMF_RESULT_SUCCESS;
+    umf_tracking_memory_provider_t *provider =
+        (umf_tracking_memory_provider_t *)hProvider;
+
+    int r = utils_mutex_lock(&provider->hTracker->splitMergeMutex);
+    if (r) {
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    tracker_alloc_info_t *value = (tracker_alloc_info_t *)critnib_get(
+        provider->hTracker->alloc_segments_map, (uintptr_t)ptr);
+    if (!value) {
+        LOG_ERR("region for removing was not found in the tracker");
+        ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        goto err;
+    }
+    if (size != value->size) {
+        LOG_ERR(
+            "requested size %zu to remove does not match the tracked size %zu",
+            size, value->size);
+        ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        goto err;
+    }
+
+    void *erasedValue =
+        critnib_remove(provider->hTracker->alloc_segments_map, (uintptr_t)ptr);
+    assert(erasedValue == value);
+    umf_ba_free(provider->hTracker->alloc_info_allocator, erasedValue);
+
+err:
+    utils_mutex_unlock(&provider->hTracker->splitMergeMutex);
+
+    return ret;
+}
diff --git a/src/provider/provider_tracking.h b/src/provider/provider_tracking.h
@@ -55,11 +55,9 @@ void umfTrackingMemoryProviderGetUpstreamProvider(
     umf_memory_provider_handle_t hTrackingProvider,
     umf_memory_provider_handle_t *hUpstream);
 
-umf_result_t trackerShrinkEntry(void *hProvider, void *ptr, size_t shrinkSize,
-                                size_t *totalSize);
+umf_result_t trackerRemoveEntry(void *hProvider, void *ptr, size_t size);
 
-umf_result_t trackerGrowEntry(void *hProvider, void *ptr, size_t growSize,
-                              size_t origSize);
+umf_result_t trackerAddEntry(void *hProvider, void *ptr, size_t size);
 
 #ifdef __cplusplus
 }
diff --git a/test/provider_fixed_memory.cpp b/test/provider_fixed_memory.cpp
@@ -556,12 +556,11 @@ TEST_P(FixedProviderTest, pool_from_ptr_whole_size_success) {
     umfPoolDestroy(proxyFixedPool);
 }
 
-TEST_P(FixedProviderTest, pool_from_ptr_half_size_success) {
+TEST_P(FixedProviderTest, pool_from_ptr_negative_half_size) {
     umf_result_t umf_result;
     size_t size_of_first_alloc;
     size_t size_of_pool_from_ptr;
     void *ptr_for_pool = nullptr;
-    void *ptr = nullptr;
 
     umf_memory_pool_handle_t proxyFixedPool = nullptr;
     umf_result = umfPoolCreate(umfProxyPoolOps(), provider.get(), nullptr, 0,
@@ -587,24 +586,9 @@ TEST_P(FixedProviderTest, pool_from_ptr_half_size_success) {
     umf_memory_provider_handle_t providerFromPtr = nullptr;
     umf_result = umfMemoryProviderCreate(umfFixedMemoryProviderOps(), params,
                                          &providerFromPtr);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-    ASSERT_NE(providerFromPtr, nullptr);
-
-    umf_memory_pool_handle_t poolFromPtr = nullptr;
-    umf_result = umfPoolCreate(umfProxyPoolOps(), providerFromPtr, nullptr, 0,
-                               &poolFromPtr);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
-
-    ptr = umfPoolMalloc(poolFromPtr, size_of_pool_from_ptr);
-    ASSERT_NE(ptr, nullptr);
-
-    memset(ptr, 0xFF, size_of_pool_from_ptr);
-
-    umf_result = umfPoolFree(poolFromPtr, ptr);
-    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(providerFromPtr, nullptr);
 
-    umfPoolDestroy(poolFromPtr);
-    umfMemoryProviderDestroy(providerFromPtr);
     umfFixedMemoryProviderParamsDestroy(params);
 
     umf_result = umfPoolFree(proxyFixedPool, ptr_for_pool);
