525 lines
28 KiB
C++
525 lines
28 KiB
C++
#define CORE_BASE
|
|
|
|
#if defined(__clang__)
|
|
# define COMPILER_CLANG 1
|
|
# if defined(_WIN32)
|
|
# define OS_WINDOWS 1
|
|
# elif defined(__linux__)
|
|
# define OS_LINUX 1
|
|
# else
|
|
# error Couldnt figure out the platform automatically
|
|
# endif
|
|
#elif defined(_MSC_VER)
|
|
# define COMPILER_MSVC 1
|
|
# define OS_WINDOWS 1
|
|
#elif defined(__GNUC__)
|
|
# define COMPILER_GCC 1
|
|
# if defined(__linux__)
|
|
# define OS_LINUX 1
|
|
# endif
|
|
#else
|
|
# error Couldnt figure out the compiler
|
|
#endif
|
|
|
|
#if defined(OS_MAC)
|
|
#define OS_UNIX 1
|
|
#endif
|
|
#if defined(OS_LINUX)
|
|
#define OS_UNIX 1
|
|
#endif
|
|
|
|
#if !defined(COMPILER_MSVC)
|
|
# define COMPILER_MSVC 0
|
|
#endif
|
|
#if !defined(COMPILER_GCC)
|
|
# define COMPILER_GCC 0
|
|
#endif
|
|
#if !defined(COMPILER_CLANG)
|
|
# define COMPILER_CLANG 0
|
|
#endif
|
|
#if !defined(OS_WINDOWS)
|
|
# define OS_WINDOWS 0
|
|
#endif
|
|
#if !defined(OS_LINUX)
|
|
# define OS_LINUX 0
|
|
#endif
|
|
#if !defined(OS_MAC)
|
|
# define OS_MAC 0
|
|
#endif
|
|
#if !defined(OS_UNIX)
|
|
# define OS_UNIX 0
|
|
#endif
|
|
|
|
#if OS_WINDOWS
|
|
#define OS_EXE ".exe"
|
|
#define OS_NAME "Win32"_s
|
|
#define OS_NAME_LOWER "win32"_s
|
|
#elif OS_LINUX
|
|
#define OS_EXE ".out"
|
|
#define OS_NAME "Linux"_s
|
|
#define OS_NAME_LOWER "linux"_s
|
|
#elif OS_MAC
|
|
#define OS_EXE ".out"
|
|
#define OS_NAME "Mac"_s
|
|
#define OS_NAME_LOWER "mac"_s
|
|
#else
|
|
#error Couldnt figure out the OS with C macros!
|
|
#endif
|
|
|
|
#if OS_WINDOWS
|
|
#define NOMINMAX
|
|
#define _CRT_SECURE_NO_WARNINGS
|
|
#include <windows.h>
|
|
#define Breakpoint __debugbreak()
|
|
#define force_inline __forceinline
|
|
#else
|
|
#define Breakpoint (*(volatile int *)0 = 0)
|
|
#define force_inline inline
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
#include <float.h>
|
|
#include <stdint.h>
|
|
typedef int8_t S8;
|
|
typedef int16_t S16;
|
|
typedef int32_t S32;
|
|
typedef int64_t S64;
|
|
typedef uint8_t U8;
|
|
typedef uint16_t U16;
|
|
typedef uint32_t U32;
|
|
typedef uint64_t U64;
|
|
typedef S8 B8;
|
|
typedef S16 B16;
|
|
typedef S32 B32;
|
|
typedef S64 B64;
|
|
|
|
typedef float F32;
|
|
typedef double F64;
|
|
|
|
#define U64MAX UINT64_MAX
|
|
#define U32MAX UINT32_MAX
|
|
#define U16MAX UINT16_MAX
|
|
#define U8MAX UINT8_MAX
|
|
#define U64MIN 0
|
|
#define U32MIN 0
|
|
#define U16MIN 0
|
|
#define U8MIN 0
|
|
#define S64MAX INT64_MAX
|
|
#define S64MIN INT64_MIN
|
|
#define S32MAX INT32_MAX
|
|
#define S32MIN INT32_MIN
|
|
#define S16MAX INT16_MAX
|
|
#define S16MIN INT16_MIN
|
|
#define S8MAX INT8_MAX
|
|
#define S8MIN INT8_MIN
|
|
#define F32MAX FLT_MAX
|
|
#define F32MIN FLT_MIN
|
|
#define F64MAX DBL_MAX
|
|
#define F64MIN DBL_MIN
|
|
|
|
#define api
|
|
#define CORE_Static static
|
|
#define global static
|
|
#define assert(x) do{if(!(x))Breakpoint;}while(0)
|
|
#define assert_message(x,...) assert(x)
|
|
#define invalid_codepath assert_message(0, "Invalid codepath")
|
|
#define invalid_return do{assert_message(0, "Invalid codepath"); return {};}while(0)
|
|
#define invalid_default_case default: invalid_codepath
|
|
#define not_implemented assert_message(0, "Not implemented")
|
|
#define unused(x) ((void)x)
|
|
#define buff_cap(x) (sizeof(x)/sizeof((x)[0]))
|
|
#define is_flag_set(val,flag) ((val) & (flag))
|
|
#define set_flag(val,flag) ((val) |= (flag))
|
|
#define unset_flag(val,flag) ((val) &= (~(flag)))
|
|
#define bit_flag(x) (1ull << (x))
|
|
#define kib(x) ((x)*1024llu)
|
|
#define mib(x) (kib(x)*1024llu)
|
|
#define gib(x) (mib(x)*1024llu)
|
|
#define JOIN1(X,Y) X##Y
|
|
#define JOIN(X,Y) JOIN1(X,Y)
|
|
#define string_expand(x) (int)x.len, x.str
|
|
|
|
struct String{
|
|
U8 *str;
|
|
S64 len;
|
|
};
|
|
global String string_null = {(U8 *)"null", 4};
|
|
|
|
union Intern_String{ // Basically just String
|
|
String s;
|
|
struct{ U8 *str; S64 len; };
|
|
};
|
|
|
|
struct Allocator {
|
|
typedef void *Allocate(Allocator *, size_t);
|
|
typedef void Deallocate(Allocator *, void *p);
|
|
|
|
Allocate *allocate;
|
|
Deallocate *deallocate;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Utilities
|
|
//-----------------------------------------------------------------------------
|
|
CORE_Static size_t
|
|
get_align_offset(size_t size, size_t align){
|
|
size_t mask = align - 1;
|
|
size_t val = size & mask;
|
|
if(val){
|
|
val = align - val;
|
|
}
|
|
return val;
|
|
}
|
|
|
|
CORE_Static size_t
|
|
align_up(size_t size, size_t align){
|
|
size_t result = size + get_align_offset(size, align);
|
|
return result;
|
|
}
|
|
|
|
CORE_Static size_t
|
|
align_down(size_t size, size_t align){
|
|
size += 1; // Make sure 8 when align is 8 doesn't get rounded down to 0
|
|
size_t result = size - (align - get_align_offset(size, align));
|
|
return result;
|
|
}
|
|
|
|
CORE_Static void
|
|
memory_copy(void *dst, void *src, size_t size){
|
|
U8 *d = (U8*)dst;
|
|
U8 *s = (U8*)src;
|
|
for(size_t i = 0; i < size; i++){
|
|
d[i] = s[i];
|
|
}
|
|
}
|
|
|
|
CORE_Static void
|
|
memory_zero(void *p, size_t size){
|
|
U8 *pp = (U8 *)p;
|
|
for(size_t i = 0; i < size; i++)
|
|
pp[i] = 0;
|
|
}
|
|
|
|
template<class T>
|
|
void swap(T &a, T &b){
|
|
T temp = a;
|
|
a = b;
|
|
b = temp;
|
|
}
|
|
|
|
template<class T>
|
|
T max(T a, T b){
|
|
if(a > b) return a;
|
|
return b;
|
|
}
|
|
|
|
template<class T>
|
|
T min(T a, T b){
|
|
if(a > b) return b;
|
|
return a;
|
|
}
|
|
|
|
template<class T>
|
|
T clamp_top(T val, T max){
|
|
if(val > max) val = max;
|
|
return val;
|
|
}
|
|
|
|
template<class T>
|
|
T clamp_bot(T bot, T val){
|
|
if(val < bot) val = bot;
|
|
return val;
|
|
}
|
|
|
|
template<class T>
|
|
T clamp(T min, T val, T max){
|
|
if(val > max) val = max;
|
|
if(val < min) val = min;
|
|
return val;
|
|
}
|
|
|
|
CORE_Static U64
|
|
hash_string(String string) {
|
|
U64 hash = (U64)14695981039346656037ULL;
|
|
for (U64 i = 0; i < string.len; i++) {
|
|
hash = hash ^ (U64)(string.str[i]);
|
|
hash = hash * (U64)1099511628211ULL;
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
CORE_Static U64
|
|
hash_u64(U64 x) {
|
|
x *= 0xff51afd7ed558ccd;
|
|
x ^= x >> 32;
|
|
return x;
|
|
}
|
|
|
|
CORE_Static U64
|
|
hash_ptr(const void *ptr) {
|
|
return hash_u64((uintptr_t)ptr);
|
|
}
|
|
|
|
CORE_Static U64
|
|
hash_mix(U64 x, U64 y) {
|
|
// @note: murmur hash 3 mixer but I add the 'y'
|
|
// which means it's probably bad, hopefully better
|
|
// then some random scribble I could do
|
|
x ^= (y >> 33);
|
|
x *= 0xff51afd7ed558ccd;
|
|
x ^= (x >> 33);
|
|
x *= 0xc4ceb9fe1a85ec53;
|
|
x ^= (y >> 33);
|
|
return x;
|
|
}
|
|
|
|
CORE_Static U64
|
|
is_pow2(U64 x) {
|
|
assert(x != 0);
|
|
B32 result = (x & (x - 1llu)) == 0;
|
|
return result;
|
|
}
|
|
|
|
CORE_Static U64
|
|
wrap_around_pow2(U64 x, U64 power_of_2) {
|
|
assert(is_pow2(power_of_2));
|
|
U64 r = (((x)&((power_of_2)-1llu)));
|
|
return r;
|
|
}
|
|
|
|
force_inline String
|
|
operator""_s(const char *str, size_t size){
|
|
return String{(U8 *)str, (S64)size};
|
|
}
|
|
|
|
force_inline B32
|
|
operator==(Intern_String a, Intern_String b){
|
|
return a.str == b.str;
|
|
}
|
|
|
|
force_inline B32
|
|
operator!=(Intern_String a, Intern_String b){
|
|
B32 result = a.str == b.str;
|
|
return !result;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Very cool macros. Since these are macros it's recommended to wrap them
|
|
// in a function and not use directly
|
|
//----- -----------------------------------------------------------------------
|
|
#define SLL_QUEUE_ADD_MOD(f, l, n, next) \
|
|
do { \
|
|
if ((f) == 0) { \
|
|
(f) = (l) = (n); \
|
|
} else { \
|
|
(l) = (l)->next = (n); \
|
|
} \
|
|
} while (0)
|
|
#define SLL_QUEUE_ADD(f, l, n) SLL_QUEUE_ADD_MOD(f, l, n, next)
|
|
|
|
#define SLL_QUEUE_POP_FIRST_MOD(f, l, next) \
|
|
do { \
|
|
if ((f) == (l)) { \
|
|
(f) = (l) = 0; \
|
|
} else { \
|
|
(f) = (f)->next; \
|
|
} \
|
|
} while (0)
|
|
#define SLL_QUEUE_POP_FIRST(f, l) SLL_QUEUE_POP_FIRST_MOD(f, l, next)
|
|
|
|
#define SLL_STACK_ADD_MOD(stack_base, new_stack_base, next) \
|
|
do { \
|
|
(new_stack_base)->next = (stack_base); \
|
|
(stack_base) = (new_stack_base); \
|
|
} while (0)
|
|
#define SLL_STACK_ADD(stack_base, new_stack_base) SLL_STACK_ADD_MOD(stack_base, new_stack_base, next)
|
|
|
|
#define SLL_STACK_POP(stack_base) \
|
|
do { \
|
|
if (stack_base) { \
|
|
auto(N) = (stack_base); \
|
|
(stack_base) = (stack_base)->next; \
|
|
(N)->next = 0; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define DLL_QUEUE_ADD_LAST_MOD(f, l, node, next, prev) \
|
|
do { \
|
|
if ((f) == 0) { \
|
|
(f) = (l) = (node); \
|
|
(node)->prev = 0; \
|
|
(node)->next = 0; \
|
|
} else { \
|
|
(l)->next = (node); \
|
|
(node)->prev = (l); \
|
|
(node)->next = 0; \
|
|
(l) = (node); \
|
|
} \
|
|
} while (0)
|
|
#define DLL_QUEUE_ADD_LAST(f, l, node) DLL_QUEUE_ADD_LAST_MOD(f, l, node, next, prev)
|
|
#define DLL_QUEUE_ADD(f, l, node) DLL_QUEUE_ADD_LAST(f, l, node)
|
|
#define DLL_QUEUE_REMOVE_MOD(first, last, node, next, prev) \
|
|
do { \
|
|
if ((first) == (last)) { \
|
|
assert_message((node) == (first), "Macro assert failed"); \
|
|
(first) = (last) = 0; \
|
|
} else if ((last) == (node)) { \
|
|
(last) = (last)->prev; \
|
|
(last)->next = 0; \
|
|
} else if ((first) == (node)) { \
|
|
(first) = (first)->next; \
|
|
(first)->prev = 0; \
|
|
} else { \
|
|
(node)->prev->next = (node)->next; \
|
|
(node)->next->prev = (node)->prev; \
|
|
} \
|
|
} while (0)
|
|
#define DLL_QUEUE_REMOVE(first, last, node) DLL_QUEUE_REMOVE_MOD(first, last, node, next, prev)
|
|
|
|
#define DLL_STACK_ADD_MOD(first, node, next, prev) \
|
|
do { \
|
|
(node)->next = (first); \
|
|
if ((first)) \
|
|
(first)->prev = (node); \
|
|
(first) = (node); \
|
|
(node)->prev = 0; \
|
|
} while (0)
|
|
#define DLL_STACK_ADD(first, node) DLL_STACK_ADD_MOD(first, node, next, prev)
|
|
#define DLL_STACK_REMOVE_MOD(first, node, next, prev) \
|
|
do { \
|
|
if ((node) == (first)) { \
|
|
(first) = (first)->next; \
|
|
if ((first)) \
|
|
(first)->prev = 0; \
|
|
} else { \
|
|
(node)->prev->next = (node)->next; \
|
|
if ((node)->next) \
|
|
(node)->next->prev = (node)->prev; \
|
|
} \
|
|
} while (0)
|
|
#define DLL_STACK_REMOVE(first, node) DLL_STACK_REMOVE_MOD(first, node, next, prev)
|
|
|
|
#define For_Linked_List_Named(a,it) for(auto *it = (a); it; it=it->next) // @todo: reference?
|
|
#define For_Linked_List(a) For_Linked_List_Named(a,it)
|
|
#define For_Named(a,it) for(auto &it : (a))
|
|
#define For(a) For_Named((a),it)
|
|
|
|
#define Iter_Named(list, it) for(auto it = iterate(list); should_we_continue(&it); advance(&it))
|
|
#define Iter(list) Iter_Named(list, it)
|
|
|
|
#define allocate_array(a, T, size,...) (T *)allocate_size(a, sizeof(T)*(size),##__VA_ARGS__)
|
|
#define allocate_struct(a, T, ...) allocate_array(a, T, 1,##__VA_ARGS__)
|
|
CORE_Static void *allocate_size(Allocator *allocator, size_t size, bool zero_memory = true) {
|
|
void *result = allocator->allocate(allocator, size);
|
|
if (zero_memory) {
|
|
memory_zero(result, size);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
CORE_Static void deallocate(Allocator *allocator, void *p) {
|
|
assert(p);
|
|
allocator->deallocate(allocator, p);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Memory OS
|
|
//-----------------------------------------------------------------------------
|
|
struct OS_Memory{
|
|
size_t commit, reserve;
|
|
U8 *data;
|
|
};
|
|
CORE_Static OS_Memory os_reserve(size_t size);
|
|
CORE_Static B32 os_commit(OS_Memory *m, size_t size);
|
|
CORE_Static void os_release(OS_Memory *m);
|
|
CORE_Static B32 os_decommit_pos(OS_Memory *m, size_t pos);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Memory arenas
|
|
//-----------------------------------------------------------------------------
|
|
global const size_t default_reserve_size = gib(4);
|
|
global const size_t default_alignment = 8;
|
|
global const size_t additional_commit_size = mib(1);
|
|
struct Arena : Allocator {
|
|
OS_Memory memory;
|
|
size_t alignment;
|
|
size_t len;
|
|
String debug_string;
|
|
};
|
|
|
|
CORE_Static void
|
|
arena_pop_pos(Arena *arena, size_t pos){
|
|
pos = clamp_top(pos, arena->len);
|
|
arena->len = pos;
|
|
}
|
|
|
|
CORE_Static void *
|
|
arena_pop(Arena *arena, size_t size){
|
|
size = clamp_top(size, arena->len);
|
|
arena->len -= size;
|
|
return arena->memory.data + arena->len;
|
|
}
|
|
|
|
CORE_Static void
|
|
arena_release(Arena *arena){
|
|
os_release(&arena->memory);
|
|
}
|
|
|
|
CORE_Static void
|
|
arena_clear(Arena *arena){
|
|
arena_pop_pos(arena, 0);
|
|
}
|
|
|
|
CORE_Static void
|
|
deallocate_stub(Allocator *, void *) {
|
|
}
|
|
|
|
CORE_Static void *
|
|
arena_push_size(Arena *a, size_t size){
|
|
size_t generous_size = size + a->alignment;
|
|
if(a->len+generous_size>a->memory.commit){
|
|
assert(a->memory.reserve > 0);
|
|
B32 result = os_commit(&a->memory, generous_size+additional_commit_size);
|
|
assert(result);
|
|
}
|
|
|
|
a->len = align_up(a->len, a->alignment);
|
|
assert(a->memory.reserve > a->len + size);
|
|
void *result = (U8*)a->memory.data + a->len;
|
|
a->len += size;
|
|
|
|
return result;
|
|
}
|
|
|
|
CORE_Static Arena
|
|
push_arena(Allocator *allocator, size_t size, String debug_name) {
|
|
Arena result = {};
|
|
result.memory.data = (U8 *)allocate_size(allocator, size);
|
|
result.memory.reserve = size;
|
|
result.alignment = default_alignment;
|
|
result.debug_string = debug_name;
|
|
result.allocate = (Allocator::Allocate *)arena_push_size;
|
|
result.deallocate = (Allocator::Deallocate *)deallocate_stub;
|
|
return result;
|
|
}
|
|
|
|
CORE_Static void
|
|
arena_init(Arena *a, String debug_name){
|
|
a->memory = os_reserve(default_reserve_size);
|
|
a->alignment = default_alignment;
|
|
a->debug_string = debug_name;
|
|
a->allocate = (Allocator::Allocate *)arena_push_size;
|
|
a->deallocate = (Allocator::Deallocate *)deallocate_stub;
|
|
}
|
|
|
|
CORE_Static Arena
|
|
arena_sub(Arena *base, size_t size, String debug_name) {
|
|
Arena result = {};
|
|
result.memory.data = (U8 *)arena_push_size(base, size);
|
|
result.memory.commit = size;
|
|
result.memory.reserve = size;
|
|
result.alignment = default_alignment;
|
|
result.len = 0;
|
|
return result;
|
|
}
|