diff options
| -rw-r--r-- | bench/tests/BenchColor.c | 292 | ||||
| -rw-r--r-- | bench/tests/BenchUnicode.c | 381 |
2 files changed, 673 insertions, 0 deletions
diff --git a/bench/tests/BenchColor.c b/bench/tests/BenchColor.c new file mode 100644 index 0000000..b34fb91 --- /dev/null +++ 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(); +} diff --git a/bench/tests/BenchUnicode.c b/bench/tests/BenchUnicode.c new file mode 100644 index 0000000..ec6fc25 --- /dev/null +++ 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(); +} |