Add two more benchmarks

2025-10-13 11:41:00 +03:00
parent 3f7b872f0f
commit 3177a54709
2 changed files with 673 additions and 0 deletions
--- a/bench/tests/BenchColor.c
+++ b/bench/tests/BenchColor.c
@@ -0,0 +1,292 @@
+#include <BH/Bench.h>
+#include <BH/Color.h>
+
+
+static BH_Color color, other, result;
+static BH_Color foreground, background;
+static uint8_t  r8, g8, b8, a8;
+static uint16_t r16, g16, b16, a16;
+static float    rf, gf, bf, af;
+static float    hf, sf, vf, lf, af_hsv, af_hsl;
+static int blendMode = BH_COLOR_MODE_NORMAL;
+
+
+BH_BENCH_TEST(SetRGBA8GetRGBA8)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBA8(&color, 100, 200, 150, 255);
+        BH_ColorRGBA8(&color, &r8, &g8, &b8, &a8);
+
+        BH_BenchDoNotOptimize(r8);
+        BH_BenchDoNotOptimize(g8);
+        BH_BenchDoNotOptimize(b8);
+        BH_BenchDoNotOptimize(a8);
+    }
+}
+
+
+BH_BENCH_TEST(SetRGBA16GetRGBA16)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBA16(&color, 32768, 40000, 50000, 65535);
+        BH_ColorRGBA16(&color, &r16, &g16, &b16, &a16);
+
+        BH_BenchDoNotOptimize(r16);
+        BH_BenchDoNotOptimize(g16);
+        BH_BenchDoNotOptimize(b16);
+        BH_BenchDoNotOptimize(a16);
+    }
+}
+
+
+BH_BENCH_TEST(SetRGBAfGetRGBAf)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&color, 0.392f, 0.784f, 0.588f, 1.0f);
+        BH_ColorRGBAf(&color, &rf, &gf, &bf, &af);
+
+        BH_BenchDoNotOptimize(rf);
+        BH_BenchDoNotOptimize(gf);
+        BH_BenchDoNotOptimize(bf);
+        BH_BenchDoNotOptimize(af);
+    }
+}
+
+
+BH_BENCH_TEST(SetHSVAfGetHSVAf)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetHSVAf(&color, 0.333f, 0.6f, 0.8f, 1.0f);
+        BH_ColorHSVAf(&color, &hf, &sf, &vf, &af_hsv);
+
+        BH_BenchDoNotOptimize(hf);
+        BH_BenchDoNotOptimize(sf);
+        BH_BenchDoNotOptimize(vf);
+        BH_BenchDoNotOptimize(af_hsv);
+    }
+}
+
+
+BH_BENCH_TEST(SetHSLAfGetHSLAf)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetHSLAf(&color, 0.333f, 0.6f, 0.5f, 1.0f);
+        BH_ColorHSLAf(&color, &hf, &sf, &lf, &af_hsl);
+
+        BH_BenchDoNotOptimize(hf);
+        BH_BenchDoNotOptimize(sf);
+        BH_BenchDoNotOptimize(lf);
+        BH_BenchDoNotOptimize(af_hsl);
+    }
+}
+
+
+BH_BENCH_TEST(ToRGBAFromHSVA)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetHSVAf(&color, 0.4f, 0.7f, 0.9f, 1.0f);
+        BH_ColorToRGBA(&color, &result);
+
+        BH_BenchDoNotOptimize(result.data.rgba.r);
+        BH_BenchDoNotOptimize(result.data.rgba.g);
+        BH_BenchDoNotOptimize(result.data.rgba.b);
+        BH_BenchDoNotOptimize(result.data.rgba.a);
+    }
+}
+
+
+BH_BENCH_TEST(ToHSVAFromRGBA)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&color, 0.2f, 0.6f, 0.4f, 1.0f);
+        BH_ColorToHSVA(&color, &result);
+
+        BH_BenchDoNotOptimize(result.data.hsva.h);
+        BH_BenchDoNotOptimize(result.data.hsva.s);
+        BH_BenchDoNotOptimize(result.data.hsva.v);
+        BH_BenchDoNotOptimize(result.data.hsva.a);
+    }
+}
+
+
+BH_BENCH_TEST(ToHSLAFromRGBA)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&color, 0.2f, 0.6f, 0.4f, 1.0f);
+        BH_ColorToHSLA(&color, &result);
+
+        BH_BenchDoNotOptimize(result.data.hsla.h);
+        BH_BenchDoNotOptimize(result.data.hsla.s);
+        BH_BenchDoNotOptimize(result.data.hsla.l);
+        BH_BenchDoNotOptimize(result.data.hsla.a);
+    }
+}
+
+
+BH_BENCH_TEST(BlendNormal)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&foreground, 0.8f, 0.3f, 0.2f, 0.7f);
+        BH_ColorSetRGBAf(&background, 0.1f, 0.5f, 0.9f, 1.0f);
+        BH_ColorBlend(&foreground, &background, BH_COLOR_MODE_NORMAL, &result);
+
+        BH_BenchDoNotOptimize(result.data.rgba.r);
+        BH_BenchDoNotOptimize(result.data.rgba.g);
+        BH_BenchDoNotOptimize(result.data.rgba.b);
+        BH_BenchDoNotOptimize(result.data.rgba.a);
+    }
+}
+
+
+BH_BENCH_TEST(BlendMultiply)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&foreground, 0.6f, 0.4f, 0.3f, 0.8f);
+        BH_ColorSetRGBAf(&background, 0.5f, 0.7f, 0.9f, 1.0f);
+        BH_ColorBlend(&foreground, &background, BH_COLOR_MODE_MULTIPLY, &result);
+
+        BH_BenchDoNotOptimize(result);
+    }
+}
+
+
+BH_BENCH_TEST(BlendScreen)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&foreground, 0.7f, 0.2f, 0.1f, 0.6f);
+        BH_ColorSetRGBAf(&background, 0.3f, 0.8f, 0.6f, 1.0f);
+        BH_ColorBlend(&foreground, &background, BH_COLOR_MODE_SCREEN, &result);
+
+        BH_BenchDoNotOptimize(result);
+    }
+}
+
+
+BH_BENCH_TEST(BlendOverlay)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&foreground, 0.5f, 0.5f, 0.5f, 0.9f);
+        BH_ColorSetRGBAf(&background, 0.4f, 0.6f, 0.3f, 1.0f);
+        BH_ColorBlend(&foreground, &background, BH_COLOR_MODE_OVERLAY, &result);
+
+        BH_BenchDoNotOptimize(result);
+    }
+}
+
+
+BH_BENCH_TEST(BlendHardLight)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&foreground, 0.8f, 0.1f, 0.1f, 0.7f);
+        BH_ColorSetRGBAf(&background, 0.5f, 0.5f, 0.5f, 1.0f);
+        BH_ColorBlend(&foreground, &background, BH_COLOR_MODE_HARD_LIGHT, &result);
+
+        BH_BenchDoNotOptimize(result);
+    }
+}
+
+
+BH_BENCH_TEST(BlendDifference)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&foreground, 0.9f, 0.2f, 0.1f, 0.8f);
+        BH_ColorSetRGBAf(&background, 0.1f, 0.8f, 0.9f, 1.0f);
+        BH_ColorBlend(&foreground, &background, BH_COLOR_MODE_DIFFERENCE, &result);
+
+        BH_BenchDoNotOptimize(result);
+    }
+}
+
+
+BH_BENCH_TEST(BlendHue)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&foreground, 0.8f, 0.3f, 0.2f, 1.0f);
+        BH_ColorSetRGBAf(&background, 0.2f, 0.7f, 0.6f, 1.0f);
+        BH_ColorBlend(&foreground, &background, BH_COLOR_MODE_HUE, &result);
+
+        BH_BenchDoNotOptimize(result);
+    }
+}
+
+
+BH_BENCH_TEST(BlendSaturation)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&foreground, 0.3f, 0.9f, 0.4f, 1.0f);
+        BH_ColorSetRGBAf(&background, 0.6f, 0.2f, 0.7f, 1.0f);
+        BH_ColorBlend(&foreground, &background, BH_COLOR_MODE_SATURATION, &result);
+
+        BH_BenchDoNotOptimize(result);
+    }
+}
+
+
+BH_BENCH_TEST(BlendColor)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&foreground, 0.1f, 0.8f, 0.3f, 1.0f);
+        BH_ColorSetRGBAf(&background, 0.7f, 0.2f, 0.6f, 1.0f);
+        BH_ColorBlend(&foreground, &background, BH_COLOR_MODE_COLOR, &result);
+
+        BH_BenchDoNotOptimize(result);
+    }
+}
+
+
+BH_BENCH_TEST(BlendLuminosity)
+{
+    while (BH_BenchIter(state))
+    {
+        BH_ColorSetRGBAf(&foreground, 0.2f, 0.8f, 0.4f, 1.0f);
+        BH_ColorSetRGBAf(&background, 0.6f, 0.3f, 0.7f, 1.0f);
+        BH_ColorBlend(&foreground, &background, BH_COLOR_MODE_LUMINOSITY, &result);
+
+        BH_BenchDoNotOptimize(result);
+    }
+}
+
+
+int main(int argc, char **argv)
+{
+    BH_UNUSED(argc);
+    BH_UNUSED(argv);
+
+    BH_BENCH_ADD(SetRGBA8GetRGBA8);
+    BH_BENCH_ADD(SetRGBA16GetRGBA16);
+    BH_BENCH_ADD(SetRGBAfGetRGBAf);
+    BH_BENCH_ADD(SetHSVAfGetHSVAf);
+    BH_BENCH_ADD(SetHSLAfGetHSLAf);
+    BH_BENCH_ADD(ToRGBAFromHSVA);
+    BH_BENCH_ADD(ToHSVAFromRGBA);
+    BH_BENCH_ADD(ToHSLAFromRGBA);
+    BH_BENCH_ADD(BlendNormal);
+    BH_BENCH_ADD(BlendMultiply);
+    BH_BENCH_ADD(BlendScreen);
+    BH_BENCH_ADD(BlendOverlay);
+    BH_BENCH_ADD(BlendHardLight);
+    BH_BENCH_ADD(BlendDifference);
+    BH_BENCH_ADD(BlendHue);
+    BH_BENCH_ADD(BlendSaturation);
+    BH_BENCH_ADD(BlendColor);
+    BH_BENCH_ADD(BlendLuminosity);
+
+    return BH_BenchRun();
+}
--- a/bench/tests/BenchUnicode.c
+++ b/bench/tests/BenchUnicode.c
@@ -0,0 +1,381 @@
+#include <BH/Bench.h>
+#include <BH/Unicode.h>
+
+
+#define BUF_SIZE 8
+
+
+static char buffer[BUF_SIZE];
+static size_t result;
+static uint32_t testUnitLower = 'a';
+static uint32_t testUnitUpper = 'A';
+static uint32_t testUnitLatin1 = 0x00E9;
+static uint32_t testUnitBMP = 0x2603;
+static uint32_t testUnitSMP = 0x1F600;
+
+static const char utf8_a[]     = { 'a' };
+static const char utf8_e_acute[] = { 0xC3, 0xA9 };
+static const char utf8_snowman[] = { 0xE2, 0x98, 0x83 };
+static const char utf8_grin[]    = { 0xF0, 0x9F, 0x98, 0x80 };
+static const char utf16_a_le[]     = { 'a', 0x00 };
+static const char utf16_e_acute_le[] = { 0xE9, 0x00 };
+static const char utf16_snowman_le[] = { 0x03, 0x26 };
+static const char utf16_grin_le[]    = { 0xD8, 0x3D, 0xDE, 0x00 };
+static const char utf16_a_be[]     = { 0x00, 'a' };
+static const char utf16_e_acute_be[] = { 0x00, 0xE9 };
+static const char utf16_snowman_be[] = { 0x26, 0x03 };
+static const char utf16_grin_be[]    = { 0x3D, 0xD8, 0x00, 0xDE };
+static const char utf32_a_le[]     = { 'a', 0x00, 0x00, 0x00 };
+static const char utf32_e_acute_le[] = { 0xE9, 0x00, 0x00, 0x00 };
+static const char utf32_snowman_le[] = { 0x03, 0x26, 0x00, 0x00 };
+static const char utf32_grin_le[]    = { 0x00, 0xF0, 0x01, 0x00 };
+static const char utf32_a_be[]     = { 0x00, 0x00, 0x00, 'a' };
+static const char utf32_e_acute_be[] = { 0x00, 0x00, 0x00, 0xE9 };
+static const char utf32_snowman_be[] = { 0x00, 0x00, 0x26, 0x03 };
+static const char utf32_grin_be[]    = { 0x00, 0x01, 0xF0, 0x00 };
+
+
+BH_BENCH_TEST(Lower)
+{
+    while (BH_BenchIter(state))
+    {
+        uint32_t lower;
+        lower = BH_UnicodeLower(testUnitUpper);
+        BH_BenchDoNotOptimize(lower);
+    }
+}
+
+
+BH_BENCH_TEST(Upper)
+{
+    while (BH_BenchIter(state))
+    {
+        uint32_t upper;
+        upper = BH_UnicodeUpper(testUnitLower);
+        BH_BenchDoNotOptimize(upper);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf8Ascii)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf8(utf8_a, 1, &testUnitLower);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitLower);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf8Latin1)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf8(utf8_e_acute, 2, &testUnitLatin1);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitLatin1);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf8BMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf8(utf8_snowman, 3, &testUnitBMP);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitBMP);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf8SMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf8(utf8_grin, 4, &testUnitSMP);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitSMP);
+    }
+}
+
+
+BH_BENCH_TEST(EncodeUtf8Ascii)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeEncodeUtf8(testUnitLower, buffer);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(buffer);
+    }
+}
+
+
+BH_BENCH_TEST(EncodeUtf8Latin1)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeEncodeUtf8(testUnitLatin1, buffer);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(buffer);
+    }
+}
+
+
+BH_BENCH_TEST(EncodeUtf8BMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeEncodeUtf8(testUnitBMP, buffer);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(buffer);
+    }
+}
+
+
+BH_BENCH_TEST(EncodeUtf8SMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeEncodeUtf8(testUnitSMP, buffer);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(buffer);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf16LEAscii)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf16LE(utf16_a_le, 2, &testUnitLower);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitLower);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf16LELatin1)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf16LE(utf16_e_acute_le, 2, &testUnitLatin1);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitLatin1);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf16LEBMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf16LE(utf16_snowman_le, 2, &testUnitBMP);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitBMP);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf16LESMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf16LE(utf16_grin_le, 4, &testUnitSMP);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitSMP);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf16BEAscii)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf16BE(utf16_a_be, 2, &testUnitLower);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitLower);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf16BESMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf16BE(utf16_grin_be, 4, &testUnitSMP);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitSMP);
+    }
+}
+
+
+BH_BENCH_TEST(EncodeUtf16LEAscii)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeEncodeUtf16LE(testUnitLower, buffer);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(buffer);
+    }
+}
+
+
+BH_BENCH_TEST(EncodeUtf16LESMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeEncodeUtf16LE(testUnitSMP, buffer);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(buffer);
+    }
+}
+
+
+BH_BENCH_TEST(EncodeUtf16BEAscii)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeEncodeUtf16BE(testUnitLower, buffer);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(buffer);
+    }
+}
+
+
+BH_BENCH_TEST(EncodeUtf16BESMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeEncodeUtf16BE(testUnitSMP, buffer);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(buffer);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf32LEAscii)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf32LE(utf32_a_le, 4, &testUnitLower);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitLower);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf32LESMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf32LE(utf32_grin_le, 4, &testUnitSMP);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitSMP);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf32BEAscii)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf32BE(utf32_a_be, 4, &testUnitLower);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitLower);
+    }
+}
+
+
+BH_BENCH_TEST(DecodeUtf32BESMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeDecodeUtf32BE(utf32_grin_be, 4, &testUnitSMP);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(testUnitSMP);
+    }
+}
+
+
+BH_BENCH_TEST(EncodeUtf32LEAscii)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeEncodeUtf32LE(testUnitLower, buffer);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(buffer);
+    }
+}
+
+
+BH_BENCH_TEST(EncodeUtf32LESMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeEncodeUtf32LE(testUnitSMP, buffer);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(buffer);
+    }
+}
+
+
+BH_BENCH_TEST(EncodeUtf32BEAscii)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeEncodeUtf32BE(testUnitLower, buffer);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(buffer);
+    }
+}
+
+
+BH_BENCH_TEST(EncodeUtf32BESMP)
+{
+    while (BH_BenchIter(state))
+    {
+        result = BH_UnicodeEncodeUtf32BE(testUnitSMP, buffer);
+        BH_BenchDoNotOptimize(result);
+        BH_BenchDoNotOptimize(buffer);
+    }
+}
+
+
+int main(int argc, char **argv)
+{
+    BH_UNUSED(argc);
+    BH_UNUSED(argv);
+
+    BH_BENCH_ADD(Lower);
+    BH_BENCH_ADD(Upper);
+    BH_BENCH_ADD(DecodeUtf8Ascii);
+    BH_BENCH_ADD(DecodeUtf8Latin1);
+    BH_BENCH_ADD(DecodeUtf8BMP);
+    BH_BENCH_ADD(DecodeUtf8SMP);
+    BH_BENCH_ADD(EncodeUtf8Ascii);
+    BH_BENCH_ADD(EncodeUtf8Latin1);
+    BH_BENCH_ADD(EncodeUtf8BMP);
+    BH_BENCH_ADD(EncodeUtf8SMP);
+    BH_BENCH_ADD(DecodeUtf16LEAscii);
+    BH_BENCH_ADD(DecodeUtf16LELatin1);
+    BH_BENCH_ADD(DecodeUtf16LEBMP);
+    BH_BENCH_ADD(DecodeUtf16LESMP);
+    BH_BENCH_ADD(DecodeUtf16BEAscii);
+    BH_BENCH_ADD(DecodeUtf16BESMP);
+    BH_BENCH_ADD(EncodeUtf16LEAscii);
+    BH_BENCH_ADD(EncodeUtf16LESMP);
+    BH_BENCH_ADD(EncodeUtf16BEAscii);
+    BH_BENCH_ADD(EncodeUtf16BESMP);
+    BH_BENCH_ADD(DecodeUtf32LEAscii);
+    BH_BENCH_ADD(DecodeUtf32LESMP);
+    BH_BENCH_ADD(DecodeUtf32BEAscii);
+    BH_BENCH_ADD(DecodeUtf32BESMP);
+    BH_BENCH_ADD(EncodeUtf32LEAscii);
+    BH_BENCH_ADD(EncodeUtf32LESMP);
+    BH_BENCH_ADD(EncodeUtf32BEAscii);
+    BH_BENCH_ADD(EncodeUtf32BESMP);
+
+    return BH_BenchRun();
+}