Reorganise files

src/core/mem/arena/mem_arena.c

@@ -0,0 +1,119 @@
+#include "mem_arena.h"
+#include "aliases.h"
+#include "mem_utils.h"
+#include "misc_utils.h"
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef DEFAULT_ALIGNMENT
+// Why 2 * sizeof(void *) instead of sizeof(void *)
+// https://handmade.network/forums/t/6860-alignment_arena_allocator
+#define DEFAULT_ALIGNMENT (2 * sizeof(void *))
+#endif /* ifndef DEFAULT_ALIGNMENT */
+
+#define ARENA_MINIMUM_CAPACITY 1024
+
+struct arena {
+  u8 *buf;
+  u8 *offset;
+  u64 capacity;
+  bool committed;
+
+#ifdef WAPP_PLATFORM_WINDOWS
+  wapp_misc_utils_padding_size(sizeof(u8 *) * 2 + sizeof(u64) + sizeof(bool));
+#endif // ifdef WAPP_PLATFORM_WINDOWS
+};
+
+// PUBLIC API
+
+bool wapp_mem_arena_init(Arena **arena, u64 base_capacity, MemAllocFlags flags,
+                         bool zero_buffer) {
+  if (!arena || *arena || base_capacity == 0) {
+    return false;
+  }
+
+  *arena = (Arena *)calloc(1, sizeof(Arena));
+  Arena *arena_ptr = *arena;
+  if (!arena_ptr) {
+    return false;
+  }
+
+  u64 arena_capacity = base_capacity >= ARENA_MINIMUM_CAPACITY
+                           ? base_capacity
+                           : ARENA_MINIMUM_CAPACITY;
+
+  arena_ptr->buf = (u8 *)wapp_mem_util_alloc(
+      NULL, arena_capacity, WAPP_MEM_ACCESS_READ_WRITE, flags,
+      zero_buffer ? WAPP_MEM_INIT_INITIALISED : WAPP_MEM_INIT_UNINITIALISED);
+
+  if (!(arena_ptr->buf)) {
+    wapp_mem_arena_destroy(arena);
+    return false;
+  }
+
+  arena_ptr->capacity = arena_capacity;
+  arena_ptr->offset = arena_ptr->buf;
+  arena_ptr->committed =
+      (flags & WAPP_MEM_ALLOC_COMMIT) == WAPP_MEM_ALLOC_COMMIT;
+
+  return true;
+}
+
+void *wapp_mem_arena_alloc(Arena *arena, u64 size) {
+  return wapp_mem_arena_alloc_aligned(arena, size, DEFAULT_ALIGNMENT);
+}
+
+void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
+  if (!arena) {
+    return NULL;
+  }
+
+  u8 *alloc_start = arena->offset;
+
+  u8 *output = wapp_mem_util_align_forward((void *)alloc_start, alignment);
+  if (output + size >= arena->buf + arena->capacity) {
+    return NULL;
+  }
+
+  arena->offset = output + size;
+
+#ifdef WAPP_PLATFORM_WINDOWS
+  if (!(arena->committed)) {
+    output = (u8 *)wapp_mem_util_alloc(
+        alloc_start, (uptr)(arena->offset) - (uptr)(alloc_start),
+        WAPP_MEM_ACCESS_READ_WRITE, WAPP_MEM_ALLOC_COMMIT,
+        WAPP_MEM_INIT_INITIALISED);
+  }
+#else
+  memset(output, 0, size);
+#endif // ifdef WAPP_PLATFORM_WINDOWS
+
+  return (void *)output;
+}
+
+void wapp_mem_arena_clear(Arena *arena) {
+  if (!arena) {
+    return;
+  }
+
+  memset(arena->buf, 0, arena->offset - arena->buf);
+  arena->offset = arena->buf;
+}
+
+void wapp_mem_arena_destroy(Arena **arena) {
+  if (!arena) {
+    return;
+  }
+
+  Arena *arena_ptr = *arena;
+  if (arena_ptr->buf) {
+    wapp_mem_util_free(arena_ptr->buf, arena_ptr->capacity);
+  }
+
+  arena_ptr->buf = arena_ptr->offset = NULL;
+  arena_ptr->capacity = 0;
+
+  free(*arena);
+  *arena = NULL;
+}

src/core/mem/arena/mem_arena.h

