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

Update quicksort/bsearch to use templates better

Browse Source
This commit is contained in:
Doyle T 2018-07-15 20:09:55 +10:00
parent 9d12c532d1
commit 1c5fdc6ce1
2 changed files with 137 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
DqnUnitTest.cpp
View File

@ -1882,7 +1882,7 @@ FILE_SCOPE void JobQueueDebugCallbackIncrementCounter(DqnJobQueue *const queue,
(void)userData;
DQN_ASSERT(queue->size == QUEUE_SIZE);
{
DqnLockGuard guard = globalJobQueueLock.LockGuard();
auto guard = globalJobQueueLock.Guard();
globalDebugCounter++;
// u32 number = globalDebugCounter;
@ -1915,7 +1915,7 @@ FILE_SCOPE void DqnJobQueue_Test()
DQN_ASSERT(DqnJobQueue_Init(&jobQueue, jobList, QUEUE_SIZE, totalThreads));
const u32 WORK_ENTRIES = 2048;
DQN_ASSERT(DqnLock_Init(&globalJobQueueLock));
DQN_ASSERT(globalJobQueueLock.Init());
for (u32 i = 0; i < WORK_ENTRIES; i++)
{
DqnJob job = {};
@ -1928,7 +1928,7 @@ FILE_SCOPE void DqnJobQueue_Test()
DqnJobQueue_BlockAndCompleteAllJobs(&jobQueue);
DQN_ASSERT(globalDebugCounter == WORK_ENTRIES);
DqnLock_Delete(&globalJobQueueLock);
globalJobQueueLock.Delete();
Log("Final incremented value: %d\n", globalDebugCounter);
}
@ -1977,7 +1977,7 @@ void DqnQuickSort_Test()
// Time Dqn_QuickSort
{
f64 start = DqnTimer_NowInS();
Dqn_QuickSort(dqnCPPArray, numInts);
DqnQuickSort(dqnCPPArray, numInts);
f64 duration = DqnTimer_NowInS() - start;
dqnCPPTimings[timingsIndex] = duration;
@ -2102,33 +2102,22 @@ void DqnHashTable_Test()
Log(Status::Ok, "HashTable");
}
void Dqn_BSearch_Test()
void DqnBSearch_Test()
{
LOG_HEADER();
if (1)
{
auto IsLessThan = [](const u32 &a, const u32 &b) -> bool {
bool result = a < b;
return result;
};
auto Equals = [](const u32 &a, const u32 &b) -> bool {
bool result = (a == b);
return result;
};
u32 array[] = {1, 2, 3};
i64 result = Dqn_BSearch<u32>(array, DQN_ARRAY_COUNT(array), 1, Equals, IsLessThan);
i64 result = DqnBSearch<u32>(array, DQN_ARRAY_COUNT(array), 1);
DQN_ASSERT(result == 0);
result = Dqn_BSearch<u32>(array, DQN_ARRAY_COUNT(array), 2, Equals, IsLessThan);
result = DqnBSearch<u32>(array, DQN_ARRAY_COUNT(array), 2);
DQN_ASSERT(result == 1);
result = Dqn_BSearch<u32>(array, DQN_ARRAY_COUNT(array), 3, Equals, IsLessThan);
result = DqnBSearch<u32>(array, DQN_ARRAY_COUNT(array), 3);
DQN_ASSERT(result == 2);
result = Dqn_BSearch<u32>(array, DQN_ARRAY_COUNT(array), 4, Equals, IsLessThan);
result = DqnBSearch<u32>(array, DQN_ARRAY_COUNT(array), 4);
DQN_ASSERT(result == -1);
Log(Status::Ok, "With odd sized array and custom compare");
}
@ -2136,19 +2125,19 @@ void Dqn_BSearch_Test()
if (1)
{
i64 array[] = {1, 2, 3, 4};
i64 result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 1);
i64 result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 1);
DQN_ASSERT(result == 0);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 2);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 2);
DQN_ASSERT(result == 1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 3);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 3);
DQN_ASSERT(result == 2);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 4);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 4);
DQN_ASSERT(result == 3);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 5);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 5);
DQN_ASSERT(result == -1);
Log(Status::Ok, "With even sized array");
}
@ -2156,22 +2145,22 @@ void Dqn_BSearch_Test()
if (1)
{
i64 array[] = {1, 2, 3};
i64 result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 0, Dqn_BSearchBound_Lower);
i64 result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 0, DqnBSearchType::MinusOne);
DQN_ASSERT(result == -1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 1, Dqn_BSearchBound_Lower);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 1, DqnBSearchType::MinusOne);
DQN_ASSERT(result == -1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 2, Dqn_BSearchBound_Lower);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 2, DqnBSearchType::MinusOne);
DQN_ASSERT(result == 0);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 3, Dqn_BSearchBound_Lower);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 3, DqnBSearchType::MinusOne);
DQN_ASSERT(result == 1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 4, Dqn_BSearchBound_Lower);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 4, DqnBSearchType::MinusOne);
DQN_ASSERT(result == 2);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 5, Dqn_BSearchBound_Lower);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 5, DqnBSearchType::MinusOne);
DQN_ASSERT(result == 2);
Log(Status::Ok, "Lower bound with odd sized array");
}
@ -2180,25 +2169,25 @@ void Dqn_BSearch_Test()
{
i64 array[] = {1, 2, 3, 4};
i64 result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 0, Dqn_BSearchBound_Lower);
i64 result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 0, DqnBSearchType::MinusOne);
DQN_ASSERT(result == -1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 1, Dqn_BSearchBound_Lower);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 1, DqnBSearchType::MinusOne);
DQN_ASSERT(result == -1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 2, Dqn_BSearchBound_Lower);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 2, DqnBSearchType::MinusOne);
DQN_ASSERT(result == 0);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 3, Dqn_BSearchBound_Lower);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 3, DqnBSearchType::MinusOne);
DQN_ASSERT(result == 1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 4, Dqn_BSearchBound_Lower);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 4, DqnBSearchType::MinusOne);
DQN_ASSERT(result == 2);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 5, Dqn_BSearchBound_Lower);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 5, DqnBSearchType::MinusOne);
DQN_ASSERT(result == 3);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 6, Dqn_BSearchBound_Lower);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 6, DqnBSearchType::MinusOne);
DQN_ASSERT(result == 3);
Log(Status::Ok, "Lower bound with even sized array");
}
@ -2206,22 +2195,22 @@ void Dqn_BSearch_Test()
if (1)
{
i64 array[] = {1, 2, 3};
i64 result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 0, Dqn_BSearchBound_Higher);
i64 result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 0, DqnBSearchType::PlusOne);
DQN_ASSERT(result == 0);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 1, Dqn_BSearchBound_Higher);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 1, DqnBSearchType::PlusOne);
DQN_ASSERT(result == 1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 2, Dqn_BSearchBound_Higher);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 2, DqnBSearchType::PlusOne);
DQN_ASSERT(result == 2);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 3, Dqn_BSearchBound_Higher);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 3, DqnBSearchType::PlusOne);
DQN_ASSERT(result == -1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 4, Dqn_BSearchBound_Higher);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 4, DqnBSearchType::PlusOne);
DQN_ASSERT(result == -1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 5, Dqn_BSearchBound_Higher);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 5, DqnBSearchType::PlusOne);
DQN_ASSERT(result == -1);
Log(Status::Ok, "Higher bound with odd sized array");
}
@ -2230,25 +2219,25 @@ void Dqn_BSearch_Test()
{
i64 array[] = {1, 2, 3, 4};
i64 result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 0, Dqn_BSearchBound_Higher);
i64 result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 0, DqnBSearchType::PlusOne);
DQN_ASSERT(result == 0);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 1, Dqn_BSearchBound_Higher);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 1, DqnBSearchType::PlusOne);
DQN_ASSERT(result == 1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 2, Dqn_BSearchBound_Higher);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 2, DqnBSearchType::PlusOne);
DQN_ASSERT(result == 2);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 3, Dqn_BSearchBound_Higher);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 3, DqnBSearchType::PlusOne);
DQN_ASSERT(result == 3);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 4, Dqn_BSearchBound_Higher);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 4, DqnBSearchType::PlusOne);
DQN_ASSERT(result == -1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 5, Dqn_BSearchBound_Higher);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 5, DqnBSearchType::PlusOne);
DQN_ASSERT(result == -1);
result = Dqn_BSearch(array, DQN_ARRAY_COUNT(array), 6, Dqn_BSearchBound_Higher);
result = DqnBSearch(array, DQN_ARRAY_COUNT(array), 6, DqnBSearchType::PlusOne);
DQN_ASSERT(result == -1);
Log(Status::Ok, "Higher bound with even sized array");
}
@ -2896,7 +2885,7 @@ int main(void)
DqnArray_Test();
DqnQuickSort_Test();
DqnHashTable_Test();
Dqn_BSearch_Test();
DqnBSearch_Test();
DqnMemSet_Test();
DqnFixedString_Test();
DqnJson_Test();

