Files
lilalloc/include/lpool.h
T

67 lines
1.8 KiB
C

#ifndef LPOOL_H_
#define LPOOL_H_
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef union LPoolBlock LPoolBlock;
union LPoolBlock {
uint32_t next; // offset from start to next free block (when not allocated)
unsigned char data[0]; // data when allocated
};
/** @file
* Pool allocator.
*
* An LPool allocates fixed size memory chunks from a provided buffer,
* and memory allocations can be free'd in any order.
*
* The backing array should be suitable aligned to the types
* that will be allocated from it. Use .e.g
* @code
* _Alignas(16) char mem[1024];
* @endcode
* as the backing buffer.
*
*/
typedef struct LPool LPool;
struct LPool {
LPoolBlock *free_list; // free list
uint8_t *start; // start of user buffer
uint8_t *end; // one past end of user buffer
uint32_t block_size; // aligned size of each block
uint32_t capacity; // number of blocks
uint32_t align; // alignment
};
/** Initialize the pool.
*
* Block size will be rounded up by alignment, or to size of a pointer if alignment is less that a pointer.
* Prefer to use lock sizes that's pointer aligned
*
* @param buffer backing buffer for the pool
* @param buffer_size size of @buffer
* @param block_size size of each allocation.
* @param alignment alignment of each block (must be power of 2)
*/
void lpool_init(LPool *pool, void *buffer, size_t buffer_size, uint32_t block_size, uint32_t alignment);
// Allocate a block from the pool. Returns NULL if no more space
[[gnu::assume_aligned(_Alignof(LPoolBlock))]]
void *lpool_alloc(LPool *pool);
// Free @p . Returns memory to the pool
void lpool_free(LPool *pool, void *p);
// Frees all memory in the pool, resetting it to initial state.
void lpool_reset(LPool *pool);
#ifdef __cplusplus
} // extern "C"
#endif
#endif