Reformat & cleanup

include/ucore/spool.h

@@ -10,7 +10,7 @@ extern "C" {
 typedef union UCPoolBlock UCPoolBlock;
 union UCPoolBlock {
     UCPoolBlock *next;      // next free block (when not allocated)
-   unsigned char data[]; // data when allocated
+    unsigned char data[0];  // data when allocated
 };
 /** @file
  * Static pool allocator.
@@ -25,7 +25,7 @@ union UCPoolBlock {
  * @endcode
  * as the backing buffer.
  *
-*/
+ */
 typedef struct UCPool UCPool;
 struct UCPool {
     UCPoolBlock *free_list;  // free list
@@ -45,11 +45,7 @@ struct UCPool {
  * @param block_size  size of each allocation.
  * @param alignment   alignment of each block (must be power of 2)
  */
-void uc_pool_init(UCPool *pool,
+void uc_pool_init(UCPool *pool, void *buffer, size_t buffer_size, size_t block_size, size_t alignment);
-               void *buffer,
-               size_t buffer_size,
-               size_t block_size,
-               size_t alignment);
 
 // Allocate a block from the pool. Returns NULL if no more space
 [[gnu::assume_aligned(_Alignof(UCPoolBlock))]]

src/small_allocator.c

@@ -15,28 +15,21 @@
  * fragmentation to a minimum
  */
 
-
-#define ALIGNMENT 16
-#define ALIGN_UP(n) (((n) + (ALIGNMENT - 1)) & ~(ALIGNMENT - 1))
-#define ALIGN_DOWN(n) ((n) & ~(ALIGNMENT - 1))
-
-#define NULL_BLOCK (0xffffffff)
-#define BLOCK_FREE  ((uint32_t)1)
-
 typedef struct BlockHeader {
     uint32_t next;            // offset from base
     uint32_t prev;            // offset from base
     uint32_t size_and_flags;  // size | free_bit
     // Padding to ensure we always return 16 byte aligned pointers.
-    // Remove padding & set ALIGNMENT to 8 to get 8 byte alignmet
-    // (for 64 bit systems, 32 bit systems might need other adjustments)
     uint8_t pad[4];
 } BlockHeader;
 
+#define ALIGNMENT sizeof(BlockHeader)
+#define ALIGN_UP(n) (((n) + (ALIGNMENT - 1)) & ~(ALIGNMENT - 1))
+#define ALIGN_DOWN(n) ((n) & ~(ALIGNMENT - 1))
 
-_Static_assert(sizeof(BlockHeader) % ALIGNMENT == 0,
+#define NULL_BLOCK (0xffffffff)
-               "BlockHeader size must be a multiple of ALIGNMENT");
+#define BLOCK_FREE ((uint32_t)1)
-
+_Static_assert(ALIGNMENT == 16, "sizeof(BlockHeader) is not 16");
 
 typedef struct {
     uint8_t* base;            // backing store
@@ -47,12 +40,12 @@ typedef struct {
 
 /* --- Header helpers --- */
 
-static inline uint32_t block_size(BlockHeader* b)
+static inline uint32_t block_size(const BlockHeader* b)
 {
     return b->size_and_flags & ~BLOCK_FREE;
 }
 
-static inline int block_is_free(BlockHeader* b)
+static inline int block_is_free(const BlockHeader* b)
 {
     return (b->size_and_flags & BLOCK_FREE) != 0;
 }
@@ -67,23 +60,22 @@ static inline void block_set_used(BlockHeader* b)
     b->size_and_flags &= ~BLOCK_FREE;
 }
 
-
 static inline void block_set_size(BlockHeader* b, uint32_t size)
 {
     uint32_t flags = b->size_and_flags & BLOCK_FREE;
     b->size_and_flags = size | flags;
 }
 
-static inline BlockHeader * bh_from_offset(const SmallAllocator *a, uint32_t off)
+static inline BlockHeader* block_from_offset(const SmallAllocator* a, uint32_t off)
 {
     if (off == NULL_BLOCK) {
         return NULL;
     }
 
-    return (BlockHeader *)((uintptr_t)a->base + off);
+    return (BlockHeader*)((uintptr_t)a->base + off);
 }
 
-static inline uint32_t bh_offset(SmallAllocator *a, BlockHeader *bh)
+static inline uint32_t bh_offset(SmallAllocator* a, BlockHeader* bh)
 {
     if (bh == NULL) {
         return NULL_BLOCK;
@@ -113,17 +105,15 @@ void small_allocator_init(SmallAllocator* a, void* backing_store, uint32_t size)
     a->last_alloc = first;
 }
 
-static void split_block(SmallAllocator *a, BlockHeader* block, uint32_t size)
+static void maybe_split_block(SmallAllocator* a, BlockHeader* block, uint32_t size)
 {
-    size = ALIGN_UP(size);
+    // assumes size is already aligned
     uint32_t bsize = block_size(block);
 
-    if (bsize < size + sizeof(BlockHeader) + ALIGNMENT)
+    if (bsize < size + sizeof(BlockHeader) + ALIGNMENT) return;
-        return;
 
     uint8_t* base = (uint8_t*)block;
-    BlockHeader* new_block =
+    BlockHeader* new_block = (BlockHeader*)(base + sizeof(BlockHeader) + size);
-        (BlockHeader*)(base + sizeof(BlockHeader) + size);
 
     uint32_t new_size = ALIGN_UP(bsize - size - sizeof(BlockHeader));
 
@@ -134,30 +124,25 @@ static void split_block(SmallAllocator *a, BlockHeader* block, uint32_t size)
     new_block->next = block->next;
     new_block->prev = bh_offset(a, block);
 
-    BlockHeader *next = bh_from_offset(a, new_block->next);
+    BlockHeader* next = block_from_offset(a, new_block->next);
     if (next) {
         next->prev = bh_offset(a, new_block);
-        //block->next->prev = new_block;
     }
 
     block->next = bh_offset(a, new_block);
 }
 
-static void merge_with_next(SmallAllocator *a, BlockHeader* block)
+static void merge_with_next(SmallAllocator* a, BlockHeader* block)
 {
-    BlockHeader* next = bh_from_offset(a, block->next);
+    BlockHeader* next = block_from_offset(a, block->next);
-    if (!next || !block_is_free(next))
+    if (next == NULL || !block_is_free(next)) return;
-        return;
 
-    uint32_t new_size = ALIGN_UP(block_size(block) +
+    uint32_t new_size = ALIGN_UP(block_size(block) + sizeof(BlockHeader) + block_size(next));
-                            sizeof(BlockHeader) +
-                            block_size(next));
 
     block_set_size(block, new_size);
     block->next = next->next;
-    BlockHeader *nextnext = bh_from_offset(a, next->next);
+    BlockHeader* nextnext = block_from_offset(a, next->next);
-    if (nextnext)
+    if (nextnext) nextnext->prev = bh_offset(a, block);
-        nextnext->prev = bh_offset(a, block);
 }
 
 void* small_alloc(SmallAllocator* a, uint32_t size)
@@ -169,12 +154,12 @@ void* small_alloc(SmallAllocator* a, uint32_t size)
 
     do {
         if (block_is_free(curr) && block_size(curr) >= size) {
-            split_block(a, curr, size);
+            maybe_split_block(a, curr, size);
             block_set_used(curr);
             a->last_alloc = curr;
             return (uint8_t*)curr + sizeof(BlockHeader);
         }
-        curr = bh_from_offset(a, curr->next) ? bh_from_offset(a, curr->next) : a->heap_start;
+        curr = block_from_offset(a, curr->next) ? block_from_offset(a, curr->next) : a->heap_start;
     } while (curr != start);
 
     return NULL;
@@ -197,7 +182,7 @@ void small_free(SmallAllocator* a, void* ptr)
     block_set_free(block);
     merge_with_next(a, block);
 
-    BlockHeader* prev = bh_from_offset(a, block->prev);
+    BlockHeader* prev = block_from_offset(a, block->prev);
     if (prev != NULL && block_is_free(prev)) {
         merge_with_next(a, prev);
 
@@ -212,27 +197,37 @@ void small_free(SmallAllocator* a, void* ptr)
 #include <stdio.h>
 #include <stdlib.h>
 
-void debug_alloc(const SmallAllocator *a)
+void debug_alloc(const SmallAllocator* a)
 {
     puts("--debug start--");
-    for (BlockHeader *b = a->heap_start ; b ; b = bh_from_offset(a, b->next)) {
+    for (BlockHeader* b = a->heap_start; b; b = block_from_offset(a, b->next)) {
         printf("Block size %u free %d prev %u next %u \n", block_size(b), block_is_free(b), b->prev, b->next);
     }
     puts("--debug end--");
 }
 
-char buff[1023*1023];
+[[gnu::aligned(16)]] char buff[1023 * 1023];
 int main(void)
 {
     printf("bh size %zu\n", sizeof(BlockHeader));
-    #define SZ 64
+#define SZ 64
     SmallAllocator a;
-    char *ptrs[SZ];
+    char* ptrs[SZ];
 
     small_allocator_init(&a, buff, sizeof buff);
-    ptrs[0] = small_alloc(&a, 16);
     debug_alloc(&a);
+    ptrs[0] = small_alloc(&a, 32);
+    ptrs[1] = small_alloc(&a, 80);
+    ptrs[2] = small_alloc(&a, 32);
+    small_free(&a, ptrs[1]);
+    ptrs[3] = small_alloc(&a, 12);
+    ptrs[4] = small_alloc(&a, 12);
+    debug_alloc(&a);
+
     small_free(&a, ptrs[0]);
+    small_free(&a, ptrs[2]);
+    small_free(&a, ptrs[3]);
+    small_free(&a, ptrs[4]);
 
     for (int i = 0; i < SZ; i++) {
         ptrs[i] = small_alloc(&a, rand() % 256 + 1);