377
dqn.h
View File

@ -898,16 +898,25 @@ DQN_FILE_SCOPE inline u32 Dqn_BitSet (u32 bits, u32 flag);
DQN_FILE_SCOPE inline u32 Dqn_BitUnset (u32 bits, u32 flag);
DQN_FILE_SCOPE inline u32 Dqn_BitToggle(u32 bits, u32 flag);
template <typename T>
using Dqn_QuickSortLessThanCallback = bool (*)(T const *, T const *, void *);
DQN_FILE_SCOPE inline bool Dqn_QuickSortDqnStringSorter(struct DqnString const *a, struct DqnString const *b, void *);
template <typename T>
DQN_FILE_SCOPE void Dqn_QuickSort(T *array, i64 size,
Dqn_QuickSortLessThanCallback<T> IsLessThan, void *userContext = nullptr)
template <typename T> using DqnQuickSort_LessThanProc = bool (*) (T const &a, T const &b, void *userContext);
#define DQN_QUICK_SORT_LESS_THAN_PROC(name) template <typename T> inline bool name(T const &a, T const &b, void *userContext)
DQN_QUICK_SORT_LESS_THAN_PROC(DqnQuickSort_DefaultLessThan)
{
if (!array || size <= 1 || !IsLessThan) return;
(void)userContext;
bool result = a < b;
return result;
}
DQN_QUICK_SORT_LESS_THAN_PROC(DqnQuickSort_StringLessThan)
{
bool result = DqnString::Cmp(a, b);
return result;
}
template <typename T, DqnQuickSort_LessThanProc<T> IsLessThan = DqnQuickSort_DefaultLessThan<T>>
DQN_FILE_SCOPE void DqnQuickSort(T *array, isize size, void *userContext = nullptr)
{
if (!array || size <= 1) return;
#if 1
// Insertion Sort, under 24->32 is an optimal amount
@ -919,7 +928,7 @@ DQN_FILE_SCOPE void Dqn_QuickSort(T *array, i64 size,
{
for (i32 checkIndex = 0; checkIndex < itemToInsertIndex; checkIndex++)
{
if (!IsLessThan(&array[checkIndex], &array[itemToInsertIndex], userContext))
if (!IsLessThan(array[checkIndex], array[itemToInsertIndex], userContext))
{
T itemToInsert = array[itemToInsertIndex];
for (i32 i = itemToInsertIndex; i > checkIndex; i--)
@ -948,7 +957,7 @@ DQN_FILE_SCOPE void Dqn_QuickSort(T *array, i64 size,
pivotIndex = lastIndex;
// 4^, 8, 7, 5, 2, 3, 6
if (IsLessThan(&array[startIndex], &array[pivotIndex], userContext)) partitionIndex++;
if (IsLessThan(array[startIndex], array[pivotIndex], userContext)) partitionIndex++;
startIndex++;
// 4, |8, 7, 5^, 2, 3, 6*
@ -957,7 +966,7 @@ DQN_FILE_SCOPE void Dqn_QuickSort(T *array, i64 size,
// 4, 5, 2, 3, |7, 8, ^6*
for (auto checkIndex = startIndex; checkIndex < lastIndex; checkIndex++)
{
if (IsLessThan(&array[checkIndex], &array[pivotIndex], userContext))
if (IsLessThan(array[checkIndex], array[pivotIndex], userContext))
{
DQN_SWAP(T, array[partitionIndex], array[checkIndex]);
partitionIndex++;
@ -967,128 +976,61 @@ DQN_FILE_SCOPE void Dqn_QuickSort(T *array, i64 size,
// Move pivot to right of partition
// 4, 5, 2, 3, |6, 8, ^7*
DQN_SWAP(T, array[partitionIndex], array[pivotIndex]);
Dqn_QuickSort(array, partitionIndex, IsLessThan, userContext);
DqnQuickSort<T, IsLessThan>(array, partitionIndex, userContext);
// Skip the value at partion index since that is guaranteed to be sorted.
// 4, 5, 2, 3, (x), 8, 7
i32 oneAfterPartitionIndex = partitionIndex + 1;
Dqn_QuickSort(array + oneAfterPartitionIndex, (size - oneAfterPartitionIndex), IsLessThan, userContext);
DqnQuickSort<T, IsLessThan>(array + oneAfterPartitionIndex, (size - oneAfterPartitionIndex), userContext);
}
template <typename T>
DQN_FILE_SCOPE void Dqn_QuickSort(T *array, i64 size)
template <typename T> using DqnBSearch_LessThanProc = bool (*)(const T&, const T&);
template <typename T> using DqnBSearch_EqualsProc = bool (*)(const T&, const T&);
#define DQN_BSEARCH_LESS_THAN_PROC(name) template <typename T> inline bool name(T const &a, T const &b)
#define DQN_BSEARCH_EQUALS_PROC(name) template <typename T> inline bool name(T const &a, T const &b)
DQN_BSEARCH_LESS_THAN_PROC(DqnBSearch_DefaultLessThan) { return a < b; }
DQN_BSEARCH_EQUALS_PROC (DqnBSearch_DefaultEquals) { return a == b; }
enum struct DqnBSearchType
{
if (!array || size <= 1) return;
Match, // Return the index of the first item that matches the find value
MinusOne, // Return the index of the first item lower than the find value
PlusOne, // Return the index of the first item higher than the find value
#if 1
// Insertion Sort, under 24->32 is an optimal amount
const i32 QUICK_SORT_THRESHOLD = 24;
if (size < QUICK_SORT_THRESHOLD)
{
i32 itemToInsertIndex = 1;
while (itemToInsertIndex < size)
{
for (i32 checkIndex = 0; checkIndex < itemToInsertIndex; checkIndex++)
{
if (!(array[checkIndex] < array[itemToInsertIndex]))
{
T itemToInsert = array[itemToInsertIndex];
for (i32 i = itemToInsertIndex; i > checkIndex; i--)
array[i] = array[i - 1];
array[checkIndex] = itemToInsert;
break;
}
}
itemToInsertIndex++;
}
return;
}
#endif
auto state = DqnRndPCG();
auto lastIndex = size - 1;
auto pivotIndex = (i64)state.Range(0, (i32)lastIndex); // TODO(doyle): RNG 64bit
auto partitionIndex = 0;
auto startIndex = 0;
// Swap pivot with last index, so pivot is always at the end of the array.
// This makes logic much simpler.
DQN_SWAP(T, array[lastIndex], array[pivotIndex]);
pivotIndex = lastIndex;
// 4^, 8, 7, 5, 2, 3, 6
if (array[startIndex] < array[pivotIndex]) partitionIndex++;
startIndex++;
// 4, |8, 7, 5^, 2, 3, 6*
// 4, 5, |7, 8, 2^, 3, 6*
// 4, 5, 2, |8, 7, ^3, 6*
// 4, 5, 2, 3, |7, 8, ^6*
for (auto checkIndex = startIndex; checkIndex < lastIndex; checkIndex++)
{
if (array[checkIndex] < array[pivotIndex])
{
DQN_SWAP(T, array[partitionIndex], array[checkIndex]);
partitionIndex++;
}
}
// Move pivot to right of partition
// 4, 5, 2, 3, |6, 8, ^7*
DQN_SWAP(T, array[partitionIndex], array[pivotIndex]);
Dqn_QuickSort(array, partitionIndex);
// Skip the value at partion index since that is guaranteed to be sorted.
// 4, 5, 2, 3, (x), 8, 7
i32 oneAfterPartitionIndex = partitionIndex + 1;
Dqn_QuickSort(array + oneAfterPartitionIndex, (size - oneAfterPartitionIndex));
}
template <typename T>
using Dqn_BSearchLessThanCallback = bool (*)(const T&, const T&);
template <typename T>
using Dqn_BSearchEqualsCallback = bool (*)(const T&, const T&);
enum Dqn_BSearchBound
{
Dqn_BSearchBound_Normal, // Return the index of the first item that matches the find value
Dqn_BSearchBound_Lower, // Return the index of the first item lower than the find value
Dqn_BSearchBound_Higher, // Return the index of the first item higher than the find value
Dqn_BSearchBound_NormalLower, // Return the index of the matching item if not found the first item lower
Dqn_BSearchBound_NormalHigher, // Return the index of the matching item if not found the first item higher
MatchOrMinusOne, // Return the index of the matching item if not found the first item lower
MatchOrPlusOne, // Return the index of the matching item if not found the first item higher
};
// bound: The behaviour of the binary search,
// type: The matching behaviour of the binary search,
// return: -1 if element not found, otherwise index of the element.
// For higher and lower bounds return -1 if there is no element higher/lower than the
// find value (i.e. -1 if the 0th element is the find val for lower bound).
template <typename T>
DQN_FILE_SCOPE i64 Dqn_BSearch(T *array, i64 size, T const &find,
Dqn_BSearchEqualsCallback<T> Equals,
Dqn_BSearchLessThanCallback<T> IsLessThan,
Dqn_BSearchBound bound = Dqn_BSearchBound_Normal)
template <typename T,
DqnBSearch_LessThanProc<T> IsLessThan = DqnBSearch_DefaultLessThan<T>,
DqnBSearch_EqualsProc<T> Equals = DqnBSearch_DefaultEquals<T>>
DQN_FILE_SCOPE i64
DqnBSearch(T const *array, isize size, T const &find, DqnBSearchType type = DqnBSearchType::Match)
{
if (size == 0 || !array) return -1;
if (size == 0 || !array)
{
return -1;
}
i64 start = 0;
i64 end = size - 1;
i64 mid = (i64)((start + end) * 0.5f);
isize start = 0;
isize end = size - 1;
isize mid = static_cast<isize>((start + end) * 0.5f);
while (start <= end)
{
if (Equals(array[mid], find))
{
if (bound == Dqn_BSearchBound_Normal ||
bound == Dqn_BSearchBound_NormalLower ||
bound == Dqn_BSearchBound_NormalHigher)
if (type == DqnBSearchType::Match ||
type == DqnBSearchType::MatchOrMinusOne ||
type == DqnBSearchType::MatchOrPlusOne)
{
return mid;
}
else if (bound == Dqn_BSearchBound_Lower)
else if (type == DqnBSearchType::MinusOne)
{
// NOTE: We can always -1 because at worst case, 0 index will go to -1 which is
// correct behaviour.
@ -1096,32 +1038,29 @@ DQN_FILE_SCOPE i64 Dqn_BSearch(T *array, i64 size, T const &find,
}
else
{
if ((mid + 1) >= size) return -1;
return mid + 1;
return ((mid + 1) >= size) ? -1 : mid + 1;
}
}
else if (IsLessThan(array[mid], find)) start = mid + 1;
else end = mid - 1;
mid = (i64)((start + end) * 0.5f);
mid = static_cast<isize>((start + end) * 0.5f);
}
if (bound == Dqn_BSearchBound_Normal)
if (type == DqnBSearchType::Match)
{
return -1;
}
if (bound == Dqn_BSearchBound_Lower || bound == Dqn_BSearchBound_NormalLower)
if (type == DqnBSearchType::MinusOne || type == DqnBSearchType::MatchOrMinusOne)
{
if (IsLessThan(find, array[mid])) return -1;
return mid;
return (IsLessThan(find, array[mid])) ? -1 : mid;
}
else
{
if (IsLessThan(array[mid], find)) return -1;
return mid;
return (IsLessThan(find, array[mid])) ? mid : -1;
}
}
DQN_FILE_SCOPE i64 Dqn_BSearch(i64 *array, i64 size, i64 find, Dqn_BSearchBound bound = Dqn_BSearchBound_Normal);
DQN_FILE_SCOPE inline i64 DqnBSearch(i64 const *array, i64 size, i64 find, DqnBSearchType type = DqnBSearchType::Match) { return DqnBSearch<i64>(array, size, find, type); }
// #DqnMem API
// =================================================================================================
@ -1325,7 +1264,7 @@ struct DqnArray
~DqnArray () { if (this->data && this->memAPI) this->memAPI->Free(data); }
void UseMemory (T *data_, isize max_, isize count_ = 0) { this->memAPI = nullptr; this->data = data_; this->max = max_; this->count = count_; }
void Clear (Dqn::ZeroClear clear = Dqn::ZeroClear::No) { if (data) { count = 0; if (clear == Dqn::ZeroClear::Yes) DqnMem_Clear(data, 0, sizeof(T) * max); } }
void Clear (Dqn::ZeroClear clear = Dqn::ZeroClear::No) { if (!data) return; count = 0; if (clear == Dqn::ZeroClear::Yes) DqnMem_Clear(data, 0, sizeof(T) * max); }
void Free () { if (data) { memAPI->Free(data); } *this = {}; }
T *Front () { DQN_ASSERT(count > 0); return data + 0; }
T *Back () { DQN_ASSERT(count > 0); return data + (count - 1); }
@ -1577,24 +1516,6 @@ struct DqnMemStack
void TempRegionKeepChanges(TempRegion region);
};
inline bool DqnMemStack_Init (DqnMemStack *me, isize size, Dqn::ZeroClear clear, u32 flags_ = 0, DqnMemAPI *api = DQN_DEFAULT_HEAP_ALLOCATOR) { return me->Init(size, clear, flags_, api); }
inline void *DqnMemStack_Push (DqnMemStack *me, isize size, u8 alignment = 4) { return me->Push(size, alignment); }
inline void *DqnMemStack_PushOnTail (DqnMemStack *me, isize size, u8 alignment = 4) { return me->PushOnTail(size, alignment); }
inline void DqnMemStack_Pop (DqnMemStack *me, void *ptr, Dqn::ZeroClear clear = Dqn::ZeroClear::No) { me->Pop(ptr, clear); }
inline void DqnMemStack_PopOnTail (DqnMemStack *me, void *ptr, Dqn::ZeroClear clear = Dqn::ZeroClear::No) { me->PopOnTail(ptr, clear); }
inline void DqnMemStack_Free (DqnMemStack *me) { me->Free(); }
inline bool DqnMemStack_FreeMemBlock (DqnMemStack *me, DqnMemStack::Block *memBlock) { return me->FreeMemBlock(memBlock); }
inline bool DqnMemStack_FreeLastBlock (DqnMemStack *me) { return me->FreeLastBlock(); }
inline void DqnMemStack_Reset (DqnMemStack *me) { me->Reset(); }
inline void DqnMemStack_ResetTail (DqnMemStack *me) { me->ResetTail(); }
inline void DqnMemStack_ClearCurrBlock (DqnMemStack *me, Dqn::ZeroClear clear) { me->ClearCurrBlock(clear); }
inline DqnMemStack::Info DqnMemStack_GetInfo (DqnMemStack *me) { return me->GetInfo(); }
inline DqnMemStack::TempRegion DqnMemStack_TempRegionBegin (DqnMemStack *me) { return me->TempRegionBegin(); }
inline void DqnMemStack_TempRegionEnd (DqnMemStack *me, DqnMemStack::TempRegion region) { me->TempRegionEnd(region); }
inline DqnMemStack::TempRegionGuard_ DqnMemStack_TempRegionGuard (DqnMemStack *me) { return me->TempRegionGuard(); }
inline void DqnMemStack_TempRegionKeepChanges(DqnMemStack *me, DqnMemStack::TempRegion region) { me->TempRegionKeepChanges(region); }
// Implementation taken from Milton, developed by Serge at
// https://github.com/serge-rgb/milton#license
#if 0
@ -1836,14 +1757,14 @@ void DqnArray<T>::EraseStable(isize *indexList, isize numIndexes)
if (numIndexes == 0 || !indexList) return;
// NOTE: Sort the index list and ensure we only remove indexes up to the size of our array
Dqn_QuickSort<isize>(indexList, numIndexes);
DqnQuickSort<isize>(indexList, numIndexes);
auto arrayHighestIndex = this->count - 1;
auto realCount = numIndexes;
if (indexList[numIndexes - 1] > arrayHighestIndex)
{
auto realNumIndexes =
Dqn_BSearch(indexList, numIndexes, arrayHighestIndex, Dqn_BSearchBound_Lower);
DqnBSearch(indexList, numIndexes, arrayHighestIndex, DqnBSearchType::MinusOne);
// NOTE: If -1, then there's no index in the indexlist that is within the range of our array
// i.e. no index we can remove without out of array bounds access
if (realNumIndexes == -1)
@ -2555,8 +2476,8 @@ typename DqnHashTable<T>::Entry *DqnHashTable<T>::Make(char const *const key, i3
// If entry for hashIndex not used yet, mark it down as a used slot.
if (!this->entries[hashIndex])
{
i64 index = Dqn_BSearch(this->usedEntries, this->usedEntriesIndex, hashIndex,
Dqn_BSearchBound_Lower);
i64 index = DqnBSearch(this->usedEntries, this->usedEntriesIndex, hashIndex,
DqnBSearchType::MinusOne);
i64 indexToEndAt = index;
if (index == -1) indexToEndAt = 0;
@ -2615,8 +2536,8 @@ void DqnHashTable<T>::Remove(char const *const key, i32 keyLen)
if (entryToFree == entry)
{
// Unique entry, so remove this index from the used list as well.
i64 indexToRemove = Dqn_BSearch(this->usedEntries, this->usedEntriesIndex,
hashIndex, Dqn_BSearchBound_Lower);
i64 indexToRemove = DqnBSearch(this->usedEntries, this->usedEntriesIndex,
hashIndex, DqnBSearchType::MinusOne);
for (i64 i = indexToRemove; i < this->usedEntriesIndex - 1; i++)
this->usedEntries[i] = this->usedEntries[i + 1];
@ -2899,13 +2820,13 @@ struct DqnVArray
DqnVArray () = default;
DqnVArray (isize size) { LazyInit(size); }
void LazyInit (isize size) { if (data) return; count = 0; max = size; data = (T *)DqnOS_VAlloc(max * sizeof(T)); DQN_ALWAYS_ASSERT(data); }
~DqnVArray () { if (data) DqnOS_VFree(data, sizeof(T) * max); }
// ~DqnVArray () { if (data) DqnOS_VFree(data, sizeof(T) * max); }
void Clear (Dqn::ZeroClear clear = Dqn::ZeroClear::No) { if (data) { count = 0; if (clear == Dqn::ZeroClear::Yes) DqnMem_Clear(data, 0, sizeof(T) * max); } }
void Free () { if (data) { DqnOS_VFree(data, sizeof(T) * max); } *this = {}; }
T *Front () { return (count > 0) (data + 0) : nullptr; }
T *Back () { return (count > 0) (data + (count - 1)) : nullptr; }
T *Make (isize num = 1) { LazyInit(1024); count += num; DQN_ASSERT(count < max); return &data[count - num]; }
T *Make (isize num = 1) { LazyInit(1024); count += num; DQN_ASSERT(count <= max); return &data[count - num]; }
T *Push (T const &v) { return Insert(count, &v, 1); }
T *Push (T const *v, isize numItems = 1) { return Insert(count, v, numItems); }
void Pop () { if (count > 0) count--; }
@ -2927,7 +2848,7 @@ template<typename T> T *DqnVArray<T>::Insert(isize index, T const *v, isize numI
index = DQN_CLAMP(index, 0, count);
isize const newCount = count + numItems;
DQN_ASSERT(newCount < max);
DQN_ASSERT(newCount <= max);
T *src = data + index;
T *dest = src + numItems;
@ -3193,7 +3114,7 @@ DQN_FILE_SCOPE f64 DqnTimer_NowInS ();
// XPlatform > #DqnLock API
// =================================================================================================
typedef struct DqnLock
struct DqnLock
{
#if defined(DQN_IS_WIN32)
CRITICAL_SECTION win32Handle;
@ -3210,32 +3131,19 @@ typedef struct DqnLock
void Release();
void Delete ();
struct Guard_
{
Guard_(DqnLock *lock_) : lock(lock_) { lock->Acquire(); }
~Guard_() { lock->Release(); }
private:
DqnLock *lock;
};
// Create a lock guard on the lock this is invoked on.
struct DqnLockGuard LockGuard();
} DqnLock;
// Lock guard automatically acquires a lock on construction and releases the associated lock on
// destruction. If the lock is unable to be acquired, the program blocks at construction until it
// can.
struct DqnLockGuard
{
// lock: Takes a pointer to a pre-existing and already initialised lock
// bool: Pass in (optionally) a pointer to a bool which returns whether a lock was successful.
// FALSE if lock is nullptr.
DqnLockGuard(DqnLock *const lock_, bool *const succeeded);
~DqnLockGuard();
private:
DqnLock *lock;
Guard_ Guard() { return Guard_(this); }
};
// lock: Pass in a pointer to a default DqnLock struct.
// In Win32, you may optionally change the win32Spincount.
DQN_FILE_SCOPE bool DqnLock_Init (DqnLock *const lock);
DQN_FILE_SCOPE void DqnLock_Acquire(DqnLock *const lock);
DQN_FILE_SCOPE void DqnLock_Release(DqnLock *const lock);
DQN_FILE_SCOPE void DqnLock_Delete (DqnLock *const lock);
// XPlatform > #DqnJobQueue API
// =================================================================================================
// DqnJobQueue is a platform abstracted "lockless" multithreaded work queue. It will create threads
@ -6449,13 +6357,6 @@ DQN_FILE_SCOPE inline u32 Dqn_BitToggle(u32 bits, u32 flag)
return result;
}
DQN_FILE_SCOPE inline bool Dqn_QuickSortDqnStringSorter(struct DqnString const *a, struct DqnString const *b, void *)
{
bool result = DqnString::Cmp(a, b);
return result;
}
// #DqnString Impleemntation
// =================================================================================================
// TODO(doyle): SSO requires handling assign/copy op when copying strings, we need to reassign the
@ -6924,56 +6825,6 @@ i32 Dqn_SplitString(char const *src, i32 srcLen, char splitChar, DqnSlice<char>
return arrayIndex;
}
DQN_FILE_SCOPE i64 Dqn_BSearch(i64 *array, i64 size, i64 find,
Dqn_BSearchBound bound)
{
if (size == 0 || !array) return -1;
i64 start = 0;
i64 end = size - 1;
i64 mid = (i64)((start + end) * 0.5f);
while (start <= end)
{
if (array[mid] == find)
{
if (bound == Dqn_BSearchBound_Normal ||
bound == Dqn_BSearchBound_NormalLower ||
bound == Dqn_BSearchBound_NormalHigher)
{
return mid;
}
else if (bound == Dqn_BSearchBound_Lower)
{
return mid - 1;
}
else
{
if ((mid + 1) >= size) return -1;
return mid + 1;
}
}
else if (array[mid] < find) start = mid + 1;
else end = mid - 1;
mid = (i64)((start + end) * 0.5f);
}
if (bound == Dqn_BSearchBound_Normal)
{
return -1;
}
if (bound == Dqn_BSearchBound_Lower || bound == Dqn_BSearchBound_NormalLower)
{
if (find < array[mid]) return -1;
return mid;
}
else
{
if (find > array[mid]) return -1;
return mid;
}
}
// TODO(doyle): This should maybe be a tokenizer ...
DQN_FILE_SCOPE DqnJson DqnJson_Get(char const *buf, i32 bufLen, char const *findProperty, i32 findPropertyLen)
{
@ -9609,16 +9460,17 @@ DQN_FILE_SCOPE f64 DqnTimer_NowInS() { return DqnTimer_NowInMs() / 1000.0f; }
// XPlatform > #DqnLock
// =================================================================================================
bool DqnLock_Init(DqnLock *lock)
bool DqnLock::Init()
{
if (!lock) return false;
#if defined(DQN_IS_WIN32)
if (InitializeCriticalSectionEx(&lock->win32Handle, lock->win32SpinCount, 0))
if (InitializeCriticalSectionEx(&this->win32Handle, this->win32SpinCount, 0))
{
return true;
}
#else
// NOTE: Static initialise, pre-empt a lock so that it gets initialised as per documentation
lock->unixHandle = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
this->unixHandle = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
DqnLock_Acquire(lock);
DqnLock_Release(lock);
return true;
@ -9627,75 +9479,38 @@ bool DqnLock_Init(DqnLock *lock)
return false;
}
void DqnLock_Acquire(DqnLock *lock)
void DqnLock::Acquire()
{
if (!lock) return;
#if defined(DQN_IS_WIN32)
EnterCriticalSection(&lock->win32Handle);
EnterCriticalSection(&this->win32Handle);
#else
// TODO(doyle): Better error handling
i32 error = pthread_mutex_lock(&lock->unixHandle);
i32 error = pthread_mutex_lock(&this->unixHandle);
DQN_ASSERT(error == 0);
#endif
}
void DqnLock_Release(DqnLock *lock)
void DqnLock::Release()
{
if (!lock) return;
#if defined(DQN_IS_WIN32)
LeaveCriticalSection(&lock->win32Handle);
LeaveCriticalSection(&this->win32Handle);
#else
// TODO(doyle): better error handling
i32 error = pthread_mutex_unlock(&lock->unixHandle);
i32 error = pthread_mutex_unlock(&this->unixHandle);
DQN_ASSERT(error == 0);
#endif
}
void DqnLock_Delete(DqnLock *lock)
void DqnLock::Delete()
{
if (!lock) return;
#if defined(DQN_IS_WIN32)
DeleteCriticalSection(&lock->win32Handle);
DeleteCriticalSection(&this->win32Handle);
#else
i32 error = pthread_mutex_destroy(&lock->unixHandle);
i32 error = pthread_mutex_destroy(&this->unixHandle);
DQN_ASSERT(error == 0);
#endif
}
bool DqnLock::Init() { return DqnLock_Init (this); }
void DqnLock::Acquire() { DqnLock_Acquire(this); }
void DqnLock::Release() { DqnLock_Release(this); }
void DqnLock::Delete() { DqnLock_Delete (this); }
DqnLockGuard DqnLock::LockGuard()
{
return DqnLockGuard(this, nullptr);
}
DqnLockGuard::DqnLockGuard(DqnLock *lock_, bool *succeeded)
{
if (lock_)
{
this->lock = lock_;
this->lock->Acquire();
if (succeeded) *succeeded = true;
}
else
{
if (succeeded) *succeeded = false;
}
}
DqnLockGuard::~DqnLockGuard()
{
if (this->lock) this->lock->Release();
}
// XPlatform > #DqnJobQueue
// =================================================================================================
typedef void *DqnThreadCallbackInternal(void *threadParam);