doylet/Dqn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename Dqn_MemArena to Dqn_ArenaAllocator

Browse Source
This commit is contained in:
doyle 2020-04-30 01:01:10 +10:00
parent 5173478766
commit 44d8f970b3
5 changed files with 164 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Code/Build.bat
View File

@ -1,7 +1,7 @@
@echo OFF
if not exist ..\Bin mkdir ..\Bin
pushd ..\Bin
if not exist ..\Build mkdir ..\Build
pushd ..\Build
REM MT Static CRT
REM EHa- Disable exception handling

152
Code/Dqn.h
View File

@ -637,9 +637,9 @@ enum struct Dqn_Allocator_Type
Custom,
};
#define DQN_ALLOCATOR_ALLOCATE_PROC(name) void *name(Dqn_isize size, Dqn_u8 alignment)
#define DQN_ALLOCATOR_REALLOC_PROC(name) void *name(void *old_ptr, Dqn_isize old_size, Dqn_isize new_size)
#define DQN_ALLOCATOR_FREE_PROC(name) void name(void *ptr)
#define DQN_ALLOCATOR_ALLOCATE_PROC(name) void *name(Dqn_isize size, Dqn_u8 alignment, void *user_context)
#define DQN_ALLOCATOR_REALLOC_PROC(name) void *name(void *old_ptr, Dqn_isize old_size, Dqn_isize new_size, void *user_context)
#define DQN_ALLOCATOR_FREE_PROC(name) void name(void *ptr, void *user_context)
typedef DQN_ALLOCATOR_ALLOCATE_PROC(Dqn_Allocator_AllocateProc);
typedef DQN_ALLOCATOR_REALLOC_PROC(Dqn_Allocator_ReallocProc);
typedef DQN_ALLOCATOR_FREE_PROC(Dqn_Allocator_FreeProc);
@ -648,8 +648,8 @@ struct Dqn_Allocator
Dqn_Allocator_Type type;
union
{
void *user;
struct Dqn_MemArena *arena;
void *user;
struct Dqn_ArenaAllocator *arena;
} context;
Dqn_isize bytes_allocated;
@ -665,28 +665,28 @@ struct Dqn_Allocator
};
DQN_HEADER_COPY_END
DQN_HEADER_COPY_PROTOTYPE(Dqn_Allocator, inline Dqn_Allocator_Null())
DQN_HEADER_COPY_PROTOTYPE(Dqn_Allocator, inline Dqn_Allocator_InitWithNull())
{
Dqn_Allocator result = {};
result.type = Dqn_Allocator_Type::Null;
return result;
}
DQN_HEADER_COPY_PROTOTYPE(Dqn_Allocator, inline Dqn_Allocator_Heap())
DQN_HEADER_COPY_PROTOTYPE(Dqn_Allocator, inline Dqn_Allocator_InitWithHeap())
{
Dqn_Allocator result = {};
result.type = Dqn_Allocator_Type::Heap;
return result;
}
DQN_HEADER_COPY_PROTOTYPE(Dqn_Allocator, inline Dqn_Allocator_XHeap())
DQN_HEADER_COPY_PROTOTYPE(Dqn_Allocator, inline Dqn_Allocator_InitWithXHeap())
{
Dqn_Allocator result = {};
result.type = Dqn_Allocator_Type::XHeap;
return result;
}
DQN_HEADER_COPY_PROTOTYPE(Dqn_Allocator, inline Dqn_Allocator_Arena(Dqn_MemArena *arena))
DQN_HEADER_COPY_PROTOTYPE(Dqn_Allocator, inline Dqn_Allocator_InitWithArena(Dqn_ArenaAllocator *arena))
{
Dqn_Allocator result = {};
result.type = Dqn_Allocator_Type::Arena;
@ -718,53 +718,53 @@ DQN_HEADER_COPY_END
// @ -------------------------------------------------------------------------------------------------
// @
// @ NOTE: Dqn_MemArena
// @ NOTE: Dqn_ArenaAllocator
// @
// @ -------------------------------------------------------------------------------------------------
DQN_HEADER_COPY_BEGIN
struct Dqn_MemBlock
struct Dqn_ArenaAllocatorBlock
{
void *memory;
Dqn_isize size;
Dqn_isize used;
Dqn_MemBlock *prev;
Dqn_MemBlock *next;
Dqn_ArenaAllocatorBlock *prev;
Dqn_ArenaAllocatorBlock *next;
};
Dqn_usize const DQN_MEM_ARENA_DEFAULT_MIN_BLOCK_SIZE = DQN_KILOBYTES(4);
struct Dqn_MemArena
struct Dqn_ArenaAllocator
{
// NOTE: Configuration (fill once after "Zero Initialisation {}")
Dqn_isize min_block_size;
Dqn_Allocator allocator;
// NOTE: Read Only
Dqn_MemBlock *curr_mem_block;
Dqn_MemBlock *top_mem_block;
Dqn_ArenaAllocatorBlock *curr_mem_block;
Dqn_ArenaAllocatorBlock *top_mem_block;
Dqn_isize highest_used_mark;
int total_allocated_mem_blocks;
};
struct Dqn_MemArenaRegion
struct Dqn_ArenaAllocatorRegion
{
Dqn_MemArena *arena;
Dqn_MemBlock *curr_mem_block;
Dqn_ArenaAllocator *arena;
Dqn_ArenaAllocatorBlock *curr_mem_block;
Dqn_isize curr_mem_block_used;
Dqn_MemBlock *top_mem_block;
Dqn_ArenaAllocatorBlock *top_mem_block;
};
struct Dqn_MemArenaScopedRegion
struct Dqn_ArenaAllocatorScopedRegion
{
Dqn_MemArenaScopedRegion(Dqn_MemArena *arena);
~Dqn_MemArenaScopedRegion();
Dqn_MemArenaRegion region;
Dqn_ArenaAllocatorScopedRegion(Dqn_ArenaAllocator *arena);
~Dqn_ArenaAllocatorScopedRegion();
Dqn_ArenaAllocatorRegion region;
};
void * Dqn_MemArena_Allocate(Dqn_MemArena *arena, Dqn_isize size, Dqn_u8 alignment);
Dqn_b32 Dqn_MemArena_Reserve(Dqn_MemArena *arena, Dqn_isize size);
DQN_HEADER_COPY_PROTOTYPE(template <typename T> T *, Dqn_MemArena_AllocateType(Dqn_MemArena *arena, Dqn_isize num))
void * Dqn_ArenaAllocator_Allocate(Dqn_ArenaAllocator *arena, Dqn_isize size, Dqn_u8 alignment);
Dqn_b32 Dqn_ArenaAllocator_Reserve(Dqn_ArenaAllocator *arena, Dqn_isize size);
DQN_HEADER_COPY_PROTOTYPE(template <typename T> T *, Dqn_ArenaAllocator_AllocateType(Dqn_ArenaAllocator *arena, Dqn_isize num))
{
auto *result = DQN_CAST(T *)Dqn_MemArena_Allocate(arena, sizeof(T) * num, alignof(T));
auto *result = DQN_CAST(T *)Dqn_ArenaAllocator_Allocate(arena, sizeof(T) * num, alignof(T));
return result;
}
@ -1220,7 +1220,7 @@ DQN_HEADER_COPY_END
DQN_HEADER_COPY_PROTOTYPE(template <typename T> Dqn_Array<T>, Dqn_Array_InitWithMemory(T *memory, Dqn_isize max, Dqn_isize len = 0))
{
Dqn_Array<T> result = {};
result.allocator = Dqn_Allocator_Null();
result.allocator = Dqn_Allocator_InitWithNull();
result.data = memory;
result.len = len;
result.max = max;
@ -1605,14 +1605,14 @@ DQN_HEADER_COPY_PROTOTYPE(void *, Dqn_Allocator_Allocate(Dqn_Allocator *allocato
case Dqn_Allocator_Type::Arena:
{
result = DQN_CAST(char *)Dqn_MemArena_Allocate(allocator->context.arena, size, alignment);
result = DQN_CAST(char *)Dqn_ArenaAllocator_Allocate(allocator->context.arena, size, alignment);
}
break;
case Dqn_Allocator_Type::Custom:
{
if (allocator->allocate)
result = DQN_CAST(char *)allocator->allocate(size, alignment);
result = DQN_CAST(char *)allocator->allocate(size, alignment, allocator->context.user);
}
break;
}
@ -1657,8 +1657,8 @@ DQN_HEADER_COPY_PROTOTYPE(void *, Dqn_Allocator_Realloc(Dqn_Allocator *allocator
case Dqn_Allocator_Type::Arena:
{
Dqn_MemArena *arena = allocator->context.arena;
result = Dqn_MemArena_Allocate(arena, new_size, metadata.alignment);
Dqn_ArenaAllocator *arena = allocator->context.arena;
result = Dqn_ArenaAllocator_Allocate(arena, new_size, metadata.alignment);
if (result) DQN_MEMCOPY(result, old_ptr, DQN_CAST(size_t) old_size);
}
break;
@ -1666,7 +1666,7 @@ DQN_HEADER_COPY_PROTOTYPE(void *, Dqn_Allocator_Realloc(Dqn_Allocator *allocator
case Dqn_Allocator_Type::Custom:
{
if (allocator->realloc)
result = allocator->realloc(old_ptr, old_size, new_size);
result = allocator->realloc(old_ptr, old_size, new_size, allocator->context.user);
}
break;
}
@ -1696,7 +1696,7 @@ DQN_HEADER_COPY_PROTOTYPE(void, Dqn_Allocator_Free(Dqn_Allocator *allocator, voi
case Dqn_Allocator_Type::Custom:
{
allocator->free(ptr);
if (allocator->free) allocator->free(ptr, allocator->context.user);
}
break;
@ -1714,17 +1714,17 @@ DQN_HEADER_COPY_PROTOTYPE(void, Dqn_Allocator_Free(Dqn_Allocator *allocator, voi
// @ -------------------------------------------------------------------------------------------------
// @
// @ NOTE: Dqn_MemArena
// @ NOTE: Dqn_ArenaAllocator
// @
// @ -------------------------------------------------------------------------------------------------
DQN_FILE_SCOPE Dqn_MemBlock *Dqn_MemArena__AllocateBlock(Dqn_MemArena *arena, Dqn_isize requested_size)
DQN_FILE_SCOPE Dqn_ArenaAllocatorBlock *Dqn_ArenaAllocator__AllocateBlock(Dqn_ArenaAllocator *arena, Dqn_isize requested_size)
{
Dqn_isize min_block_size = arena->min_block_size;
if (min_block_size == 0) min_block_size = DQN_MEM_ARENA_DEFAULT_MIN_BLOCK_SIZE;
Dqn_isize mem_block_size = DQN_MAX(min_block_size, requested_size);
auto const allocate_size = DQN_CAST(Dqn_isize)(sizeof(*arena->curr_mem_block) + mem_block_size);
auto *result = DQN_CAST(Dqn_MemBlock *)Dqn_Allocator_Allocate(&arena->allocator, allocate_size, alignof(Dqn_MemBlock));
auto *result = DQN_CAST(Dqn_ArenaAllocatorBlock *)Dqn_Allocator_Allocate(&arena->allocator, allocate_size, alignof(Dqn_ArenaAllocatorBlock));
if (!result) return result;
*result = {};
@ -1734,7 +1734,7 @@ DQN_FILE_SCOPE Dqn_MemBlock *Dqn_MemArena__AllocateBlock(Dqn_MemArena *arena, Dq
return result;
}
DQN_FILE_SCOPE void Dqn_MemArena__FreeBlock(Dqn_MemArena *arena, Dqn_MemBlock *block)
DQN_FILE_SCOPE void Dqn_ArenaAllocator__FreeBlock(Dqn_ArenaAllocator *arena, Dqn_ArenaAllocatorBlock *block)
{
if (!block)
return;
@ -1748,7 +1748,7 @@ DQN_FILE_SCOPE void Dqn_MemArena__FreeBlock(Dqn_MemArena *arena, Dqn_MemBlock *b
Dqn_Allocator_Free(&arena->allocator, block);
}
DQN_FILE_SCOPE void Dqn_MemArena__AttachBlock(Dqn_MemArena *arena, Dqn_MemBlock *new_block)
DQN_FILE_SCOPE void Dqn_ArenaAllocator__AttachBlock(Dqn_ArenaAllocator *arena, Dqn_ArenaAllocatorBlock *new_block)
{
if (arena->top_mem_block)
{
@ -1764,11 +1764,11 @@ DQN_FILE_SCOPE void Dqn_MemArena__AttachBlock(Dqn_MemArena *arena, Dqn_MemBlock
}
}
DQN_HEADER_COPY_PROTOTYPE(void *, Dqn_MemArena_Allocate(Dqn_MemArena *arena, Dqn_isize size, Dqn_u8 alignment))
DQN_HEADER_COPY_PROTOTYPE(void *, Dqn_ArenaAllocator_Allocate(Dqn_ArenaAllocator *arena, Dqn_isize size, Dqn_u8 alignment))
{
Dqn_isize allocation_size = Dqn_AllocateMetadata_SizeRequired(size, alignment);
Dqn_b32 need_new_mem_block = true;
for (Dqn_MemBlock *mem_block = arena->curr_mem_block; mem_block; mem_block = mem_block->next)
for (Dqn_ArenaAllocatorBlock *mem_block = arena->curr_mem_block; mem_block; mem_block = mem_block->next)
{
Dqn_b32 can_fit_in_block = (mem_block->used + allocation_size) <= mem_block->size;
if (can_fit_in_block)
@ -1781,9 +1781,9 @@ DQN_HEADER_COPY_PROTOTYPE(void *, Dqn_MemArena_Allocate(Dqn_MemArena *arena, Dqn
if (need_new_mem_block)
{
Dqn_MemBlock *new_block = Dqn_MemArena__AllocateBlock(arena, allocation_size);
Dqn_ArenaAllocatorBlock *new_block = Dqn_ArenaAllocator__AllocateBlock(arena, allocation_size);
if (!new_block) return nullptr;
Dqn_MemArena__AttachBlock(arena, new_block);
Dqn_ArenaAllocator__AttachBlock(arena, new_block);
arena->curr_mem_block = arena->top_mem_block;
}
@ -1795,13 +1795,13 @@ DQN_HEADER_COPY_PROTOTYPE(void *, Dqn_MemArena_Allocate(Dqn_MemArena *arena, Dqn
return result;
}
DQN_HEADER_COPY_PROTOTYPE(void, Dqn_MemArena_Free(Dqn_MemArena *arena))
DQN_HEADER_COPY_PROTOTYPE(void, Dqn_ArenaAllocator_Free(Dqn_ArenaAllocator *arena))
{
for (Dqn_MemBlock *mem_block = arena->top_mem_block; mem_block;)
for (Dqn_ArenaAllocatorBlock *mem_block = arena->top_mem_block; mem_block;)
{
Dqn_MemBlock *block_to_free = mem_block;
Dqn_ArenaAllocatorBlock *block_to_free = mem_block;
mem_block = block_to_free->prev;
Dqn_MemArena__FreeBlock(arena, block_to_free);
Dqn_ArenaAllocator__FreeBlock(arena, block_to_free);
}
auto allocator = arena->allocator;
@ -1811,7 +1811,7 @@ DQN_HEADER_COPY_PROTOTYPE(void, Dqn_MemArena_Free(Dqn_MemArena *arena))
arena->allocator = allocator;
}
DQN_HEADER_COPY_PROTOTYPE(Dqn_b32, Dqn_MemArena_Reserve(Dqn_MemArena *arena, Dqn_isize size))
DQN_HEADER_COPY_PROTOTYPE(Dqn_b32, Dqn_ArenaAllocator_Reserve(Dqn_ArenaAllocator *arena, Dqn_isize size))
{
if (arena->top_mem_block)
{
@ -1819,38 +1819,38 @@ DQN_HEADER_COPY_PROTOTYPE(Dqn_b32, Dqn_MemArena_Reserve(Dqn_MemArena *arena, Dqn
if (remaining_space >= size) return true;
}
Dqn_MemBlock *new_block = Dqn_MemArena__AllocateBlock(arena, size);
Dqn_ArenaAllocatorBlock *new_block = Dqn_ArenaAllocator__AllocateBlock(arena, size);
if (!new_block) return false;
Dqn_MemArena__AttachBlock(arena, new_block);
Dqn_ArenaAllocator__AttachBlock(arena, new_block);
return true;
}
DQN_HEADER_COPY_PROTOTYPE(Dqn_MemArena, Dqn_MemArena_InitWithAllocator(Dqn_Allocator allocator, Dqn_isize size))
DQN_HEADER_COPY_PROTOTYPE(Dqn_ArenaAllocator, Dqn_ArenaAllocator_InitWithAllocator(Dqn_Allocator allocator, Dqn_isize size))
{
Dqn_MemArena result = {};
DQN_ASSERT_MSG(size >= DQN_ISIZEOF(*result.curr_mem_block), "(%zu >= %zu) There needs to be enough space to encode the Dqn_MemBlock struct into the memory buffer", size, sizeof(*result.curr_mem_block));
Dqn_ArenaAllocator result = {};
DQN_ASSERT_MSG(size >= DQN_ISIZEOF(*result.curr_mem_block), "(%zu >= %zu) There needs to be enough space to encode the Dqn_ArenaAllocatorBlock struct into the memory buffer", size, sizeof(*result.curr_mem_block));
result.allocator = allocator;
Dqn_MemBlock *mem_block = Dqn_MemArena__AllocateBlock(&result, size);
Dqn_MemArena__AttachBlock(&result, mem_block);
Dqn_ArenaAllocatorBlock *mem_block = Dqn_ArenaAllocator__AllocateBlock(&result, size);
Dqn_ArenaAllocator__AttachBlock(&result, mem_block);
return result;
}
DQN_HEADER_COPY_PROTOTYPE(Dqn_MemArena, Dqn_MemArena_InitMemory(void *memory, Dqn_isize size))
DQN_HEADER_COPY_PROTOTYPE(Dqn_ArenaAllocator, Dqn_ArenaAllocator_InitWithMemory(void *memory, Dqn_isize size))
{
Dqn_MemArena result = {};
DQN_ASSERT_MSG(size >= DQN_ISIZEOF(*result.curr_mem_block), "(%zu >= %zu) There needs to be enough space to encode the Dqn_MemBlock struct into the memory buffer", size, sizeof(*result.curr_mem_block));
result.allocator = Dqn_Allocator_Null();
auto *mem_block = DQN_CAST(Dqn_MemBlock *) memory;
Dqn_ArenaAllocator result = {};
DQN_ASSERT_MSG(size >= DQN_ISIZEOF(*result.curr_mem_block), "(%zu >= %zu) There needs to be enough space to encode the Dqn_ArenaAllocatorBlock struct into the memory buffer", size, sizeof(*result.curr_mem_block));
result.allocator = Dqn_Allocator_InitWithNull();
auto *mem_block = DQN_CAST(Dqn_ArenaAllocatorBlock *) memory;
*mem_block = {};
mem_block->memory = DQN_CAST(Dqn_u8 *) memory + sizeof(*mem_block);
mem_block->size = size - DQN_CAST(Dqn_isize)sizeof(*mem_block);
Dqn_MemArena__AttachBlock(&result, mem_block);
Dqn_ArenaAllocator__AttachBlock(&result, mem_block);
return result;
}
DQN_HEADER_COPY_PROTOTYPE(void, Dqn_MemArena_ResetUsage(Dqn_MemArena *arena, Dqn_ZeroMem zero_mem))
DQN_HEADER_COPY_PROTOTYPE(void, Dqn_ArenaAllocator_ResetUsage(Dqn_ArenaAllocator *arena, Dqn_ZeroMem zero_mem))
{
for (Dqn_MemBlock *block = arena->top_mem_block; block; block = block->prev)
for (Dqn_ArenaAllocatorBlock *block = arena->top_mem_block; block; block = block->prev)
{
if (zero_mem == Dqn_ZeroMem::Yes)
DQN_MEMSET(block->memory, 0, DQN_CAST(size_t)block->used);
@ -1859,9 +1859,9 @@ DQN_HEADER_COPY_PROTOTYPE(void, Dqn_MemArena_ResetUsage(Dqn_MemArena *arena, Dqn
}
}
Dqn_MemArenaRegion Dqn_MemArena_BeginRegion(Dqn_MemArena *arena)
Dqn_ArenaAllocatorRegion Dqn_ArenaAllocator_BeginRegion(Dqn_ArenaAllocator *arena)
{
Dqn_MemArenaRegion result = {};
Dqn_ArenaAllocatorRegion result = {};
result.arena = arena;
result.curr_mem_block = arena->curr_mem_block;
result.curr_mem_block_used = (arena->curr_mem_block) ? arena->curr_mem_block->used : 0;
@ -1869,18 +1869,18 @@ Dqn_MemArenaRegion Dqn_MemArena_BeginRegion(Dqn_MemArena *arena)
return result;
}
void Dqn_MemArena_EndRegion(Dqn_MemArenaRegion region)
void Dqn_ArenaAllocator_EndRegion(Dqn_ArenaAllocatorRegion region)
{
while (region.top_mem_block != region.arena->top_mem_block)
{
Dqn_MemBlock *block_to_free = region.arena->top_mem_block;
Dqn_ArenaAllocatorBlock *block_to_free = region.arena->top_mem_block;
if (region.arena->curr_mem_block == block_to_free)
region.arena->curr_mem_block = block_to_free->prev;
region.arena->top_mem_block = block_to_free->prev;
Dqn_MemArena__FreeBlock(region.arena, block_to_free);
Dqn_ArenaAllocator__FreeBlock(region.arena, block_to_free);
}
for (Dqn_MemBlock *mem_block = region.arena->top_mem_block; mem_block != region.curr_mem_block; mem_block = mem_block->prev)
for (Dqn_ArenaAllocatorBlock *mem_block = region.arena->top_mem_block; mem_block != region.curr_mem_block; mem_block = mem_block->prev)
mem_block->used = 0;
if (region.arena->curr_mem_block)
@ -1888,19 +1888,19 @@ void Dqn_MemArena_EndRegion(Dqn_MemArenaRegion region)
region = {};
}
Dqn_MemArenaScopedRegion::Dqn_MemArenaScopedRegion(Dqn_MemArena *arena)
Dqn_ArenaAllocatorScopedRegion::Dqn_ArenaAllocatorScopedRegion(Dqn_ArenaAllocator *arena)
{
this->region = Dqn_MemArena_BeginRegion(arena);
this->region = Dqn_ArenaAllocator_BeginRegion(arena);
}
Dqn_MemArenaScopedRegion::~Dqn_MemArenaScopedRegion()
Dqn_ArenaAllocatorScopedRegion::~Dqn_ArenaAllocatorScopedRegion()
{
Dqn_MemArena_EndRegion(this->region);
Dqn_ArenaAllocator_EndRegion(this->region);
}
Dqn_MemArenaScopedRegion Dqn_MemArena_MakeScopedRegion(Dqn_MemArena *arena)
Dqn_ArenaAllocatorScopedRegion Dqn_ArenaAllocator_MakeScopedRegion(Dqn_ArenaAllocator *arena)
{
return Dqn_MemArenaScopedRegion(arena);
return Dqn_ArenaAllocatorScopedRegion(arena);
}
// @ -------------------------------------------------------------------------------------------------

16
Code/DqnHeader.h
View File

@ -163,10 +163,10 @@ int main(int argc, char *argv[])
return 0;
}
Dqn_MemArena arena = {};
arena.allocator = Dqn_Allocator_XHeap();
Dqn_Allocator allocator = Dqn_Allocator_Arena(&arena);
Dqn_MemArena_Reserve(&arena, DQN_MEGABYTES(16));
Dqn_ArenaAllocator arena = {};
arena.allocator = Dqn_Allocator_InitWithXHeap();
Dqn_Allocator allocator = Dqn_Allocator_InitWithArena(&arena);
Dqn_ArenaAllocator_Reserve(&arena, DQN_MEGABYTES(16));
for (Dqn_isize arg_index = 1; arg_index < argc; ++arg_index)
{
char const *file = argv[arg_index];
@ -206,7 +206,7 @@ int main(int argc, char *argv[])
}
}
auto *header_entries = Dqn_MemArena_AllocateType<HeaderEntry>(&arena, num_header_entries);
auto *header_entries = Dqn_ArenaAllocator_AllocateType<HeaderEntry>(&arena, num_header_entries);
Dqn_isize header_entries_index = 0;
Dqn_isize max_prototype_return_val = 0;
@ -245,7 +245,7 @@ int main(int argc, char *argv[])
ptr++;
Dqn_isize comment_len = ptr - comment_start;
entry->comment.str = Dqn_MemArena_AllocateType<char>(&arena, comment_len);
entry->comment.str = Dqn_ArenaAllocator_AllocateType<char>(&arena, comment_len);
DQN_FOR_EACH(comment_index, comment_len)
{
// NOTE: We capture "// @", and we want to skip the @ symbol, its ugly which is at the index 3
@ -272,8 +272,8 @@ int main(int argc, char *argv[])
return -1;
}
Dqn_isize copy_len = copy_end - copy_start;
entry->copy_range.str = Dqn_MemArena_AllocateType<char>(&arena, copy_len);
Dqn_isize copy_len = copy_end - copy_start;
entry->copy_range.str = Dqn_ArenaAllocator_AllocateType<char>(&arena, copy_len);
DQN_FOR_EACH(copy_index, copy_len)
{
char ch = copy_start[copy_index];

122
Code/DqnHeader_Generated.h
View File

@ -217,9 +217,9 @@ enum struct Dqn_Allocator_Type
Custom,
};
#define DQN_ALLOCATOR_ALLOCATE_PROC(name) void *name(Dqn_isize size, Dqn_u8 alignment)
#define DQN_ALLOCATOR_REALLOC_PROC(name) void *name(void *old_ptr, Dqn_isize old_size, Dqn_isize new_size)
#define DQN_ALLOCATOR_FREE_PROC(name) void name(void *ptr)
#define DQN_ALLOCATOR_ALLOCATE_PROC(name) void *name(Dqn_isize size, Dqn_u8 alignment, void *user_context)
#define DQN_ALLOCATOR_REALLOC_PROC(name) void *name(void *old_ptr, Dqn_isize old_size, Dqn_isize new_size, void *user_context)
#define DQN_ALLOCATOR_FREE_PROC(name) void name(void *ptr, void *user_context)
typedef DQN_ALLOCATOR_ALLOCATE_PROC(Dqn_Allocator_AllocateProc);
typedef DQN_ALLOCATOR_REALLOC_PROC(Dqn_Allocator_ReallocProc);
typedef DQN_ALLOCATOR_FREE_PROC(Dqn_Allocator_FreeProc);
@ -228,8 +228,8 @@ struct Dqn_Allocator
Dqn_Allocator_Type type;
union
{
void *user;
struct Dqn_MemArena *arena;
void *user;
struct Dqn_ArenaAllocator *arena;
} context;
Dqn_isize bytes_allocated;
@ -244,10 +244,10 @@ struct Dqn_Allocator
Dqn_Allocator_FreeProc *free;
};
Dqn_Allocator inline Dqn_Allocator_Null();
Dqn_Allocator inline Dqn_Allocator_Heap();
Dqn_Allocator inline Dqn_Allocator_XHeap();
Dqn_Allocator inline Dqn_Allocator_Arena(Dqn_MemArena *arena);
Dqn_Allocator inline Dqn_Allocator_InitWithNull();
Dqn_Allocator inline Dqn_Allocator_InitWithHeap();
Dqn_Allocator inline Dqn_Allocator_InitWithXHeap();
Dqn_Allocator inline Dqn_Allocator_InitWithArena(Dqn_ArenaAllocator *arena);
template <typename T> T * Dqn_Allocator_AllocateType(Dqn_Allocator *allocator, Dqn_isize num);
// -------------------------------------------------------------------------------------------------
//
@ -263,52 +263,52 @@ struct Dqn_AllocateMetadata
// -------------------------------------------------------------------------------------------------
//
// NOTE: Dqn_MemArena
// NOTE: Dqn_ArenaAllocator
//
// -------------------------------------------------------------------------------------------------
struct Dqn_MemBlock
struct Dqn_ArenaAllocatorBlock
{
void *memory;
Dqn_isize size;
Dqn_isize used;
Dqn_MemBlock *prev;
Dqn_MemBlock *next;
Dqn_ArenaAllocatorBlock *prev;
Dqn_ArenaAllocatorBlock *next;
};
Dqn_usize const DQN_MEM_ARENA_DEFAULT_MIN_BLOCK_SIZE = DQN_KILOBYTES(4);
struct Dqn_MemArena
struct Dqn_ArenaAllocator
{
// NOTE: Configuration (fill once after "Zero Initialisation {}")
Dqn_isize min_block_size;
Dqn_Allocator allocator;
// NOTE: Read Only
Dqn_MemBlock *curr_mem_block;
Dqn_MemBlock *top_mem_block;
Dqn_ArenaAllocatorBlock *curr_mem_block;
Dqn_ArenaAllocatorBlock *top_mem_block;
Dqn_isize highest_used_mark;
int total_allocated_mem_blocks;
};
struct Dqn_MemArenaRegion
struct Dqn_ArenaAllocatorRegion
{
Dqn_MemArena *arena;
Dqn_MemBlock *curr_mem_block;
Dqn_ArenaAllocator *arena;
Dqn_ArenaAllocatorBlock *curr_mem_block;
Dqn_isize curr_mem_block_used;
Dqn_MemBlock *top_mem_block;
Dqn_ArenaAllocatorBlock *top_mem_block;
};
struct Dqn_MemArenaScopedRegion
struct Dqn_ArenaAllocatorScopedRegion
{
Dqn_MemArenaScopedRegion(Dqn_MemArena *arena);
~Dqn_MemArenaScopedRegion();
Dqn_MemArenaRegion region;
Dqn_ArenaAllocatorScopedRegion(Dqn_ArenaAllocator *arena);
~Dqn_ArenaAllocatorScopedRegion();
Dqn_ArenaAllocatorRegion region;
};
void * Dqn_MemArena_Allocate(Dqn_MemArena *arena, Dqn_isize size, Dqn_u8 alignment);
Dqn_b32 Dqn_MemArena_Reserve(Dqn_MemArena *arena, Dqn_isize size);
DQN_HEADER_COPY_PROTOTYPE(template <typename T> T *, Dqn_MemArena_AllocateType(Dqn_MemArena *arena, Dqn_isize num))
void * Dqn_ArenaAllocator_Allocate(Dqn_ArenaAllocator *arena, Dqn_isize size, Dqn_u8 alignment);
Dqn_b32 Dqn_ArenaAllocator_Reserve(Dqn_ArenaAllocator *arena, Dqn_isize size);
DQN_HEADER_COPY_PROTOTYPE(template <typename T> T *, Dqn_ArenaAllocator_AllocateType(Dqn_ArenaAllocator *arena, Dqn_isize num))
{
auto *result = DQN_CAST(T *)Dqn_MemArena_Allocate(arena, sizeof(T) * num, alignof(T));
auto *result = DQN_CAST(T *)Dqn_ArenaAllocator_Allocate(arena, sizeof(T) * num, alignof(T));
return result;
}
@ -340,37 +340,36 @@ struct Dqn_String
// NOTE: String Builder
//
// -------------------------------------------------------------------------------------------------
struct Dqn_StringBuilderBuffer
struct Dqn_StringBuilderBlock
{
char *mem;
Dqn_isize size;
Dqn_isize used;
Dqn_StringBuilderBuffer *next;
char *mem;
Dqn_isize size;
Dqn_isize used;
Dqn_StringBuilderBlock *next;
};
Dqn_isize constexpr DQN_STRING_BUILDER_MIN_MEM_BUF_ALLOC_SIZE = DQN_KILOBYTES(4);
template <Dqn_usize N = DQN_KILOBYTES(16)>
Dqn_isize constexpr DQN_STRING_BUILDER_MIN_BLOCK_SIZE = DQN_KILOBYTES(4);
template <Dqn_isize N = DQN_KILOBYTES(16)>
struct Dqn_StringBuilder
{
Dqn_Allocator allocator;
char fixed_mem[N];
Dqn_isize fixed_mem_used;
Dqn_StringBuilderBuffer *next_mem_buf;
Dqn_StringBuilderBuffer *last_mem_buf;
Dqn_isize string_len;
Dqn_Allocator allocator;
char fixed_mem[N];
Dqn_StringBuilderBlock fixed_mem_block;
Dqn_StringBuilderBlock *last_mem_block;
};
// The necessary length to build the string, it returns the length including the null-terminator
template <Dqn_usize N> Dqn_isize Dqn_StringBuilder_BuildLen(Dqn_StringBuilder<N> const *builder);
template <Dqn_usize N> void Dqn_StringBuilder_BuildInBuffer(Dqn_StringBuilder<N> const *builder, char *dest, Dqn_usize dest_size);
template <Dqn_usize N> char * Dqn_StringBuilder_Build(Dqn_StringBuilder<N> *builder, Dqn_Allocator *allocator, Dqn_isize *len = nullptr);
template <Dqn_usize N> Dqn_String Dqn_StringBuilder_BuildString(Dqn_StringBuilder<N> *builder, Dqn_Allocator *allocator);
template <Dqn_usize N> void Dqn_StringBuilder_VFmtAppend(Dqn_StringBuilder<N> *builder, char const *fmt, va_list va);
template <Dqn_usize N> void Dqn_StringBuilder_FmtAppend(Dqn_StringBuilder<N> *builder, char const *fmt, ...);
template <Dqn_usize N> void Dqn_StringBuilder_Append(Dqn_StringBuilder<N> *builder, char const *str, Dqn_isize len = -1);
template <Dqn_usize N> void Dqn_StringBuilder_AppendString(Dqn_StringBuilder<N> *builder, Dqn_String const string);
template <Dqn_usize N> void Dqn_StringBuilder_AppendChar(Dqn_StringBuilder<N> *builder, char ch);
template <Dqn_usize N> void Dqn_StringBuilder_Free(Dqn_StringBuilder<N> *builder);
// size_required: The length of the string not including the null terminator.
// The necessary length to build the string, it returns the length not including the null-terminator
template <Dqn_isize N> Dqn_isize Dqn_StringBuilder_BuildLength(Dqn_StringBuilder<N> const *builder);
template <Dqn_isize N> void Dqn_StringBuilder_BuildToDest(Dqn_StringBuilder<N> const *builder, char *dest, Dqn_usize dest_size);
template <Dqn_isize N> char * Dqn_StringBuilder_Build(Dqn_StringBuilder<N> *builder, Dqn_Allocator *allocator, Dqn_isize *len = nullptr);
template <Dqn_isize N> Dqn_String Dqn_StringBuilder_BuildString(Dqn_StringBuilder<N> *builder, Dqn_Allocator *allocator);
template <Dqn_isize N> void Dqn_StringBuilder_VFmtAppend(Dqn_StringBuilder<N> *builder, char const *fmt, va_list va);
template <Dqn_isize N> void Dqn_StringBuilder_FmtAppend(Dqn_StringBuilder<N> *builder, char const *fmt, ...);
template <Dqn_isize N> void Dqn_StringBuilder_Append(Dqn_StringBuilder<N> *builder, char const *str, Dqn_isize len = -1);
template <Dqn_isize N> void Dqn_StringBuilder_AppendString(Dqn_StringBuilder<N> *builder, Dqn_String const string);
template <Dqn_isize N> void Dqn_StringBuilder_AppendChar(Dqn_StringBuilder<N> *builder, char ch);
template <Dqn_isize N> void Dqn_StringBuilder_Free(Dqn_StringBuilder<N> *builder);
// -------------------------------------------------------------------------------------------------
//
// NOTE: Dqn_Slices
@ -465,6 +464,7 @@ struct Dqn_FixedString
{
union { char data[MAX_]; char str[MAX_]; char buf[MAX_]; };
Dqn_isize len;
Dqn_isize max = MAX_;
Dqn_FixedString() { data[0] = 0; len = 0; }
Dqn_FixedString(char const *fmt, ...)
@ -542,15 +542,15 @@ void * Dqn_Allocator_Realloc(Dqn_Allocator *
void Dqn_Allocator_Free(Dqn_Allocator *allocator, void *ptr);
// -------------------------------------------------------------------------------------------------
//
// NOTE: Dqn_MemArena
// NOTE: Dqn_ArenaAllocator
//
// -------------------------------------------------------------------------------------------------
void * Dqn_MemArena_Allocate(Dqn_MemArena *arena, Dqn_isize size, Dqn_u8 alignment);
void Dqn_MemArena_Free(Dqn_MemArena *arena);
Dqn_b32 Dqn_MemArena_Reserve(Dqn_MemArena *arena, Dqn_isize size);
Dqn_MemArena Dqn_MemArena_InitWithAllocator(Dqn_Allocator allocator, Dqn_isize size);
Dqn_MemArena Dqn_MemArena_InitMemory(void *memory, Dqn_isize size);
void Dqn_MemArena_ResetUsage(Dqn_MemArena *arena, Dqn_ZeroMem zero_mem);
void * Dqn_ArenaAllocator_Allocate(Dqn_ArenaAllocator *arena, Dqn_isize size, Dqn_u8 alignment);
void Dqn_ArenaAllocator_Free(Dqn_ArenaAllocator *arena);
Dqn_b32 Dqn_ArenaAllocator_Reserve(Dqn_ArenaAllocator *arena, Dqn_isize size);
Dqn_ArenaAllocator Dqn_ArenaAllocator_InitWithAllocator(Dqn_Allocator allocator, Dqn_isize size);
Dqn_ArenaAllocator Dqn_ArenaAllocator_InitWithMemory(void *memory, Dqn_isize size);
void Dqn_ArenaAllocator_ResetUsage(Dqn_ArenaAllocator *arena, Dqn_ZeroMem zero_mem);
// -------------------------------------------------------------------------------------------------
//
// NOTE: Dqn_Asprintf (Allocate Sprintf)
@ -613,8 +613,8 @@ Dqn_V4 operator*(Dqn_Mat4 const &mat, Dqn_V4
// -------------------------------------------------------------------------------------------------
void Dqn_Bit_UnsetInplace(Dqn_u32 *flags, Dqn_u32 bitfield);
void Dqn_Bit_SetInplace(Dqn_u32 *flags, Dqn_u32 bitfield);
Dqn_b32 Dqn_Bit_IsSet(Dqn_u32 flags, Dqn_u32 bitfield);
Dqn_b32 Dqn_Bit_IsNotSet(Dqn_u32 flags, Dqn_u32 bitfield);
Dqn_b32 Dqn_Bit_IsSet(Dqn_u32 bits, Dqn_u32 bits_to_set);
Dqn_b32 Dqn_Bit_IsNotSet(Dqn_u32 bits, Dqn_u32 bits_to_check);
// -------------------------------------------------------------------------------------------------
//
// NOTE: Safe Arithmetic

34
Code/Dqn_UnitTests.cpp
View File

@ -16,7 +16,7 @@ struct TestingState
int num_tests_in_group;
int num_tests_ok_in_group;
TestState test;
Dqn_MemArena arena_;
Dqn_ArenaAllocator arena_;
Dqn_Allocator allocator;
};
@ -33,8 +33,8 @@ struct TestingState
{ \
if (testing_state.test.fail_expr.len == 0) testing_state.num_tests_ok_in_group++; \
TestState_PrintResult(&testing_state.test); \
Dqn_MemArena_ResetUsage(&testing_state.arena_, Dqn_ZeroMem::No); \
testing_state.allocator = Dqn_Allocator_Arena(&testing_state.arena_); \
Dqn_ArenaAllocator_ResetUsage(&testing_state.arena_, Dqn_ZeroMem::No); \
testing_state.allocator = Dqn_Allocator_InitWithArena(&testing_state.arena_); \
testing_state.test = {}; \
}; \
testing_state.test.name = Dqn_Asprintf(&testing_state.allocator, test_name); \
@ -121,7 +121,7 @@ DQN_FILE_SCOPE void UnitTests()
{
{
TEST_START_SCOPE(testing_state, "HeapAllocator - Allocate Small");
Dqn_Allocator allocator = Dqn_Allocator_Heap();
Dqn_Allocator allocator = Dqn_Allocator_InitWithHeap();
char constexpr EXPECT[] = "hello_world";
char *buf = DQN_CAST(char *)Dqn_Allocator_Allocate(&allocator, Dqn_ArrayCount(EXPECT), alignof(char));
DQN_DEFER { Dqn_Allocator_Free(&allocator, buf); };
@ -131,7 +131,7 @@ DQN_FILE_SCOPE void UnitTests()
{
TEST_START_SCOPE(testing_state, "XHeapAllocator - Allocate Small");
Dqn_Allocator allocator = Dqn_Allocator_XHeap();
Dqn_Allocator allocator = Dqn_Allocator_InitWithXHeap();
char constexpr EXPECT[] = "hello_world";
char *buf = DQN_CAST(char *)Dqn_Allocator_Allocate(&allocator, Dqn_ArrayCount(EXPECT), alignof(char));
DQN_DEFER { Dqn_Allocator_Free(&allocator, buf); };
@ -141,9 +141,9 @@ DQN_FILE_SCOPE void UnitTests()
{
TEST_START_SCOPE(testing_state, "ArenaAllocator - Allocate Small");
Dqn_MemArena arena = {};
arena.allocator = Dqn_Allocator_Heap();
Dqn_Allocator allocator = Dqn_Allocator_Arena(&arena);
Dqn_ArenaAllocator arena = {};
arena.allocator = Dqn_Allocator_InitWithHeap();
Dqn_Allocator allocator = Dqn_Allocator_InitWithArena(&arena);
char constexpr EXPECT[] = "hello_world";
char *buf = DQN_CAST(char *)Dqn_Allocator_Allocate(&allocator, Dqn_ArrayCount(EXPECT), alignof(char));
DQN_DEFER { Dqn_Allocator_Free(&allocator, buf); };
@ -158,7 +158,7 @@ DQN_FILE_SCOPE void UnitTests()
Dqn_u8 const NUM_BYTES = sizeof(Dqn_u32);
{
TEST_START_SCOPE(testing_state, "HeapAllocator - Align to 3 bytes");
Dqn_Allocator allocator = Dqn_Allocator_Heap();
Dqn_Allocator allocator = Dqn_Allocator_InitWithHeap();
auto *buf = DQN_CAST(Dqn_u32 *)Dqn_Allocator_Allocate(&allocator, NUM_BYTES, ALIGNMENT3);
DQN_DEFER { Dqn_Allocator_Free(&allocator, buf); };
int buf_mod_alignment = DQN_CAST(int)(DQN_CAST(uintptr_t)buf % ALIGNMENT3);
@ -167,7 +167,7 @@ DQN_FILE_SCOPE void UnitTests()
{
TEST_START_SCOPE(testing_state, "XHeapAllocator - Align to 3 bytes");
Dqn_Allocator allocator = Dqn_Allocator_XHeap();
Dqn_Allocator allocator = Dqn_Allocator_InitWithXHeap();
auto *buf = DQN_CAST(Dqn_u32 *)Dqn_Allocator_Allocate(&allocator, NUM_BYTES, ALIGNMENT3);
DQN_DEFER { Dqn_Allocator_Free(&allocator, buf); };
int buf_mod_alignment = DQN_CAST(int)(DQN_CAST(uintptr_t)buf % ALIGNMENT3);
@ -176,8 +176,8 @@ DQN_FILE_SCOPE void UnitTests()
{
TEST_START_SCOPE(testing_state, "ArenaAllocator - Align to 3 bytes");
Dqn_MemArena arena = {};
Dqn_Allocator allocator = Dqn_Allocator_Arena(&arena);
Dqn_ArenaAllocator arena = {};
Dqn_Allocator allocator = Dqn_Allocator_InitWithArena(&arena);
auto *buf = DQN_CAST(Dqn_u32 *)Dqn_Allocator_Allocate(&allocator, NUM_BYTES, ALIGNMENT3);
int buf_mod_alignment = DQN_CAST(int)(DQN_CAST(uintptr_t)buf % ALIGNMENT3);
TEST_EXPECT_MSG(testing_state, buf_mod_alignment == 0, "buf_mod_alignment: %d", buf_mod_alignment);
@ -191,7 +191,7 @@ DQN_FILE_SCOPE void UnitTests()
Dqn_u8 const MAX_OFFSET = (ALIGNMENT3 - 1) + sizeof(Dqn_AllocateMetadata);
{
TEST_START_SCOPE(testing_state, "HeapAllocator - Allocation metadata initialised");
Dqn_Allocator allocator = Dqn_Allocator_Heap();
Dqn_Allocator allocator = Dqn_Allocator_InitWithHeap();
char *buf = DQN_CAST(char *)Dqn_Allocator_Allocate(&allocator, NUM_BYTES, ALIGNMENT3);
DQN_DEFER { Dqn_Allocator_Free(&allocator, buf); };
Dqn_AllocateMetadata metadata = Dqn_AllocateMetadata_Get(buf);
@ -201,7 +201,7 @@ DQN_FILE_SCOPE void UnitTests()
{
TEST_START_SCOPE(testing_state, "XHeapAllocator - Allocation metadata initialised");
Dqn_Allocator allocator = Dqn_Allocator_XHeap();
Dqn_Allocator allocator = Dqn_Allocator_InitWithXHeap();
char *buf = DQN_CAST(char *)Dqn_Allocator_Allocate(&allocator, NUM_BYTES, ALIGNMENT3);
DQN_DEFER { Dqn_Allocator_Free(&allocator, buf); };
Dqn_AllocateMetadata metadata = Dqn_AllocateMetadata_Get(buf);
@ -211,8 +211,8 @@ DQN_FILE_SCOPE void UnitTests()
{
TEST_START_SCOPE(testing_state, "ArenaAllocator - Allocation metadata initialised");
Dqn_MemArena arena = {};
Dqn_Allocator allocator = Dqn_Allocator_Arena(&arena);
Dqn_ArenaAllocator arena = {};
Dqn_Allocator allocator = Dqn_Allocator_InitWithArena(&arena);
char *buf = DQN_CAST(char *)Dqn_Allocator_Allocate(&allocator, NUM_BYTES, ALIGNMENT3);
DQN_DEFER { Dqn_Allocator_Free(&allocator, buf); };
Dqn_AllocateMetadata metadata = Dqn_AllocateMetadata_Get(buf);
@ -489,7 +489,7 @@ DQN_FILE_SCOPE void UnitTests()
// ---------------------------------------------------------------------------------------------
{
TEST_DECLARE_GROUP_SCOPED(testing_state, "Dqn_StringBuilder");
Dqn_Allocator allocator = Dqn_Allocator_Heap();
Dqn_Allocator allocator = Dqn_Allocator_InitWithHeap();
// NOTE: Dqn_StringBuilder_Append
{
{