Add more benchmarks, add subcount option

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);
 
 

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);
+        ips = state->iterations / (millis / 1000.0f) * state->subcount;
-        ns = (millis * 1000000.0) / state->iterations;
+        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;

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();
+}

bench/tests/BenchBox2f.c

@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
+#include <BH/Bench.h>
-#include "BH/Math/Box2f.h"
+#include <BH/Math/Box2f.h>
 
 
 

bench/tests/BenchBox3f.c

@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
+#include <BH/Bench.h>
-#include "BH/Math/Box3f.h"
+#include <BH/Math/Box3f.h>
 
 
 static float boxAMin[3] = {1.0f, 2.0f, 3.0f};

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();
+}

bench/tests/BenchLine.c

@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
+#include <BH/Bench.h>
-#include "BH/Math/Line.h"
+#include <BH/Math/Line.h>
 
 
 static float pointA[2] = {1.0f, 2.0f};

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();
+}

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();
+}

bench/tests/BenchPlane.c

@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
+#include <BH/Bench.h>
-#include "BH/Math/Plane.h"
+#include <BH/Math/Plane.h>
 
 
 static float pointA[3] = {1.0f, 2.0f, 3.0f};

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();
+}

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();
+}

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();
+}

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();
+}

bench/tests/BenchVec2f.c

@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
+#include <BH/Bench.h>
-#include "BH/Math/Vec2f.h"
+#include <BH/Math/Vec2f.h>
 
 
 static float vecA[2] = {1.0f, 2.0f};

bench/tests/BenchVec2i.c

@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
+#include <BH/Bench.h>
-#include "BH/Math/Vec2i.h"
+#include <BH/Math/Vec2i.h>
 
 
 static int vecA[2] = {5, -3};

bench/tests/BenchVec3f.c

@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
+#include <BH/Bench.h>
-#include "BH/Math/Vec3f.h"
+#include <BH/Math/Vec3f.h>
 
 
 static float vecA[3] = {1.0f, 2.0f, 3.0f};

bench/tests/BenchVec3i.c

@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
+#include <BH/Bench.h>
-#include "BH/Math/Vec3i.h"
+#include <BH/Math/Vec3i.h>
 
 
 static int vecA[3] = {1, 2, 3};

bench/tests/BenchVec4f.c

@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
+#include <BH/Bench.h>
-#include "BH/Math/Vec4f.h"
+#include <BH/Math/Vec4f.h>
 
 
 static float vecA[4] = {1.0f, 2.0f, 3.0f, 4.0f};

bench/tests/BenchVec4i.c

@@ -1,5 +1,5 @@
-#include "BH/Bench.h"
+#include <BH/Bench.h>
-#include "BH/Math/Vec4i.h"
+#include <BH/Math/Vec4i.h>
 
 
 static int vecA[4] = {1, 2, 3, 4};