@@ -0,0 +1,37 @@
+#ifndef MEM_ARENA_H
+#define MEM_ARENA_H
+
+#include "aliases.h"
+#include "mem_utils.h"
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+typedef struct arena Arena;
+
+#define wapp_mem_arena_init_default(arena_dptr, base_capacity)                 \
+  (wapp_mem_arena_init(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE,      \
+                       false))
+#define wapp_mem_arena_init_commit(arena_dptr, base_capacity)                  \
+  (wapp_mem_arena_init(arena_dptr, base_capacity,                              \
+                       WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, false))
+#define wapp_mem_arena_init_zero(arena_dptr, base_capacity)                    \
+  (wapp_mem_arena_init(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE, true))
+#define wapp_mem_arena_init_commit_and_zero(arena_dptr, base_capacity)         \
+  (wapp_mem_arena_init(arena_dptr, base_capacity,                              \
+                       WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, true))
+
+bool wapp_mem_arena_init(Arena **arena, u64 base_capacity, MemAllocFlags flags,
+                         bool zero_buffer);
+void *wapp_mem_arena_alloc(Arena *arena, u64 size);
+void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment);
+void wapp_mem_arena_clear(Arena *arena);
+void wapp_mem_arena_destroy(Arena **arena);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // !MEM_ARENA_H

src/core/mem/util/mem_utils.c

@@ -0,0 +1,115 @@
+#include "mem_utils.h"
+#include "aliases.h"
+#include "platform.h"
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(WAPP_PLATFORM_WINDOWS)
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <memoryapi.h>
+
+internal const i32 access_types[] = {
+    [WAPP_MEM_ACCESS_NONE] = PAGE_NOACCESS,
+    [WAPP_MEM_ACCESS_READ_ONLY] = PAGE_READONLY,
+    [WAPP_MEM_ACCESS_EXEC_ONLY] = PAGE_EXECUTE,
+    [WAPP_MEM_ACCESS_READ_WRITE] = PAGE_READWRITE,
+    [WAPP_MEM_ACCESS_READ_EXEC] = PAGE_EXECUTE_READ,
+    [WAPP_MEM_ACCESS_READ_WRITE_EXEC] = PAGE_EXECUTE_READWRITE,
+};
+
+internal inline void *alloc_windows(void *addr, u64 size, MemAccess access,
+                                    MemAllocFlags flags);
+#elif defined(WAPP_PLATFORM_POSIX)
+#include <sys/mman.h>
+
+internal const i32 access_types[] = {
+    [WAPP_MEM_ACCESS_NONE] = PROT_NONE,
+    [WAPP_MEM_ACCESS_READ_ONLY] = PROT_READ,
+    [WAPP_MEM_ACCESS_EXEC_ONLY] = PROT_EXEC,
+    [WAPP_MEM_ACCESS_READ_WRITE] = PROT_READ | PROT_WRITE,
+    [WAPP_MEM_ACCESS_READ_EXEC] = PROT_READ | PROT_EXEC,
+    [WAPP_MEM_ACCESS_READ_WRITE_EXEC] = PROT_READ | PROT_WRITE | PROT_EXEC,
+};
+
+internal inline void *alloc_posix(void *addr, u64 size, MemAccess access,
+                                  MemAllocFlags flags);
+#else
+#error "Unrecognised platform"
+#endif
+
+internal bool is_power_of_two(u64 num) { return (num & (num - 1)) == 0; }
+
+void *wapp_mem_util_align_forward(void *ptr, u64 alignment) {
+  if (!ptr) {
+    return NULL;
+  }
+
+  assert(is_power_of_two(alignment));
+
+  uptr p = (uptr)ptr;
+  uptr align = (uptr)alignment;
+
+  // Similar to p % align, but it's a faster implementation that works fine
+  // because align is guaranteed to be a power of 2
+  uptr modulo = p & (align - 1);
+
+  if (modulo != 0) {
+    p += align - modulo;
+  }
+
+  return (void *)p;
+}
+
+void *wapp_mem_util_alloc(void *addr, u64 size, MemAccess access,
+                          MemAllocFlags flags, MemInitType type) {
+#if defined(WAPP_PLATFORM_WINDOWS)
+  // Ensure memory is committed if it's meant to be initialised
+  if (type == WAPP_MEM_INIT_INITIALISED) {
+    flags |= WAPP_MEM_ALLOC_COMMIT;
+  }
+
+  void *output = alloc_windows(addr, size, access, flags);
+#elif defined(WAPP_PLATFORM_POSIX)
+  void *output = alloc_posix(addr, size, access, flags);
+#else
+  return NULL;
+#endif
+
+  if (type == WAPP_MEM_INIT_INITIALISED) {
+    memset(output, 0, size);
+  }
+
+  return output;
+}
+
+void wapp_mem_util_free(void *ptr, u64 size) {
+#if defined(WAPP_PLATFORM_WINDOWS)
+  VirtualFree(ptr, size, MEM_RELEASE);
+#elif defined(WAPP_PLATFORM_POSIX)
+  munmap(ptr, size);
+#endif
+}
+
+#ifdef WAPP_PLATFORM_WINDOWS
+internal inline void *alloc_windows(void *addr, u64 size, MemAccess access,
+                                    MemAllocFlags flags) {
+  return VirtualAlloc(addr, (SIZE_T)size, flags, access_types[access]);
+}
+#endif
+
+#if defined(WAPP_PLATFORM_POSIX)
+internal inline void *alloc_posix(void *addr, u64 size, MemAccess access,
+                                  MemAllocFlags flags) {
+  i32 alloc_flags = flags | MAP_ANON | MAP_PRIVATE;
+
+#if defined(WAPP_PLATFORM_LINUX) || defined(WAPP_PLATFORM_GNU) ||              \
+    defined(WAPP_PLATFORM_NET_BSD)
+  alloc_flags |= MAP_NORESERVE;
+#endif
+
+  return mmap(addr, size, access_types[access], alloc_flags, -1, 0);
+}
+#endif

