sarena, add temp allocations

include/ucore/sarena.h

@@ -22,14 +22,20 @@ extern "C" {
  * Once allocated, a piece of memory obtained from the
  * allocator cannot be free'd individually, only the entire SArena can
  * be free'd/reset
-*/
+ */
 typedef struct UCSArena UCSArena;
 struct UCSArena {
-    unsigned char *start; // start of user buffer
-    unsigned char *curr;  // next alloc point
-    unsigned char *end;   // one past end of user buffer
+    unsigned char *start;  // start of user buffer
+    unsigned char *curr;   // next alloc point
+    unsigned char *end;    // one past end of user buffer
+    int tmp_allocs;        // no of uc_sar_tmp_begin calls
 };
 
+typedef struct UCSTmpAlloc UCSTmpAlloc;
+struct UCSTmpAlloc {
+    unsigned char *alloc_point;
+    UCSArena *arena;
+};
 /** Initialize a UCSArena with predefined backing array.
  *
  * @data must be an array type
@@ -39,8 +45,7 @@ struct UCSArena {
  * UCSArena a = UC_BV_STATIC_INITIALIZER(v);
  * @endcode
  */
-#define UC_SAR_STATIC_INITIALIZER(data)\
-    UC_SAR_INITIALIZER((data), sizeof(data))
+#define UC_SAR_STATIC_INITIALIZER(data) UC_SAR_INITIALIZER((data), sizeof(data))
 
 /** Initializer for UCSArena with predefined memory
  * Use as
@@ -54,12 +59,7 @@ struct UCSArena {
  * UCSArena a = UC_BV_INIT(m, 128);
  * @endcode
  */
-#define UC_SAR_INITIALIZER(data, sz)\
-    {\
-    (data),\
-    (data),\
-    (data) + sz\
-    }
+#define UC_SAR_INITIALIZER(data, sz) {(data), (data), (data) + sz}
 
 /** Initialize a UCSArena with an array as the backing memory to allocate from.
  * The macro can be used at local scope to allocate memory automatic on the stack,
@@ -78,12 +78,12 @@ struct UCSArena {
  * is needed.
  * @param var_name Variable name for the allocator
  * @param size_  byte size of the backing array
-*/
+ */
 #define UC_SAR_ALLOC_DEF(var_name, size_) \
-    struct {\
-        _Alignas(16) char memory[size_]; \
-    } var_name ## _memory;\
-    UCSArena var_name = UC_SAR_STATIC_INITIALIZER(var_name ## _memory.memory)
+    struct {                              \
+        _Alignas(16) char memory[size_];  \
+    } var_name##_memory;                  \
+    UCSArena var_name = UC_SAR_STATIC_INITIALIZER(var_name##_memory.memory)
 
 /** Allocate space for @type_ , returned memory is aligned to requirements
  * of @type.
@@ -96,16 +96,21 @@ struct UCSArena {
  * struct Foo *str = UC_SAR_ALLOC_ALIGNED(&my_allocator, struct Foo[32]);
  * @endcode
  */
-#define UC_SAR_ALLOC_ALIGNED(allocator, type_) \
-    uc_sar_alloc_aligned((allocator), sizeof (type_), _Alignof(type_))
+#define UC_SAR_ALLOC_ALIGNED(allocator, type_) uc_sar_alloc_aligned((allocator), sizeof(type_), _Alignof(type_))
 
-//Initialize an UCSArena to allocate from @mem which is @sz bytes
-static  inline void uc_sar_init(UCSArena *a, void *mem, size_t sz)
+// Initialize an UCSArena to allocate from @mem which is @sz bytes
+static inline void uc_sar_init(UCSArena *a, void *mem, size_t sz)
 {
     a->start = a->curr = mem;
     a->end = a->start + sz;
 }
 
+// begin temporary allocation. All allocations afterwards will be released in uc_sar_tmp_end
+UCSTmpAlloc uc_sar_tmp_begin(UCSArena *a);
+
+// end temporary allocations, releaseing all allocations since the most recent uc_sar_tmp_begin
+void uc_sar_tmp_end(const UCSTmpAlloc *state);
+
 // Allocate @sz bytes from the UCSArena. Returns NULL if not enough space
 void *uc_sar_alloc(UCSArena *a, size_t sz);
 
@@ -113,7 +118,6 @@ void *uc_sar_alloc(UCSArena *a, size_t sz);
 // Returns NULL if not enough space
 void *uc_sar_alloc_aligned(UCSArena *a, size_t sz, unsigned int align) [[gnu::alloc_align(2)]];
 
-
 static inline void uc_sar_reset(UCSArena *a)
 {
     a->curr = a->start;

include/ucore/spool.h

@@ -9,8 +9,8 @@ extern "C" {
 
 typedef union UCPoolBlock UCPoolBlock;
 union UCPoolBlock {
-   UCPoolBlock *next; // next free block (when not allocated)
-   unsigned char data[]; // data when allocated
+    UCPoolBlock *next;      // next free block (when not allocated)
+    unsigned char data[0];  // data when allocated
 };
 /** @file
  * Static pool allocator.
@@ -25,15 +25,15 @@ union UCPoolBlock {
  * @endcode
  * as the backing buffer.
  *
-*/
+ */
 typedef struct UCPool UCPool;
 struct UCPool {
-   UCPoolBlock *free_list;   // free list
-   size_t block_size; // aligned size of each block
-   size_t capacity;   // number of blocks
-   size_t align;      // alignment
-   UCPoolBlock *start;       // start of user buffer
-   UCPoolBlock *end;         // one past end of user buffer
+    UCPoolBlock *free_list;  // free list
+    size_t block_size;       // aligned size of each block
+    size_t capacity;         // number of blocks
+    size_t align;            // alignment
+    UCPoolBlock *start;      // start of user buffer
+    UCPoolBlock *end;        // one past end of user buffer
 };
 
 /** Initialize the pool.
@@ -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 *buffer,
-               size_t buffer_size,
-               size_t block_size,
-               size_t alignment);
+void uc_pool_init(UCPool *pool, 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/sarena.c

@@ -14,17 +14,32 @@ void *uc_sar_alloc(UCSArena *a, size_t sz)
 void *uc_sar_alloc_aligned(UCSArena *a, size_t sz, unsigned int align)
 {
     assert(align != 0);
-    assert((align & (align - 1)) == 0); //power of 2
+    assert((align & (align - 1)) == 0);  // power of 2
 
     uintptr_t curr = (uintptr_t)a->curr;
     uintptr_t aligned = (curr + (align - (uintptr_t)1)) & ~(align - (uintptr_t)1);
     unsigned char *start = (unsigned char *)aligned;
 
-     if (start + sz > a->end) {
+    if (start + sz > a->end) {
         return NULL;
-     }
+    }
 
-     a->curr = start + sz;
+    a->curr = start + sz;
 
-     return start;
+    return start;
+}
+
+UCSTmpAlloc uc_sar_tmp_begin(UCSArena *a)
+{
+    UCSTmpAlloc state = {.alloc_point = a->curr, .arena = a};
+    a->tmp_allocs++;
+    return state;
+}
+
+void uc_sar_tmp_end(const UCSTmpAlloc *state)
+{
+    UCSArena *a = state->arena;
+    assert(a->tmp_allocs > 0);
+    a->curr = state->alloc_point;
+    a->tmp_allocs--;
 }

src/small_allocator.c

@@ -8,53 +8,44 @@
  * - Allocated pointers are aligned to 16 bytes.
  * - Backing buffer must be aligned to 16 bytes start
  * - 4Gb - 16 is max for the allocator backing buffer.
- * - An allocation "wastes" 16 bytes for the block header
  * - Allocation of > 0 bytes returns a size aligned up to 16 bytes
  * - Allocation of 0 bytes returns a valid pointer with 0 usable space
- *
  * The allocator maintains a doubly linked list of blocks,
  * when blocks are free'd, adjacent blocks are merged to keep
  * fragmentation to a minimum
  */
 
+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.
+    uint8_t pad[4];
+} BlockHeader;
 
-#define ALIGNMENT 16
+#define ALIGNMENT sizeof(BlockHeader)
 #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;
-
-
-_Static_assert(sizeof(BlockHeader) % ALIGNMENT == 0,
-               "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
-    uint32_t size;                 // total size
-    BlockHeader* heap_start;     // first block
-    BlockHeader* last_alloc;     // next-fit pointer
+    uint8_t* base;            // backing store
+    uint32_t size;            // total size
+    BlockHeader* heap_start;  // first block
+    BlockHeader* last_alloc;  // next-fit pointer
 } SmallAllocator;
 
 /* --- 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;
 }
@@ -69,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;
@@ -115,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)
-        return;
+    if (bsize < size + sizeof(BlockHeader) + ALIGNMENT) return;
 
     uint8_t* base = (uint8_t*)block;
-    BlockHeader* new_block =
-        (BlockHeader*)(base + sizeof(BlockHeader) + size);
+    BlockHeader* new_block = (BlockHeader*)(base + sizeof(BlockHeader) + size);
 
     uint32_t new_size = ALIGN_UP(bsize - size - sizeof(BlockHeader));
 
@@ -136,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);
-    if (!next || !block_is_free(next))
-        return;
+    BlockHeader* next = block_from_offset(a, block->next);
+    if (next == NULL || !block_is_free(next)) return;
 
-    uint32_t new_size = ALIGN_UP(block_size(block) +
-                            sizeof(BlockHeader) +
-                            block_size(next));
+    uint32_t new_size = ALIGN_UP(block_size(block) + sizeof(BlockHeader) + block_size(next));
 
     block_set_size(block, new_size);
     block->next = next->next;
-    BlockHeader *nextnext = bh_from_offset(a, next->next);
-    if (nextnext)
-        nextnext->prev = bh_offset(a, block);
+    BlockHeader* nextnext = block_from_offset(a, next->next);
+    if (nextnext) nextnext->prev = bh_offset(a, block);
 }
 
 void* small_alloc(SmallAllocator* a, uint32_t size)
@@ -171,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;
@@ -199,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);
 
@@ -214,36 +197,46 @@ 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);
     }
 
     for (int i = 0; i < SZ; i++) {
-       // if (rand() % 2 == 0) {
-            small_free(&a, ptrs[i]);
-       // }
+        // if (rand() % 2 == 0) {
+        small_free(&a, ptrs[i]);
+        // }
     }
     debug_alloc(&a);
 }