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.

3 files changed, 148 insertions, 2 deletions

diff --git a/tools/slang-test/slang-test.vcxproj b/tools/slang-test/slang-test.vcxproj
index 4987e1ce3..54ea6f342 100644
--- a/tools/slang-test/slang-test.vcxproj
+++ b/tools/slang-test/slang-test.vcxproj
@@ -171,6 +171,7 @@
     <ClCompile Include="os.cpp" />
     <ClCompile Include="render-api-util.cpp" />
     <ClCompile Include="test-context.cpp" />
+    <ClCompile Include="unit-test-byte-encode.cpp" />
     <ClCompile Include="unit-test-free-list.cpp" />
     <ClCompile Include="unit-test-memory-arena.cpp" />
   </ItemGroup>
@@ -182,4 +183,4 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project> 
\ No newline at end of file
+</Project>
\ No newline at end of file
diff --git a/tools/slang-test/slang-test.vcxproj.filters b/tools/slang-test/slang-test.vcxproj.filters
index 4c000ba58..03bb10348 100644
--- a/tools/slang-test/slang-test.vcxproj.filters
+++ b/tools/slang-test/slang-test.vcxproj.filters
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
     <Filter Include="Header Files">
@@ -38,5 +38,8 @@
     <ClCompile Include="unit-test-memory-arena.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="unit-test-byte-encode.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>
\ No newline at end of file
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 <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#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<uint8_t> encodedBuffer;
+        encodedBuffer.SetSize(ByteEncodeUtil::kMaxLiteEncodeUInt32 * blockSize);
+
+        List<uint32_t> initialBuffer;
+        initialBuffer.SetSize(blockSize);
+        List<uint32_t> 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