From 7ea9ff03f4fc766f21d5896aea220d17f236dd70 Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Tue, 9 Oct 2018 11:51:41 -0400 Subject: Feature/var byte encoding (#665) * * Remove the need for IRHighLevelDecoration in Emit * Use the IRLayoutDecoration for GeometryShaderPrimitiveTypeModifier * Initial look at at variable byte encoding, and simple unit test. * Fixing problems with comparison due to naming differences with slang/fxc. * * More tests and perf improvements for byte encoding. * Mechanism to detect processor and processor features in main slang header. * Split out cpu based defines into slang-cpu-defines.h so do not polute slang.h * Support for variable byte encoding on serialization. * Removed unused flag. * Fix warning. * Fix calcMsByte32 for 0 values without using intrinsic. * Fix a mistake in calculating maximum instruction size. --- tools/slang-test/unit-test-byte-encode.cpp | 142 +++++++++++++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 tools/slang-test/unit-test-byte-encode.cpp (limited to 'tools/slang-test/unit-test-byte-encode.cpp') diff --git a/tools/slang-test/unit-test-byte-encode.cpp b/tools/slang-test/unit-test-byte-encode.cpp new file mode 100644 index 000000000..c0944b27d --- /dev/null +++ b/tools/slang-test/unit-test-byte-encode.cpp @@ -0,0 +1,142 @@ +// unit-test-byte-encode.cpp + +#include "../../source/core/slang-byte-encode-util.h" + +#include +#include +#include + +#include "test-context.h" + +#include "../../source/core/slang-random-generator.h" +#include "../../source/core/list.h" + +using namespace Slang; + +static void checkUInt32(uint32_t value) +{ + uint8_t buffer[ByteEncodeUtil::kMaxLiteEncodeUInt32 + 1]; + + int writeLen = ByteEncodeUtil::encodeLiteUInt32(value, buffer); + buffer[writeLen] = 0xcd; + + uint32_t decode; + int readLen = ByteEncodeUtil::decodeLiteUInt32(buffer, &decode); + + SLANG_CHECK(readLen == writeLen && decode == value); +} + +static void byteEncodeUnitTest() +{ + DefaultRandomGenerator randGen(0x5346536a); + + { + SLANG_CHECK(ByteEncodeUtil::calcMsb8(0) == -1); + SLANG_CHECK(ByteEncodeUtil::calcMsb8(1) == 0); + SLANG_CHECK(ByteEncodeUtil::calcMsb8(0x81) == 7); + } + + { + SLANG_CHECK(ByteEncodeUtil::calcMsb32(0) == -1); + SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x81) == 7); + SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00000001) == 0); + SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00000081) == 7); + SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00000181) == 8); + SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00008181) == 15); + SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00018181) == 16); + SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x00818181) == 23); + SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x01818181) == 24); + SLANG_CHECK(ByteEncodeUtil::calcMsb32(0x81818181) == 31); + SLANG_CHECK(ByteEncodeUtil::calcMsb32(0xffffffff) == 31); + } + + { + SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00000000) == -1); + SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00000001) == 0); + SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00000081) == 0); + SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00000181) == 1); + SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00008181) == 1); + SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00018181) == 2); + SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x00818181) == 2); + SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x01818181) == 3); + SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0x81818181) == 3); + SLANG_CHECK(ByteEncodeUtil::calcMsByte32(0xffffffff) == 3); + } + + { + SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00000001) == 0); + SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00000081) == 0); + SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00000181) == 1); + SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00008181) == 1); + SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00018181) == 2); + SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x00818181) == 2); + SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x01818181) == 3); + SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0x81818181) == 3); + SLANG_CHECK(ByteEncodeUtil::calcNonZeroMsByte32(0xffffffff) == 3); + } + + { + const int blockSize = 1024; + + List encodedBuffer; + encodedBuffer.SetSize(ByteEncodeUtil::kMaxLiteEncodeUInt32 * blockSize); + + List initialBuffer; + initialBuffer.SetSize(blockSize); + List decodeBuffer; + decodeBuffer.SetSize(blockSize); + // Put in cache? + memset(decodeBuffer.begin(), 0, blockSize * sizeof(uint32_t)); + + for (int i = 0; i < blockSize; i++) + { + const int v = ByteEncodeUtil::calcMsb8(uint32_t((randGen.nextInt32() & 0xf) | 1)); + + // Make the commonality of different numbers that bytes are most common, then shorts etc.. + uint32_t mask; + switch (v) + { + case 0: mask = 0xffffffff; break; + case 1: mask = 0x00ffffff; break; + case 2: mask = 0x0000ffff; break; + case 3: mask = 0x000000ff; break; + } + + initialBuffer[i] = randGen.nextInt32() & mask; + } + + size_t numEncodeBytes = ByteEncodeUtil::encodeLiteUInt32(initialBuffer.begin(), blockSize, encodedBuffer.begin()); + + SLANG_CHECK(ByteEncodeUtil::calcEncodeLiteSizeUInt32(initialBuffer.begin(), blockSize) == numEncodeBytes); + + size_t numEncodeBytes2 = ByteEncodeUtil::decodeLiteUInt32(encodedBuffer.begin(), blockSize, decodeBuffer.begin()); + + SLANG_CHECK(numEncodeBytes2 == numEncodeBytes); + + SLANG_CHECK(memcmp(decodeBuffer.begin(), initialBuffer.begin(), sizeof(uint32_t) * blockSize) == 0); + } + + { + checkUInt32(uint32_t(0)); + checkUInt32(uint32_t(0x7fffff)); + checkUInt32(uint32_t(0x7fff)); + checkUInt32(uint32_t(0x7f)); + checkUInt32(uint32_t(0x7fffffff)); + checkUInt32(uint32_t(0xffffffff)); + +#if 1 + for (int64_t i = 0; i < SLANG_INT64(0x100000000); i += 371) + { + checkUInt32(uint32_t(i)); + } +#else + for (int64_t i = 0; i < SLANG_INT64(0x100000000); i += 1) + { + checkUInt32(uint32_t(i)); + } +#endif + } + +} + +SLANG_UNIT_TEST("ByteEncode", byteEncodeUnitTest); \ No newline at end of file -- cgit v1.2.3