aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--bench/include/BH/Bench.h7
-rw-r--r--bench/src/Bench.c13
-rw-r--r--bench/tests/BenchAlgo.c169
-rw-r--r--bench/tests/BenchBox2f.c4
-rw-r--r--bench/tests/BenchBox3f.c4
-rw-r--r--bench/tests/BenchHashmap.c136
-rw-r--r--bench/tests/BenchLine.c4
-rw-r--r--bench/tests/BenchMat3f.c190
-rw-r--r--bench/tests/BenchMat4f.c285
-rw-r--r--bench/tests/BenchPlane.c4
-rw-r--r--bench/tests/BenchQueue.c117
-rw-r--r--bench/tests/BenchRay2f.c143
-rw-r--r--bench/tests/BenchRay3f.c115
-rw-r--r--bench/tests/BenchString.c286
-rw-r--r--bench/tests/BenchVec2f.c4
-rw-r--r--bench/tests/BenchVec2i.c4
-rw-r--r--bench/tests/BenchVec3f.c4
-rw-r--r--bench/tests/BenchVec3i.c4
-rw-r--r--bench/tests/BenchVec4f.c4
-rw-r--r--bench/tests/BenchVec4i.c4
20 files changed, 1479 insertions, 22 deletions
diff --git a/bench/include/BH/Bench.h b/bench/include/BH/Bench.h
index 6bf322b..db8d922 100644
--- a/bench/include/BH/Bench.h
+++ b/bench/include/BH/Bench.h
@@ -2,6 +2,9 @@
#define BH_BENCH_H
+#include <BH/Common.h>
+
+
typedef struct BH_Bench BH_Bench;
typedef void (*BH_BenchCallback)(BH_Bench *);
@@ -21,6 +24,10 @@ void BH_BenchAdd(const char *name,
int BH_BenchIter(BH_Bench *state);
+void BH_BenchSubcount(BH_Bench *state,
+ size_t count);
+
+
int BH_BenchRun(void);
diff --git a/bench/src/Bench.c b/bench/src/Bench.c
index 79a4e10..97410c3 100644
--- a/bench/src/Bench.c
+++ b/bench/src/Bench.c
@@ -14,6 +14,7 @@ struct BH_Bench
BH_BenchCallback cb;
int started;
size_t iterations;
+ size_t subcount;
};
@@ -51,6 +52,7 @@ void BH_BenchAdd(const char *name,
bench->cb = cb;
bench->started = 0;
bench->iterations = 0;
+ bench->subcount = 1;
/* Append benchmark entry */
current = root;
@@ -84,8 +86,8 @@ int BH_BenchIter(BH_Bench *state)
if (millis > 1000 || state->iterations > 1000000000)
{
float ips, ns;
- ips = state->iterations / (millis / 1000.0f);
- ns = (millis * 1000000.0) / state->iterations;
+ ips = state->iterations / (millis / 1000.0f) * state->subcount;
+ ns = (millis * 1000000.0) / state->iterations / state->subcount;
printf("%-12s %.2f ips (%.2f ns)\n", state->name, ips, ns);
return 0;
}
@@ -93,6 +95,13 @@ int BH_BenchIter(BH_Bench *state)
}
+void BH_BenchSubcount(BH_Bench *state,
+ size_t count)
+{
+ state->subcount = count;
+}
+
+
int BH_BenchRun(void)
{
BH_Bench *current;
diff --git a/bench/tests/BenchAlgo.c b/bench/tests/BenchAlgo.c
new file mode 100644
index 0000000..3bad224
--- /dev/null
+++ b/bench/tests/BenchAlgo.c
@@ -0,0 +1,169 @@
+#include <BH/Bench.h>
+#include <BH/Algo.h>
+
+
+#define NUM_ENTRIES 1000
+
+
+static int testArray[NUM_ENTRIES];
+static int tempArray[NUM_ENTRIES];
+static int pivotValue;
+
+
+static int intEqual(const void *a, const void *b)
+{
+ int ia, ib;
+ ia = *(const int*)a;
+ ib = *(const int*)b;
+ return (ia > ib) - (ia < ib);
+}
+
+
+static void algoSetup(void)
+{
+ int i;
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ {
+ testArray[i] = NUM_ENTRIES - i;
+ tempArray[i] = NUM_ENTRIES - i;
+ }
+ pivotValue = NUM_ENTRIES / 2;
+}
+
+
+BH_BENCH_TEST(Swap)
+{
+ int a = 123;
+ int b = 456;
+ algoSetup();
+
+ while (BH_BenchIter(state))
+ {
+ BH_Swap(&a, &b, sizeof(int));
+ BH_BenchDoNotOptimize(a);
+ BH_BenchDoNotOptimize(b);
+ BH_Swap(&a, &b, sizeof(int));
+ }
+}
+
+
+BH_BENCH_TEST(Partition)
+{
+ algoSetup();
+
+ while (BH_BenchIter(state))
+ {
+ void *pivot, *result;
+ for (int i = 0; i < NUM_ENTRIES; ++i)
+ testArray[i] = tempArray[i];
+
+ pivot = &pivotValue;
+ result = BH_Partition(pivot, testArray, NUM_ENTRIES, sizeof(int), intEqual);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(testArray);
+ }
+}
+
+
+BH_BENCH_TEST(Sort)
+{
+ algoSetup();
+
+ while (BH_BenchIter(state))
+ {
+ int i;
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ testArray[i] = tempArray[i];
+
+ BH_Sort(testArray, NUM_ENTRIES, sizeof(int), intEqual);
+ BH_BenchDoNotOptimize(testArray);
+ }
+}
+
+
+BH_BENCH_TEST(HeapMake)
+{
+ algoSetup();
+
+ while (BH_BenchIter(state))
+ {
+ int i;
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ testArray[i] = tempArray[i];
+
+ BH_HeapMake(testArray, NUM_ENTRIES, sizeof(int), intEqual);
+ BH_BenchDoNotOptimize(testArray);
+ }
+}
+
+
+BH_BENCH_TEST(HeapRemove)
+{
+ algoSetup();
+
+ while (BH_BenchIter(state))
+ {
+ int i;
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ testArray[i] = tempArray[i];
+ BH_HeapMake(testArray, NUM_ENTRIES, sizeof(int), intEqual);
+ BH_HeapRemove(testArray, NUM_ENTRIES, sizeof(int), intEqual);
+ BH_BenchDoNotOptimize(testArray);
+ }
+}
+
+
+BH_BENCH_TEST(HeapInsert)
+{
+ algoSetup();
+
+ while (BH_BenchIter(state))
+ {
+ int i, value;
+
+ for (i = 0; i < NUM_ENTRIES - 1; ++i)
+ testArray[i] = tempArray[i];
+ testArray[NUM_ENTRIES - 1] = 0;
+ BH_HeapMake(testArray, NUM_ENTRIES - 1, sizeof(int), intEqual);
+
+ value = 250;
+ BH_HeapInsert(&value, testArray, NUM_ENTRIES - 1, sizeof(int), intEqual);
+ BH_BenchDoNotOptimize(testArray);
+ }
+}
+
+
+BH_BENCH_TEST(HeapReplace)
+{
+ algoSetup();
+
+ while (BH_BenchIter(state))
+ {
+ int i, value;
+
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ testArray[i] = tempArray[i];
+ BH_HeapMake(testArray, NUM_ENTRIES, sizeof(int), intEqual);
+
+ value = 100;
+ BH_HeapReplace(&value, testArray, NUM_ENTRIES, sizeof(int), intEqual);
+ BH_BenchDoNotOptimize(testArray);
+ }
+}
+
+
+int main(int argc, char **argv)
+{
+ BH_UNUSED(argc);
+ BH_UNUSED(argv);
+
+ BH_BENCH_ADD(Swap);
+ BH_BENCH_ADD(Partition);
+ BH_BENCH_ADD(Sort);
+ BH_BENCH_ADD(HeapMake);
+ BH_BENCH_ADD(HeapRemove);
+ BH_BENCH_ADD(HeapInsert);
+ BH_BENCH_ADD(HeapReplace);
+
+ return BH_BenchRun();
+}
diff --git a/bench/tests/BenchBox2f.c b/bench/tests/BenchBox2f.c
index 34f0aa6..81806a4 100644
--- a/bench/tests/BenchBox2f.c
+++ b/bench/tests/BenchBox2f.c
@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
-#include "BH/Math/Box2f.h"
+#include <BH/Bench.h>
+#include <BH/Math/Box2f.h>
diff --git a/bench/tests/BenchBox3f.c b/bench/tests/BenchBox3f.c
index 08d9713..f224c31 100644
--- a/bench/tests/BenchBox3f.c
+++ b/bench/tests/BenchBox3f.c
@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
-#include "BH/Math/Box3f.h"
+#include <BH/Bench.h>
+#include <BH/Math/Box3f.h>
static float boxAMin[3] = {1.0f, 2.0f, 3.0f};
diff --git a/bench/tests/BenchHashmap.c b/bench/tests/BenchHashmap.c
new file mode 100644
index 0000000..ad8041f
--- /dev/null
+++ b/bench/tests/BenchHashmap.c
@@ -0,0 +1,136 @@
+#include <BH/Bench.h>
+#include <BH/Hashmap.h>
+#include <stdio.h>
+
+
+#define NUM_ENTRIES 1000
+
+
+static int keys[NUM_ENTRIES];
+static char values[NUM_ENTRIES][16];
+static BH_Hashmap *map;
+static BH_Hashmap *warmMap;
+
+
+int BH_IntEqual(const void *a, const void *b)
+{
+ return (*(const int*)a == *(const int*)b) ? 0 : 1;
+}
+
+
+size_t BH_IntHash(const void *key)
+{
+ int k = *(const int*)key;
+ return (size_t)((k * 2654435761U) >> 8);
+}
+
+
+static void setupData(void)
+{
+ int i;
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ {
+ keys[i] = i + 1;
+ sprintf(values[i], "value_%d", i + 1);
+ }
+}
+
+
+static void setupWarmMap(void)
+{
+ int i;
+ warmMap = BH_HashmapNew(BH_IntEqual, BH_IntHash);
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ {
+ BH_HashmapInsert(warmMap, &keys[i], values[i]);
+ }
+}
+
+
+BH_BENCH_TEST(NewFree)
+{
+ while (BH_BenchIter(state))
+ {
+ map = BH_HashmapNew(BH_IntEqual, BH_IntHash);
+ BH_BenchDoNotOptimize(map);
+ BH_HashmapFree(map);
+ }
+}
+
+
+BH_BENCH_TEST(ReserveInsert)
+{
+ BH_BenchSubcount(state, NUM_ENTRIES);
+ while (BH_BenchIter(state))
+ {
+ map = BH_HashmapNew(BH_IntEqual, BH_IntHash);
+ BH_HashmapReserve(map, NUM_ENTRIES);
+
+ for (int i = 0; i < NUM_ENTRIES; ++i)
+ {
+ BH_HashmapInsert(map, &keys[i], values[i]);
+ }
+ BH_HashmapClear(map);
+
+ BH_BenchDoNotOptimize(map);
+ BH_HashmapFree(map);
+ }
+}
+
+
+BH_BENCH_TEST(Lookup)
+{
+ BH_BenchSubcount(state, NUM_ENTRIES);
+ while (BH_BenchIter(state))
+ {
+ int i;
+ void *value = NULL;
+
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ {
+ BH_HashmapAt(warmMap, &keys[i], &value);
+ }
+ BH_BenchDoNotOptimize(value);
+ }
+}
+
+
+BH_BENCH_TEST(Remove)
+{
+ BH_BenchSubcount(state, NUM_ENTRIES);
+ while (BH_BenchIter(state))
+ {
+ int i;
+ map = BH_HashmapNew(BH_IntEqual, BH_IntHash);
+
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ {
+ BH_HashmapInsert(map, &keys[i], values[i]);
+ }
+
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ {
+ BH_HashmapRemove(map, &keys[i]);
+ }
+
+ BH_BenchDoNotOptimize(map);
+ BH_HashmapFree(map);
+ }
+}
+
+
+int main(int argc, char **argv)
+{
+ BH_UNUSED(argc);
+ BH_UNUSED(argv);
+
+ setupData();
+ setupWarmMap();
+
+ BH_BENCH_ADD(NewFree);
+ BH_BENCH_ADD(ReserveInsert);
+ BH_BENCH_ADD(Lookup);
+ BH_BENCH_ADD(Remove);
+
+ return BH_BenchRun();
+}
diff --git a/bench/tests/BenchLine.c b/bench/tests/BenchLine.c
index bbef886..57481d6 100644
--- a/bench/tests/BenchLine.c
+++ b/bench/tests/BenchLine.c
@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
-#include "BH/Math/Line.h"
+#include <BH/Bench.h>
+#include <BH/Math/Line.h>
static float pointA[2] = {1.0f, 2.0f};
diff --git a/bench/tests/BenchMat3f.c b/bench/tests/BenchMat3f.c
new file mode 100644
index 0000000..8d85c04
--- /dev/null
+++ b/bench/tests/BenchMat3f.c
@@ -0,0 +1,190 @@
+#include <BH/Bench.h>
+#include <BH/Math/Mat3f.h>
+
+
+static float matA[9] =
+{
+ 1.0f, 0.5f, 0.0f,
+ 0.2f, 2.0f, 0.3f,
+ 0.0f, 0.1f, 1.5f
+};
+static float matB[9] =
+{
+ 0.8f, 0.0f, 0.2f,
+ 0.1f, 1.2f, 0.4f,
+ 0.3f, 0.0f, 0.9f
+};
+static float outMat[9];
+static float outInv[9];
+static float vec3[3] = {1.5f, 2.5f, 1.0f};
+static float vec2[2] = {3.0f, 4.0f};
+static float outVec3[3];
+static float outVec2[2];
+
+
+BH_BENCH_TEST(Identity)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat3fIdentity(outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(Add)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat3fAdd(matA, matB, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(Sub)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat3fSub(matA, matB, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(Mul)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat3fMul(matA, matB, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(Scale)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat3fScale(matA, 2.5f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(Transpose)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat3fTranspose(matA, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(Trace)
+{
+ while (BH_BenchIter(state))
+ {
+ float trace;
+ trace = BH_Mat3fTrace(matA);
+ BH_BenchDoNotOptimize(trace);
+ }
+}
+
+
+BH_BENCH_TEST(Det)
+{
+ while (BH_BenchIter(state))
+ {
+ float det;
+ det = BH_Mat3fDet(matA);
+ BH_BenchDoNotOptimize(det);
+ }
+}
+
+
+BH_BENCH_TEST(Inverse)
+{
+ while (BH_BenchIter(state))
+ {
+ int result;
+ result = BH_Mat3fInverse(matA, outInv);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(outInv);
+ }
+}
+
+
+BH_BENCH_TEST(FromScale)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat3fFromScale(2.0f, 3.0f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(FromTranslation)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat3fFromTranslation(4.0f, -2.0f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(FromRotation)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat3fFromRotation(0.7854f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(ApplyVec3f)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat3fApplyVec3f(matA, vec3, outVec3);
+ BH_BenchDoNotOptimize(outVec3);
+ }
+}
+
+
+BH_BENCH_TEST(ApplyVec2f)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat3fApplyVec2f(matA, vec2, outVec2);
+ BH_BenchDoNotOptimize(outVec2);
+ }
+}
+
+
+int main(int argc, char **argv)
+{
+ BH_UNUSED(argc);
+ BH_UNUSED(argv);
+
+ BH_BENCH_ADD(Identity);
+ BH_BENCH_ADD(Add);
+ BH_BENCH_ADD(Sub);
+ BH_BENCH_ADD(Mul);
+ BH_BENCH_ADD(Scale);
+ BH_BENCH_ADD(Transpose);
+ BH_BENCH_ADD(Trace);
+ BH_BENCH_ADD(Det);
+ BH_BENCH_ADD(Inverse);
+ BH_BENCH_ADD(FromScale);
+ BH_BENCH_ADD(FromTranslation);
+ BH_BENCH_ADD(FromRotation);
+ BH_BENCH_ADD(ApplyVec3f);
+ BH_BENCH_ADD(ApplyVec2f);
+
+ return BH_BenchRun();
+}
diff --git a/bench/tests/BenchMat4f.c b/bench/tests/BenchMat4f.c
new file mode 100644
index 0000000..c124cc7
--- /dev/null
+++ b/bench/tests/BenchMat4f.c
@@ -0,0 +1,285 @@
+#include <BH/Bench.h>
+#include <BH/Math/Mat4f.h>
+
+
+static float matA[16] =
+{
+ 1.0f, 0.2f, 0.0f, 0.0f,
+ 0.1f, 1.5f, 0.3f, 0.0f,
+ 0.0f, 0.0f, 2.0f, 0.0f,
+ 1.0f, 2.0f, 3.0f, 1.0f
+};
+static float matB[16] =
+{
+ 0.9f, 0.0f, 0.1f, 0.0f,
+ 0.0f, 1.1f, 0.0f, 0.0f,
+ 0.2f, 0.3f, 0.8f, 0.0f,
+ 0.5f, 1.0f, 1.5f, 1.0f
+};
+static float outMat[16];
+static float outInv[16];
+static float vec4[4] = {1.0f, 2.0f, 3.0f, 1.0f};
+static float vec3[3] = {4.0f, 5.0f, 6.0f};
+static float outVec4[4];
+static float outVec3[3];
+static float quat[4] = {0.707f, 0.0f, 0.0f, 0.707f};
+static float axis[3] = {0.577f, 0.577f, 0.577f};
+static float camPos[3] = {0.0f, 0.0f, 5.0f};
+static float camAt[3] = {0.0f, 0.0f, 0.0f};
+static float camUp[3] = {0.0f, 1.0f, 0.0f};
+
+
+BH_BENCH_TEST(Identity)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fIdentity(outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(Add)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fAdd(matA, matB, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(Sub)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fSub(matA, matB, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(Mul)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fMul(matA, matB, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(Scale)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fScale(matA, 1.5f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(Transpose)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fTranspose(matA, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(Trace)
+{
+ while (BH_BenchIter(state))
+ {
+ float trace;
+ trace = BH_Mat4fTrace(matA);
+ BH_BenchDoNotOptimize(trace);
+ }
+}
+
+
+BH_BENCH_TEST(Det)
+{
+ while (BH_BenchIter(state))
+ {
+ float det;
+ det = BH_Mat4fDet(matA);
+ BH_BenchDoNotOptimize(det);
+ }
+}
+
+
+BH_BENCH_TEST(Inverse)
+{
+ while (BH_BenchIter(state))
+ {
+ int result;
+ result = BH_Mat4fInverse(matA, outInv);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(outInv);
+ }
+}
+
+
+BH_BENCH_TEST(FromScale)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fFromScale(2.0f, 3.0f, 4.0f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(FromTranslation)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fFromTranslation(1.0f, -1.0f, 2.5f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(FromRotationX)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fFromRotationX(0.7854f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(FromRotationY)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fFromRotationY(0.7854f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(FromRotationZ)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fFromRotationZ(0.7854f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(FromAxis)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fFromAxis(axis, 1.0472f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(FromEuler)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fFromEuler(0.3f, 0.4f, 0.5f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(FromQuat4f)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fFromQuat4f(quat, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(FromOrtho)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fFromOrtho(-4.0f, 4.0f, -3.0f, 3.0f, 0.1f, 100.0f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(FromFrustum)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fFromFrustum(60.0f, 1.77f, 0.1f, 100.0f, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(FromLookAt)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fFromLookAt(camPos, camAt, camUp, outMat);
+ BH_BenchDoNotOptimize(outMat);
+ }
+}
+
+
+BH_BENCH_TEST(ApplyVec4f)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fApplyVec4f(matA, vec4, outVec4);
+ BH_BenchDoNotOptimize(outVec4);
+ }
+}
+
+
+BH_BENCH_TEST(ApplyVec3f)
+{
+ while (BH_BenchIter(state))
+ {
+ BH_Mat4fApplyVec3f(matA, vec3, outVec3);
+ BH_BenchDoNotOptimize(outVec3);
+ }
+}
+
+
+int main(int argc, char **argv)
+{
+ BH_UNUSED(argc);
+ BH_UNUSED(argv);
+
+ BH_BENCH_ADD(Identity);
+ BH_BENCH_ADD(Add);
+ BH_BENCH_ADD(Sub);
+ BH_BENCH_ADD(Mul);
+ BH_BENCH_ADD(Scale);
+ BH_BENCH_ADD(Transpose);
+ BH_BENCH_ADD(Trace);
+ BH_BENCH_ADD(Det);
+ BH_BENCH_ADD(Inverse);
+ BH_BENCH_ADD(FromScale);
+ BH_BENCH_ADD(FromTranslation);
+ BH_BENCH_ADD(FromRotationX);
+ BH_BENCH_ADD(FromRotationY);
+ BH_BENCH_ADD(FromRotationZ);
+ BH_BENCH_ADD(FromAxis);
+ BH_BENCH_ADD(FromEuler);
+ BH_BENCH_ADD(FromQuat4f);
+ BH_BENCH_ADD(FromOrtho);
+ BH_BENCH_ADD(FromFrustum);
+ BH_BENCH_ADD(FromLookAt);
+ BH_BENCH_ADD(ApplyVec4f);
+ BH_BENCH_ADD(ApplyVec3f);
+
+ return BH_BenchRun();
+}
diff --git a/bench/tests/BenchPlane.c b/bench/tests/BenchPlane.c
index 4c5a115..1ff4cf0 100644
--- a/bench/tests/BenchPlane.c
+++ b/bench/tests/BenchPlane.c
@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
-#include "BH/Math/Plane.h"
+#include <BH/Bench.h>
+#include <BH/Math/Plane.h>
static float pointA[3] = {1.0f, 2.0f, 3.0f};
diff --git a/bench/tests/BenchQueue.c b/bench/tests/BenchQueue.c
new file mode 100644
index 0000000..0e683d9
--- /dev/null
+++ b/bench/tests/BenchQueue.c
@@ -0,0 +1,117 @@
+#include <BH/Bench.h>
+#include <BH/Queue.h>
+
+
+#define NUM_ENTRIES 1000
+
+
+static int values[NUM_ENTRIES];
+static BH_Queue *queue;
+static void *frontValue;
+static void *iter;
+static void *iterValue;
+
+
+static void setupData()
+{
+ int i;
+ queue = BH_QueueNew();
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ {
+ values[i] = i + 1;
+ BH_QueueInsert(queue, &values[i]);
+ }
+}
+
+
+BH_BENCH_TEST(NewFree)
+{
+ while (BH_BenchIter(state))
+ {
+ queue = BH_QueueNew();
+ BH_BenchDoNotOptimize(queue);
+ if (queue) BH_QueueFree(queue);
+ }
+}
+
+
+BH_BENCH_TEST(ReserveInsert)
+{
+ BH_BenchSubcount(state, NUM_ENTRIES);
+ while (BH_BenchIter(state))
+ {
+ int i;
+ queue = BH_QueueNew();
+ BH_QueueReserve(queue, NUM_ENTRIES);
+
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ {
+ values[i] = i + 1;
+ BH_QueueInsert(queue, &values[i]);
+ }
+
+ BH_BenchDoNotOptimize(queue);
+ BH_QueueFree(queue);
+ }
+}
+
+
+BH_BENCH_TEST(FrontRemove)
+{
+ BH_BenchSubcount(state, NUM_ENTRIES);
+ while (BH_BenchIter(state))
+ {
+ int i;
+ queue = BH_QueueNew();
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ {
+ values[i] = i + 1;
+ BH_QueueInsert(queue, &values[i]);
+ }
+
+ for (i = 0; i < NUM_ENTRIES; ++i)
+ {
+ if (BH_QueueFront(queue, &frontValue) == 0)
+ {
+ BH_QueueRemove(queue);
+ }
+ }
+
+ BH_BenchDoNotOptimize(frontValue);
+ BH_BenchDoNotOptimize(queue);
+ BH_QueueFree(queue);
+ }
+}
+
+
+BH_BENCH_TEST(Iterate)
+{
+ setupData();
+ BH_BenchSubcount(state, NUM_ENTRIES);
+ while (BH_BenchIter(state))
+ {
+ iter = NULL;
+ iterValue = NULL;
+ while ((iter = BH_QueueIterNext(queue, iter)) != NULL)
+ {
+ iterValue = BH_QueueIterValue(iter);
+ }
+ BH_BenchDoNotOptimize(iterValue);
+ }
+
+ BH_QueueFree(queue);
+}
+
+
+int main(int argc, char **argv)
+{
+ BH_UNUSED(argc);
+ BH_UNUSED(argv);
+
+ BH_BENCH_ADD(NewFree);
+ BH_BENCH_ADD(ReserveInsert);
+ BH_BENCH_ADD(FrontRemove);
+ BH_BENCH_ADD(Iterate);
+
+ return BH_BenchRun();
+}
diff --git a/bench/tests/BenchRay2f.c b/bench/tests/BenchRay2f.c
new file mode 100644
index 0000000..0354ead
--- /dev/null
+++ b/bench/tests/BenchRay2f.c
@@ -0,0 +1,143 @@
+#include <BH/Bench.h>
+#include <BH/Math/Ray2f.h>
+
+static float rayAStart[2] = {1.0f, 1.0f};
+static float rayADir[2] = {1.0f, 0.5f};
+static float rayBStart[2] = {3.0f, 0.0f};
+static float rayBDir[2] = {-0.5f, 1.0f};
+static float lineEq[3] = {1.0f, 1.0f, -4.0f};
+static float segStart[2] = {0.0f, 3.0f};
+static float segEnd[2] = {5.0f, 2.0f};
+static float boxMin[2] = {2.0f, 2.0f};
+static float boxMax[2] = {6.0f, 5.0f};
+static float outPoint[2];
+
+
+BH_BENCH_TEST(IntersectLine)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Ray2fIntersectLine(rayAStart, rayADir, lineEq, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+BH_BENCH_TEST(IntersectTime)
+{
+ while (BH_BenchIter(state))
+ {
+ float time1, time2;
+ int result;
+ result = BH_Ray2fIntersectTime(rayAStart, rayADir, rayBStart, rayBDir, &time1, &time2);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(time1);
+ BH_BenchDoNotOptimize(time2);
+ }
+}
+
+
+BH_BENCH_TEST(IntersectRay)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Ray2fIntersectRay(rayAStart, rayADir, rayBStart, rayBDir, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+BH_BENCH_TEST(IntersectSegment)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Ray2fIntersectSegment(rayAStart, rayADir, segStart, segEnd, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+BH_BENCH_TEST(SegmentIntersectLine)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Segment2fIntersectLine(segStart, segEnd, lineEq, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+BH_BENCH_TEST(SegmentIntersectSegment)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Segment2fIntersectSegment(segStart, segEnd, rayAStart, rayBStart, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+BH_BENCH_TEST(IntersectBox2f)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Ray2fIntersectBox2f(rayAStart, rayADir, boxMin, boxMax, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+BH_BENCH_TEST(SegmentIntersectBox2f)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Segment2fIntersectBox2f(segStart, segEnd, boxMin, boxMax, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+int main(int argc, char **argv)
+{
+ BH_UNUSED(argc);
+ BH_UNUSED(argv);
+
+ BH_BENCH_ADD(IntersectLine);
+ BH_BENCH_ADD(IntersectTime);
+ BH_BENCH_ADD(IntersectRay);
+ BH_BENCH_ADD(IntersectSegment);
+ BH_BENCH_ADD(SegmentIntersectLine);
+ BH_BENCH_ADD(SegmentIntersectSegment);
+ BH_BENCH_ADD(IntersectBox2f);
+ BH_BENCH_ADD(SegmentIntersectBox2f);
+
+ return BH_BenchRun();
+}
diff --git a/bench/tests/BenchRay3f.c b/bench/tests/BenchRay3f.c
new file mode 100644
index 0000000..de7b00d
--- /dev/null
+++ b/bench/tests/BenchRay3f.c
@@ -0,0 +1,115 @@
+#include <BH/Bench.h>
+#include <BH/Math/Ray3f.h>
+
+
+static float rayStart[3] = {0.0f, 0.0f, 0.0f};
+static float rayDir[3] = {1.0f, 1.0f, 1.0f};
+static float segStart[3] = {-2.0f, -2.0f, -2.0f};
+static float segEnd[3] = {2.0f, 2.0f, 2.0f};
+static float planeEq[4] = {1.0f, 1.0f, 1.0f, -3.0f};
+static float triA[3] = {1.0f, 1.0f, 1.0f};
+static float triB[3] = {2.0f, 1.0f, 0.0f};
+static float triC[3] = {0.0f, 2.0f, 1.0f};
+static float boxMin[3] = {1.0f, 1.0f, 1.0f};
+static float boxMax[3] = {3.0f, 3.0f, 3.0f};
+static float outPoint[3];
+
+
+BH_BENCH_TEST(IntersectPlane)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Ray3fIntersectPlane(rayStart, rayDir, planeEq, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+BH_BENCH_TEST(IntersectTriangle)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Ray3fIntersectTriangle(rayStart, rayDir, triA, triB, triC, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+BH_BENCH_TEST(SegmentIntersectPlane)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Segment3fIntersectPlane(segStart, segEnd, planeEq, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+BH_BENCH_TEST(SegmentIntersectTriangle)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Segment3fIntersectTriangle(segStart, segEnd, triA, triB, triC, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+BH_BENCH_TEST(IntersectBox3f)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Ray3fIntersectBox3f(rayStart, rayDir, boxMin, boxMax, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+BH_BENCH_TEST(SegmentIntersectBox3f)
+{
+ while (BH_BenchIter(state))
+ {
+ float t;
+ int result;
+ result = BH_Segment3fIntersectBox3f(segStart, segEnd, boxMin, boxMax, &t, outPoint);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(t);
+ BH_BenchDoNotOptimize(outPoint);
+ }
+}
+
+
+int main(int argc, char **argv)
+{
+ BH_UNUSED(argc);
+ BH_UNUSED(argv);
+
+ BH_BENCH_ADD(IntersectPlane);
+ BH_BENCH_ADD(IntersectTriangle);
+ BH_BENCH_ADD(SegmentIntersectPlane);
+ BH_BENCH_ADD(SegmentIntersectTriangle);
+ BH_BENCH_ADD(IntersectBox3f);
+ BH_BENCH_ADD(SegmentIntersectBox3f);
+
+ return BH_BenchRun();
+}
diff --git a/bench/tests/BenchString.c b/bench/tests/BenchString.c
new file mode 100644
index 0000000..e44aaf0
--- /dev/null
+++ b/bench/tests/BenchString.c
@@ -0,0 +1,286 @@
+#include <BH/Bench.h>
+#include <BH/String.h>
+
+
+#define BUF_SIZE 64
+static char buffer[BUF_SIZE];
+static size_t actual;
+static double testDouble = 1234.5678;
+static int8_t testInt8s = -128;
+static int16_t testInt16s = -32768;
+static int32_t testInt32s = -2147483647;
+static int64_t testInt64s = -9223372036854775807LL;
+static uint8_t testInt8u = 255;
+static uint16_t testInt16u = 65535;
+static uint32_t testInt32u = 4294967295U;
+static uint64_t testInt64u = 18446744073709551615ULL;
+static const char *strDouble = "1234.5678";
+static const char *strInt8s = "-128";
+static const char *strInt16s = "-32768";
+static const char *strInt32s = "-2147483647";
+static const char *strInt64s = "-9223372036854775807";
+static const char *strInt8u = "255";
+static const char *strInt16u = "65535";
+static const char *strInt32u = "4294967295";
+static const char *strInt64u = "18446744073709551615";
+static size_t parsedSize;
+
+
+BH_BENCH_TEST(StringFromDouble)
+{
+ while (BH_BenchIter(state))
+ {
+ int result;
+ result = BH_StringFromDouble(buffer, BUF_SIZE, testDouble, 'f', 6, &actual);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(buffer);
+ BH_BenchDoNotOptimize(actual);
+ }
+}
+
+
+BH_BENCH_TEST(StringFromInt8s)
+{
+ while (BH_BenchIter(state))
+ {
+ int result;
+ result = BH_StringFromInt8s(buffer, BUF_SIZE, testInt8s, 10, &actual);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(buffer);
+ BH_BenchDoNotOptimize(actual);
+ }
+}
+
+
+BH_BENCH_TEST(StringFromInt16s)
+{
+ while (BH_BenchIter(state))
+ {
+ int result;
+ result = BH_StringFromInt16s(buffer, BUF_SIZE, testInt16s, 10, &actual);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(buffer);
+ BH_BenchDoNotOptimize(actual);
+ }
+}
+
+
+BH_BENCH_TEST(StringFromInt32s)
+{
+ while (BH_BenchIter(state))
+ {
+ int result;
+ result = BH_StringFromInt32s(buffer, BUF_SIZE, testInt32s, 10, &actual);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(buffer);
+ BH_BenchDoNotOptimize(actual);
+ }
+}
+
+
+BH_BENCH_TEST(StringFromInt64s)
+{
+ while (BH_BenchIter(state))
+ {
+ int result;
+ result = BH_StringFromInt64s(buffer, BUF_SIZE, testInt64s, 10, &actual);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(buffer);
+ BH_BenchDoNotOptimize(actual);
+ }
+}
+
+
+BH_BENCH_TEST(StringFromInt8u)
+{
+ while (BH_BenchIter(state))
+ {
+ int result;
+ result = BH_StringFromInt8u(buffer, BUF_SIZE, testInt8u, 10, &actual);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(buffer);
+ BH_BenchDoNotOptimize(actual);
+ }
+}
+
+
+BH_BENCH_TEST(StringFromInt16u)
+{
+ while (BH_BenchIter(state))
+ {
+ int result;
+ result = BH_StringFromInt16u(buffer, BUF_SIZE, testInt16u, 10, &actual);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(buffer);
+ BH_BenchDoNotOptimize(actual);
+ }
+}
+
+
+BH_BENCH_TEST(StringFromInt32u)
+{
+ while (BH_BenchIter(state))
+ {
+ int result;
+ result = BH_StringFromInt32u(buffer, BUF_SIZE, testInt32u, 10, &actual);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(buffer);
+ BH_BenchDoNotOptimize(actual);
+ }
+}
+
+
+BH_BENCH_TEST(StringFromInt64u)
+{
+ while (BH_BenchIter(state))
+ {
+ int result;
+ result = BH_StringFromInt64u(buffer, BUF_SIZE, testInt64u, 10, &actual);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(buffer);
+ BH_BenchDoNotOptimize(actual);
+ }
+}
+
+
+BH_BENCH_TEST(StringToDouble)
+{
+ while (BH_BenchIter(state))
+ {
+ double result;
+ parsedSize = 0;
+ result = BH_StringToDouble(strDouble, &parsedSize);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(parsedSize);
+ }
+}
+
+
+BH_BENCH_TEST(StringToInt8s)
+{
+ while (BH_BenchIter(state))
+ {
+ int8_t result;
+ parsedSize = 0;
+ result = BH_StringToInt8s(strInt8s, &parsedSize, 10);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(parsedSize);
+ }
+}
+
+
+BH_BENCH_TEST(StringToInt16s)
+{
+ while (BH_BenchIter(state))
+ {
+ int16_t result;
+ parsedSize = 0;
+ result = BH_StringToInt16s(strInt16s, &parsedSize, 10);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(parsedSize);
+ }
+}
+
+
+BH_BENCH_TEST(StringToInt32s)
+{
+ while (BH_BenchIter(state))
+ {
+ int32_t result;
+ parsedSize = 0;
+ result = BH_StringToInt32s(strInt32s, &parsedSize, 10);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(parsedSize);
+ }
+}
+
+
+BH_BENCH_TEST(StringToInt64s)
+{
+ while (BH_BenchIter(state))
+ {
+ int64_t result;
+ parsedSize = 0;
+ result = BH_StringToInt64s(strInt64s, &parsedSize, 10);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(parsedSize);
+ }
+}
+
+
+BH_BENCH_TEST(StringToInt8u)
+{
+ while (BH_BenchIter(state))
+ {
+ uint8_t result;
+ parsedSize = 0;
+ result = BH_StringToInt8u(strInt8u, &parsedSize, 10);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(parsedSize);
+ }
+}
+
+
+BH_BENCH_TEST(StringToInt16u)
+{
+ while (BH_BenchIter(state))
+ {
+ uint16_t result;
+ parsedSize = 0;
+ result = BH_StringToInt16u(strInt16u, &parsedSize, 10);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(parsedSize);
+ }
+}
+
+
+BH_BENCH_TEST(StringToInt32u)
+{
+ while (BH_BenchIter(state))
+ {
+ uint32_t result;
+ parsedSize = 0;
+ result = BH_StringToInt32u(strInt32u, &parsedSize, 10);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(parsedSize);
+ }
+}
+
+
+BH_BENCH_TEST(StringToInt64u)
+{
+ while (BH_BenchIter(state))
+ {
+ uint64_t result;
+ parsedSize = 0;
+ result = BH_StringToInt64u(strInt64u, &parsedSize, 10);
+ BH_BenchDoNotOptimize(result);
+ BH_BenchDoNotOptimize(parsedSize);
+ }
+}
+
+
+int main(void)
+{
+ BH_BENCH_ADD(StringFromDouble);
+ BH_BENCH_ADD(StringFromInt8s);
+ BH_BENCH_ADD(StringFromInt16s);
+ BH_BENCH_ADD(StringFromInt32s);
+ BH_BENCH_ADD(StringFromInt64s);
+ BH_BENCH_ADD(StringFromInt8u);
+ BH_BENCH_ADD(StringFromInt16u);
+ BH_BENCH_ADD(StringFromInt32u);
+ BH_BENCH_ADD(StringFromInt64u);
+
+ BH_BENCH_ADD(StringToDouble);
+ BH_BENCH_ADD(StringToInt8s);
+ BH_BENCH_ADD(StringToInt16s);
+ BH_BENCH_ADD(StringToInt32s);
+ BH_BENCH_ADD(StringToInt64s);
+ BH_BENCH_ADD(StringToInt8u);
+ BH_BENCH_ADD(StringToInt16u);
+ BH_BENCH_ADD(StringToInt32u);
+ BH_BENCH_ADD(StringToInt64u);
+
+ return BH_BenchRun();
+}
diff --git a/bench/tests/BenchVec2f.c b/bench/tests/BenchVec2f.c
index a180bd7..b62d00d 100644
--- a/bench/tests/BenchVec2f.c
+++ b/bench/tests/BenchVec2f.c
@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
-#include "BH/Math/Vec2f.h"
+#include <BH/Bench.h>
+#include <BH/Math/Vec2f.h>
static float vecA[2] = {1.0f, 2.0f};
diff --git a/bench/tests/BenchVec2i.c b/bench/tests/BenchVec2i.c
index 945a9c5..b0ac41d 100644
--- a/bench/tests/BenchVec2i.c
+++ b/bench/tests/BenchVec2i.c
@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
-#include "BH/Math/Vec2i.h"
+#include <BH/Bench.h>
+#include <BH/Math/Vec2i.h>
static int vecA[2] = {5, -3};
diff --git a/bench/tests/BenchVec3f.c b/bench/tests/BenchVec3f.c
index 5908626..9f4ec4d 100644
--- a/bench/tests/BenchVec3f.c
+++ b/bench/tests/BenchVec3f.c
@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
-#include "BH/Math/Vec3f.h"
+#include <BH/Bench.h>
+#include <BH/Math/Vec3f.h>
static float vecA[3] = {1.0f, 2.0f, 3.0f};
diff --git a/bench/tests/BenchVec3i.c b/bench/tests/BenchVec3i.c
index 8e356f3..a74df1c 100644
--- a/bench/tests/BenchVec3i.c
+++ b/bench/tests/BenchVec3i.c
@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
-#include "BH/Math/Vec3i.h"
+#include <BH/Bench.h>
+#include <BH/Math/Vec3i.h>
static int vecA[3] = {1, 2, 3};
diff --git a/bench/tests/BenchVec4f.c b/bench/tests/BenchVec4f.c
index c7aebb3..d730650 100644
--- a/bench/tests/BenchVec4f.c
+++ b/bench/tests/BenchVec4f.c
@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
-#include "BH/Math/Vec4f.h"
+#include <BH/Bench.h>
+#include <BH/Math/Vec4f.h>
static float vecA[4] = {1.0f, 2.0f, 3.0f, 4.0f};
diff --git a/bench/tests/BenchVec4i.c b/bench/tests/BenchVec4i.c
index 56ceb42..24ad29d 100644
--- a/bench/tests/BenchVec4i.c
+++ b/bench/tests/BenchVec4i.c
@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
-#include "BH/Math/Vec4i.h"
+#include <BH/Bench.h>
+#include <BH/Math/Vec4i.h>
static int vecA[4] = {1, 2, 3, 4};
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-01 01:49:45 +0000