bump tb

Signed-off-by: Shaw Summa <[email protected]>

test/tables/test.lua

@@ -0,0 +1,22 @@
+local function BottomUpTree(item, depth)
+    if depth > 0 then
+        local i = item + item
+        depth = depth - 1
+        local left = BottomUpTree(i - 1, depth)
+        local right = BottomUpTree(i, depth)
+        return {item, left, right}
+    else
+        return {item}
+    end
+end
+
+local function ItemCheck(tree)
+    if tree[2] then
+        return tree[1] + ItemCheck(tree[2]) - ItemCheck(tree[3])
+    else
+        return tree[1]
+    end
+end
+
+local stretchtree = BottomUpTree(0, 12)
+print(ItemCheck(stretchtree))

vendor/common/arena.h

@@ -20,38 +20,33 @@
 #endif
 
 enum {
-    TB_ARENA_SMALL_CHUNK_SIZE  =          16 * 1024,
-    TB_ARENA_MEDIUM_CHUNK_SIZE =    4 * 1024 * 1024,
-    TB_ARENA_LARGE_CHUNK_SIZE  =   16 * 1024 * 1024,
+    TB_ARENA_SMALL_CHUNK_SIZE  =         4 * 1024,
+    TB_ARENA_MEDIUM_CHUNK_SIZE =       512 * 1024,
+    TB_ARENA_LARGE_CHUNK_SIZE  = 64 * 1024 * 1024,
 
     TB_ARENA_ALIGNMENT = 16,
 };
 
-typedef struct TB_ArenaChunk TB_ArenaChunk;
-struct TB_ArenaChunk {
-    TB_ArenaChunk* next;
-    size_t pad;
-    char data[];
-};
+typedef struct TB_Arena TB_Arena;
+struct TB_Arena {
+    TB_Arena* next;
 
-typedef struct TB_Arena {
-    size_t chunk_size;
-    TB_ArenaChunk* base;
-    TB_ArenaChunk* top;
+    // we only care about this for the root arena chunk but whatever
+    TB_Arena* top;
 
     // top of the allocation space
     char* watermark;
     char* high_point; // &top->data[chunk_size]
 
-    size_t highest_point;
-} TB_Arena;
+    char data[];
+};
 
 typedef struct TB_ArenaSavepoint {
-    TB_ArenaChunk* top;
+    TB_Arena* top;
     char* watermark;
 } TB_ArenaSavepoint;
 
-#define TB_ARENA_FOR(it, arena) for (TB_ArenaChunk* it = (arena)->base; it != NULL; it = it->next)
+#define TB_ARENA_FOR(it, arena) for (TB_Arena* it = (arena); it != NULL; it = it->next)
 
 #define TB_ARENA_ALLOC(arena, T) tb_arena_alloc(arena, sizeof(T))
 #define TB_ARENA_ARR_ALLOC(arena, count, T) tb_arena_alloc(arena, (count) * sizeof(T))
@@ -71,6 +66,7 @@ TB_API void tb_arena_pop(TB_Arena* restrict arena, void* ptr, size_t size);
 // in case you wanna mix unaligned and aligned arenas
 TB_API void tb_arena_realign(TB_Arena* restrict arena);
 
+TB_API size_t tb_arena_chunk_size(TB_Arena* arena);
 TB_API size_t tb_arena_current_size(TB_Arena* arena);
 
 // savepoints

vendor/common/buffer.h

@@ -6,26 +6,23 @@ struct nl_buffer_t;
 typedef struct nl_buffer_t nl_buffer_t;
 
 struct nl_buffer_t {
-    void *arena;
     char *buf;
     int len;
     int alloc;
 };
 
-nl_buffer_t *nl_buffer_new(void *arena);
+nl_buffer_t *nl_buffer_new(void);
 void nl_buffer_alloc(nl_buffer_t *buf);
 
-void nl_buffer_format(nl_buffer_t *buf, const char *fmt, ...) __attribute__ (( format( printf, 2, 3 ) )) ;
+void nl_buffer_format(nl_buffer_t *buf, const char *fmt, ...);
 char *nl_buffer_get(nl_buffer_t *buf);
-char *nl_buffer_copy(nl_buffer_t *buf);
 
 #ifdef NL_BUFFER_IMPL
 
