noselasd/nob
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity
Files
10186202adda6a4b48c0034def50694a536fe656
nob/src/main.c
T

699 lines
19 KiB
C
Raw Blame History

#include "base_core.h"
#include "arena.h"
#include "mini_arena.h"
#include "platform.h"
#include "pool.h"
#include "string.h"
#include <stdio.h>
#include <stdlib.h>
void arena_dump(const Arena *arena)
{
return;
MemoryBlock *block = arena->current;
puts("@@@@@@@@@@");
while (block) {
puts("-----Arena-----");
printf("base: %p\n", block->base);
printf("size: %u\n", block->size);
printf("first_free: %u\n", block->first_free);
printf("total_used: %lu\n",block->arena_offset);
printf("prev: %p\n", block->prev);
puts("-----Arena end-");
block = block->prev;
}
}
static void arena_test_1(void)
{
TRACEF("\n");
ArenaOptions arena_params = {};
U32 arena_size = MB(1) + MemoryBlock_Header_Size;
U32 commit_size = KB(8);
arena_params.size = arena_size;
arena_params.commit_size = commit_size;
Arena arena;
arena_init(&arena, &arena_params);
arena_dump(&arena);
void *ptr = arena_push(&arena, 512, 1);
MemoryZero(ptr, 512);
printf("Allocated ptr %p\n", ptr);
arena_dump(&arena);
ptr = arena_push(&arena, 512, 1);
MemoryZero(ptr, 512);
printf("Allocated ptr %p\n", ptr);
arena_dump(&arena);
ptr = arena_push(&arena, 1, 1);
MemoryZero(ptr, 1);
printf("Allocated ptr %p\n", ptr);
arena_dump(&arena);
arena_free(&arena);
}
static void arena_test_2(void)
{
TRACEF("\n");
ArenaOptions arena_params = {};
U32 arena_size = MB(3) + MemoryBlock_Header_Size;
U32 commit_size = KB(72);
U32 push_size = KB(32);
arena_params.size = arena_size;
arena_params.commit_size = commit_size;
Arena arena;
arena_init(&arena, &arena_params);
void *ptr;
ptr = arena_push(&arena, push_size, 8);
MemoryZero(ptr, push_size);
printf("Allocated ptr %p\n", ptr);
arena_dump(&arena);
ATemp checkpoint = arena_temp_begin(&arena);
ptr = arena_push(&arena, MB(4)+3, 8);
MemoryZero(ptr, MB(2));
ptr = arena_push(&arena, commit_size * 3, 8);
MemoryZero(ptr, commit_size * 3 );
ptr = arena_push(&arena, commit_size , 8);
MemoryZero(ptr, commit_size );
ATemp checkpoint2 = arena_temp_begin(&arena);
ptr = arena_push(&arena, 64, 8);
MemoryZero(ptr, 64);
arena_temp_end(&checkpoint2);
arena_temp_end(&checkpoint);
arena_reset_to(&arena, 1088);
arena_dump(&arena);
ptr = arena_push(&arena, 1, KB(16));
((U8*)ptr)[0] = 0x37;
ptr = arena_push(&arena, 1, KB(16));
((U8*)ptr)[0] = 0x73;
ptr = arena_push(&arena, 0, KB(4));
//((U8*)ptr)[0] = 0x73;
// arena_reset_to(&arena, 1089);
arena_dump(&arena);
arena_reset_to(&arena, 0);
for (U64 i = 0; i < MB(4); i++) {
ptr = arena_push(&arena, 3, 1);
MemoryZero(ptr, 3);
}
arena_free(&arena);
}
static void arena_test_3(void)
{
TRACEF("\n");
ArenaOptions arena_params = {};
U32 arena_size = KB(97) + MemoryBlock_Header_Size;
U32 commit_size = KB(97);
arena_params.size = arena_size;
arena_params.commit_size = commit_size;
Arena arena;
arena_init(&arena, &arena_params);
arena_dump(&arena);
void *ptr = arena_push(&arena, KB(64), 32);
MemoryZero(ptr, KB(64));
printf("Allocated ptr %p\n", ptr);
arena_dump(&arena);
ptr = arena_push(&arena, KB(97) - KB(64), 32);
MemoryZero(ptr, KB(97) - KB(64));
printf("Allocated ptr %p\n", ptr);
arena_dump(&arena);
arena_free(&arena);
}
// Exercises the alignment-padding edge case: a fresh block has first_free at
// MemoryBlock_Header_Size (64), so a large alignment pushes the user pointer
// well past the header. Requesting (block_size - 64) bytes with page alignment
// previously tripped the end_pos <= block->size assert because the alignment
// gap was not accounted for. After the fix this should allocate a larger block.
static void arena_test_4(void)
{
TRACEF("\n");
U32 page_size = platform_page_size();
ArenaOptions arena_params = {};
U32 arena_size = MB(1) + MemoryBlock_Header_Size;
U32 commit_size = KB(64);
arena_params.size = arena_size;
arena_params.commit_size = commit_size;
Arena arena;
arena_init(&arena, &arena_params);
// block_size is the page-aligned arena_size. Request nearly the whole block
// but with page alignment, so the alignment gap (a full page) forces a grow.
U32 block_size = arena.block_size;
U32 push_size = block_size - MemoryBlock_Header_Size;
void *ptr = arena_push(&arena, push_size, page_size);
Assert(IsAlignedTo((uintptr_t)ptr, page_size));
MemoryZero(ptr, push_size);
printf("test_4: allocated %u bytes page-aligned at %p\n", push_size, ptr);
arena_dump(&arena);
// A second page-aligned push to make sure the cursor math still holds.
ptr = arena_push(&arena, page_size, page_size);
Assert(IsAlignedTo((uintptr_t)ptr, page_size));
MemoryZero(ptr, page_size);
printf("test_4: allocated %u bytes page-aligned at %p\n", page_size, ptr);
arena_free(&arena);
}
static void arena_test_allocator_interface(void)
{
TRACEF("\n");
U32 page_size = platform_page_size();
ArenaOptions arena_params = {};
U32 arena_size = MB(1) + MemoryBlock_Header_Size;
U32 commit_size = KB(64);
arena_params.size = arena_size;
arena_params.commit_size = commit_size;
Arena arena;
arena_init(&arena, &arena_params);
Allocator allocator = arena_allocator(&arena);
// block_size is the page-aligned arena_size. Request nearly the whole block
// but with page alignment, so the alignment gap (a full page) forces a grow.
U32 block_size = arena.block_size;
U32 push_size = block_size - MemoryBlock_Header_Size;
void *ptr = allocator_push(&allocator, push_size, page_size);
Assert(IsAlignedTo((uintptr_t)ptr, page_size));
MemoryZero(ptr, push_size);
printf("test_4: allocated %u bytes page-aligned at %p\n", push_size, ptr);
arena_dump(&arena);
// A second page-aligned push to make sure the cursor math still holds.
ptr = allocator_push(&allocator, page_size, page_size);
Assert(IsAlignedTo((uintptr_t)ptr, page_size));
MemoryZero(ptr, page_size);
printf("test_4: allocated %u bytes page-aligned at %p\n", page_size, ptr);
allocator_free_all(&allocator);
arena_free(&arena);
}
static void arena_test_decommit(void)
{
TRACEF("\n");
U32 page_size = platform_page_size();
ArenaOptions arena_params = {};
U32 arena_size = MB(1) + MemoryBlock_Header_Size;
U32 commit_size = KB(64);
arena_params.size = arena_size;
arena_params.commit_size = commit_size;
Arena arena;
arena_init(&arena, &arena_params);
void *ptr = arena_push(&arena, commit_size * 10, 8);
MemoryZero(ptr, commit_size * 10);
arena_reset(&arena);
void *pre_ptr = arena_push(&arena, 5, 4);
ATemp tmp = arena_temp_begin(&arena);
ptr = arena_push(&arena, commit_size * 2 + 13, 8);
MemoryZero(ptr, commit_size * 2 + 13);
arena_temp_end(&tmp);
MemoryZero(pre_ptr, 5);
arena_free(&arena);
}
void miniarena_test1(void)
{
TRACEF("\n");
#define arena_size 4096
MARENA_DEFINE(arena, arena_size, 8);
int i;
for (i = 0; ; i++) {
void *ptr = marena_push(&arena, 1);
if (ptr == NULL) {
break;
}
}
printf("miniarena_test1,size %u pushed %d bytes first_free %u\n", arena.size, i, arena.first_free);
marena_reset(&arena);
MTemp checkpoint = marena_temp_begin(&arena);
void *ptr = marena_push(&arena, arena_size);
Assert(ptr != NULL);
Assert(arena.first_free == arena_size);
MemoryZero(ptr, arena_size);
marena_temp_end(&checkpoint);
Assert(arena.first_free == 0);
U32 *val = marena_push_type(&arena, U32);
*val = 0xa0b0c0d0;
printf("marena val 0x%x\n", *val);
printf("miniarena_test1,size %u bytes first_free %u\n", arena.size, arena.first_free);
Assert(arena.first_free == sizeof(U32));
}
typedef struct PoolTest PoolTest;
struct PoolTest{
U32 n;
PoolTest *next;
char name[12];
};
void apool_test(void)
{
TRACEF("\n");
Arena arena;
arena_init(&arena, &ArenaOptions_Default);
Allocator allocator = arena_allocator(&arena);
APool *pool = apool_create_ex(&allocator, 16, sizeof(PoolTest), alignof(PoolTest));
PoolTest *list = NULL;
for (U32 i = 0; i < U32_Max; i++) {
PoolTest *pt = apool_alloc(pool);
if (pt == NULL){
break;
}
pt->n = i;
pt->next = list;
list = pt;
}
for (PoolTest *p = list; p; p = p->next){
printf("Pooltest %u\n",p->n);
}
PoolTest *next;
U32 count = 0;
for (PoolTest *p = list; count < 7 && p; p = next){
count++;
next = p->next;
printf("Pooltest freeing %u\n",p->n);
apool_free(pool, p);
}
list = NULL;
for (U32 i = 0; i < U32_Max; i++) {
PoolTest *pt = apool_alloc(pool);
if (pt == NULL){
break;
}
pt->n = i;
pt->next = list;
list = pt;
}
for (PoolTest *p = list; p; p = p->next){
printf("Pooltest %u\n",p->n);
}
allocator_free_all(&allocator);
arena_free(&arena);
}
void apool_test_miniarena(void)
{
TRACEF("\n");
MArena arena;
U8 data[4096];
marena_init(&arena, data, sizeof data);
Allocator allocator = marena_allocator(&arena);
APool *pool = apool_create_ex(&allocator, 16, sizeof(PoolTest), alignof(PoolTest));
PoolTest *list = NULL;
for (U32 i = 0; i < U32_Max; i++) {
PoolTest *pt = apool_alloc(pool);
if (pt == NULL){
break;
}
pt->n = i;
pt->next = list;
list = pt;
}
for (PoolTest *p = list; p; p = p->next){
printf("Pooltest %u\n",p->n);
}
PoolTest *next;
U32 count = 0;
for (PoolTest *p = list; count < 7 && p; p = next){
count++;
next = p->next;
printf("Pooltest freeing %u\n",p->n);
apool_free(pool, p);
}
list = NULL;
for (U32 i = 0; i < U32_Max; i++) {
PoolTest *pt = apool_alloc(pool);
if (pt == NULL){
break;
}
pt->n = i;
pt->next = list;
list = pt;
}
for (PoolTest *p = list; p; p = p->next){
printf("Pooltest %u\n",p->n);
}
allocator_free_all(&allocator);
}
void apool_test_autogrow(void)
{
TRACEF("\n");
Arena arena;
arena_init(&arena, &ArenaOptions_Default);
Allocator allocator = arena_allocator(&arena);
APool *pool = apool_create(&allocator, APOOL_AUTOGROW, PoolTest);
PoolTest *list = NULL;
for (U32 i = 0; i < 4; i++) {
PoolTest *pt = apool_alloc(pool);
if (pt == NULL){
break;
}
pt->n = i;
pt->next = list;
list = pt;
}
for (PoolTest *p = list; p; p = p->next){
printf("Pooltest %u\n",p->n);
}
PoolTest *next;
U32 count = 0;
for (PoolTest *p = list; count < 3 && p; p = next){
count++;
next = p->next;
printf("Pooltest freeing %u\n",p->n);
apool_free(pool, p);
}
list = NULL;
for (U32 i = 0; i < 5; i++) {
PoolTest *pt = apool_alloc(pool);
if (pt == NULL){
break;
}
pt->n = i;
pt->next = list;
list = pt;
}
for (PoolTest *p = list; p; p = p->next){
printf("Pooltest %u\n",p->n);
}
allocator_free_all(&allocator);
arena_free(&arena);
}
void string_test_1(void)
{
TRACEF("\n");
Str str1 = S("Hello");
printf("str1: %.*s len %d\n", str1.len, str1.str, str1.len);
U64 str1_index_of_l = str_find_byte(str1, 'l');
U64 str1_index_of_g = str_find_byte(str1, 'g');
printf("str1: index of l %ld, index of g: %ld\n", str1_index_of_l, str1_index_of_g);
MARENA_DEFINE(arena, 512, 1);
Allocator alloc = marena_allocator(&arena);
Str str2 = str_dup(&alloc, S(" World"));
Str str3 = str_concat(&alloc, str1, str2);
printf("str3: %.*s len %d\n", str3.len, str3.str, str3.len);
}
void string_split_test_1(void)
{
TRACEF("\n");
Str str1 = S("|a:bb|ccc|");
Str sep = S("|:");
STRVEC_DEFINE(strings, 16);
str_split(str1, sep, &strings);
for (U32 i = 0; i < strings.len; i++) {
Str *str = &strings.strings[i];
printf("split %u: '%.*s'\n", i, str->len, str->str);
}
}
void string_test_misc(void)
{
TRACEF("\n");
Str str1 = S("Hello World");
bool prefix1 = str_starts_with(str1, S("He"));
bool prefix2 = str_starts_with(str1, S(""));
bool prefix3 = str_starts_with(str1, S("false"));
bool prefix4 = str_starts_with(str1, S("Hello World"));
bool suffix1 = str_ends_with(str1, S("orld"));
bool suffix2 = str_ends_with(str1, S(""));
bool suffix3 = str_ends_with(str1, S("false"));
bool suffix4 = str_ends_with(str1, S("Hello World"));
printf("matches: %d %d %d %d %d %d %d %d\n", prefix1, prefix2, prefix3, prefix4, suffix1, suffix2, suffix3, suffix4);
Str str2 = S(" Hello World\t \n");
Str str2_trim = str_ascii_trim(str2);
printf("str2_trim: '%.*s'\n", str2_trim.len, str2_trim.str);
printf("str2_trim == str1: %d\n", str_eq(str1, str2_trim));
Str str3 = str_empty();
Str str3_trim = str_ascii_trim(str3);
printf("str3_trim: '%.*s'\n", str3_trim.len, str3_trim.str);
Str str4 = S(" \t\t ");
Str str4_trim = str_ascii_trim(str4);
printf("str4_trim: '%.*s'\n", str4_trim.len, str4_trim.str);
S64 found = str_index(str1, S("World"));
printf("1. found %ld\n", found);
found = str_index(str_empty(), S("World"));
printf("2. found %ld\n", found);
found = str_index(str_empty(), S(""));
printf("3. found %ld\n", found);
found = str_index(str1, S(" "));
printf("4. found %ld\n", found);
}
void string_test_join(void)
{
TRACEF("\n");
Arena arena;
arena_init(&arena, &ArenaOptions_Default);
Allocator allocator = arena_allocator(&arena);
Str strs[3] = {S("1"), S("two"), S("3-3")};
StrVec vec = STRVEC_STATIC_INITIALIZER(strs);
Str str = str_join(&allocator, vec, S("/"));
printf("str_join 1 '%.*s'\n", str.len, str.str);
str = str_join(&allocator, vec, S(""));
printf("str_join 2 '%.*s'\n", str.len, str.str);
vec.len = 0;
str = str_join(&allocator, vec, S("/"));
printf("str_join 2 '%.*s'\n", str.len, str.str);
}
void print_runes(Str str)
{
U32 offset = 0;
U32 len = str_rune_count(str);
printf("rune len %d\n", len);
while (offset < str.len) {
RuneDecode d = str_utf8_decode(str, offset);
printf("Rune: %d valid: %d\n", d.rune, d.valid);
offset += d.width;
}
}
void string_test_utf8(void)
{
TRACEF("\n");
Str str1 = S("Test 1ø2 ☺");
TRACEF("str1:\n");
print_runes(str1);
Str str2 = str_empty();
TRACEF("str2:\n");
print_runes(str2);
Str str3 = S("1Å 2\xc6" "3\xc3");
TRACEF("str3:\n");
print_runes(str3);
const char rune_error[] = {0xEF, 0xBF, 0xBD, 0x00} ; // RUNE_ERROR encoded in utf-8
Str str4 = S(rune_error);
TRACEF("str4:\n");
print_runes(str4); // this should be a valid code point
}
void string_test_hex(void)
{
TRACEF("\n");
MArena arena;
U8 data[4096];
marena_init(&arena, data, sizeof data);
Allocator allocator = marena_allocator(&arena);
Str str1 = S("Hello World ☺");
Str str1_encoded = str_hex_encode_alloc(&allocator, str1);
printf("str1_encoded: '%.*s'\n", str1_encoded.len, str1_encoded.str);
Str str1_decoded = str_hex_decode_alloc(&allocator, str1_encoded);
printf("str1_decoded: '%.*s'\n", str1_decoded.len, str1_decoded.str);
Str str2 = S("");
Str str2_encoded = str_hex_encode_alloc(&allocator, str2);
printf("str2_encoded: '%.*s'\n", str2_encoded.len, str2_encoded.str);
Str str2_decoded = str_hex_decode_alloc(&allocator, str2_encoded);
printf("str2_decoded: '%.*s'\n", str2_decoded.len, str2_decoded.str);
}
typedef struct StrSLNode StrSLNode;
struct StrSLNode {
Str str;
StrSLNode *next;
};
typedef struct StrSList StrSList;
struct StrSList {
StrSLNode *first;
StrSLNode **last;
};
void string_test_slist(void)
{
TRACEF("\n");
Str str1 = S("one");
Str str2 = S("two");
Str str3 = S("three");
StrSList strlist = {};
StrSLNode n1 = {str1, NULL};
StrSLNode n2 = {str2, NULL};
StrSLNode n3 = {str3, NULL};
SListInit(&strlist);
SListAddFirst(&strlist, &n1);
SListAddFirst(&strlist, &n2);
SListAddFirst(&strlist, &n3);
TRACEF("List test first\n");
for (StrSLNode *n = strlist.first; n != NULL; n = n->next) {
printf("Node: %.*s\n", n->str.len, n->str.str);
}
TRACEF("List test first done\n");
SListInit(&strlist);
SListAddLast(&strlist, &n1);
SListAddLast(&strlist, &n2);
SListAddLast(&strlist, &n3);
SListRemoveFirst(&strlist);
TRACEF("List test last\n");
for (StrSLNode *n = strlist.first; n != NULL; n = n->next) {
printf("Node: %.*s\n", n->str.len, n->str.str);
}
TRACEF("List test last done\n");
}
typedef struct StrDLNode StrDLNode;
struct StrDLNode {
Str str;
StrDLNode *next;
StrDLNode *prev;
};
typedef struct StrDList StrDList;
struct StrDList {
StrDLNode *first;
StrDLNode *last;
};
void string_test_dlist(void)
{
TRACEF("\n");
Str str1 = S("one");
Str str2 = S("two");
Str str3 = S("three");
Str str4 = S("four");
StrDList strlist = {};
StrDLNode n1 = {str1, NULL, NULL};
StrDLNode n2 = {str2, NULL, NULL};
StrDLNode n3 = {str3, NULL, NULL};
StrDLNode n4 = {str4, NULL, NULL};
DListInit(&strlist);
DListAddFirst(&strlist, &n1);
DListAddFirst(&strlist, &n2);
DListAddFirst(&strlist, &n3);
TRACEF("List test first\n");
for (StrDLNode *n = strlist.first; n != NULL; n = n->next) {
printf("Node: %.*s\n", n->str.len, n->str.str);
}
TRACEF("List test first done\n");
DListInit(&strlist);
DListAddLast(&strlist, &n2);
DListAddLast(&strlist, &n3);
DListAddLast(&strlist, &n4);
DListAddFirst(&strlist, &n1);
TRACEF("List test full\n");
for (StrDLNode *n = strlist.first; n != NULL; n = n->next) {
printf("Node: %.*s\n", n->str.len, n->str.str);
}
TRACEF("List test full done\n");
DListRemove(&strlist, &n1);
DListRemoveFirst(&strlist);
DListRemoveLast(&strlist);
TRACEF("List test tail removed\n");
for (StrDLNode *n = strlist.first; n != NULL; n = n->next) {
printf("Node: %.*s\n", n->str.len, n->str.str);
}
TRACEF("List test tail removed done\n");
}
int main(int argc, char *argv[])
{
arena_test_1();
arena_test_2();
arena_test_3();
arena_test_4();
arena_test_decommit();
arena_test_allocator_interface();
miniarena_test1();
apool_test();
apool_test_autogrow();
apool_test_miniarena();
string_test_1();
string_split_test_1();
string_test_misc();
string_test_join();
string_test_utf8();
string_test_hex();
string_test_slist();
string_test_dlist();
}
Reference in New Issue View Git Blame Copy Permalink