First pass support for half on vk (shader-slang#912)

* Look at getting half to work on vk.

* Alter half test so can always produce consistent test results.

* First pass working half on vk.

* Improve comments for vulkan extensions around half.

* Upgraded vulkan headers to v1.1.103

https://github.com/KhronosGroup/Vulkan-Headers

* * Add getFeatures on Render interface
* Vulkan renderer determines at startup if it can support half
* Parse render-features on render-test

* Small changes to half-calc.slang test.

* Structured buffer half access works as expected for Vk, but isn't for dx12, so disable for now.

* Require the half feature for renderers for the half-structured-buffer.slang test.

* * Added ToolReturnCode to be more rigerous about how a return code is passed back from a tool
* Added support for a tool being able to pass back an 'ignored' result.
* Used enum codes to indicate meanings
* Made spawnAndWait return a ToolReturnCode

* Ignore tests that don't have required render-feature

* Fix macro line continuation usage.

* Check dx12 has half support.

* Checking for half on dx12 - if CheckFeatureSupport fails, don't fail renderer initialization.

* Fix typo.

Author: jsmall-zzz

source/slang/emit.cpp

@@ -47,6 +47,8 @@ struct ExtensionUsageTracker
     StringBuilder glslExtensionRequireLines;
 
     ProfileVersion profileVersion = ProfileVersion::GLSL_110;
+
+    bool hasHalfExtension = false;
 };
 
 void requireGLSLExtension(
@@ -76,6 +78,21 @@ void requireGLSLVersionImpl(
     }
 }
 
+void requireGLSLHalfExtension(ExtensionUsageTracker* tracker)
+{
+    if (!tracker->hasHalfExtension)
+    {
+        // https://github.com/KhronosGroup/GLSL/blob/master/extensions/ext/GL_EXT_shader_16bit_storage.txt
+        requireGLSLExtension(tracker, "GL_EXT_shader_16bit_storage");
+
+        // https://github.com/KhronosGroup/GLSL/blob/master/extensions/ext/GL_EXT_shader_explicit_arithmetic_types.txt
+        // Use GL_KHX_shader_explicit_arithmetic_types because that is what appears defined in glslang 
+        requireGLSLExtension(tracker, "GL_KHX_shader_explicit_arithmetic_types");
+        
+        tracker->hasHalfExtension = true;
+    }
+}
+
 
 // Shared state for an entire emit session
 struct SharedEmitContext
@@ -810,7 +827,12 @@ struct EmitVisitor
 
         case kIROp_BoolType:    Emit("b");		break;
 
-        case kIROp_HalfType:    Emit("f16");		break;
+        case kIROp_HalfType:
+        {
+            _requireHalf();
+            Emit("f16");
+            break;
+        }
         case kIROp_DoubleType:  Emit("d");		break;
 
         case kIROp_VectorType:
@@ -1197,6 +1219,14 @@ struct EmitVisitor
         }
     }
 
+    void _requireHalf()
+    {
+        if (getTarget(context) == CodeGenTarget::GLSL)
+        {
+            requireGLSLHalfExtension(&context->shared->extensionUsageTracker);
+        }
+    }
+
     void emitSimpleTypeImpl(IRType* type)
     {
         switch (type->op)
@@ -1217,7 +1247,19 @@ struct EmitVisitor
         case kIROp_UIntType:    Emit("uint");       return;
         case kIROp_UInt64Type:  Emit("uint64_t");   return;
 
-        case kIROp_HalfType:    Emit("half");       return;
+        case kIROp_HalfType:
+        {
+            _requireHalf();
+            if (getTarget(context) == CodeGenTarget::GLSL)
+            {
+                Emit("float16_t");
+            }
+            else
+            {
+                Emit("half");
+            }
+            return;
+        }
         case kIROp_FloatType:   Emit("float");      return;
         case kIROp_DoubleType:  Emit("double");     return;
 

tests/compute/half-calc.slang

@@ -0,0 +1,32 @@
+//TEST(compute):COMPARE_COMPUTE:-dx12 -compute -use-dxil -profile cs_6_2 -render-features half
+//TEST(compute):COMPARE_COMPUTE:-vk -compute -use-dxil -profile cs_6_2 -render-features half
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):dxbinding(0),glbinding(0),out
+
+// Test for doing a calculation using half
+
+RWStructuredBuffer<float> outputBuffer;
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    uint tid = dispatchThreadID.x;
+    
+    //half2 v0 = { 1, -2 };
+    //half2 v1 = { -2, 4 };
+    
+    //half2 v2 = (v0 * 2.0f + v1);
+    
+    // This should work (it compiles on dxc, but slang doesn't seem to have overloads yet)
+    //half offset = length(v2);
+    
+    //half offset = v2.x + v2.y;
+    
+    half offset = 0.0f;
+    
+    half v = tid;
+    v *= half(3.0f);
+    v += half(1.0f);
+    v += offset;
+    
+    outputBuffer[tid] = v;
+}