-nl_buffer_t *nl_buffer_new(void *alloc) {
-    nl_buffer_t *buf = tb_arena_alloc(alloc, sizeof(nl_buffer_t));
-    buf->arena = alloc;
+nl_buffer_t *nl_buffer_new(void) {
+    nl_buffer_t *buf = NL_MALLOC(sizeof(nl_buffer_t));
     buf->alloc = 16;
-    buf->buf = tb_arena_unaligned_alloc(buf->arena, sizeof(char) * buf->alloc);
+    buf->buf = NL_MALLOC(sizeof(char) * buf->alloc);
     buf->buf[0] = '\0';
     buf->len = 0;
     return buf;
@@ -40,7 +37,7 @@ void nl_buffer_format(nl_buffer_t *buf, const char *restrict fmt, ...) {
         va_end(ap);
         if (avail <= written) {
             buf->alloc = buf->alloc * 2 + 16;
-            buf->buf = tb_arena_realloc(buf->arena, buf->buf, sizeof(char) * buf->alloc);
+            buf->buf = NL_REALLOC(buf->buf, sizeof(char) * buf->alloc);
             continue;
         }
         buf->len += written;
@@ -52,13 +49,6 @@ char *nl_buffer_get(nl_buffer_t *buf) {
     return buf->buf;
 }
 
-char *nl_buffer_copy(nl_buffer_t *buf) {
-    int len = strlen(buf->buf);
-    char *ret = NL_MALLOC(len + 1);
-    memcpy(ret, buf->buf, len + 1);
-    return ret;
-}
-
 #endif
 
 #endif

vendor/common/chunked_array.h

@@ -36,7 +36,8 @@ NL_ChunkedArr nl_chunked_arr_alloc(TB_Arena* arena) {
 
     ptrdiff_t leftovers = arena->high_point - (arena->watermark + sizeof(NL_ChunkedArr));
     if (leftovers < 64) {
-        leftovers = arena->chunk_size - (sizeof(NL_ArrChunk) + sizeof(TB_ArenaChunk));
+        size_t chunk_size = tb_arena_chunk_size(arena);
+        leftovers = chunk_size - (sizeof(NL_ArrChunk) + sizeof(TB_Arena));
     }
 
     ptrdiff_t num_elems = leftovers / sizeof(void*);
@@ -52,7 +53,8 @@ void nl_chunked_arr_put(NL_ChunkedArr* arr, void* v) {
     NL_ArrChunk* last = arr->last;
     if (last->cap == last->count) {
         // allocate new chunk
-        ptrdiff_t leftovers = arr->arena->chunk_size - (sizeof(NL_ArrChunk) + sizeof(TB_ArenaChunk));
+        size_t chunk_size = tb_arena_chunk_size(arr->arena);
+        ptrdiff_t leftovers = chunk_size - (sizeof(NL_ArrChunk) + sizeof(TB_Arena));
         ptrdiff_t num_elems = leftovers / sizeof(void*);
         NL_ArrChunk* new_chk = tb_arena_alloc(arr->arena, sizeof(NL_ChunkedArr) + num_elems*sizeof(void*));
 

vendor/common/common.c

@@ -1,7 +1,3 @@
-#if defined(EMSCRIPTEN)
-#define NDEBUG 1
-#endif
-
 // Common is just a bunch of crap i want accessible to all projects in the Cuik repo
 #include "arena.h"
 #include "futex.h"
@@ -89,42 +85,37 @@ TB_Arena* tb_arena_create(size_t chunk_size) {
     }
 
     // allocate initial chunk
-    TB_ArenaChunk* c = cuik__valloc(chunk_size);
-    c->next = NULL;
-
-    TB_Arena* arena = (TB_Arena*) c->data;
-    arena->chunk_size = chunk_size;
-    arena->watermark  = &c->data[sizeof(TB_Arena)];
-    arena->high_point = &c->data[chunk_size - sizeof(TB_ArenaChunk)];
-    arena->base = arena->top = c;
+    TB_Arena* arena = cuik__valloc(chunk_size);
+    arena->watermark  = arena->data;
+    arena->high_point = &arena->data[chunk_size - sizeof(TB_Arena)];
+    arena->top = arena;
     return arena;
 }
 
 void tb_arena_destroy(TB_Arena* restrict arena) {
-    if (arena) {
-        TB_ArenaChunk* c = arena->base;
-        while (c != NULL) {
-            TB_ArenaChunk* next = c->next;
-            cuik__vfree(c, arena->chunk_size);
-            c = next;
-        }
+    TB_Arena* c = arena;
+    while (c != NULL) {
+        TB_Arena* next = c->next;
+        cuik__vfree(c, tb_arena_chunk_size(c));
+        c = next;
     }
 }
 
 void* tb_arena_unaligned_alloc(TB_Arena* restrict arena, size_t size) {
-    if (LIKELY(arena->watermark + size <= arena->high_point)) {
-        char* ptr = arena->watermark;
-        arena->watermark += size;
+    TB_Arena* top = arena->top;
+    if (LIKELY(top->watermark + size <= top->high_point)) {
+        char* ptr = top->watermark;
+        top->watermark += size;
         return ptr;
     } else {
-        assert(size < arena->chunk_size - sizeof(TB_ArenaChunk));
+        // slow path, we need to allocate more pages
+        size_t chunk_size = tb_arena_chunk_size(arena);
+        assert(size < chunk_size - sizeof(TB_Arena));
 
-        // slow path, we need to allocate more
-        TB_ArenaChunk* c = cuik__valloc(arena->chunk_size);
+        TB_Arena* c = cuik__valloc(chunk_size);
         c->next = NULL;
-
-        arena->watermark  = c->data + size;
-        arena->high_point = &c->data[arena->chunk_size - sizeof(TB_ArenaChunk)];
+        c->watermark  = c->data + size;
+        c->high_point = &c->data[chunk_size - sizeof(TB_Arena)];
 
         // append to top
         arena->top->next = c;
@@ -143,7 +134,7 @@ TB_API void* tb_arena_realloc(TB_Arena* restrict arena, void* old, size_t size)
 
     char* dst = tb_arena_unaligned_alloc(arena, size);
     if (dst != p && old) {
-        memmove(dst, old, size);
+        memcpy(dst, old, size);
     }
     return dst;
 }
@@ -180,17 +171,16 @@ TB_ArenaSavepoint tb_arena_save(TB_Arena* arena) {
 
 void tb_arena_restore(TB_Arena* arena, TB_ArenaSavepoint sp) {
     // kill any chunks which are ahead of the top
-    TB_ArenaChunk* c = sp.top->next;
+    TB_Arena* c = sp.top->next;
     while (c != NULL) {
-        TB_ArenaChunk* next = c->next;
-        cuik__vfree(c, arena->chunk_size);
+        TB_Arena* next = c->next;
+        cuik__vfree(c, tb_arena_chunk_size(c));
         c = next;
     }
 
     arena->top = sp.top;
     arena->top->next = NULL;
     arena->watermark = sp.watermark;
-    arena->high_point = &sp.top->data[arena->chunk_size - sizeof(TB_ArenaChunk)];
 }
 
 void* tb_arena_alloc(TB_Arena* restrict arena, size_t size) {
@@ -202,37 +192,38 @@ void* tb_arena_alloc(TB_Arena* restrict arena, size_t size) {
 }
 
 void tb_arena_clear(TB_Arena* arena) {
-    TB_ArenaChunk* c = arena->base;
-    if (c == NULL) return;
+    if (arena != NULL) {
+        arena->watermark = arena->data;
+        arena->top = arena;
 
-    arena->watermark = &c->data[sizeof(TB_Arena)];
-    arena->high_point = &c->data[arena->chunk_size - sizeof(TB_ArenaChunk)];
-    arena->base = arena->top = c;
+        // remove extra chunks
+        TB_Arena* c = arena->next;
+        while (c != NULL) {
+            TB_Arena* next = c->next;
+            cuik__vfree(c, tb_arena_chunk_size(c));
+            c = next;
+        }
 
-    // remove extra chunks
-    c = c->next;
-    while (c != NULL) {
-        TB_ArenaChunk* next = c->next;
-        cuik__vfree(c, arena->chunk_size);
-        c = next;
+        arena->next = NULL;
     }
-
-    arena->top->next = NULL;
 }
 
 bool tb_arena_is_empty(TB_Arena* arena) {
-    return arena->base == NULL;
+    return arena->top != arena || (arena->watermark - arena->data) > 0;
+}
+
+size_t tb_arena_chunk_size(TB_Arena* arena) {
+    return arena->high_point - (char*) arena;
 }
 
 size_t tb_arena_current_size(TB_Arena* arena) {
     size_t total = 0;
-    TB_ArenaChunk* c = arena->base;
-    while (c != arena->top) {
-        total += arena->chunk_size;
+    TB_Arena* c = arena;
+    while (c != NULL) {
+        total += arena->watermark - (char*) arena;
         c = c->next;
     }
-
-    return total + (arena->watermark - (char*) arena->top);
+    return total;
 }
 
 ////////////////////////////////

vendor/common/log.h

@@ -40,12 +40,12 @@ enum { LOG_TRACE, LOG_DEBUG, LOG_INFO, LOG_WARN, LOG_ERROR, LOG_FATAL };
 #define log_fatal(...) log_log(LOG_FATAL, __FILE__, __LINE__, __VA_ARGS__)
 #define log_watch(fmt, var) log_log(LOG_DEBUG, __FILE__, __LINE__, #var " = " fmt, (uint64_t)var)
 #else
-#define log_trace(...) (void) (__VA_ARGS__, 0)
-#define log_debug(...) (void) (__VA_ARGS__, 0)
-#define log_info(...)  (void) (__VA_ARGS__, 0)
-#define log_warn(...)  (void) (__VA_ARGS__, 0)
-#define log_error(...) (void) (__VA_ARGS__, 0)
-#define log_fatal(...) (void) (__VA_ARGS__, 0)
+#define log_trace(...) (__VA_ARGS__, 0)
+#define log_debug(...) (__VA_ARGS__, 0)
+#define log_info(...)  (__VA_ARGS__, 0)
+#define log_warn(...)  (__VA_ARGS__, 0)
+#define log_error(...) (__VA_ARGS__, 0)
+#define log_fatal(...) (__VA_ARGS__, 0)
 #define log_watch(fmt, var) (var, 0)
 #endif