Add umf_ba_linear_pool_contains_pointer

Add umf_ba_linear_pool_contains_pointer().
It returns:
- 0 if ptr does not belong to the pool or
- size (> 0) of the memory region from ptr
  to the end of the pool if ptr belongs to the pool.

It will be useful to implement realloc() in the proxy library.

Added also the baseAllocLinearPoolContainsPointer test.

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

Author: ldorau

src/base_alloc/base_alloc_linear.c

@@ -175,3 +175,33 @@ void umf_ba_linear_destroy(umf_ba_linear_pool_t *pool) {
     util_mutex_destroy_not_free(&pool->metadata.lock);
     ba_os_free(pool, pool->metadata.pool_size);
 }
+
+// umf_ba_linear_pool_contains_pointer() returns:
+// - 0 if ptr does not belong to the pool or
+// - size (> 0) of the memory region from ptr
+//   to the end of the pool if ptr belongs to the pool
+size_t umf_ba_linear_pool_contains_pointer(umf_ba_linear_pool_t *pool,
+                                           void *ptr) {
+    util_mutex_lock(&pool->metadata.lock);
+    char *cptr = (char *)ptr;
+    if (cptr >= pool->data &&
+        cptr < ((char *)(pool)) + pool->metadata.pool_size) {
+        size_t size = ((char *)(pool)) + pool->metadata.pool_size - cptr;
+        util_mutex_unlock(&pool->metadata.lock);
+        return size;
+    }
+
+    umf_ba_next_linear_pool_t *next_pool = pool->next_pool;
+    while (next_pool) {
+        if (cptr >= next_pool->data &&
+            cptr < ((char *)(next_pool)) + next_pool->pool_size) {
+            size_t size = ((char *)(next_pool)) + next_pool->pool_size - cptr;
+            util_mutex_unlock(&pool->metadata.lock);
+            return size;
+        }
+        next_pool = next_pool->next_pool;
+    }
+
+    util_mutex_unlock(&pool->metadata.lock);
+    return 0;
+}

src/base_alloc/base_alloc_linear.h

@@ -26,6 +26,8 @@ typedef struct umf_ba_linear_pool umf_ba_linear_pool_t;
 umf_ba_linear_pool_t *umf_ba_linear_create(size_t pool_size);
 void *umf_ba_linear_alloc(umf_ba_linear_pool_t *pool, size_t size);
 void umf_ba_linear_destroy(umf_ba_linear_pool_t *pool);
+size_t umf_ba_linear_pool_contains_pointer(umf_ba_linear_pool_t *pool,
+                                           void *ptr);
 
 #ifdef __cplusplus
 }

test/test_base_alloc_linear.cpp

@@ -27,6 +27,24 @@ TEST_F(test, baseAllocLinearAllocMoreThanPoolSize) {
     memset(ptr, 0, new_size);
 }
 
+TEST_F(test, baseAllocLinearPoolContainsPointer) {
+    auto pool = std::shared_ptr<umf_ba_linear_pool_t>(
+        umf_ba_linear_create(0 /* minimal pool size (page size) */),
+        umf_ba_linear_destroy);
+
+    size_t size = 16;
+    void *ptr = umf_ba_linear_alloc(pool.get(), size);
+    UT_ASSERTne(ptr, NULL);
+    memset(ptr, 0, size);
+
+    // assert pool contains pointer ptr
+    UT_ASSERTne(umf_ba_linear_pool_contains_pointer(pool.get(), ptr), 0);
+
+    // assert pool does NOT contain pointer 0x0123
+    UT_ASSERTeq(umf_ba_linear_pool_contains_pointer(pool.get(), (void *)0x0123),
+                0);
+}
+
 TEST_F(test, baseAllocLinearMultiThreadedAllocMemset) {
     static constexpr int NTHREADS = 10;
     static constexpr int ITERATIONS = 1000;