tests/compute/half-calc.slang.expected.txt

@@ -0,0 +1,4 @@
+3F800000
+40800000
+40E00000
+41200000

tests/compute/half-structured-buffer.slang

@@ -0,0 +1,30 @@
+//TEST(compute):COMPARE_COMPUTE:-vk -compute -profile cs_6_2 -render-features half
+//Disable on Dx12 for now - because writing to structured buffer produces unexpected results
+//DISABLE_TEST(compute):COMPARE_COMPUTE:-dx12 -compute -use-dxil -profile cs_6_2 -render-features half
+//TEST_INPUT:ubuffer(data=[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0], stride=16):dxbinding(0),glbinding(0),out
+
+struct Thing
+{
+    uint pos;
+    float radius;
+    half4 color;
+};
+
+RWStructuredBuffer<Thing> outputBuffer;
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    uint tid = dispatchThreadID.x;
+    
+    float v = float(tid);
+    
+    float base = v* 4.0f;
+    
+    Thing thing;
+    thing.pos = tid;
+    thing.color = half4(base, base + 1.0f, base + 2.0f, base + 3.0f);    
+    thing.radius = v;
+    
+    outputBuffer[tid] = thing;
+}

tests/compute/half-structured-buffer.slang.expected.txt

@@ -0,0 +1,16 @@
+0
+0
+3C000000
+42004000
+1
+3F800000
+45004400
+47004600
+2
+40000000
+48804800
+49804900
+3
+40400000
+4A804A00
+4B804B00

tools/gfx/render-d3d11.cpp

@@ -54,6 +54,7 @@ class D3D11Renderer : public Renderer
 
     // Renderer    implementation
     virtual SlangResult initialize(const Desc& desc, void* inWindowHandle) override;
+    virtual const List<String>& getFeatures() override { return m_features; }
     virtual void setClearColor(const float color[4]) override;
     virtual void clearFrame() override;
     virtual void presentFrame() override;
@@ -329,6 +330,8 @@ class D3D11Renderer : public Renderer
     Desc m_desc;
 
     float m_clearColor[4] = { 0, 0, 0, 0 };
+
+    List<String> m_features;
 };
 
 Renderer* createD3D11Renderer()

tools/gfx/render-d3d12.cpp

@@ -55,6 +55,7 @@ class D3D12Renderer : public Renderer
 public:
     // Renderer    implementation
     virtual SlangResult initialize(const Desc& desc, void* inWindowHandle) override;
+    virtual const List<String>& getFeatures() override { return m_features; }
     virtual void setClearColor(const float color[4]) override;
     virtual void clearFrame() override;
     virtual void presentFrame() override;
@@ -571,6 +572,8 @@ class D3D12Renderer : public Renderer
     PFN_D3D12_SERIALIZE_ROOT_SIGNATURE m_D3D12SerializeRootSignature = nullptr;
 
     HWND m_hwnd = nullptr;
+
+    List<String> m_features;
 };
 
 Renderer* createD3D12Renderer()
@@ -1397,6 +1400,8 @@ Result D3D12Renderer::initialize(const Desc& desc, void* inWindowHandle)
         return SLANG_FAIL;
     }
 
+
+
     FlagCombiner combiner;
     // TODO: we should probably provide a command-line option
     // to override UseDebug of default rather than leave it
