arena.c

Go to the documentation of this file.

// Copyright (C) 2021, 2023 Ethan Uppal. All rights reserved.
 
#include "arena.h"
#include <stdlib.h>      // exit
#include <stdint.h>      // uint64_t
#include <string.h>      // memcpy
#include <stdio.h>       // fprintf
#include <errno.h>       // errno
#include <sys/mman.h>    // mmap
#include <unistd.h>      // sysconf
#include <libgen.h>      // basename
#include "util/abort.h"  // ps_exit, CHECK
 
// TODO: fix up later
#ifdef PS_DEBUG_ARENA
    #define _PSDebug(...) fprintf(stderr, "arena: " __VA_ARGS__)
#else
    #define _PSDebug(...) /* nothing */
#endif
#define NUSED __attribute__((unused))
 
struct ps_arena_allocator arenas[__PS_ARENA_COUNT];
 
void ps_arena_open(enum ps_arena_domain domain) {
    CHECK({
        if (domain < 0 || domain >= __PS_ARENA_COUNT) {
            _PSDebug("Invalid arena domain: %d\n", domain);
            ps_exit(EXIT_FAILURE);
        }
    })
    struct ps_arena_allocator* arena = &arenas[domain];
    arena->page_size = sysconf(_SC_PAGESIZE);
    arena->start = mmap(NULL, PS_INITIAL_ARENA_MMAP, PROT_NONE,
        MAP_ANON | MAP_PRIVATE, -1, 0);
    mprotect(arena->start, arena->page_size, PROT_READ | PROT_WRITE);
    if (arena->start == MAP_FAILED) {
        _PSDebug("mmap: %s\n", strerror(errno));
        ps_exit(EXIT_FAILURE);
    }
    arena->offset = 0;
    _PSDebug("Arena initialized at %p with %llu bytes\n", arena->start,
        PS_INITIAL_ARENA_MMAP);
}
 
void ps_arena_close(enum ps_arena_domain domain) {
    CHECK({
        if (domain < 0 || domain >= __PS_ARENA_COUNT) {
            _PSDebug("Invalid arena domain: %d\n", domain);
            ps_exit(EXIT_FAILURE);
        }
    })
    struct ps_arena_allocator* arena = &arenas[domain];
    if (!arena->start) {
        return;
    }
    munmap(arena->start, PS_INITIAL_ARENA_MMAP);
    arena->start = NULL;
    _PSDebug("Arena was destroyed using %lu out of %llu bytes\n", arena->offset,
        PS_INITIAL_ARENA_MMAP);
}
 
#define _PS_ARENA_ALLOCATE(arena, n)                                           \
    do {                                                                       \
        if (arena->offset + n >= PS_INITIAL_ARENA_MMAP) {                      \
            _PSDebug("Exhausted arena virtual memory\n%s", "");                \
            ps_exit(1);                                                        \
        }                                                                      \
        arena->offset += n;                                                    \
        if ((arena->offset & (arena->page_size - 1)) > 0) {                    \
            const size_t new_size = (arena->offset + arena->page_size - 1)     \
                                    & -(arena->page_size);                     \
            mprotect(arena->start, new_size, PROT_READ | PROT_WRITE);          \
        }                                                                      \
    } while (0)
 
void* ps_arena_allocate(enum ps_arena_domain domain, size_t n) {
    struct ps_arena_allocator* arena = &arenas[domain];
    n = (n + 15ULL) & -16ULL;
    void* ptr = (char*)arena->start + arena->offset;
    _PS_ARENA_ALLOCATE(arena, n);
    return ptr;
}
 
void* ps_arena_allocate_debug(enum ps_arena_domain domain, size_t n,
    const char* file NUSED, const char* func NUSED, size_t line NUSED) {
    void* ptr = ps_arena_allocate(domain, n);
    _PSDebug("New arena object %p (%llu bytes) in %s at %s:%zu\n", ptr, n, func,
        basename(file), line);
    return ptr;
}
 
char* arena_strndup(enum ps_arena_domain arena, const char* str,
    size_t length) {
    char* new_str = arena_alloc(arena, length + 1);
    new_str[length] = 0;
    memcpy(new_str, str, length);
    return new_str;
}