src/core/mem/util/mem_utils.h

@@ -0,0 +1,61 @@
+#ifndef MEM_UTILS_H
+#define MEM_UTILS_H
+
+#include "aliases.h"
+#include "platform.h"
+
+#if defined(WAPP_PLATFORM_WINDOWS)
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <memoryapi.h>
+#elif defined(WAPP_PLATFORM_POSIX)
+#include <sys/mman.h>
+#else
+#error "Unrecognised platform"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+typedef enum mem_access {
+  WAPP_MEM_ACCESS_NONE,
+  WAPP_MEM_ACCESS_READ_ONLY,
+  WAPP_MEM_ACCESS_EXEC_ONLY,
+  WAPP_MEM_ACCESS_READ_WRITE,
+  WAPP_MEM_ACCESS_READ_EXEC,
+  WAPP_MEM_ACCESS_READ_WRITE_EXEC,
+} MemAccess;
+
+typedef enum mem_alloc_flags {
+#if defined(WAPP_PLATFORM_WINDOWS)
+  WAPP_MEM_ALLOC_RESERVE = MEM_RESERVE,
+  WAPP_MEM_ALLOC_COMMIT = MEM_COMMIT,
+#elif defined(WAPP_PLATFORM_LINUX) || defined(WAPP_PLATFORM_GNU)
+  WAPP_MEM_ALLOC_RESERVE = 0,
+  WAPP_MEM_ALLOC_COMMIT = MAP_POPULATE,
+#elif defined(WAPP_PLATFORM_FREE_BSD)
+  WAPP_MEM_ALLOC_RESERVE = 0,
+  WAPP_MEM_ALLOC_COMMIT = MAP_PREFAULT_READ,
+#elif defined(WAPP_PLATFORM_BSD) || defined(WAPP_PLATFORM_UNIX) ||             \
+    defined(WAPP_PLATFORM_APPLE)
+  WAPP_MEM_ALLOC_RESERVE = 0,
+  WAPP_MEM_ALLOC_COMMIT = 0,
+#endif
+} MemAllocFlags;
+
+typedef enum mem_init_type {
+  WAPP_MEM_INIT_UNINITIALISED,
+  WAPP_MEM_INIT_INITIALISED,
+} MemInitType;
+
+void *wapp_mem_util_align_forward(void *ptr, u64 alignment);
+void *wapp_mem_util_alloc(void *addr, u64 size, MemAccess access,
+                          MemAllocFlags flags, MemInitType type);
+void wapp_mem_util_free(void *ptr, u64 size);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // !MEM_UTILS_H