WIP: CPU compute coverage (shader-slang#1030)

* Add support for '=' when defining a name in test.

* Add support for  double intrinsics.

* Add support for asdouble
Add findOrAddInst - used instead of findOrEmitHoistableInst, for nominal instructions.
Support cloning of string literals.
C++ working on more compute tests.

* Constant buffer support in reflection.
Fixed debugging into source for generated C++.
buffer-layout.slang works.

* Added cpu test result.

* Remove some commented out code.
Comment on next fixes.

* Improvements to reflection CPU code.

* C++ working with ByteAddressBuffer.

* Enabled more compute tests for CPU.

* Enabled more compute tests on CPU.
Added support for [] style access to a vector.

* Enabled more CPU compute tests.

* Handling of buffer-type-splitting.slang
Named buffers can be paths to resources

* Fix some warnings, remove some dead code.

* Fix problem with verification of number of operands for asuint/asint as they can have 1 or 3 operands. asdouble takes 2.

* Fix handling in MemoryArena around aligned allocations. That _allocateAlignedFromNewBlock assumed the block allocated has the aligment that was requested and so did not correct the start address.

Author: jsmall-zzz

prelude/slang-cpp-scalar-intrinsics.h

@@ -20,6 +20,13 @@ union Union32
     float f;
 };
 
