Add struct am_onesize_cfg with crit_enter(exit) callbacks

Author: adel-mamin

libs/event/event.c

@@ -63,7 +63,10 @@ void am_event_add_pool(void *pool, int size, int block_size, int alignment) {
     memset(&blk, 0, sizeof(blk));
     blk.ptr = pool;
     blk.size = size;
-    am_onesize_init(&me->pool[me->npool], &blk, block_size, alignment);
+    struct am_onesize_cfg cfg = {
+        .pool = &blk, .block_size = block_size, .alignment = alignment
+    };
+    am_onesize_ctor(&me->pool[me->npool], &cfg);
 
     ++me->npool;
 }

libs/onesize/onesize.c

@@ -60,14 +60,17 @@ void *am_onesize_allocate(struct am_onesize *hnd, int size) {
         return NULL;
     }
 
+    hnd->crit_enter();
     if (am_slist_is_empty(&hnd->fl)) {
+        hnd->crit_exit();
         return NULL;
     }
 
     struct am_slist_item *elem = am_slist_pop_front(&hnd->fl);
     AM_ASSERT(elem);
 
     am_onesize_run_stats(hnd, 1, 0);
+    hnd->crit_exit();
 
     return elem;
 }
@@ -82,15 +85,17 @@ void am_onesize_free(struct am_onesize *hnd, const void *ptr) {
 
     struct am_slist_item *p = AM_CAST(struct am_slist_item *, ptr);
 
+    hnd->crit_enter();
     am_slist_push_front(&hnd->fl, p);
     am_onesize_run_stats(hnd, 0, 1);
+    hnd->crit_exit();
 }
 
 /**
  * Internal initialization routine.
  * @param hnd  the allocator
  */
