Add linear base allocator

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

Author: ldorau

src/CMakeLists.txt

@@ -10,6 +10,7 @@ set(UMF_LIBS umf_utils)
 
 set(UMF_SOURCES
     base_alloc/base_alloc.c
+    base_alloc/base_alloc_linear.c
     memory_pool.c
     memory_provider.c
     memory_provider_get_last_failed.c

src/base_alloc/base_alloc_linear.c

@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <assert.h>
+
+#include "base_alloc_internal.h"
+#include "base_alloc_linear.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+
+// minimum size of a single pool of the base allocator
+#define MINIMUM_LINEAR_POOL_SIZE (ba_os_get_page_size())
+
+// alignment of the base allocator
+#define MEMORY_ALIGNMENT (8)
+
+typedef struct umf_ba_next_linear_pool_t umf_ba_next_linear_pool_t;
+
+// metadata is set and used only in the main (the first) pool
+struct umf_ba_main_linear_pool_meta_t {
+    size_t pool_size; // size of each pool (argument of each ba_os_alloc() call)
+    os_mutex_t *lock;
+    char *data_ptr;
+    size_t size_left;
+#ifndef NDEBUG
+    size_t n_pools;
+#endif /* NDEBUG */
+};
+
+// the main pool of the base allocator (there is only one such pool)
+struct umf_ba_linear_pool_t {
+    // address of the beginning of the next pool (a list of allocated pools to be freed in umf_ba_linear_destroy())
+    umf_ba_next_linear_pool_t *next_pool;
+
+    // metadata is set and used only in the main (the first) pool
+    struct umf_ba_main_linear_pool_meta_t metadata;
+
+    // data area of the main pool (the first one) starts here
+    char data[];
+};
+
+// the "next" pools of the base allocator (pools allocated later, when we run out of the memory of the main pool)
+struct umf_ba_next_linear_pool_t {
+    // address of the beginning of the next pool (a list of allocated pools to be freed in umf_ba_linear_destroy())
+    umf_ba_next_linear_pool_t *next_pool;
+
+    // data area of all pools except of the main (the first one) starts here
+    char data[];
+};
+
+#ifndef NDEBUG
+static void ba_debug_checks(umf_ba_linear_pool_t *pool) {
+    // count pools
+    size_t n_pools = 1;
+    umf_ba_next_linear_pool_t *next_pool = pool->next_pool;
+    while (next_pool) {
+        n_pools++;
+        next_pool = next_pool->next_pool;
+    }
+    assert(n_pools == pool->metadata.n_pools);
+}
+#endif /* NDEBUG */
+
+umf_ba_linear_pool_t *umf_ba_linear_create(size_t pool_size) {
+    size_t mutex_size = align_size(util_mutex_get_size(), MEMORY_ALIGNMENT);
+    size_t metadata_size = sizeof(struct umf_ba_main_linear_pool_meta_t);
+    pool_size = pool_size + metadata_size + mutex_size;
+    if (pool_size < MINIMUM_LINEAR_POOL_SIZE) {
+        pool_size = MINIMUM_LINEAR_POOL_SIZE;
+    }
+
+    pool_size = align_size(pool_size, ba_os_get_page_size());
+
+    umf_ba_linear_pool_t *pool = (umf_ba_linear_pool_t *)ba_os_alloc(pool_size);
+    if (!pool) {
+        return NULL;
+    }
+
+    pool->metadata.pool_size = pool_size;
+    pool->next_pool = NULL; // this is the only pool now
+#ifndef NDEBUG
+    pool->metadata.n_pools = 1;
+#endif /* NDEBUG */
+
+    char *data_ptr = (char *)&pool->data;
+    size_t size_left = pool_size - offsetof(umf_ba_linear_pool_t, data);
+
+    // allocate and init lock
+    pool->metadata.lock = util_mutex_init(data_ptr);
+    if (!pool->metadata.lock) {
+        ba_os_free(pool, pool_size);
+        return NULL;
+    }
+
+    pool->metadata.data_ptr = data_ptr + mutex_size;   // lock is here
+    pool->metadata.size_left = size_left - mutex_size; // for lock
+
+    return pool;
+}
+
+void *umf_ba_linear_alloc(umf_ba_linear_pool_t *pool, size_t size) {
+    size_t aligned_size = align_size(size, MEMORY_ALIGNMENT);
+    util_mutex_lock(pool->metadata.lock);
+    if (pool->metadata.size_left < aligned_size) {
+        umf_ba_next_linear_pool_t *new_pool =
+            (umf_ba_next_linear_pool_t *)ba_os_alloc(pool->metadata.pool_size);
+        if (!new_pool) {
+            util_mutex_unlock(pool->metadata.lock);
+            return NULL;
+        }
+
+        // add the new pool to the list of pools
+        new_pool->next_pool = pool->next_pool;
+        pool->next_pool = new_pool;
+
+#ifndef NDEBUG
+        pool->metadata.n_pools++;
+#endif /* NDEBUG */
+
+        pool->metadata.data_ptr = (char *)&new_pool->data;
+        pool->metadata.size_left = pool->metadata.pool_size -
+                                   offsetof(umf_ba_next_linear_pool_t, data);
+    }
+
+    void *ptr = pool->metadata.data_ptr;
+    pool->metadata.data_ptr += aligned_size;
+    pool->metadata.size_left -= aligned_size;
+#ifndef NDEBUG
+    ba_debug_checks(pool);
+#endif /* NDEBUG */
+    util_mutex_unlock(pool->metadata.lock);
+
+    return ptr;
+}
+
+void umf_ba_linear_destroy(umf_ba_linear_pool_t *pool) {
+#ifndef NDEBUG
+    ba_debug_checks(pool);
+#endif /* NDEBUG */
+    size_t size = pool->metadata.pool_size;
+    umf_ba_next_linear_pool_t *current_pool;
+    umf_ba_next_linear_pool_t *next_pool = pool->next_pool;
+    while (next_pool) {
+        current_pool = next_pool;
+        next_pool = next_pool->next_pool;
+        ba_os_free(current_pool, size);
+    }
+
+    util_mutex_destroy_not_free(pool->metadata.lock);
+    ba_os_free(pool, size);
+}

src/base_alloc/base_alloc_linear.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+/* A MT-safe fixed-size-pool base allocator */
+
+#ifndef UMF_BASE_ALLOC_LINEAR_H
+#define UMF_BASE_ALLOC_LINEAR_H 1
+
+#include <stddef.h>
+
+typedef struct umf_ba_linear_pool_t 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);
+
+#endif /* UMF_BASE_ALLOC_LINEAR_H */

