143 lines
2.0 KiB
D
143 lines
2.0 KiB
D
import core.stdc.stdio : Printf = printf;
|
|
|
|
alias i8 = byte;
|
|
alias i16 = short;
|
|
alias i32 = int;
|
|
alias i64 = long;
|
|
|
|
alias u8 = ubyte;
|
|
alias u16 = ushort;
|
|
alias u32 = uint;
|
|
alias u64 = ulong;
|
|
|
|
alias f32 = float;
|
|
alias f64 = double;
|
|
|
|
alias b32 = uint;
|
|
|
|
alias usize = size_t;
|
|
|
|
version(linux)
|
|
{
|
|
import core.sys.posix.sys.mman;
|
|
|
|
void*
|
|
MemAlloc(u64 size)
|
|
{
|
|
return mmap(null, size, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0);
|
|
}
|
|
|
|
void
|
|
MemFree(void* ptr, u64 size)
|
|
{
|
|
assert(munmap(ptr, size) == 0, "MemFree failure");
|
|
}
|
|
|
|
}
|
|
|
|
struct Node(T)
|
|
{
|
|
Node!(T)* next;
|
|
T value;
|
|
}
|
|
|
|
struct SLList(T)
|
|
{
|
|
Node!(T)* first;
|
|
Node!(T)* last;
|
|
}
|
|
|
|
pragma(inline): void
|
|
Push(T)(SLList!(T)*list, Node!(T)* node, Node!(T)* nil)
|
|
{
|
|
if (CheckNil(nil, list.first))
|
|
{
|
|
list.first = list.last = node;
|
|
node.next = nil;
|
|
}
|
|
else
|
|
{
|
|
list.last.next = node;
|
|
list.last = node;
|
|
node.next = nil;
|
|
}
|
|
}
|
|
|
|
pragma(inline): bool
|
|
CheckNil(T)(Node!(T)* nil, Node!(T)* node)
|
|
{
|
|
return node == null || node == nil;
|
|
}
|
|
|
|
struct Arena
|
|
{
|
|
u8* mem;
|
|
u64 length;
|
|
u64 pos;
|
|
};
|
|
|
|
Arena
|
|
CreateArena(u64 size)
|
|
{
|
|
Arena arena = {
|
|
mem: cast(u8 *)MemAlloc(size),
|
|
length: size,
|
|
pos: 0,
|
|
};
|
|
|
|
assert(arena.mem != null, "Unable to allocate memory for arena");
|
|
|
|
return arena;
|
|
};
|
|
|
|
T[]
|
|
AllocArray(T)(Arena* arena, u64 count)
|
|
{
|
|
void* mem = AllocAlign(arena, T.sizeof * count, DEFAULT_ALIGNMENT);
|
|
memset(mem, 0, T.sizeof * count);
|
|
return (cast(T*)mem)[0 .. count];
|
|
}
|
|
|
|
T*
|
|
Alloc(T)(Arena* arena)
|
|
{
|
|
void* mem = AllocAlign(arena, T.sizeof, DEFAULT_ALIGNMENT);
|
|
memset(mem, 0, T.sizeof);
|
|
return cast(T*)mem;
|
|
};
|
|
|
|
void*
|
|
AllocAlign(Arena* arena, u64 size, u64 alignment)
|
|
{
|
|
void* ptr = null;
|
|
|
|
uintptr mem_pos = cast(uintptr)arena.mem;
|
|
uintptr current = mem_pos + arena.pos;
|
|
uintptr offset = AlignPow2(current, alignment) - mem_pos;
|
|
|
|
if (offset+size <= arena.length)
|
|
{
|
|
ptr = &arena.mem[offset];
|
|
arena.pos = offset+size;
|
|
}
|
|
else
|
|
{
|
|
Printf("AllocAlign failure: out of memory, size requested: %llu", size);
|
|
assert(0);
|
|
}
|
|
|
|
return ptr;
|
|
};
|
|
|
|
void
|
|
Reset(Arena* arena)
|
|
{
|
|
arena.pos = 0;
|
|
}
|
|
|
|
void
|
|
Free(Arena* arena)
|
|
{
|
|
(arena.mem);
|
|
}
|