@@ -1426,6 +1431,22 @@ Result D3D12Renderer::initialize(const Desc& desc, void* inWindowHandle)
         return SLANG_FAIL;
     }
 
+    // Find what features are supported
+    {
+        // Check this is how this is laid out...
+        SLANG_COMPILE_TIME_ASSERT(D3D_SHADER_MODEL_6_0 == 0x60);
+
+        D3D12_FEATURE_DATA_SHADER_MODEL featureShaderMode;
+        featureShaderMode.HighestShaderModel = D3D_SHADER_MODEL(0x62);
+
+        if (SLANG_SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_SHADER_MODEL, &featureShaderMode, sizeof(featureShaderMode))) &&
+            featureShaderMode.HighestShaderModel >= 0x62)
+        {
+            // With sm_6_2 we have half
+            m_features.Add("half");
+        }
+    }
+
     m_numRenderFrames = 3;
     m_numRenderTargets = 2;
 

tools/gfx/render-gl.cpp

@@ -81,6 +81,7 @@ class GLRenderer : public Renderer
 
     // Renderer    implementation
     virtual SlangResult initialize(const Desc& desc, void* inWindowHandle) override;
+    virtual const List<String>& getFeatures() override { return m_features; }
     virtual void setClearColor(const float color[4]) override;
     virtual void clearFrame() override;
     virtual void presentFrame() override;
@@ -354,6 +355,8 @@ class GLRenderer : public Renderer
 
     Desc m_desc;
 
+    List<String> m_features;
+
     // Declare a function pointer for each OpenGL
     // extension function we need to load
 #define DECLARE_GL_EXTENSION_FUNC(NAME, TYPE) TYPE NAME;

tools/gfx/render-vk.cpp

@@ -42,6 +42,7 @@ class VKRenderer : public Renderer
 
     // Renderer    implementation
     virtual SlangResult initialize(const Desc& desc, void* inWindowHandle) override;
+    virtual const List<String>& getFeatures() override { return m_features; }
     virtual void setClearColor(const float color[4]) override;
     virtual void clearFrame() override;
     virtual void presentFrame() override;
@@ -488,6 +489,7 @@ class VKRenderer : public Renderer
     float m_clearColor[4] = { 0, 0, 0, 0 };
 
     Desc m_desc;
+    List<String> m_features;
 };
 
 /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! VkRenderer::Buffer !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
