// gb.hpp - v0.32 - public domain C++11 helper library - no warranty implied; use at your own risk // (Experimental) A C++11 helper library without STL geared towards game development /* LICENSE This software is in the public domain. Where that dedication is not recognized, you are granted a perpetual, irrevocable license to copy, distribute, and modify this file as you see fit. WARNING - This library is _highly_ experimental and features may not work as expected. - This also means that many functions are not documented. - This library is not compatible with STL at all! (By design) CONTENTS: - Common Macros - Assert - Types - Type Traits - C++11 Move Semantics - Defer - Casts - bit_cast - pseudo_cast - Memory - Mutex - Atomics - Semaphore - Thread - Allocator - Heap Allocator - Arena Allocator - Functions - String - Array - Hash Table - Hash Functions */ /* Version History: 0.33 - Explicit Everything! No ctor/dtor on Array and Hash_Table 0.32 - Change const position convention 0.31a - Minor fixes 0.31 - Remove `_Allocator` suffix for allocator types 0.30 - sort::quick 0.29 - GB_ASSERT prints call stack 0.28 - Pool Allocator 0.27 - Dealloc to Free & More Hashing Functions 0.26a - Heap_Allocator Fix 0.26 - Better Allocation system 0.25a - Array bug fix 0.25 - Faster Heap_Allocator for Windows using HeapAlloc 0.24b - Even More Hash_Table Bug Fixes 0.24a - Hash_Table Bug Fixes 0.24 - More documentation and bug fixes 0.23 - Move Semantics for Array and Hash_Table 0.22 - Code rearrangment into namespaces 0.21d - Fix array::free 0.21c - Fix Another Typo causing unresolved external symbol 0.21b - Typo fixes 0.21a - Better `static` keywords 0.21 - Separate Math Library 0.20a - #ifndef for many macros 0.20 - Angle 0.19 - Cache friendly Transform and String fixes 0.18 - Hash_Table bug fixes 0.17 - Death to OOP 0.16 - All References are const convention 0.15 - Namespaced Types 0.14 - Casts and Quaternion Look At 0.13a - Fix Todos 0.13 - Basic Type Traits 0.12 - Random 0.11 - Complex 0.10 - Atomics 0.09 - Bug Fixes 0.08 - Matrix(2,3) 0.07 - Bug Fixes 0.06 - Os spec ideas 0.05 - Transform Type and Quaternion Functions 0.04 - String 0.03 - Hash Functions 0.02 - Hash Table 0.01 - Initial Version */ #ifndef GB_INCLUDE_GB_HPP #define GB_INCLUDE_GB_HPP #if !defined(__cplusplus) && __cplusplus >= 201103L #error This library is only for C++11 and above #endif // NOTE(bill): Because static means three different things in C/C++ // Great Design(!) #ifndef global_variable #define global_variable static #define internal_linkage static #define local_persist static #endif /* Example for static defines global_variable const f32 TAU = 6.283185f; global_variable void* g_memory; internal_linkage void some_function(...) { local_persist u32 count = 0; ... count++; ... } */ // `global_variable` : variable is in the global scope // `internal_linkage` : function is only visible for this linkage // `local_persist` : variable persists for the particular function scope #if defined(_MSC_VER) #define _ALLOW_KEYWORD_MACROS #ifndef alignof // Needed for MSVC 2013 'cause Microsoft "loves" standards #define alignof(x) __alignof(x) #endif #endif //////////////////////////////// // // // System OS // // // //////////////////////////////// #if defined(_WIN32) || defined(_WIN64) #ifndef GB_SYSTEM_WINDOWS #define GB_SYSTEM_WINDOWS 1 #endif #elif defined(__APPLE__) && defined(__MACH__) #ifndef GB_SYSTEM_OSX #define GB_SYSTEM_OSX 1 #endif #elif defined(__unix__) #ifndef GB_SYSTEM_UNIX #define GB_SYSTEM_UNIX 1 #endif #if defined(__linux__) #ifndef GB_SYSTEM_LINUX #define GB_SYSTEM_LINUX 1 #endif #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) #ifndef GB_SYSTEM_FREEBSD #define GB_SYSTEM_FREEBSD 1 #endif #else #error This UNIX operating system is not supported by gb.hpp #endif #else #error This operating system is not supported by gb.hpp #endif #if defined(_MSC_VER) // Microsoft Visual Studio #define GB_COMPILER_MSVC 1 #elif defined(__clang__) // Clang #define GB_COMPILER_CLANG 1 #elif defined(__GNUC__) || defined(__GNUG__) && !(defined(__clang__) || defined(__INTEL_COMPILER)) // GNU GCC/G++ Compiler #define GB_COMPILER_GNU_GCC 1 #elif defined(__INTEL_COMPILER) // Intel C++ Compiler #define GB_COMPILER_INTEL 1 #endif //////////////////////////////// // // // Environment Bit Size // // // //////////////////////////////// #if defined(_WIN32) || defined(_WIN64) #if defined(_WIN64) #ifndef GB_ARCH_64_BIT #define GB_ARCH_64_BIT 1 #endif #else #ifndef GB_ARCH_32_BIT #define GB_ARCH_32_BIT 1 #endif #endif #endif // TODO(bill): Check if this works on clang #if defined(__GNUC__) #if defined(__x86_64__) || defined(__ppc64__) #ifndef GB_ARCH_64_BIT #define GB_ARCH_64_BIT 1 #endif #else #ifndef GB_ARCH_32_BIT #define GB_ARCH_32_BIT 1 #endif #endif #endif #ifndef GB_EDIAN_ORDER #define GB_EDIAN_ORDER #define GB_IS_BIG_EDIAN (!*(unsigned char*)&(unsigned short){1}) #define GB_IS_LITTLE_EDIAN (!GB_IS_BIG_EDIAN) #endif #ifndef GB_IS_POWER_OF_TWO #define GB_IS_POWER_OF_TWO(x) ((x) != 0) && !((x) & ((x) - 1)) #endif #if !defined(GB_HAS_NO_CONSTEXPR) #if defined(_GNUC_VER) && _GNUC_VER < 406 // Less than gcc 4.06 #define GB_HAS_NO_CONSTEXPR 1 #elif defined(_MSC_VER) && _MSC_VER < 1900 // Less than Visual Studio 2015/MSVC++ 14.0 #define GB_HAS_NO_CONSTEXPR 1 #elif !defined(__GXX_EXPERIMENTAL_CXX0X__) && __cplusplus < 201103L #define GB_HAS_NO_CONSTEXPR 1 #endif #endif #if defined(GB_HAS_NO_CONSTEXPR) #define GB_CONSTEXPR #else #define GB_CONSTEXPR constexpr #endif #ifndef GB_FORCE_INLINE #if defined(_MSC_VER) #define GB_FORCE_INLINE __forceinline #else #define GB_FORCE_INLINE __attribute__ ((__always_inline__)) #endif #endif //////////////////////////////// // // // Includes // // // //////////////////////////////// #include #include #if !defined(GB_NO_STDIO) #include #endif #if defined(GB_SYSTEM_WINDOWS) #define NOMINMAX 1 #define VC_EXTRALEAN 1 #define WIN32_EXTRA_LEAN 1 #define WIN32_LEAN_AND_MEAN 1 #include // TODO(bill): Should we include only the needed headers? #include // Time functions #undef NOMINMAX #undef VC_EXTRALEAN #undef WIN32_EXTRA_LEAN #undef WIN32_LEAN_AND_MEAN #include #else #include #include #endif #ifndef GB_UNUSED #define GB_UNUSED(x) ((void)sizeof(x)) #endif #if !defined(GB_ASSERT) #if !defined(NDEBUG) #define GB_ASSERT(x, ...) ((void)(gb__assert_handler((x), #x, __FILE__, __LINE__, ##__VA_ARGS__))) // Helper function used as a better alternative to assert which allows for // optional printf style error messages extern "C" void gb__assert_handler(bool condition, char const* condition_str, char const* filename, size_t line, char const* error_text = nullptr, ...); #else #define GB_ASSERT(x, ...) ((void)sizeof(x)) #endif #endif //////////////////////////////// // // // snprintf_msvc // // // //////////////////////////////// #if !defined(GB_NO_STDIO) && defined(_MSC_VER) extern "C" inline int gb__vsnprintf_compatible(char* buffer, size_t size, char const* format, va_list args) { int result = -1; if (size > 0) result = _vsnprintf_s(buffer, size, _TRUNCATE, format, args); if (result == -1) return _vscprintf(format, args); return result; } extern "C" inline int gb__snprintf_compatible(char* buffer, size_t size, char const* format, ...) { va_list args; va_start(args, format); int result = gb__vsnprintf_compatible(buffer, size, format, args); va_end(args); return result; } #if !defined(GB_DO_NOT_USE_MSVC_SPRINTF_FIX) #define snprintf gb__snprintf_compatible #define vsnprintf gb__vsnprintf_compatible #endif // GB_DO_NOT_USE_MSVC_SPRINTF_FIX #endif #if defined(GB_NO_GB_NAMESPACE) #define __GB_NAMESPACE_START #define __GB_NAMESPACE_END #define __GB_NAMESPACE_PREFIX #else #ifndef __GB_NAMESPACE_PREFIX #define __GB_NAMESPACE_PREFIX gb #endif // NOTE(bill): __GB_NAMESPACE_PREFIX cannot be blank // This is why macros that not meant to be touched have `__` prefix // You can change them if you know what you are doing #define __GB_NAMESPACE_START namespace __GB_NAMESPACE_PREFIX { #define __GB_NAMESPACE_END } // namespace __GB_NAMESPACE_PREFIX #endif #if !defined(GB_BASIC_WITHOUT_NAMESPACE) __GB_NAMESPACE_START #endif // GB_BASIC_WITHOUT_NAMESPACE //////////////////////////////// // // // Types // // // //////////////////////////////// #ifndef GB_BASIC_TYPES #define GB_BASIC_TYPES #if defined(_MSC_VER) using u8 = unsigned __int8; using s8 = signed __int8; using u16 = unsigned __int16; using s16 = signed __int16; using u32 = unsigned __int32; using s32 = signed __int32; using u64 = unsigned __int64; using s64 = signed __int64; #else // NOTE(bill): Of the platforms that I build for, these will be correct using u8 = unsigned char; using s8 = signed char; using u16 = unsigned short; using s16 = signed short; using u32 = unsigned int; using s32 = signed int; using u64 = unsigned long long; using s64 = signed long long; #endif static_assert( sizeof(u8) == 1, "u8 is not 8 bits"); static_assert(sizeof(u16) == 2, "u16 is not 16 bits"); static_assert(sizeof(u32) == 4, "u32 is not 32 bits"); static_assert(sizeof(u64) == 8, "u64 is not 64 bits"); using f32 = float; using f64 = double; #if defined(GB_B8_AS_BOOL) using bool8 = bool; #else using bool8 = s8; #endif using bool32 = s32; // NOTE(bill): (std::)size_t is not used not because it's a bad concept but on // the platforms that I will be using: // sizeof(size_t) == sizeof(usize) == sizeof(ssize) // NOTE(bill): This also allows for a signed version of size_t which is similar // to ptrdiff_t // NOTE(bill): If (u)intptr is a better fit, please use that. // NOTE(bill): Also, I hate the `_t` suffix #if defined(GB_ARCH_64_BIT) using ssize = s64; using usize = u64; #elif defined(GB_ARCH_32_BIT) using usize = s32; using usize = u32; #else #error Unknown architecture bit size #endif static_assert(sizeof(usize) == sizeof(size_t), "`usize` is not the same size as `size_t`"); static_assert(sizeof(ssize) == sizeof(usize), "`ssize` is not the same size as `usize`"); using intptr = intptr_t; using uintptr = uintptr_t; using ptrdiff = ptrdiff_t; #endif #if !defined(GB_U8_MIN) #define GB_U8_MIN 0u #define GB_U8_MAX 0xffu #define GB_S8_MIN (-0x7f - 1) #define GB_S8_MAX 0x7f #define GB_U16_MIN 0u #define GB_U16_MAX 0xffffu #define GB_S16_MIN (-0x7fff - 1) #define GB_S16_MAX 0x7fff #define GB_U32_MIN 0u #define GB_U32_MAX 0xffffffffu #define GB_S32_MIN (-0x7fffffff - 1) #define GB_S32_MAX 0x7fffffff #define GB_U64_MIN 0ull #define GB_U64_MAX 0xffffffffffffffffull #define GB_S64_MIN (-0x7fffffffffffffffll - 1) #define GB_S64_MAX 0x7fffffffffffffffll #endif #if defined(GB_ARCH_64_BIT) && !defined(GB_USIZE_MIX) #define GB_USIZE_MIX GB_U64_MIN #define GB_USIZE_MAX GB_U64_MAX #define GB_SSIZE_MIX GB_S64_MIN #define GB_SSIZE_MAX GB_S64_MAX #elif defined(GB_ARCH_32_BIT) && !defined(GB_USIZE_MIX) #define GB_USIZE_MIX GB_U32_MIN #define GB_USIZE_MAX GB_U32_MAX #define GB_SSIZE_MIX GB_S32_MIN #define GB_SSIZE_MAX GB_S32_MAX #endif #if defined(GB_BASIC_WITHOUT_NAMESPACE) && !defined(U8_MIN) #define U8_MIN 0u #define U8_MAX 0xffu #define S8_MIN (-0x7f - 1) #define S8_MAX 0x7f #define U16_MIN 0u #define U16_MAX 0xffffu #define S16_MIN (-0x7fff - 1) #define S16_MAX 0x7fff #define U32_MIN 0u #define U32_MAX 0xffffffffu #define S32_MIN (-0x7fffffff - 1) #define S32_MAX 0x7fffffff #define U64_MIN 0ull #define U64_MAX 0xffffffffffffffffull #define S64_MIN (-0x7fffffffffffffffll - 1) #define S64_MAX 0x7fffffffffffffffll #if defined(GB_ARCH_64_BIT) && !defined(GB_USIZE_MIX) #define USIZE_MIX U64_MIN #define USIZE_MAX U64_MAX #define SSIZE_MIX S64_MIN #define SSIZE_MAX S64_MAX #elif defined(GB_ARCH_32_BIT) && !defined(GB_USIZE_MIX) #define USIZE_MIX U32_MIN #define USIZE_MAX U32_MAX #define SSIZE_MIX S32_MIN #define SSIZE_MAX S32_MAX #endif #endif #if !defined(GB_BASIC_WITHOUT_NAMESPACE) __GB_NAMESPACE_END #endif // GB_BASIC_WITHOUT_NAMESPACE __GB_NAMESPACE_START //////////////////////////////// // // // C++11 Types Traits // // // //////////////////////////////// template struct Add_Const_Def { using Type = const T; }; template using Add_Const = typename Add_Const_Def::Type; template struct Add_Volatile_Def { using Type = volatile T; }; template using Add_Volatile = typename Add_Volatile_Def::Type; template using Add_Const_Volatile = Add_Const>; template struct Add_Lvalue_Reference_Def { using Type = T&; }; template struct Add_Lvalue_Reference_Def { using Type = T&; }; template struct Add_Lvalue_Reference_Def { using Type = T&; }; template <> struct Add_Lvalue_Reference_Def { using Type = void; }; template <> struct Add_Lvalue_Reference_Def { using Type = void const; }; template <> struct Add_Lvalue_Reference_Def { using Type = void volatile; }; template <> struct Add_Lvalue_Reference_Def { using Type = void const volatile; }; template using Add_Lvalue_Reference = typename Add_Lvalue_Reference_Def::Type; template struct Add_Rvalue_Reference_Def { using Type = T&&; }; template struct Add_Rvalue_Reference_Def { using Type = T&; }; template struct Add_Rvalue_Reference_Def { using Type = T&&; }; template <> struct Add_Rvalue_Reference_Def { using Type = void; }; template <> struct Add_Rvalue_Reference_Def { using Type = void const; }; template <> struct Add_Rvalue_Reference_Def { using Type = void volatile; }; template <> struct Add_Rvalue_Reference_Def { using Type = void const volatile; }; template using Add_Rvalue_Reference = typename Add_Rvalue_Reference_Def::Type; template struct Remove_Pointer_Def { using Type = T; }; template struct Remove_Pointer_Def { using Type = T; }; template struct Remove_Pointer_Def { using Type = T; }; template struct Remove_Pointer_Def { using Type = T; }; template struct Remove_Pointer_Def { using Type = T; }; template using Remove_Pointer = typename Remove_Pointer_Def::Type; template struct Add_Pointer_Def { using Type = T*; }; template using Add_Pointer = typename Add_Pointer_Def::Type; template struct Remove_Const_Def { using Type = T; }; template struct Remove_Const_Def { using Type = T; }; template using Remove_Const = typename Remove_Const_Def::Type; template struct Remove_Volatile_Def { using Type = T; }; template struct Remove_Volatile_Def { using Type = T; }; template using Remove_Volatile = typename Remove_Const_Def::Type; template using Remove_Const_Volatile = Remove_Const>; template struct Remove_Reference_Def { using Type = T; }; template struct Remove_Reference_Def { using Type = T; }; template struct Remove_Reference_Def { using Type = T; }; template using Remove_Reference = typename Remove_Reference_Def::Type; template struct Integral_Constant { global_variable const T VALUE = v; using Value_Type = T; using Type = Integral_Constant; }; template struct Extent : Integral_Constant {}; template struct Extent : Integral_Constant {}; template struct Extent : Integral_Constant::VALUE> {}; template struct Extent : Integral_Constant {}; template struct Extent : Integral_Constant::VALUE> {}; template struct Remove_Extent_Def { using Type = T; }; template struct Remove_Extent_Def { using Type = T; }; template struct Remove_Extent_Def { using Type = T; }; // TODO(bill): Do I "need" all of these template traits? //////////////////////////////// // // // C++11 Move Semantics // // // //////////////////////////////// template inline T&& forward_ownership(Remove_Reference& t) { return static_cast(t); } template inline T&& forward_ownership(Remove_Reference&& t) { return static_cast(t); } template inline Remove_Reference&& move_ownership(T&& t) { return static_cast&&>(t); } __GB_NAMESPACE_END //////////////////////////////// // // // Defer // // // //////////////////////////////// #ifndef GB_DEFER #define GB_DEFER __GB_NAMESPACE_START namespace impl { template struct Defer { Func f; Defer(Func&& f) : f{forward_ownership(f)} {} ~Defer() { f(); }; }; template inline Defer defer_func(Func&& f) { return Defer(forward_ownership(f)); } } // namespace impl __GB_NAMESPACE_END // NOTE(bill): These macros are in the global namespace thus, defer can be treated without a __GB_NAMESPACE_PREFIX:: prefix #define GB_DEFER_1(x, y) x##y #define GB_DEFER_2(x, y) GB_DEFER_1(x, y) #define GB_DEFER_3(x) GB_DEFER_2(GB_DEFER_2(GB_DEFER_2(x, __COUNTER__), _), __LINE__) #define defer(code) auto GB_DEFER_3(_defer_) = ::impl::defer_func([&](){code;}) /* EXAMPLES // `defer (...)` will defer a statement till the end of scope FILE* file = fopen("test.txt", "rb"); if (file == nullptr) { // Handle Error } defer (fclose(file)); // Will always be called at the end of scope // auto m = mutex::make(); defer (mutex::destroy(&m)); // Mutex will be destroyed at the end of scope { mutex::lock(&m); defer (mutex::unlock(&m)); // Mutex will unlock at end of scope // Do whatever } // You can scope multiple statements together if needed with {...} defer ({ func1(); func2(); func3(); }); */ #endif #if !defined(GB_CASTS_WITHOUT_NAMESPACE) __GB_NAMESPACE_START #endif // GB_CASTS_WITHOUT_NAMESPACE #ifndef GB_SPECIAL_CASTS #define GB_SPECIAL_CASTS // NOTE(bill): Very similar to doing `*(T*)(&u)` template inline Dest bit_cast(Source const& source) { static_assert(sizeof(Dest) <= sizeof(Source), "bit_cast(Source const&) - sizeof(Dest) <= sizeof(Source)"); Dest dest; ::memcpy(&dest, &source, sizeof(Dest)); return dest; } // IMPORTANT NOTE(bill): Very similar to doing `*(T*)(&u)` but easier/clearer to write // however, it can be dangerous if sizeof(T) > sizeof(U) e.g. unintialized memory, undefined behavior // *(T*)(&u) ~~ pseudo_cast(u) template inline T pseudo_cast(U const& u) { return reinterpret_cast(u); } /* EXAMPLES: // bit_cast u8 arr[4] = {0x78, 0x56, 0x34, 0x12}; u32 var = bit_cast(arr); // Little edian => 0x12345678 // pseudo_cast - except from gb_math.hpp Sphere calculate_min_bounding(void const* vertices, usize num_vertices, usize stride, usize offset, f32 step) { auto gen = random::make(0); u8 const* vertex = reinterpret_cast(vertices); vertex += offset; Vector3 position = pseudo_cast(vertex[0]); Vector3 center = position; center += pseudo_cast(vertex[1 * stride]); center *= 0.5f; Vector3 d = position - center; f32 max_dist_sq = math::dot(d, d); f32 radius_step = step * 0.37f; bool done; do { done = true; for (u32 i = 0, index = random::uniform_u32(&gen, 0, num_vertices-1); i < num_vertices; i++, index = (index + 1)%num_vertices) { Vector3 position = pseudo_cast(vertex[index * stride]); d = position - center; f32 dist_sq = math::dot(d, d); if (dist_sq > max_dist_sq) { done = false; center = d * radius_step; max_dist_sq = math::lerp(max_dist_sq, dist_sq, step); break; } } } while (!done); Sphere result; result.center = center; result.radius = math::sqrt(max_dist_sq); return result; } */ #endif // FORENOTE(bill): There used to be a magic_cast that was equivalent to // a C-style cast but I removed it as I could not get it work as intented // for everything using only C++ style casts (it needed to a c-style cast) #if !defined(GB_CASTS_WITHOUT_NAMESPACE) __GB_NAMESPACE_END #endif // GB_CASTS_WITHOUT_NAMESPACE __GB_NAMESPACE_START //////////////////////////////// // // // Memory // // // //////////////////////////////// template inline usize array_count(T const(& )[N]) { return N; } inline s64 kilobytes(s64 x) { return (x) * 1024ll; } inline s64 megabytes(s64 x) { return kilobytes(x) * 1024ll; } inline s64 gigabytes(s64 x) { return megabytes(x) * 1024ll; } inline s64 terabytes(s64 x) { return gigabytes(x) * 1024ll; } struct Mutex { #if defined(GB_SYSTEM_WINDOWS) HANDLE win32_mutex; #else pthread_mutex_t posix_mutex; #endif }; namespace mutex { Mutex make(); void destroy(Mutex* mutex); void lock(Mutex* mutex); bool try_lock(Mutex* mutex); void unlock(Mutex* mutex); } // namespace mutex // Atomic Types struct Atomic32 { u32 nonatomic; }; struct Atomic64 { u64 nonatomic; }; namespace atomic { u32 load(Atomic32 const volatile* object); void store(Atomic32 volatile* object, u32 value); u32 compare_exchange_strong(Atomic32 volatile* object, u32 expected, u32 desired); u32 exchanged(Atomic32 volatile* object, u32 desired); u32 fetch_add(Atomic32 volatile* object, s32 operand); u32 fetch_and(Atomic32 volatile* object, u32 operand); u32 fetch_or(Atomic32 volatile* object, u32 operand); u64 load(Atomic64 const volatile* object); void store(Atomic64 volatile* object, u64 value); u64 compare_exchange_strong(Atomic64 volatile* object, u64 expected, u64 desired); u64 exchanged(Atomic64 volatile* object, u64 desired); u64 fetch_add(Atomic64 volatile* object, s64 operand); u64 fetch_and(Atomic64 volatile* object, u64 operand); u64 fetch_or(Atomic64 volatile* object, u64 operand); } // namespace atomic struct Semaphore { #if defined(GB_SYSTEM_WINDOWS) HANDLE win32_handle; #else Mutex mutex; pthread_cond_t cond; s32 count; #endif }; namespace semaphore { Semaphore make(); void destroy(Semaphore* semaphore); void post(Semaphore* semaphore, u32 count = 1); void wait(Semaphore* semaphore); } // namespace semaphore // TODO(bill): Is this thread procedure definition good enough? using Thread_Procedure = void(void*); struct Thread { #if defined(GB_SYSTEM_WINDOWS) HANDLE win32_handle; #else pthread_t posix_handle; #endif Thread_Procedure* function; void* data; Semaphore semaphore; usize stack_size; bool32 is_running; }; namespace thread { Thread make(); void destroy(Thread* t); void start(Thread* t, Thread_Procedure* func, void* data = nullptr, usize stack_size = 0); void join(Thread* t); bool is_running(Thread const& t); u32 current_id(); } // namespace thread // Default alignment for memory allocations #ifndef GB_DEFAULT_ALIGNMENT #define GB_DEFAULT_ALIGNMENT 8 #endif // Base class for memory allocators - Pretty much a vtable struct Allocator { // Allocates the specified amount of memory aligned to the specified alignment void* (*alloc)(Allocator* a, usize size, usize align); // Frees an allocation made with alloc() void (*free)(Allocator* a, void* ptr); // Returns the amount of usuable memory allocated at `ptr`. /// // If the allocator does not support tracking of the allocation size, // the function will return -1 s64 (*allocated_size)(Allocator* a, void const* ptr); // Returns the total amount of memory allocated by this allocator /// // If the allocator does not track memory, the function will return -1 s64 (*total_allocated)(Allocator* a); }; struct Heap : Allocator { struct Header { usize size; }; Mutex mutex; bool32 use_mutex; s64 total_allocated_count; s64 allocation_count; #if defined(GB_SYSTEM_WINDOWS) HANDLE win32_heap_handle; #endif }; namespace heap { Heap make(bool use_mutex = true); void destroy(Heap* heap); } // namespace heap struct Arena : Allocator { Allocator* backing; void* physical_start; s64 total_size; s64 total_allocated_count; s64 temp_count; }; namespace arena { Arena make(Allocator* backing, usize size); Arena make(void* start, usize size); void destroy(Arena* arena); void clear(Arena* arena); } // namespace arena struct Temporary_Arena_Memory { Arena* arena; s64 original_count; }; namespace temporary_arena_memory { Temporary_Arena_Memory make(Arena* arena); void free(Temporary_Arena_Memory tmp); } // namespace temporary_arena_memory struct Pool : Allocator { Allocator* backing; void* physical_start; void* free_list; usize block_size; usize block_align; s64 total_size; }; namespace pool { Pool make(Allocator* backing, usize num_blocks, usize block_size, usize block_align = GB_DEFAULT_ALIGNMENT); void destroy(Pool* pool); } // namespace pool namespace memory { void* align_forward(void* ptr, usize align); void* pointer_add(void* ptr, usize bytes); void* pointer_sub(void* ptr, usize bytes); void const* pointer_add(void const* ptr, usize bytes); void const* pointer_sub(void const* ptr, usize bytes); template void fill(T* ptr, usize count, T const& value); template void fill(T* ptr, usize count, T&& value); void zero(void* ptr, usize bytes); void copy(void const* src, usize bytes, void* dest); void move(void const* src, usize bytes, void* dest); bool equals(void const* a, void const* b, usize bytes); template void zero_struct(T* ptr); template void zero_array(T* ptr, usize count); template void copy_array(T const* src_array, usize count, T* dest_array); template void copy_struct(T const* src_array, T* dest_array); template void swap(T* a, T* b); template void swap(T (& a)[N], T (& b)[N]); } // namespace memory // Allocator Functions void* alloc(Allocator* a, usize size, usize align = GB_DEFAULT_ALIGNMENT); void free(Allocator* a, void* ptr); s64 allocated_size(Allocator* a, void const* ptr); s64 total_allocated(Allocator* a); template inline T* alloc_struct(Allocator* a) { return static_cast(alloc(a, sizeof(T), alignof(T))); } template inline T* alloc_array(Allocator* a, usize count) { return static_cast(alloc(a, count * sizeof(T), alignof(T))); } //////////////////////////////// // // // String // // // // C compatible string // // // //////////////////////////////// // A "better" string type that is compatible with C style read-only functions using String = char*; namespace string { using Size = u32; struct Header { Allocator* allocator; Size length; Size capacity; }; inline Header* header(String str) { return reinterpret_cast(str) - 1; } String make(Allocator* a, char const* str = ""); String make(Allocator* a, void const* str, Size num_bytes); void free(String str); String duplicate(Allocator* a, String const str); Size length(String const str); Size capacity(String const str); Size available_space(String const str); void clear(String str); void append(String* str, char c); void append(String* str, String const other); void append_cstring(String* str, char const* other); void append(String* str, void const* other, Size num_bytes); void make_space_for(String* str, Size add_len); usize allocation_size(String const str); bool equals(String const lhs, String const rhs); int compare(String const lhs, String const rhs); // NOTE(bill): three-way comparison void trim(String* str, char const* cut_set); void trim_space(String* str); } // namespace string // TODO(bill): string libraries //////////////////////////////// // // // Array // // // //////////////////////////////// #ifndef GB_ARRAY_BOUND_CHECKING #define GB_ARRAY_BOUND_CHECKING 1 #endif // Dynamic resizable array for POD types only template struct Array { using Type = T; Allocator* allocator; s64 count; s64 capacity; T* data; T const& operator[](usize index) const; T& operator[](usize index); }; // NOTE(bill): There are not ctor/dtor for Array. // These are explicit functions e.g. /* auto old_array = array::make(...); auto new_array = array::copy(old_array); array::free(&old_array); array::free(&new_array); */ // This allows functions to be passed by value at a low cost namespace array { // Helper functions to make, free, and copy an array template Array make(Allocator* allocator, usize count = 0); template void free(Array* array); // TODO(bill): Is passing by value okay here or is pass by const& ? // (sizeof(Array) = 16 + sizeof(void*)) (24 bytes on x86, 32 bytes on x64) template Array copy(Array array, Allocator* allocator = nullptr); // Appends `item` to the end of the array template void append(Array* a, T const& item); template void append(Array* a, T&& item); // Appends `items[count]` to the end of the array template void append(Array* a, T const* items, usize count); // Append the contents of another array of the same type template void append(Array* a, Array other); // Pops the last item form the array. The array cannot be empty. template void pop(Array* a); // Removes all items from the array - does not free memory template void clear(Array* a); // Modify the size of a array - only reallocates when necessary template void resize(Array* a, usize count); // Makes sure that the array has at least the specified capacity - or the array the grows template void reserve(Array* a, usize capacity); // Reallocates the array to the specific capacity template void set_capacity(Array* a, usize capacity); // Grows the array to keep append() to be O(1) template void grow(Array* a, usize min_capacity = 0); } // namespace array // Used to iterate over the array with a C++11 for loop template inline T* begin(Array& a) { return a.data; } template inline T const* begin(Array const& a) { return a.data; } template inline T* begin(Array&& a) { return a.data; } template inline T* end(Array& a) { return a.data + a.count; } template inline T const* end(Array const& a) { return a.data + a.count; } template inline T* end(Array&& a) { return a.data + a.count; } //////////////////////////////// // // // Hash Table // // // //////////////////////////////// // Hash table for POD types only with a u64 key template struct Hash_Table { using Type = T; struct Entry { u64 key; s64 next; T value; }; Array hashes; Array entries; }; namespace hash_table { // Helper function to make, free, and copy a hash table template Hash_Table make(Allocator* a); template void free(Hash_Table* h); template Hash_Table copy(Hash_Table const& h, Allocator* a = nullptr); // Return `true` if the specified key exist in the hash table template bool has(Hash_Table const& h, u64 key); // Returns the value stored at the key, or a `default_value` if the key is not found in the hash table template T const& get(Hash_Table const& h, u64 key, T const& default_value); // Sets the value for the key in the hash table template void set(Hash_Table* h, u64 key, T const& value); template void set(Hash_Table* h, u64 key, T&& value); // Removes the key from the hash table if it exists template void remove(Hash_Table* h, u64 key); // Resizes the hash table's lookup table to the specified size template void reserve(Hash_Table* h, usize capacity); // Remove all elements from the hash table template void clear(Hash_Table* h); } // namespace hash_table // Used to iterate over the array with a C++11 for loop - in random order template typename Hash_Table::Entry const* begin(Hash_Table const& h); template typename Hash_Table::Entry const* end(Hash_Table const& h); namespace multi_hash_table { // Outputs all the items that with the specified key template void get(Hash_Table const& h, u64 key, Array& items); // Returns the count of entries with the specified key template usize count(Hash_Table const& h, u64 key); // Finds the first entry with specified key in the hash table template typename Hash_Table::Entry const* find_first(Hash_Table const& h, u64 key); // Finds the next entry with same key as `e` template typename Hash_Table::Entry const* find_next(Hash_Table const& h, typename Hash_Table::Entry const* e); // Inserts the `value` as an additional value for the specified key template void insert(Hash_Table* h, u64 key, T const& value); template void insert(Hash_Table* h, u64 key, T&& value); // Removes a specified entry `e` from the hash table template void remove_entry(Hash_Table* h, typename Hash_Table::Entry const* e); // Removes all entries with from the hash table with the specified key template void remove_all(Hash_Table* h, u64 key); } // namespace multi_hash_table //////////////////////////////// // // // Hash // // // //////////////////////////////// namespace hash { u32 adler32(void const* key, u32 num_bytes); u32 crc32(void const* key, u32 num_bytes); u64 crc64(void const* key, usize num_bytes); u32 fnv32(void const* key, usize num_bytes); u64 fnv64(void const* key, usize num_bytes); u32 fnv32a(void const* key, usize num_bytes); u64 fnv64a(void const* key, usize num_bytes); u32 murmur32(void const* key, u32 num_bytes, u32 seed = 0x9747b28c); u64 murmur64(void const* key, usize num_bytes, u64 seed = 0x9747b28c); } // namespace hash //////////////////////////////// // // // Sort // // // //////////////////////////////// namespace sort { // Comparison_Function // NOTE(bill): Similar to str(n)cmp // a < b --> -1 // a == b --> 0 // a > b --> +1 // Quick Sort (Qsort) template void quick(T* array, usize count, Comparison_Function compare); // TODO(bill): Implement other sorting algorithms } // namespace sort //////////////////////////////// // // // Time // // // //////////////////////////////// struct Time { s64 microseconds; }; extern Time const TIME_ZERO; namespace time { Time now(); void sleep(Time time); Time seconds(f32 s); Time milliseconds(s32 ms); Time microseconds(s64 us); f32 as_seconds(Time t); s32 as_milliseconds(Time t); s64 as_microseconds(Time t); } // namespace time bool operator==(Time left, Time right); bool operator!=(Time left, Time right); bool operator<(Time left, Time right); bool operator>(Time left, Time right); bool operator<=(Time left, Time right); bool operator>=(Time left, Time right); Time operator+(Time right); Time operator-(Time right); Time operator+(Time left, Time right); Time operator-(Time left, Time right); Time& operator+=(Time& left, Time right); Time& operator-=(Time& left, Time right); Time operator*(Time left, f32 right); Time operator*(Time left, s64 right); Time operator*(f32 left, Time right); Time operator*(s64 left, Time right); Time& operator*=(Time& left, f32 right); Time& operator*=(Time& left, s64 right); Time operator/(Time left, f32 right); Time operator/(Time left, s64 right); Time& operator/=(Time& left, f32 right); Time& operator/=(Time& left, s64 right); f32 operator/(Time left, Time right); Time operator%(Time left, Time right); Time& operator%=(Time& left, Time right); //////////////////////////////// // // // OS // // // //////////////////////////////// // TODO(bill): Should this be system:: vs os:: ? namespace os { u64 rdtsc(); } // namespace os //////////////////////////////// // // // Template Implementations // // // //////////////////////////////// //////////////////////////////// // // // Array // // // //////////////////////////////// template inline T const& Array::operator[](usize index) const { #if GB_ARRAY_BOUND_CHECKING GB_ASSERT(index < static_cast(capacity), "Array out of bounds"); #endif return data[index]; } template inline T& Array::operator[](usize index) { #if GB_ARRAY_BOUND_CHECKING GB_ASSERT(index < static_cast(capacity), "Array out of bounds"); #endif return data[index]; } namespace array { template inline Array make(Allocator* allocator, usize count) { Array result = {}; result.allocator = allocator; if (count > 0) { result.data = alloc_array(allocator, count); if (result.data) result.count = result.capacity = count; } return result; } template inline void free(Array* a) { if (a->allocator) free(a->allocator, a->data); a->count = 0; a->capacity = 0; a->data = nullptr; } template inline Array copy(Array other, Allocator* allocator) { Array result = {}; if (allocator) result.allocator = allocator; else result.allocator = other.allocator; auto new_count = other.count; array::resize(&result, new_count); memory::copy_array(other.data, new_count, data); return result; } template inline void append(Array* a, T const& item) { if (a->capacity < a->count + 1) array::grow(a); a->data[a->count++] = item; } template inline void append(Array* a, T&& item) { if (a->capacity < a->count + 1) array::grow(a); a->data[a->count++] = move_ownership(item); } template inline void append(Array* a, T const* items, usize count) { if (a->capacity <= a->count + static_cast(count)) array::grow(a, a->count + count); memory::copy_array(items, count, &a->data[a->count]); a->count += count; } template inline void append(Array* a, Array other) { array::append(a, other.data, other.count); } template inline void pop(Array* a) { GB_ASSERT(a->count > 0); a->count--; } template inline void clear(Array* a) { a->count = 0; } template inline void resize(Array* a, usize count) { if (a->capacity < static_cast(count)) array::grow(a, count); a->count = count; } template inline void reserve(Array* a, usize capacity) { if (a->capacity < static_cast(capacity)) array::set_capacity(a, capacity); } template inline void set_capacity(Array* a, usize capacity) { if (static_cast(capacity) == a->capacity) return; if (static_cast(capacity) < a->count) array::resize(a, capacity); T* data = nullptr; if (capacity > 0) { data = alloc_array(a->allocator, capacity); memory::copy_array(a->data, a->count, data); } free(a->allocator, a->data); a->data = data; a ->capacity = capacity; } template inline void grow(Array* a, usize min_capacity) { // TODO(bill): Decide on decent growing formula for Array usize capacity = 2 * a->capacity + 8; if (capacity < min_capacity) capacity = min_capacity; set_capacity(a, capacity); } } // namespace array //////////////////////////////// // // // Hash Table // // // //////////////////////////////// namespace hash_table { template inline Hash_Table make(Allocator* a) { Hash_Table result = {}; result.hashes = array::make(a); result.entries = array::make::Entry>(a); return result; } template inline void free(Hash_Table* h) { if (h->hashes.allocator) array::free(&h->hashes); if (h->entries.allocator) array::free(&h->entries); } template inline Hash_Table copy(Hash_Table const& other, Allocator* allocator) { Allocator* a = other.hashes.allocator; if (allocator) a = allocator; Hash_Table result = {}; result.hashes = array::copy(other.hashes, a); result.entries = array::copy(other.entries, a); return result; } namespace impl { struct Find_Result { s64 hash_index; s64 data_prev; s64 entry_index; }; template usize add_entry(Hash_Table* h, u64 key); template void erase(Hash_Table* h, Find_Result const& fr); template Find_Result find_result_from_key(Hash_Table const& h, u64 key); template Find_Result find_result_from_entry(Hash_Table const& h, typename Hash_Table::Entry const* e); template s64 make_entry(Hash_Table* h, u64 key); template void find_and_erase_entry(Hash_Table* h, u64 key); template s64 find_entry_or_fail(Hash_Table const& h, u64 key); template s64 find_or_make_entry(Hash_Table* h, u64 key); template void rehash(Hash_Table* h, usize new_capacity); template void grow(Hash_Table* h); template bool is_full(Hash_Table* h); template usize add_entry(Hash_Table* h, u64 key) { typename Hash_Table::Entry e = {}; e.key = key; e.next = -1; usize e_index = h->entries.count; array::append(&h->entries, e); return e_index; } template void erase(Hash_Table* h, Find_Result const& fr) { if (fr.data_prev < 0) h->hashes[fr.hash_index] = h->entries[fr.entry_index].next; else h->entries[fr.data_prev].next = h->entries[fr.entry_index].next; array::pop(&h->entries); // Update array count if (fr.entry_index == h->entries.count) return; h->entries[fr.entry_index] = h->entries[h->entries.count]; auto last = impl::find_result_from_key(*h, h->entries[fr.entry_index].key); if (last.data_prev < 0) h->hashes[last.hash_index] = fr.entry_index; else h->entries[last.entry_index].next = fr.entry_index; } template Find_Result find_result_from_key(Hash_Table const& h, u64 key) { Find_Result fr = {}; fr.hash_index = -1; fr.data_prev = -1; fr.entry_index = -1; if (h.hashes.count == 0) return fr; fr.hash_index = key % h.hashes.count; fr.entry_index = h.hashes[fr.hash_index]; while (fr.entry_index >= 0) { if (h.entries[fr.entry_index].key == key) return fr; fr.data_prev = fr.entry_index; fr.entry_index = h.entries[fr.entry_index].next; } return fr; } template Find_Result find_result_from_entry(Hash_Table const& h, typename Hash_Table::Entry const* e) { Find_Result fr = {}; fr.hash_index = -1; fr.data_prev = -1; fr.entry_index = -1; if (h.hashes.count == 0 || !e) return fr; fr.hash_index = e->key % h.hashes.count; fr.entry_index = h.hashes[fr.hash_index]; while (fr.entry_index >= 0) { if (&h.entries[fr.entry_index] == e) return fr; fr.data_prev = fr.entry_index; fr.entry_index = h.entries[fr.entry_index].next; } return fr; } template s64 make_entry(Hash_Table* h, u64 key) { Find_Result const fr = impl::find_result_from_key(*h, key); s64 const index = impl::add_entry(h, key); if (fr.data_prev < 0) h->hashes[fr.hash_index] = index; else h->entries[fr.data_prev].next = index; h->entries[index].next = fr.entry_index; return index; } template void find_and_erase_entry(Hash_Table* h, u64 key) { Find_Result const fr = impl::find_result_from_key(*h, key); if (fr.entry_index >= 0) impl::erase(h, fr); } template s64 find_entry_or_fail(Hash_Table const& h, u64 key) { return impl::find_result_from_key(h, key).entry_index; } template s64 find_or_make_entry(Hash_Table* h, u64 key) { auto const fr = impl::find_result_from_key(*h, key); if (fr.entry_index >= 0) return fr.entry_index; s64 index = impl::add_entry(h, key); if (fr.data_prev < 0) h->hashes[fr.hash_index] = index; else h->entries[fr.data_prev].next = index; return index; } template void rehash(Hash_Table* h, usize new_capacity) { auto nh = hash_table::make(h->hashes.allocator); array::resize(&nh.hashes, new_capacity); array::reserve(&nh.entries, h->entries.count); for (usize i = 0; i < new_capacity; i++) nh.hashes[i] = -1; for (s64 i = 0; i < h->entries.count; i++) { auto const* e = &h->entries[i]; multi_hash_table::insert(&nh, e->key, e->value); } Hash_Table empty_ht{h->hashes.allocator}; hash_table::free(h); memory::copy_struct(&nh, h); memory::copy_struct(&empty_ht, &nh); } template inline void grow(Hash_Table* h) { const usize new_capacity = 2 * h->entries.count + 8; impl::rehash(h, new_capacity); } template inline bool is_full(Hash_Table* h) { // Make sure that there is enough space f64 const maximum_load_coefficient = 0.75; return h->entries.count >= maximum_load_coefficient * h->hashes.count; } } // namespace impl template inline bool has(Hash_Table const& h, u64 key) { return impl::find_entry_or_fail(h, key) >= 0; } template inline T const& get(Hash_Table const& h, u64 key, T const& default_value) { s64 const index = impl::find_entry_or_fail(h, key); if (index < 0) return default_value; return h.entries[index].value; } template inline void set(Hash_Table* h, u64 key, T const& value) { if (h->hashes.count == 0) impl::grow(h); s64 const index = impl::find_or_make_entry(h, key); h->entries[index].value = value; if (impl::is_full(h)) impl::grow(h); } template inline void set(Hash_Table* h, u64 key, T&& value) { if (h->hashes.count == 0) impl::grow(h); s64 const index = impl::find_or_make_entry(h, key); h->entries[index].value = move_ownership(value); if (impl::is_full(h)) impl::grow(h); } template inline void remove(Hash_Table* h, u64 key) { impl::find_and_erase_entry(h, key); } template inline void reserve(Hash_Table* h, usize capacity) { impl::rehash(h, capacity); } template inline void clear(Hash_Table* h) { array::clear(&h->hashes); array::clear(&h->entries); } } // namespace hash_table template inline typename Hash_Table::Entry const* begin(Hash_Table const& h) { return begin(h.entries); } template inline typename Hash_Table::Entry const* end(Hash_Table const& h) { return end(h.entries); } namespace multi_hash_table { template inline void get(Hash_Table const& h, u64 key, Array& items) { auto e = multi_hash_table::find_first(h, key); while (e) { array::append(items, e->value); e = multi_hash_table::find_next(h, e); } } template inline usize count(Hash_Table const& h, u64 key) { usize count = 0; auto e = multi_hash_table::find_first(h, key); while (e) { count++; e = multi_hash_table::find_next(h, e); } return count; } template inline typename Hash_Table::Entry const* find_first(Hash_Table const& h, u64 key) { s64 const index = hash_table::impl::find_entry_or_fail(h, key); if (index < 0) return nullptr; return &h.entries[index]; } template typename Hash_Table::Entry const* find_next(Hash_Table const& h, typename Hash_Table::Entry const* e) { if (!e) return nullptr; auto index = e->next; while (index >= 0) { if (h.entries[index].key == e->key) return &h.entries[index]; index = h.entries[index].next; } return nullptr; } template inline void insert(Hash_Table* h, u64 key, T const& value) { if (h->hashes.count == 0) hash_table::impl::grow(h); auto next = hash_table::impl::make_entry(h, key); h->entries[next].value = value; if (hash_table::impl::is_full(h)) hash_table::impl::grow(h); } template inline void insert(Hash_Table* h, u64 key, T&& value) { if (h->hashes.count == 0) hash_table::impl::grow(h); auto next = hash_table::impl::make_entry(h, key); h->entries[next].value = move_ownership(value); if (hash_table::impl::is_full(h)) hash_table::impl::grow(h); } template inline void remove_entry(Hash_Table* h, typename Hash_Table::Entry const* e) { auto const fr = hash_table::impl::find_result_from_entry(*h, e); if (fr.entry_index >= 0) hash_table::impl::erase(h, fr); } template inline void remove_all(Hash_Table* h, u64 key) { while (hash_table::has(*h, key)) hash_table::remove(h, key); } } // namespace multi_hash_table namespace memory { template inline void fill(T* ptr, usize count, T const& value) { for (usize i = 0; i < count; i++) ptr[i] = value; } template inline void fill(T* ptr, usize count, T&& value) { for (usize i = 0; i < count; i++) ptr[i] = move_ownership(value); } template inline void zero_struct(T* ptr) { memory::zero(ptr, sizeof(T)); } template inline void zero_array(T* ptr, usize count) { memory::zero(ptr, count * sizeof(T)); } template inline void copy_array(T const* src_array, usize count, T* dest_array) { memory::copy(src_array, count * sizeof(T), dest_array); } template inline void copy_struct(T const* src_array, T* dest_array) { memory::copy(src_array, sizeof(T), dest_array); } template inline void swap(T* a, T* b) { T c = move_ownership(*a); *a = move_ownership(*b); *b = move_ownership(c); } template inline void swap(T (& a)[N], T (& b)[N]) { for (usize i = 0; i < N; i++) math::swap(&a[i], &b[i]); } } // namespace memory //////////////////////////////// // // // Sort // // // //////////////////////////////// namespace sort { template void quick(T* array, usize count, Comparison_Function compare) { if (count < 2) return; T const& mid = array[count/2]; s64 i = 0; s64 j = count-1; while (true) { while (compare(array[i], mid) < 0) i++; while (compare(mid, array[j]) < 0) j--; if (i >= j) break; memory::swap(&array[i], &array[j]); i++; j--; } sort::quick(array, i, compare); sort::quick(array+i, count-i, compare); } } // namespace sort __GB_NAMESPACE_END #endif // GB_INCLUDE_GB_HPP // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // It's turtles all the way down! // // // // // //////////////////////////////// // // // Implemenation // // // //////////////////////////////// #if defined(GB_IMPLEMENTATION) #if defined(GB_SYSTEM_WINDOWS) #if !defined(GB_NO_STDIO) #include #pragma comment(lib, "dbghelp.lib") // TODO(bill): Should this be pragma included or not? internal_linkage void gb__print_call_stack(FILE* out_stream) { SymInitialize(GetCurrentProcess(), nullptr, true); SymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_UNDNAME); DWORD mtype = {}; CONTEXT ctx = {}; ctx.ContextFlags = CONTEXT_CONTROL; RtlCaptureContext(&ctx); STACKFRAME64 stack = {}; #if defined(_M_IX86) mtype = IMAGE_FILE_MACHINE_I386; stack.AddrPC.Offset = ctx.Eip; stack.AddrPC.Mode = AddrModeFlat; stack.AddrFrame.Offset = ctx.Ebp; stack.AddrFrame.Mode = AddrModeFlat; stack.AddrStack.Offset = ctx.Esp; stack.AddrStack.Mode = AddrModeFlat; #elif defined(_M_X64) mtype = IMAGE_FILE_MACHINE_AMD64; stack.AddrPC.Offset = ctx.Rip; stack.AddrPC.Mode = AddrModeFlat; stack.AddrFrame.Offset = ctx.Rsp; stack.AddrFrame.Mode = AddrModeFlat; stack.AddrStack.Offset = ctx.Rsp; stack.AddrStack.Mode = AddrModeFlat; #else #error Unknown Windows Platform #endif DWORD ldsp = 0; IMAGEHLP_LINE64 line = {}; line.SizeOfStruct = sizeof(IMAGEHLP_LINE64); char buf[sizeof(SYMBOL_INFO) + (MAX_SYM_NAME * sizeof(TCHAR))]; SYMBOL_INFO* sym = reinterpret_cast(buf); sym->SizeOfStruct = sizeof(SYMBOL_INFO); sym->MaxNameLen = MAX_SYM_NAME; UINT layer_count = 0; while (StackWalk64(mtype, GetCurrentProcess(), GetCurrentThread(), &stack, &ctx, nullptr, SymFunctionTableAccess64, SymGetModuleBase64, nullptr)) { if (stack.AddrPC.Offset == 0) break; BOOL result = SymGetLineFromAddr64(GetCurrentProcess(), stack.AddrPC.Offset, &ldsp, &line); result = result && SymFromAddr(GetCurrentProcess(), stack.AddrPC.Offset, 0, sym); if (result) { fprintf(out_stream, "\t[%u] `%s` (%s:%d)\n", layer_count, sym->Name, line.FileName, line.LineNumber); } else { fprintf(out_stream, "\t[%u] 0x%p\n", layer_count, stack.AddrPC.Offset); } layer_count++; } SymCleanup(GetCurrentProcess()); } #endif #else #error gb__print_call_stack() not implemeneted // TODO(bill): Implemenet gb__print_call_stack() #endif // Helper function used as a better alternative to assert which allows for // optional printf style error messages inline void gb__assert_handler(bool condition, char const* condition_str, char const* filename, size_t line, char const* error_text, ...) { if (condition) return; #if !defined(GB_NO_STDIO) FILE* out_stream = stderr; fprintf(out_stream, "ASSERT! %s(%lu): %s", filename, line, condition_str); if (error_text) { fprintf(out_stream, " - "); va_list args; va_start(args, error_text); vfprintf(out_stream, error_text, args); va_end(args); } fprintf(out_stream, "\n"); fprintf(out_stream, "Stacktrack:\n"); gb__print_call_stack(out_stream); #endif // TODO(bill): Are these decent breaking functions??? #if defined(GB_COMPILER_MSVC) __debugbreak(); #elif defined(GB_COMPILER_GNU_GCC) __builtin_trap(); #else #error Implement aborting function #endif } __GB_NAMESPACE_START //////////////////////////////// // // // Memory // // // //////////////////////////////// namespace mutex { inline Mutex make() { Mutex m = {}; #if defined(GB_SYSTEM_WINDOWS) m.win32_mutex = CreateMutex(0, false, 0); #else pthread_mutex_init(&m.posix_mutex, nullptr); #endif return m; } inline void destroy(Mutex* m) { #if defined(GB_SYSTEM_WINDOWS) CloseHandle(m->win32_mutex); #else pthread_mutex_destroy(&m->posix_mutex); #endif } inline void lock(Mutex* m) { #if defined(GB_SYSTEM_WINDOWS) WaitForSingleObject(m->win32_mutex, INFINITE); #else pthread_mutex_lock(&m->posix_mutex); #endif } inline bool try_lock(Mutex* m) { #if defined(GB_SYSTEM_WINDOWS) return WaitForSingleObject(m->win32_mutex, 0) == WAIT_OBJECT_0; #else return pthread_mutex_trylock(&m->posix_mutex) == 0; #endif } inline void unlock(Mutex* m) { #if defined(GB_SYSTEM_WINDOWS) ReleaseMutex(m->win32_mutex); #else pthread_mutex_unlock(&m->posix_mutex); #endif } } // namespace mutex // Atomics namespace atomic { #if defined(_MSC_VER) inline u32 load(Atomic32 const volatile* object) { return object->nonatomic; } inline void store(Atomic32 volatile* object, u32 value) { object->nonatomic = value; } inline u32 compare_exchange_strong(Atomic32 volatile* object, u32 expected, u32 desired) { return _InterlockedCompareExchange(reinterpret_cast(object), desired, expected); } inline u32 exchanged(Atomic32 volatile* object, u32 desired) { return _InterlockedExchange(reinterpret_cast(object), desired); } inline u32 fetch_add(Atomic32 volatile* object, s32 operand) { return _InterlockedExchangeAdd(reinterpret_cast(object), operand); } inline u32 fetch_and(Atomic32 volatile* object, u32 operand) { return _InterlockedAnd(reinterpret_cast(object), operand); } inline u32 fetch_or_32(Atomic32 volatile* object, u32 operand) { return _InterlockedOr(reinterpret_cast(object), operand); } inline u64 load(Atomic64 const volatile* object) { #if defined(GB_ARCH_64_BIT) return object->nonatomic; #else // NOTE(bill): The most compatible way to get an atomic 64-bit load on x86 is with cmpxchg8b u64 result; __asm { mov esi, object; mov ebx, eax; mov ecx, edx; lock cmpxchg8b [esi]; mov dword ptr result, eax; mov dword ptr result[4], edx; } return result; #endif } inline void store(Atomic64 volatile* object, u64 value) { #if defined(GB_ARCH_64_BIT) object->nonatomic = value; #else // NOTE(bill): The most compatible way to get an atomic 64-bit store on x86 is with cmpxchg8b __asm { mov esi, object; mov ebx, dword ptr value; mov ecx, dword ptr value[4]; retry: cmpxchg8b [esi]; jne retry; } #endif } inline u64 compare_exchange_strong(Atomic64 volatile* object, u64 expected, u64 desired) { return _InterlockedCompareExchange64(reinterpret_cast(object), desired, expected); } inline u64 exchanged(Atomic64 volatile* object, u64 desired) { #if defined(GB_ARCH_64_BIT) return _InterlockedExchange64(reinterpret_cast(object), desired); #else u64 expected = object->nonatomic; while (true) { u64 original = _InterlockedCompareExchange64(reinterpret_cast(object), desired, expected); if (original == expected) return original; expected = original; } #endif } inline u64 fetch_add(Atomic64 volatile* object, s64 operand) { #if defined(GB_ARCH_64_BIT) return _InterlockedExchangeAdd64(reinterpret_cast(object), operand); #else u64 expected = object->nonatomic; while (true) { u64 original = _InterlockedExchange64(reinterpret_cast(object), expected + operand, expected); if (original == expected) return original; expected = original; } #endif } inline u64 fetch_and(Atomic64 volatile* object, u64 operand) { #if defined(GB_ARCH_64_BIT) return _InterlockedAnd64(reinterpret_cast(object), operand); #else u64 expected = object->nonatomic; while (true) { u64 original = _InterlockedCompareExchange64(reinterpret_cast(object), expected & operand, expected); if (original == expected) return original; expected = original; } #endif } inline u64 fetch_or(Atomic64 volatile* object, u64 operand) { #if defined(GB_ARCH_64_BIT) return _InterlockedAnd64(reinterpret_cast(object), operand); #else u64 expected = object->nonatomic; while (true) { u64 original = _InterlockedCompareExchange64(reinterpret_cast(object), expected | operand, expected); if (original == expected) return original; expected = original; } #endif } #else #error TODO(bill): Implement atomics for this platform #endif } // namespace atomic namespace semaphore { Semaphore make() { Semaphore semaphore = {}; #if defined(GB_SYSTEM_WINDOWS) semaphore.win32_handle = CreateSemaphore(nullptr, 0, GB_S32_MAX, nullptr); GB_ASSERT(semaphore.win32_handle != nullptr, "CreateSemaphore: GetLastError = %d", GetLastError()); #else semaphore.count = 0; s32 result = pthread_cond_init(&semaphore.cond, nullptr); GB_ASSERT(result == 0, "pthread_cond_init: errno = %d", result); semaphore.mutex = mutex::make(); #endif return semaphore; } void destroy(Semaphore* semaphore) { #if defined(GB_SYSTEM_WINDOWS) BOOL err = CloseHandle(semaphore->win32_handle); GB_ASSERT(err != 0, "CloseHandle: GetLastError = %d", GetLastError()); #else s32 result = pthread_cond_destroy(&semaphore->cond); GB_ASSERT(result == 0, "pthread_cond_destroy: errno = %d", result); mutex::destroy(&semaphore->mutex); #endif } void post(Semaphore* semaphore, u32 count) { #if defined(GB_SYSTEM_WINDOWS) BOOL err = ReleaseSemaphore(semaphore->win32_handle, count, nullptr); GB_ASSERT(err != 0, "ReleaseSemaphore: GetLastError = %d", GetLastError()); #else mutex::lock(&semaphore->mutex); for (u32 i = 0; i < count; i++) { s32 result = pthread_cond_signal(&semaphore->cond); GB_ASSERT(result == 0, "pthread_cond_signal: errno = %d", result); } semaphore->count += count; mutex::unlock(&semaphore->mutex); #endif } void wait(Semaphore* semaphore) { #if defined(GB_SYSTEM_WINDOWS) DWORD result = WaitForSingleObject(semaphore->win32_handle, INFINITE); GB_ASSERT(result == WAIT_OBJECT_0, "WaitForSingleObject: GetLastError = %d", GetLastError()); #else mutex::lock(&semaphore->mutex); while (count <= 0) { s32 result = pthread_cond_wait(&semaphore->cond, &semaphore->mutex.posix_mutex); GB_ASSERT(result == 0, "pthread_cond_wait: errno = %d", result); } count--; mutex::unlock(&semaphore->mutex); #endif } } // namespace semaphore namespace thread { Thread make() { Thread t = {}; #if defined(GB_SYSTEM_WINDOWS) t.win32_handle = INVALID_HANDLE_VALUE; #else t.posix_handle = 0; #endif t.function = nullptr; t.data = nullptr; t.stack_size = 0; t.is_running = false; t.semaphore = semaphore::make(); return t; } void destroy(Thread* t) { if (t->is_running) thread::join(t); semaphore::destroy(&t->semaphore); } internal_linkage void run(Thread* t) { semaphore::post(&t->semaphore); t->function(t->data); } #if defined(GB_SYSTEM_WINDOWS) internal_linkage DWORD WINAPI thread_proc(void* arg) { thread::run(static_cast(arg)); return 0; } #else internal_linkage void* thread_proc(void* arg) { thread::run(static_cast(arg)); return nullptr; } #endif void start(Thread* t, Thread_Procedure* func, void* data, usize stack_size) { GB_ASSERT(!t->is_running); GB_ASSERT(func != nullptr); t->function = func; t->data = data; t->stack_size = stack_size; #if defined(GB_SYSTEM_WINDOWS) t->win32_handle = CreateThread(nullptr, stack_size, thread_proc, t, 0, nullptr); GB_ASSERT(t->win32_handle != nullptr, "CreateThread: GetLastError = %d", GetLastError()); #else pthread_attr_t attr; s32 result = pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); GB_ASSERT(result == 0, "pthread_attr_init: errno = %d", result); if (t->stack_size != 0) { result = pthread_attr_setstacksize(&attr, t->stack_size); GB_ASSERT(result == 0, "pthread_attr_setstacksize: errno = %d", result); } result = pthread_create(&t->posix_handle, &attr, thread_proc, thread); GB_ASSERT(result == 0, "pthread_create: errno = %d", result); // NOTE(bill): Free attr memory result = pthread_attr_destroy(&attr); GB_ASSERT(result == 0, "pthread_attr_destroy: errno = %d", result); // NOTE(bill): So much boiler patch compared to windows.h (for once) #endif t->is_running = true; semaphore::wait(&t->semaphore); } void join(Thread* t) { if (!t->is_running) return; #if defined(GB_SYSTEM_WINDOWS) WaitForSingleObject(t->win32_handle, INFINITE); CloseHandle(t->win32_handle); t->win32_handle = INVALID_HANDLE_VALUE; #else int result = pthread_join(t->posix_handle, nullptr); t->posix_handle = 0; #endif t->is_running = false; } inline bool is_running(Thread const& thread) { return thread.is_running != 0; } inline u32 current_id() { u32 thread_id; #if defined(GB_SYSTEM_WINDOWS) u8* thread_local_storage = reinterpret_cast(__readgsqword(0x30)); thread_id = *reinterpret_cast