From d4a4a0770a3770f93c6d49eec007959837fcb34d Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sun, 1 Nov 2015 00:45:54 +0000 Subject: [PATCH] gb.hpp - Hash_Table bug fixes --- README.md | 2 +- gb.hpp | 157 +++++++++++++++++++++++++++++------------------------- 2 files changed, 84 insertions(+), 75 deletions(-) diff --git a/README.md b/README.md index 25a2f0f..da36fa6 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ library | latest version | category | languages | description ----------------|----------------|----------|-----------|------------- **gb_string.h** | 0.93 | strings | C, C++ | A better string library for C & C++ **gb_ini.h** | 0.91 | misc | C, C++ | A simple ini file loader library for C & C++ -**gb.hpp** | 0.16 | misc | C++11 | (Experimental) A C++11 helper library without STL geared towards game development +**gb.hpp** | 0.18 | misc | C++11 | (Experimental) A C++11 helper library without STL geared towards game development ## FAQ diff --git a/gb.hpp b/gb.hpp index 595c6bb..6815006 100644 --- a/gb.hpp +++ b/gb.hpp @@ -1,8 +1,9 @@ -// gb.hpp - v0.16 - public domain C++11 helper library - no warranty implied; use at your own risk +// gb.hpp - v0.18 - 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 /* Version History: + 0.18 - Hash_Table bug fixes 0.17 - Death to OOP 0.16 - All References are const convention 0.15 - Namespaced Types @@ -703,10 +704,10 @@ struct Thread namespace thread { Thread make(); -void destroy(Thread* thread); -void start(Thread* thread, Thread_Function* func, void* data = nullptr, usize stack_size = 0); -void stop(Thread* thread); -bool is_running(const Thread& thread); +void destroy(Thread* t); +void start(Thread* t, Thread_Function* func, void* data = nullptr, usize stack_size = 0); +void stop(Thread* t); +bool is_running(const Thread& t); } // namespace thread @@ -898,8 +899,8 @@ template void* Temp_Allocator::alloc(usize size, usize align) { - current_pointer = (u8*)memory::align_forward(current_pointer, align); - if (size > (usize)physical_end - current_pointer) + current_pointer = static_cast(memory::align_forward(current_pointer, align)); + if (size > static_cast(physical_end) - current_pointer) { usize to_allocate = sizeof(void*) + size + align; if (to_allocate < chunk_size) @@ -907,10 +908,10 @@ Temp_Allocator::alloc(usize size, usize align) chunk_size *= 2; void* ptr = backing_->alloc(to_allocate); *static_cast(physical_start) = ptr; - current_pointer = physical_start = (u8*)ptr; + current_pointer = physical_start = static_cast(ptr); *static_cast(physical_start) = 0; current_pointer = memory::pointer_add(current_pointer, sizeof(void*)); - current_pointer = (u8*)memory::align_forward(current_pointer, align); + current_pointer = static_cast(memory::align_forward(current_pointer, align)); } void* result = current_pointer; @@ -918,7 +919,6 @@ Temp_Allocator::alloc(usize size, usize align) return (result); } - namespace memory { inline void* @@ -1161,7 +1161,7 @@ struct Hash_Table Array hashes; Array entries; - Hash_Table() = default; + Hash_Table(); explicit Hash_Table(Allocator* a); Hash_Table(const Hash_Table& other); Hash_Table& operator=(const Hash_Table& other); @@ -1226,7 +1226,6 @@ Array::Array(Allocator* a, usize count_) , capacity(0) , data(nullptr) { - if (count_ > 0) { data = alloc_array(a, count_); @@ -1254,7 +1253,7 @@ template inline Array::~Array() { - if (allocator) + if (allocator && capacity > 0) dealloc(allocator, data); } @@ -1263,6 +1262,8 @@ template Array& Array::operator=(const Array& other) { + if (allocator == nullptr) + allocator = other.allocator; const auto n = other.count; array::resize(this, n); memory::copy(data, other.data, n * sizeof(T)); @@ -1276,11 +1277,8 @@ template inline Array make(Allocator* allocator, usize count) { - Array array = {}; - array.allocator = allocator; - array.count = 0; - array.capacity = 0; - array.data = nullptr; + Array array{allocator}; + if (count > 0) { array.data = alloc_array(allocator, count); @@ -1293,10 +1291,10 @@ make(Allocator* allocator, usize count) template inline void -dealloc(Array* array) +dealloc(Array* a) { - if (array.allocator) - dealloc(array.allocator, array.data); + if (a->allocator) + dealloc(a->allocator, a->data); } template @@ -1312,7 +1310,7 @@ template inline void append(Array* a, const T* items, usize count) { - if (a->capacity <= a->count + count) + if (a->capacity <= a->count + static_cast(count)) array::grow(a, a->count + count); memory::copy(&a->data[a->count], items, count * sizeof(T)); @@ -1389,6 +1387,13 @@ grow(Array* a, usize min_capacity) /// Hash Table /// /// /// //////////////////////////////// +template +inline +Hash_Table::Hash_Table() +: hashes() +, entries() +{ +} template inline @@ -1410,8 +1415,8 @@ template inline Hash_Table& Hash_Table::operator=(const Hash_Table& other) { - hashes = other.hashes; - entries = other.entries; + hashes = other.hashes; + entries = other.entries; return *this; } @@ -1422,7 +1427,8 @@ template inline Hash_Table make(Allocator* a) { - return Hash_Table(a); + Hash_Table h{a}; + return h; } namespace impl @@ -1602,11 +1608,11 @@ rehash(Hash_Table* h, usize new_capacity) multi_hash_table::insert(&nh, e.key, e.value); } - auto empty = hash_table::make(h->hashes.allocator); + Hash_Table empty_ht{h->hashes.allocator}; h->~Hash_Table(); - memory::copy(&h, &nh, sizeof(Hash_Table)); - memory::copy(&nh, &empty, sizeof(Hash_Table)); + memory::copy(h, &nh, sizeof(Hash_Table)); + memory::copy(&nh, &empty_ht, sizeof(Hash_Table)); } template @@ -2275,6 +2281,7 @@ extern const f32 PI; extern const f32 TAU; extern const f32 SQRT_2; extern const f32 SQRT_3; +extern const f32 SQRT_5; extern const f32 F32_PRECISION; @@ -3130,43 +3137,43 @@ namespace thread Thread make() { - Thread thread = {}; + Thread t = {}; #if defined(GB_SYSTEM_WINDOWS) - thread.win32_handle = INVALID_HANDLE_VALUE; + t.win32_handle = INVALID_HANDLE_VALUE; #else - thread.posix_handle = 0; + t.posix_handle = 0; #endif - thread.function = nullptr; - thread.data = nullptr; - thread.stack_size = 0; - thread.is_running = false; - thread.semaphore = semaphore::make(); + t.function = nullptr; + t.data = nullptr; + t.stack_size = 0; + t.is_running = false; + t.semaphore = semaphore::make(); - return thread; + return t; } void -destroy(Thread* thread) +destroy(Thread* t) { - if (thread->is_running) - thread::stop(thread); + if (t->is_running) + thread::stop(t); - semaphore::destroy(&thread->semaphore); + semaphore::destroy(&t->semaphore); } internal s32 -run(Thread* thread) +run(Thread* t) { - semaphore::post(&thread->semaphore); - return thread->function(thread->data); + semaphore::post(&t->semaphore); + return t->function(t->data); } #if defined(GB_SYSTEM_WINDOWS) internal DWORD WINAPI thread_proc(void* arg) { - Thread* thread = static_cast(arg); - s32 result = thread::run(thread); + Thread* t = static_cast(arg); + s32 result = thread::run(t); return result; } @@ -3182,17 +3189,17 @@ thread_proc(void* arg) #endif void -start(Thread* thread, Thread_Function* func, void* data, usize stack_size) +start(Thread* t, Thread_Function* func, void* data, usize stack_size) { - GB_ASSERT(!thread->is_running); + GB_ASSERT(!t->is_running); GB_ASSERT(func != nullptr); - thread->function = func; - thread->data = data; - thread->stack_size = stack_size; + t->function = func; + t->data = data; + t->stack_size = stack_size; #if defined(GB_SYSTEM_WINDOWS) - thread->win32_handle = CreateThread(nullptr, stack_size, thread_proc, thread, 0, nullptr); - GB_ASSERT(thread->win32_handle != nullptr, + t->win32_handle = CreateThread(nullptr, stack_size, thread_proc, t, 0, nullptr); + GB_ASSERT(t->win32_handle != nullptr, "CreateThread: GetLastError = %d", GetLastError()); #else @@ -3201,13 +3208,13 @@ start(Thread* thread, Thread_Function* func, void* data, usize stack_size) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); GB_ASSERT(result == 0, "pthread_attr_init: errno = %d", result); - if (thread->stack_size != 0) + if (t->stack_size != 0) { - result = pthread_attr_setstacksize(&attr, thread->stack_size); + result = pthread_attr_setstacksize(&attr, t->stack_size); GB_ASSERT(result == 0, "pthread_attr_setstacksize: errno = %d", result); } - result = pthread_create(&thread->posix_handle, &attr, thread_proc, thread); + result = pthread_create(&t->posix_handle, &attr, thread_proc, thread); GB_ASSERT(result == 0, "pthread_create: errno = %d", result); // NOTE(bill): Free attr memory @@ -3217,25 +3224,26 @@ start(Thread* thread, Thread_Function* func, void* data, usize stack_size) // NOTE(bill): So much boiler patch compared to windows.h (for once) #endif - thread->is_running = true; - semaphore::wait(&thread->semaphore); + t->is_running = true; + semaphore::wait(&t->semaphore); } void -stop(Thread* thread) +stop(Thread* t) { - if (!thread->is_running) + if (!t->is_running) return; #if defined(GB_SYSTEM_WINDOWS) - WaitForSingleObject(thread->win32_handle, INFINITE); - CloseHandle(thread->win32_handle); - thread->win32_handle = INVALID_HANDLE_VALUE; + 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 - thread->is_running = false; + t->is_running = false; } bool @@ -5178,15 +5186,16 @@ Transform& operator/=(Transform& ws, const Transform& ps) namespace math { -const f32 ZERO = 0.0f; -const f32 ONE = 1.0f; -const f32 THIRD = 0.33333333f; -const f32 TWO_THIRDS = 0.66666667f; -const f32 E = 2.718281828f; -const f32 PI = 3.141592654f; -const f32 TAU = 6.283185307f; -const f32 SQRT_2 = 1.414213562f; -const f32 SQRT_3 = 1.732050808f; +const f32 ZERO = 0.0f; +const f32 ONE = 1.0f; +const f32 THIRD = 0.33333333f; +const f32 TWO_THIRDS = 0.66666667f; +const f32 E = 2.718281828f; +const f32 PI = 3.141592654f; +const f32 TAU = 6.283185307f; +const f32 SQRT_2 = 1.414213562f; +const f32 SQRT_3 = 1.732050808f; +const f32 SQRT_5 = 2.236067978f; const f32 F32_PRECISION = 1.0e-7f;