-static void am_onesize_init_internal(struct am_onesize *hnd) {
+static void am_onesize_ctor_internal(struct am_onesize *hnd) {
     am_slist_init(&hnd->fl);
 
     char *ptr = (char *)hnd->pool.ptr;
@@ -108,9 +113,11 @@ void am_onesize_free_all(struct am_onesize *hnd) {
 
     struct am_onesize *s = (struct am_onesize *)hnd;
 
+    hnd->crit_enter();
     int minfree = hnd->minfree;
-    am_onesize_init_internal(s);
+    am_onesize_ctor_internal(s);
     hnd->minfree = minfree; /* cppcheck-suppress redundantAssignment */
+    hnd->crit_exit();
 }
 
 void am_onesize_iterate_over_allocated(
@@ -128,17 +135,21 @@ void am_onesize_iterate_over_allocated(
     }
     int iterated = 0;
     num = AM_MIN(num, total);
+    hnd->crit_enter();
     for (int i = 0; (i < total) && (iterated < num); i++) {
         AM_ASSERT(AM_ALIGNOF_PTR(ptr) >= AM_ALIGNOF(struct am_slist_item));
         struct am_slist_item *item = AM_CAST(struct am_slist_item *, ptr);
         if (am_slist_owns(&impl->fl, item)) {
             continue; /* the item is free */
         }
         /* the item is allocated */
+        hnd->crit_exit();
         cb(ctx, iterated, (char *)item, impl->block_size);
+        hnd->crit_enter();
         ptr += impl->block_size;
         iterated++;
     }
+    hnd->crit_exit();
 }
 
 int am_onesize_get_nfree(const struct am_onesize *hnd) {
@@ -161,31 +172,42 @@ int am_onesize_get_nblocks(const struct am_onesize *hnd) {
     return hnd->ntotal;
 }
 
-void am_onesize_init(
-    struct am_onesize *hnd, struct am_blk *pool, int block_size, int alignment
-) {
+static void am_onesize_crit_enter(void) {}
+static void am_onesize_crit_exit(void) {}
+
+void am_onesize_ctor(struct am_onesize *hnd, struct am_onesize_cfg *cfg) {
     AM_ASSERT(hnd);
-    AM_ASSERT(pool);
-    AM_ASSERT(pool->ptr);
-    AM_ASSERT(pool->size > 0);
-    AM_ASSERT(pool->size >= block_size);
-    AM_ASSERT(alignment >= AM_ALIGNOF(struct am_slist_item));
+    AM_ASSERT(cfg);
+    AM_ASSERT(cfg->pool);
+    AM_ASSERT(cfg->pool->ptr);
+    AM_ASSERT(cfg->pool->size > 0);
+    AM_ASSERT(cfg->pool->size >= cfg->block_size);
+    AM_ASSERT(cfg->alignment >= AM_ALIGNOF(struct am_slist_item));
 
     memset(hnd, 0, sizeof(*hnd));
 
-    void *alignedptr = AM_ALIGN_PTR_UP(pool->ptr, alignment);
-    int affix = (int)((uintptr_t)alignedptr - (uintptr_t)pool->ptr);
-    AM_ASSERT(affix < pool->size);
-    pool->size -= affix;
-    pool->ptr = alignedptr;
+    void *alignedptr = AM_ALIGN_PTR_UP(cfg->pool->ptr, cfg->alignment);
+    int affix = (int)((uintptr_t)alignedptr - (uintptr_t)cfg->pool->ptr);
+    AM_ASSERT(affix < cfg->pool->size);
+    cfg->pool->size -= affix;
+    cfg->pool->ptr = alignedptr;
 
-    block_size = AM_MAX(block_size, (int)sizeof(struct am_slist_item));
-    block_size = AM_MAX(block_size, alignment);
+    cfg->block_size =
+        AM_MAX(cfg->block_size, (int)sizeof(struct am_slist_item));
+    cfg->block_size = AM_MAX(cfg->block_size, cfg->alignment);
 
-    AM_ASSERT(pool->size >= block_size);
+    AM_ASSERT(cfg->pool->size >= cfg->block_size);
 
-    hnd->pool = *pool;
-    hnd->block_size = block_size;
+    hnd->pool = *cfg->pool;
+    hnd->block_size = cfg->block_size;
+
+    if (cfg->crit_enter && cfg->crit_exit) {
+        hnd->crit_enter = cfg->crit_enter;
+        hnd->crit_exit = cfg->crit_exit;
+    } else {
+        hnd->crit_enter = am_onesize_crit_enter;
+        hnd->crit_exit = am_onesize_crit_exit;
+    }
 
-    am_onesize_init_internal(hnd);
+    am_onesize_ctor_internal(hnd);
 }

libs/onesize/onesize.h

@@ -45,25 +45,41 @@ struct am_onesize {
     int nfree;          /**< current number of blocks in free list */
     int ntotal;         /**< total number of blocks */
     int minfree;        /**< minimum number of blocks in free list */
+    /** Enter critical section */
+    void (*crit_enter)(void);
+    /** Exit critical section */
+    void (*crit_exit)(void);
+};
+
+/** Onesize configuration. */
+struct am_onesize_cfg {
+    /** the memory pool */
+    struct am_blk *pool;
+    /**
+     * The maximum size of the memory block the allocator
+     * can allocate [bytes]. The allocation of memory blocks
+     * bigger that this size will fail.
+     */
+    int block_size;
+    /** The alignment of allocated memory blocks [bytes] */
+    int alignment;
+    /** Enter critical section */
+    void (*crit_enter)(void);
+    /** Exit critical section */
+    void (*crit_exit)(void);
 };
 
 /**
- * Initializes a new onesize allocator.
+ * Construct a new onesize allocator.
  * Allocation requests up to block_size bytes are
  * rounded up to block_size bytes and served from a singly-linked
  * list of buffers. Due to the simplicity of onesize allocator
  * management, allocations from it are fast.
  *
- * @param hnd         the allocator
- * @param pool        the memory pool
- * @param block_size  the maximum size of the memory block the allocator
- *                    can allocate [bytes]. The allocation of memory blocks
- *                    bigger that this size will fail.
- * @param alignment   the alignment of allocated memory blocks [bytes]
+ * @param hnd  the allocator
+ * @param cfg  configuration
  */
-void am_onesize_init(
-    struct am_onesize *hnd, struct am_blk *pool, int block_size, int alignment
-);
+void am_onesize_ctor(struct am_onesize *hnd, struct am_onesize_cfg *cfg);
 
 /**
  * Allocate memory if \p size is <= block_size. The block at the front

libs/onesize/test.c

@@ -44,7 +44,12 @@ int main(void) {
     } test_arr[2];
     struct am_blk blk = {.ptr = &test_arr[0], .size = sizeof(test_arr)};
 
-    am_onesize_init(&ma, &blk, sizeof(struct test), AM_ALIGNOF(struct test));
+    struct am_onesize_cfg cfg = {
+        .pool = &blk,
+        .block_size = sizeof(struct test),
+        .alignment = AM_ALIGNOF(struct test)
+    };
+    am_onesize_ctor(&ma, &cfg);
 
     AM_ASSERT(am_onesize_get_nfree(&ma) == 2);