A simple arena (bump) allocator in C Solution, output & explanation

#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>

enum { ALIGN = 16 };

struct arena {
    unsigned char *base;
    size_t used, size;
};

bool arena_init(struct arena *a, size_t size) {
    a->base = malloc(size);
    a->used = 0;
    a->size = size;
    return a->base != NULL;
}

void *arena_alloc(struct arena *a, size_t n) {
    size_t start = (a->used + ALIGN - 1) / ALIGN * ALIGN;      /* round up to 16 */
    if (start > a->size || n > a->size - start)
        return NULL;                                           /* not enough room */
    a->used = start + n;
    return a->base + start;
}

void arena_free_all(struct arena *a) {
    free(a->base);                                             /* one free for everything */
    a->base = NULL;
}

int main(void) {
    struct arena a;
    if (!arena_init(&a, 64))
        return 1;
    int *x = arena_alloc(&a, 3 * sizeof *x);
    char *name = arena_alloc(&a, 10);
    double *big = arena_alloc(&a, 64);
    printf("x at offset %td, name at offset %td\n",
           (unsigned char *) x - a.base, (unsigned char *) name - a.base);
    printf("64 more bytes: %s\n", big != NULL ? "ok" : "out of space");
    printf("used %zu of %zu\n", a.used, a.size);
    arena_free_all(&a);
    return 0;
}

x at offset 0, name at offset 16
64 more bytes: out of space
used 26 of 64