test/CMakeLists.txt

@@ -117,4 +117,7 @@ if(LINUX)
     add_umf_test(NAME base_alloc
                 SRCS test_base_alloc.c
                 LIBS umf_utils)
+    add_umf_test(NAME base_alloc_linear
+                SRCS test_base_alloc_linear.c
+                LIBS umf_utils)
 endif()

test/test_base_alloc_linear.c

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+#include "base_alloc_linear.h"
+#include "test_helpers.h"
+
+#define NTHREADS 10
+#define ITERATIONS 1000
+#define MAX_ALLOCATION_SIZE 1024
+
+static void *start_routine(void *arg) {
+    struct buffer_t {
+        unsigned char *ptr;
+        size_t size;
+    } buffer[ITERATIONS];
+    umf_ba_linear_pool_t *pool = (umf_ba_linear_pool_t *)arg;
+
+    long TID = syscall(SYS_gettid);
+
+    for (int i = 0; i < ITERATIONS; i++) {
+        buffer[i].size = (rand() * MAX_ALLOCATION_SIZE) / RAND_MAX;
+        buffer[i].ptr = umf_ba_linear_alloc(pool, buffer[i].size);
+        memset(buffer[i].ptr, (i + TID) & 0xFF, buffer[i].size);
+    }
+
+    for (int i = 0; i < ITERATIONS; i++) {
+        for (int k = 0; k < buffer[i].size; k++) {
+            if (*(buffer[i].ptr + k) != ((i + TID) & 0xFF)) {
+                fprintf(
+                    stderr,
+                    "i = %i k = %i, *(buffer[i].ptr + k) = %i != ((i + TID) & "
+                    "0xFF) = %li\n",
+                    i, k, *(buffer[i].ptr + k), ((i + TID) & 0xFF));
+            }
+            UT_ASSERTeq(*(buffer[i].ptr + k), ((i + TID) & 0xFF));
+        }
+    }
+
+    return NULL;
+}
+
+int main() {
+    pthread_t thread[NTHREADS];
+    umf_ba_linear_pool_t *pool = umf_ba_linear_create(MAX_ALLOCATION_SIZE);
+
+    for (int i = 0; i < NTHREADS; i++) {
+        int ret = pthread_create(&thread[i], NULL, start_routine, pool);
+        if (ret) {
+            fprintf(stderr, "pthread_create() failed!\n");
+            UT_ASSERTeq(ret, 0);
+        }
+    }
+
+    for (int i = 0; i < NTHREADS; i++) {
+        void *retval;
+        int ret = pthread_join(thread[i], &retval);
+        if (ret) {
+            fprintf(stderr, "pthread_join() failed!\n");
+            UT_ASSERTeq(ret, 0);
+        }
+    }
+
+    umf_ba_linear_destroy(pool);
+
+    return 0;
+}