@@ -898,6 +900,8 @@ SlangResult VKRenderer::initialize(const Desc& desc, void* inWindowHandle)
     {
         VK_KHR_SURFACE_EXTENSION_NAME,
 
+        VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
+
 #if SLANG_WINDOWS_FAMILY
         VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
 #else
@@ -949,6 +953,71 @@ SlangResult VKRenderer::initialize(const Desc& desc, void* inWindowHandle)
 
     SLANG_RETURN_ON_FAIL(m_api.initPhysicalDevice(physicalDevices[selectedDeviceIndex]));
 
+    List<const char*> deviceExtensions;
+    deviceExtensions.Add(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+    VkDeviceCreateInfo deviceCreateInfo = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
+    deviceCreateInfo.queueCreateInfoCount = 1;
+    
+    deviceCreateInfo.pEnabledFeatures = &m_api.m_deviceFeatures;
+
+    // Get the device features (doesn't use, but useful when debugging)
+    if (m_api.vkGetPhysicalDeviceFeatures2)
+    {
+        VkPhysicalDeviceFeatures2 deviceFeatures2 = {};
+        deviceFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+        m_api.vkGetPhysicalDeviceFeatures2(m_api.m_physicalDevice, &deviceFeatures2);
+    }
+
+    VkPhysicalDeviceProperties basicProps = {};
+    m_api.vkGetPhysicalDeviceProperties(m_api.m_physicalDevice, &basicProps);
+
+    // Get the API version
+    const uint32_t majorVersion = VK_VERSION_MAJOR(basicProps.apiVersion);
+    const uint32_t minorVersion = VK_VERSION_MINOR(basicProps.apiVersion);
+
+    // Float16 features
+    // Need in this scope because it will be linked into the device creation (if it is available)
+    VkPhysicalDeviceFloat16Int8FeaturesKHR float16Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR };
+
+    // API version check, can't use vkGetPhysicalDeviceProperties2 yet since this device might not support it
+    if (VK_MAKE_VERSION(majorVersion, minorVersion, 0) >= VK_API_VERSION_1_1 &&
+        m_api.vkGetPhysicalDeviceProperties2 &&
+        m_api.vkGetPhysicalDeviceFeatures2)
+    {
+        VkPhysicalDeviceProperties2 physicalDeviceProps2;
+
+        physicalDeviceProps2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+        physicalDeviceProps2.pNext = nullptr;
+        physicalDeviceProps2.properties = {};
+
+        m_api.vkGetPhysicalDeviceProperties2(m_api.m_physicalDevice, &physicalDeviceProps2);
+
+        // Get device features
+        VkPhysicalDeviceFeatures2 deviceFeatures2 = {};
+        deviceFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+
+        // Link together for lookup 
+        float16Features.pNext = deviceFeatures2.pNext;
+        deviceFeatures2.pNext = &float16Features;
+
+        m_api.vkGetPhysicalDeviceFeatures2(m_api.m_physicalDevice, &deviceFeatures2);
+
+        // If we have float16 features then enable
+        if (float16Features.shaderFloat16)
+        {
+            // Link into the creation features
+            float16Features.pNext = (void*)deviceCreateInfo.pNext;
+            deviceCreateInfo.pNext = &float16Features;
+
+            // Add the Float16 extension
+            deviceExtensions.Add(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME);
+
+            // We have half support
+            m_features.Add("half");
+        }   
+    }
+
     int queueFamilyIndex = m_api.findQueue(VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT);
     assert(queueFamilyIndex >= 0);
 
@@ -958,18 +1027,10 @@ SlangResult VKRenderer::initialize(const Desc& desc, void* inWindowHandle)
     queueCreateInfo.queueCount = 1;
     queueCreateInfo.pQueuePriorities = &queuePriority;
 
-    char const* const deviceExtensions[] =
-    {
-        VK_KHR_SWAPCHAIN_EXTENSION_NAME,
-    };
-
-    VkDeviceCreateInfo deviceCreateInfo = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
-    deviceCreateInfo.queueCreateInfoCount = 1;
     deviceCreateInfo.pQueueCreateInfos = &queueCreateInfo;
-    deviceCreateInfo.pEnabledFeatures = &m_api.m_deviceFeatures;
 
-    deviceCreateInfo.enabledExtensionCount = SLANG_COUNT_OF(deviceExtensions);
-    deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions;
+    deviceCreateInfo.enabledExtensionCount = uint32_t(deviceExtensions.Count());
+    deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions.Buffer();
 
     SLANG_VK_RETURN_ON_FAIL(m_api.vkCreateDevice(m_api.m_physicalDevice, &deviceCreateInfo, nullptr, &m_device));
     SLANG_RETURN_ON_FAIL(m_api.initDeviceProcs(m_device));

tools/gfx/render.h

@@ -785,6 +785,9 @@ class Renderer: public Slang::RefObject
 
     virtual SlangResult initialize(const Desc& desc, void* inWindowHandle) = 0;
 
+    bool hasFeature(const Slang::UnownedStringSlice& feature) { return getFeatures().IndexOf(Slang::String(feature)) != UInt(-1); }
+    virtual const Slang::List<Slang::String>& getFeatures() = 0;
+
     virtual void setClearColor(const float color[4]) = 0;
     virtual void clearFrame() = 0;
 

tools/gfx/vk-api.cpp

@@ -49,11 +49,15 @@ Slang::Result VulkanApi::initInstanceProcs(VkInstance instance)
 
     VK_API_ALL_INSTANCE_PROCS(VK_API_GET_INSTANCE_PROC)
 
+    // Get optional 
+    VK_API_INSTANCE_PROCS_OPT(VK_API_GET_INSTANCE_PROC)
+
     if (!areDefined(ProcType::Instance))
     {
         return SLANG_FAIL;
     }
 
+
     m_instance = instance;
     return SLANG_OK;
 }