+union Union64
+{
+    uint64_t u;
+    int64_t i;
+    double d;
+};
+
 // Helpers
 SLANG_FORCE_INLINE float F32_calcSafeRadians(float radians)
 {
@@ -112,10 +119,6 @@ SLANG_FORCE_INLINE double F64_lerp(double x, double y, double s) { return x + s
 SLANG_FORCE_INLINE double F64_clamp(double x, double min, double max) { return (x < min) ? min : ((x > max) ? max : x); }
 SLANG_FORCE_INLINE void F64_sincos(double f, double& outSin, double& outCos) { outSin = F64_sin(f); outCos = F64_cos(f); }
 
-// TODO!
-//uint32_t F64_asuint(float f);
-//int32_t F64_asint(float f);
-
 // ----------------------------- I32 -----------------------------------------
 
 SLANG_FORCE_INLINE int32_t I32_abs(int32_t f) { return (f < 0) ? -f : f; }
@@ -126,7 +129,13 @@ SLANG_FORCE_INLINE int32_t I32_max(int32_t a, int32_t b) { return a > b ? a : b;
 SLANG_FORCE_INLINE int32_t I32_clamp(int32_t x, int32_t min, int32_t max) { return ( x < min) ? min : ((x > max) ? max : x); }
 
 SLANG_FORCE_INLINE float I32_asfloat(int32_t x) { Union32 u; u.i = x; return u.f; }
-SLANG_FORCE_INLINE uint32_t I32_asuint(int32_t x) { return uint32_t(x); } 
+SLANG_FORCE_INLINE uint32_t I32_asuint(int32_t x) { return uint32_t(x); }
+SLANG_FORCE_INLINE double I32_asdouble(int32_t low, int32_t hi )
+{
+    Union64 u;
+    u.i = (int64_t(hi) << 32) | low;
+    return u.d;
+}
 
 // ----------------------------- U32 -----------------------------------------
 
@@ -140,6 +149,32 @@ SLANG_FORCE_INLINE uint32_t U32_clamp(uint32_t x, uint32_t min, uint32_t max) {
 SLANG_FORCE_INLINE float U32_asfloat(uint32_t x) { Union32 u; u.u = x; return u.f; }
 SLANG_FORCE_INLINE uint32_t U32_asint(int32_t x) { return uint32_t(x); } 
 
+SLANG_FORCE_INLINE double U32_asdouble(uint32_t low, uint32_t hi)
+{
+    Union64 u;
+    u.u = (uint64_t(hi) << 32) | low;
+    return u.d;
+}
+
+// ----------------------------- F64 -----------------------------------------
+
+SLANG_FORCE_INLINE void F64_asuint(double d, uint32_t& low, uint32_t& hi)
+{
+    Union64 u;
+    u.d = d;
+    low = uint32_t(u.u);
+    hi = uint32_t(u.u >> 32);
+}
+
+SLANG_FORCE_INLINE void F64_asint(double d, int32_t& low, uint32_t& hi)
+{
+    Union64 u;
+    u.d = d;
+    low = int32_t(u.u);
+    hi = int32_t(u.u >> 32);
+}
+
+
 #ifdef SLANG_PRELUDE_NAMESPACE
 } 
 #endif

source/core/slang-memory-arena.cpp

@@ -42,19 +42,19 @@ void MemoryArena::_initialize(size_t blockPayloadSize, size_t alignment)
     // Ensure it's alignment is at least kMinAlignment 
     alignment = (alignment < kMinAlignment) ? kMinAlignment : alignment;
 
+    const size_t alignMask = alignment - 1;
+
+    // Make sure the payload is rounded up to the alignment
+    blockPayloadSize = (blockPayloadSize + alignMask) & ~alignMask;
+
     m_blockPayloadSize = blockPayloadSize;
-    size_t blockAllocSize = blockPayloadSize;
 
     // If alignment required is larger then the backing allocators then
     // make larger to ensure when alignment correction takes place it will be aligned
-    if (alignment > kMinAlignment)
-    {
-        blockAllocSize += alignment;
-    }
-
+    const size_t blockAllocSize = (alignment > kMinAlignment) ? (blockPayloadSize + alignment) : blockPayloadSize;
+    
     m_blockAllocSize = blockAllocSize;
     m_blockAlignment = alignment;
-
     m_availableBlocks = nullptr;
 
     m_blockFreeList.init(sizeof(Block), sizeof(void*), 16);
@@ -217,12 +217,17 @@ MemoryArena::Block* MemoryArena::_newNormalBlock()
         return block;
     }
 
-    return _newBlock(m_blockAllocSize, m_blockAlignment);
+    Block* block = _newBlock(m_blockAllocSize, m_blockAlignment);
+    // Check that every normal block has m_blockPayloadSize space
+    assert(size_t(block->m_end - block->m_start) >= m_blockPayloadSize);
+    return block;
 }
 
 MemoryArena::Block* MemoryArena::_newBlock(size_t allocSize, size_t alignment)
 {
     assert(alignment >= m_blockAlignment);
+    // Alignment must be a power of 2
+    assert(((alignment - 1) & alignment) == 0);
 
     // Allocate block
     Block* block = (Block*)m_blockFreeList.allocate();
@@ -289,9 +294,10 @@ void* MemoryArena::_allocateAlignedFromNewBlock(size_t size, size_t alignment)
     //
     // An improvement might be to have some abstraction that sits on top that can do this tracking (or have the blocks
     // themselves record if they alias over a previously used block - but we don't bother with this here.
-    if (allocSize > m_blockAllocSize)
+    // If the alignment is greater than regular alignment we need to handle specially
+    if (allocSize > m_blockPayloadSize || (alignment > m_blockAlignment && allocSize + alignment > m_blockPayloadSize)) 
     {
-        // This is an odd-sized block so just allocate the whole thing
+        // This is an odd-sized block so just allocate the whole thing.
         block = _newBlock(allocSize, alignment);
     }
     else
@@ -310,10 +316,11 @@ void* MemoryArena::_allocateAlignedFromNewBlock(size_t size, size_t alignment)
     // Make the current block 
     _addCurrentBlock(block);
 
-    // Allocated memory is just the start of this block
-    uint8_t* memory = m_current;
-    // It must already be aligned
-    assert((size_t(m_current) & alignMask) == 0);
+    // Align the memory    
+    uint8_t* memory = (uint8_t*)((size_t(m_current) + alignMask) & ~alignMask);
+
+    // It must be aligned
+    assert((size_t(memory) & alignMask) == 0);
 
     // Do the aligned allocation (which must fit) by aligning the pointer
     // It must fit if the previous code is correct...

source/core/slang-token-reader.h

@@ -189,6 +189,15 @@ namespace Slang
         {
             tokenPtr -= count;
         }
+        Token ReadMatchingToken(TokenType type)
+        {
+            auto token = ReadToken();
+            if (token.Type != type)
+            {
+                throw TextFormatException("Text parsing error: unexpected token.");
+            }
+            return token;
+        }
         Token ReadToken()
         {
             if (tokenPtr < (int)tokens.getCount())

source/slang/slang-compiler.cpp

@@ -1529,6 +1529,11 @@ SlangResult dissassembleDXILUsingDXC(
             sharedLib->m_temporaryFileSet = productFileSet;
             productFileSet.clear();
 
+            // Copy the paths in the temporary file set
+            // We particularly want to do this to keep the source
+            sharedLib->m_temporaryFileSet.add(temporaryFileSet.m_paths);
+            temporaryFileSet.clear();
+
             // Output the shared library
             outSharedLib = sharedLib;
         }