Add rawBufferLoad/rawBufferStore tests for the compute pipeline (#1763)

* Add rawBufferLoad/rawBufferStore tests for compute pipeline

Covers:
- SRV (Load) and UAV buffers (Load, Store)
- declared in root signature as root values and in a descriptor table
- used as [RW]ByteAddressBuffer and [RW]StructuredBuffer
- data types half, float, double, int16_t, int32_t, int64_t,
- scalar type + vectors with 2 to 4 elements

The 16-bit type tests are temporarily disabled because of a bug in WARP
(set to Priority 2 and not run by hcttest).

The 64-bit type tests are disabled the same way until WARP supports shader
model 6.3.

tools/clang/test/HLSL/ShaderOpArith.xml

@@ -582,19 +582,90 @@
     </Shader>
   </ShaderOp>
 
-  <ShaderOp Name="ComputeRawBufferLdStI32" CS="CS">
-  </ShaderOp>>
-  <ShaderOp Name="ComputeRawBufferLdStFloat" CS="CS">
-  </ShaderOp>>
-  <ShaderOp Name="ComputeRawBufferLdStI64" CS="CS">
-  </ShaderOp>>
-  <ShaderOp Name="ComputeRawBufferLdStDouble" CS="CS">
+  <ShaderOp Name="ComputeRawBufferLdSt32Bit" CS="CS">
+    <RootSignature>RootFlags(0), SRV(t0), SRV(t1), UAV(u0), UAV(u1), DescriptorTable(SRV(t2,numDescriptors=2), UAV(u2,numDescriptors=2))</RootSignature>
+    <Resource Name="SRVBuffer0" Dimension="BUFFER" Width="40"  InitialResourceState="COPY_DEST" Init="ByName" Format="R32_TYPELESS"/>
+    <Resource Name="SRVBuffer1" Dimension="BUFFER" Width="40"  InitialResourceState="COPY_DEST" Init="ByName" />
+    <Resource Name="SRVBuffer2" Dimension="BUFFER" Width="40"  InitialResourceState="COPY_DEST" Init="ByName" Format="R32_TYPELESS"/>
+    <Resource Name="SRVBuffer3" Dimension="BUFFER" Width="40"  InitialResourceState="COPY_DEST" Init="ByName" />
+    <Resource Name="UAVBuffer0" Dimension="BUFFER" Width="120" InitialResourceState="COPY_DEST" Init="ByName" Flags="ALLOW_UNORDERED_ACCESS" TransitionTo="UNORDERED_ACCESS" ReadBack="true" Format="R32_TYPELESS" />
+    <Resource Name="UAVBuffer1" Dimension="BUFFER" Width="120" InitialResourceState="COPY_DEST" Init="ByName" Flags="ALLOW_UNORDERED_ACCESS" TransitionTo="UNORDERED_ACCESS" ReadBack="true" />
+    <Resource Name="UAVBuffer2" Dimension="BUFFER" Width="120" InitialResourceState="COPY_DEST" Init="ByName" Flags="ALLOW_UNORDERED_ACCESS" TransitionTo="UNORDERED_ACCESS" ReadBack="true" Format="R32_TYPELESS" />
+    <Resource Name="UAVBuffer3" Dimension="BUFFER" Width="120" InitialResourceState="COPY_DEST" Init="ByName" Flags="ALLOW_UNORDERED_ACCESS" TransitionTo="UNORDERED_ACCESS" ReadBack="true" />
+    <RootValues>
+      <RootValue Index="0" ResName="SRVBuffer0" />
+      <RootValue Index="1" ResName="SRVBuffer1" />
+      <RootValue Index="2" ResName="UAVBuffer0" />
+      <RootValue Index="3" ResName="UAVBuffer1" />
+      <RootValue Index="4" HeapName="ResHeap" />
+    </RootValues>
+    <DescriptorHeap Name="ResHeap" Type="CBV_SRV_UAV">
+      <Descriptor Name='SRVBuffer2' Kind='SRV' ResName='SRVBuffer2' Flags='RAW' NumElements="10" Format="R32_TYPELESS" />
+      <Descriptor Name='SRVBuffer3' Kind='SRV' ResName='SRVBuffer3' NumElements="1" StructureByteStride="40" />
+      <Descriptor Name='UAVBuffer2' Kind='UAV' ResName='UAVBuffer2' Flags='RAW' NumElements="30" Format="R32_TYPELESS" />
+      <Descriptor Name='UAVBuffer3' Kind='UAV' ResName='UAVBuffer3' NumElements="1" StructureByteStride="120" />
+    </DescriptorHeap>
+    <Shader Name="CS" Target="cs_6_2">
+      <![CDATA[// Shader source code will be set at runtime]]>
+    </Shader>
   </ShaderOp>>
-  <ShaderOp Name="ComputeRawBufferLdStI16" CS="CS">
+  
+  <ShaderOp Name="ComputeRawBufferLdSt64Bit" CS="CS">
+    <RootSignature>RootFlags(0), SRV(t0), SRV(t1), UAV(u0), UAV(u1), DescriptorTable(SRV(t2,numDescriptors=2), UAV(u2,numDescriptors=2))</RootSignature>
+    <Resource Name="SRVBuffer0" Dimension="BUFFER" Width="80"  InitialResourceState="COPY_DEST" Init="ByName" Format="R32_TYPELESS"/>
+    <Resource Name="SRVBuffer1" Dimension="BUFFER" Width="80"  InitialResourceState="COPY_DEST" Init="ByName" />
+    <Resource Name="SRVBuffer2" Dimension="BUFFER" Width="80"  InitialResourceState="COPY_DEST" Init="ByName" Format="R32_TYPELESS"/>
+    <Resource Name="SRVBuffer3" Dimension="BUFFER" Width="80"  InitialResourceState="COPY_DEST" Init="ByName" />
+    <Resource Name="UAVBuffer0" Dimension="BUFFER" Width="240" InitialResourceState="COPY_DEST" Init="ByName" Flags="ALLOW_UNORDERED_ACCESS" TransitionTo="UNORDERED_ACCESS" ReadBack="true" Format="R32_TYPELESS" />
+    <Resource Name="UAVBuffer1" Dimension="BUFFER" Width="240" InitialResourceState="COPY_DEST" Init="ByName" Flags="ALLOW_UNORDERED_ACCESS" TransitionTo="UNORDERED_ACCESS" ReadBack="true" />
+    <Resource Name="UAVBuffer2" Dimension="BUFFER" Width="240" InitialResourceState="COPY_DEST" Init="ByName" Flags="ALLOW_UNORDERED_ACCESS" TransitionTo="UNORDERED_ACCESS" ReadBack="true" Format="R32_TYPELESS" />
+    <Resource Name="UAVBuffer3" Dimension="BUFFER" Width="240" InitialResourceState="COPY_DEST" Init="ByName" Flags="ALLOW_UNORDERED_ACCESS" TransitionTo="UNORDERED_ACCESS" ReadBack="true" />
+    <RootValues>
+      <RootValue Index="0" ResName="SRVBuffer0" />
+      <RootValue Index="1" ResName="SRVBuffer1" />
+      <RootValue Index="2" ResName="UAVBuffer0" />
+      <RootValue Index="3" ResName="UAVBuffer1" />
+      <RootValue Index="4" HeapName="ResHeap" />
+    </RootValues>
+    <DescriptorHeap Name="ResHeap" Type="CBV_SRV_UAV">
+      <Descriptor Name='SRVBuffer2' Kind='SRV' ResName='SRVBuffer2' Flags='RAW' NumElements="20" Format="R32_TYPELESS" />
+      <Descriptor Name='SRVBuffer3' Kind='SRV' ResName='SRVBuffer3' NumElements="1" StructureByteStride="80" />
+      <Descriptor Name='UAVBuffer2' Kind='UAV' ResName='UAVBuffer2' Flags='RAW' NumElements="60" Format="R32_TYPELESS" />
+      <Descriptor Name='UAVBuffer3' Kind='UAV' ResName='UAVBuffer3' NumElements="1" StructureByteStride="240" />
+    </DescriptorHeap>
+    <Shader Name="CS" Target="cs_6_2">
+      <![CDATA[// Shader source code will be set at runtime]]>
+    </Shader>
   </ShaderOp>>
-  <ShaderOp Name="ComputeRawBufferLdStHalf" CS="CS">
+
+  <ShaderOp Name="ComputeRawBufferLdSt16Bit" CS="CS">
+    <RootSignature>RootFlags(0), SRV(t0), SRV(t1), UAV(u0), UAV(u1), DescriptorTable(SRV(t2,numDescriptors=2), UAV(u2,numDescriptors=2))</RootSignature>
+    <Resource Name="SRVBuffer0" Dimension="BUFFER" Width="20" InitialResourceState="COPY_DEST" Init="ByName" Format="R32_TYPELESS"/>
+    <Resource Name="SRVBuffer1" Dimension="BUFFER" Width="20" InitialResourceState="COPY_DEST" Init="ByName" />
+    <Resource Name="SRVBuffer2" Dimension="BUFFER" Width="20" InitialResourceState="COPY_DEST" Init="ByName" Format="R32_TYPELESS"/>
+    <Resource Name="SRVBuffer3" Dimension="BUFFER" Width="20" InitialResourceState="COPY_DEST" Init="ByName" />
+    <Resource Name="UAVBuffer0" Dimension="BUFFER" Width="60" Flags="ALLOW_UNORDERED_ACCESS" InitialResourceState="COPY_DEST" TransitionTo="UNORDERED_ACCESS" Init="ByName" ReadBack="true" Format="R32_TYPELESS" />
+    <Resource Name="UAVBuffer1" Dimension="BUFFER" Width="60" Flags="ALLOW_UNORDERED_ACCESS" InitialResourceState="COPY_DEST" TransitionTo="UNORDERED_ACCESS" Init="ByName" ReadBack="true" />
+    <Resource Name="UAVBuffer2" Dimension="BUFFER" Width="60" Flags="ALLOW_UNORDERED_ACCESS" InitialResourceState="COPY_DEST" TransitionTo="UNORDERED_ACCESS" Init="ByName" ReadBack="true" Format="R32_TYPELESS" />
+    <Resource Name="UAVBuffer3" Dimension="BUFFER" Width="60" Flags="ALLOW_UNORDERED_ACCESS" InitialResourceState="COPY_DEST" TransitionTo="UNORDERED_ACCESS" Init="ByName" ReadBack="true" />
+    <RootValues>
+      <RootValue Index="0" ResName="SRVBuffer0" />
+      <RootValue Index="1" ResName="SRVBuffer1" />
+      <RootValue Index="2" ResName="UAVBuffer0" />
+      <RootValue Index="3" ResName="UAVBuffer1" />
+      <RootValue Index="4" HeapName="ResHeap" />
+    </RootValues>
+    <DescriptorHeap Name="ResHeap" Type="CBV_SRV_UAV">
+      <Descriptor Name='SRVBuffer2' Kind='SRV' ResName='SRVBuffer2' Flags='RAW' NumElements="5" Format="R32_TYPELESS" />
+      <Descriptor Name='SRVBuffer3' Kind='SRV' ResName='SRVBuffer3' NumElements="1" StructureByteStride="20" />
+      <Descriptor Name='UAVBuffer2' Kind='UAV' ResName='UAVBuffer2' Flags='RAW' NumElements="15" Format="R32_TYPELESS" />
+      <Descriptor Name='UAVBuffer3' Kind='UAV' ResName='UAVBuffer3' NumElements="1" StructureByteStride="60" />
+    </DescriptorHeap>
+    <Shader Name="CS" Target="cs_6_2">
+      <![CDATA[// Shader source code will be set at runtime]]>
+    </Shader>
   </ShaderOp>>
-  
+
   <ShaderOp Name="GraphicsRawBufferLdStI32" PS="PS" VS="VS">
   </ShaderOp>
   <ShaderOp Name="GraphicsRawBufferLdStFloat" PS="PS" VS="VS">

tools/clang/unittests/HLSL/ExecutionTest.cpp

@@ -301,7 +301,9 @@ public:
   END_TEST_METHOD()
 
   TEST_METHOD(BasicShaderModel61);
-  TEST_METHOD(BasicShaderModel63);
+  BEGIN_TEST_METHOD(BasicShaderModel63)
+    TEST_METHOD_PROPERTY(L"Priority", L"2") // Remove this line once warp supports this feature in Shader Model 6.3
+  END_TEST_METHOD()
 
   BEGIN_TEST_METHOD(WaveIntrinsicsActiveIntTest)
     TEST_METHOD_PROPERTY(L"DataSource", L"Table:ShaderOpArithTable.xml#WaveIntrinsicsActiveIntTable")
@@ -410,14 +412,31 @@ public:
   
   TEST_METHOD(ComputeRawBufferLdStI32);
   TEST_METHOD(ComputeRawBufferLdStFloat);
-  TEST_METHOD(ComputeRawBufferLdStI64);
-  TEST_METHOD(ComputeRawBufferLdStDouble);
-  TEST_METHOD(ComputeRawBufferLdStI16);
-  TEST_METHOD(ComputeRawBufferLdStHalf);
+
+  BEGIN_TEST_METHOD(ComputeRawBufferLdStI64)
+    TEST_METHOD_PROPERTY(L"Priority", L"2") // Remove this line once warp supports this feature in Shader Model 6.3
+  END_TEST_METHOD()
+  BEGIN_TEST_METHOD(ComputeRawBufferLdStDouble)
+    TEST_METHOD_PROPERTY(L"Priority", L"2") // Remove this line once warp supports this feature in Shader Model 6.3
+  END_TEST_METHOD()
+    
+  BEGIN_TEST_METHOD(ComputeRawBufferLdStI16)
+    TEST_METHOD_PROPERTY(L"Priority", L"2") // This test is disabled because of a bug in WARP; TODO: enable once the bug is fixed
+  END_TEST_METHOD()
+  BEGIN_TEST_METHOD(ComputeRawBufferLdStHalf)
+    TEST_METHOD_PROPERTY(L"Priority", L"2") // This test is disabled because of a bug in WARP; TODO: enable once the bug is fixed
+  END_TEST_METHOD()
+
   TEST_METHOD(GraphicsRawBufferLdStI32);
   TEST_METHOD(GraphicsRawBufferLdStFloat);
-  TEST_METHOD(GraphicsRawBufferLdStI64);
-  TEST_METHOD(GraphicsRawBufferLdStDouble);
+
+  BEGIN_TEST_METHOD(GraphicsRawBufferLdStI64)
+    TEST_METHOD_PROPERTY(L"Priority", L"2") // Remove this line once warp supports this feature in Shader Model 6.3
+  END_TEST_METHOD()
+  BEGIN_TEST_METHOD(GraphicsRawBufferLdStDouble)
+    TEST_METHOD_PROPERTY(L"Priority", L"2") // Remove this line once warp supports this feature in Shader Model 6.3
+  END_TEST_METHOD()
+
   TEST_METHOD(GraphicsRawBufferLdStI16);
   TEST_METHOD(GraphicsRawBufferLdStHalf);
 
@@ -489,7 +508,22 @@ public:
      Half
   };
 
-  void RunRawBufferLdStTest(D3D_SHADER_MODEL shaderModel, RawBufferLdStType dataType, char *shaderOpName = nullptr);
+  template <class Ty>
+  struct RawBufferLdStTestData {
+    Ty v1, v2[2], v3[3], v4[4];
+  };
+
+  template <class Ty>
+  struct RawBufferLdStUavData {
+    RawBufferLdStTestData<Ty> input, output, srvOut;
+  };
+
+  template <class Ty>
+  void RunComputeRawBufferLdStTest(D3D_SHADER_MODEL shaderModel, RawBufferLdStType dataType,
+                            const char *shaderOpName, const RawBufferLdStTestData<Ty> &testData);
+
+  void RunGraphicsRawBufferLdStTest(D3D_SHADER_MODEL shaderModel, RawBufferLdStType dataType,
+                            const char *shaderOpName);
 
   template <class Ty>
   void RunBasicShaderModelTest(CComPtr<ID3D12Device> pDevice, const char *pShaderModelStr, const char *pShader, Ty *pInputDataPairs, unsigned inputDataCount);
@@ -5873,55 +5907,153 @@ TEST_F(ExecutionTest, BarycentricsTest) {
     //SavePixelsToFile(pPixels, DXGI_FORMAT_R32G32B32A32_FLOAT, width, height, L"barycentric.bmp");
 }
 
+static const char RawBufferTestComputeShader[] =
+"// Note: COMPONENT_TYPE and COMPONENT_SIZE will be defined via compiler option -D\r\n"
+"typedef COMPONENT_TYPE scalar; \r\n"
+"typedef vector<COMPONENT_TYPE, 2> vector2; \r\n"
+"typedef vector<COMPONENT_TYPE, 3> vector3; \r\n"
+"typedef vector<COMPONENT_TYPE, 4> vector4; \r\n"
+"\r\n"
+"struct TestData { \r\n"
+"  scalar  v1; \r\n"
+"  vector2 v2; \r\n"
+"  vector3 v3; \r\n"
+"  vector4 v4; \r\n"
+"}; \r\n"
+"\r\n"
+"struct UavData {\r\n"
+"  TestData input; \r\n"
+"  TestData output; \r\n"
+"  TestData srvOut; \r\n"
+"}; \r\n"
+"\r\n"
+"ByteAddressBuffer           srv0 : register(t0); \r\n"
+"StructuredBuffer<TestData>  srv1 : register(t1); \r\n"
+"ByteAddressBuffer           srv2 : register(t2); \r\n"
+"StructuredBuffer<TestData>  srv3 : register(t3); \r\n"
+"\r\n"
+"RWByteAddressBuffer         uav0 : register(u0); \r\n"
+"RWStructuredBuffer<UavData> uav1 : register(u1); \r\n"
+"RWByteAddressBuffer         uav2 : register(u2); \r\n"
+"RWStructuredBuffer<UavData> uav3 : register(u3); \r\n"
+"\r\n"
+"[numthreads(1, 1, 1)]\r\n"
+"void main(uint GI : SV_GroupIndex) {\r\n"
+"\r\n"
+"  // offset of 'out' in 'UavData'\r\n"
+"  const int out_offset = COMPONENT_SIZE * 10; \r\n"
+"\r\n"
+"  // offset of 'srv_out' in 'UavData'\r\n"
+"  const int srv_out_offset = COMPONENT_SIZE * 10 * 2; \r\n"
+"\r\n"
+"  // offsets within the 'Data' struct\r\n"
+"  const int v1_offset = 0; \r\n"
+"  const int v2_offset = COMPONENT_SIZE; \r\n"
+"  const int v3_offset = COMPONENT_SIZE * 3; \r\n"
+"  const int v4_offset = COMPONENT_SIZE * 6; \r\n"
+"\r\n"
+"  uav0.Store(srv_out_offset + v1_offset, srv0.Load<scalar>(v1_offset)); \r\n"
+"  uav0.Store(srv_out_offset + v2_offset, srv0.Load<vector2>(v2_offset)); \r\n"
+"  uav0.Store(srv_out_offset + v3_offset, srv0.Load<vector3>(v3_offset)); \r\n"
+"  uav0.Store(srv_out_offset + v4_offset, srv0.Load<vector4>(v4_offset)); \r\n"
+"\r\n"
+"  uav1[0].srvOut.v1 = srv1[0].v1; \r\n"
+"  uav1[0].srvOut.v2 = srv1[0].v2; \r\n"
+"  uav1[0].srvOut.v3 = srv1[0].v3; \r\n"
+"  uav1[0].srvOut.v4 = srv1[0].v4; \r\n"
+"\r\n"
+"  uav2.Store(srv_out_offset + v1_offset, srv2.Load<scalar>(v1_offset)); \r\n"
+"  uav2.Store(srv_out_offset + v2_offset, srv2.Load<vector2>(v2_offset)); \r\n"
+"  uav2.Store(srv_out_offset + v3_offset, srv2.Load<vector3>(v3_offset)); \r\n"
+"  uav2.Store(srv_out_offset + v4_offset, srv2.Load<vector4>(v4_offset)); \r\n"
+"\r\n"
+"  uav3[0].srvOut.v1 = srv3[0].v1; \r\n"
+"  uav3[0].srvOut.v2 = srv3[0].v2; \r\n"
+"  uav3[0].srvOut.v3 = srv3[0].v3; \r\n"
+"  uav3[0].srvOut.v4 = srv3[0].v4; \r\n"
+"\r\n"
+"  uav0.Store(out_offset + v1_offset, uav0.Load<scalar>(v1_offset)); \r\n"
+"  uav0.Store(out_offset + v2_offset, uav0.Load<vector2>(v2_offset)); \r\n"
+"  uav0.Store(out_offset + v3_offset, uav0.Load<vector3>(v3_offset)); \r\n"
+"  uav0.Store(out_offset + v4_offset, uav0.Load<vector4>(v4_offset)); \r\n"
+"\r\n"
+"  uav1[0].output.v1 = uav1[0].input.v1; \r\n"
+"  uav1[0].output.v2 = uav1[0].input.v2; \r\n"
+"  uav1[0].output.v3 = uav1[0].input.v3; \r\n"
+"  uav1[0].output.v4 = uav1[0].input.v4; \r\n"
+"\r\n"
+"  uav2.Store(out_offset + v1_offset, uav2.Load<scalar>(v1_offset)); \r\n"
+"  uav2.Store(out_offset + v2_offset, uav2.Load<vector2>(v2_offset)); \r\n"
+"  uav2.Store(out_offset + v3_offset, uav2.Load<vector3>(v3_offset)); \r\n"
+"  uav2.Store(out_offset + v4_offset, uav2.Load<vector4>(v4_offset)); \r\n"
+"\r\n"
+"  uav3[0].output.v1 = uav3[0].input.v1; \r\n"
+"  uav3[0].output.v2 = uav3[0].input.v2; \r\n"
+"  uav3[0].output.v3 = uav3[0].input.v3; \r\n"
+"  uav3[0].output.v4 = uav3[0].input.v4; \r\n"
+"};";
+
 TEST_F(ExecutionTest, ComputeRawBufferLdStI32) {
-  RunRawBufferLdStTest(D3D_SHADER_MODEL_6_2, RawBufferLdStType::I32, "ComputeRawBufferLdStI32");
+  RawBufferLdStTestData<int32_t> data = { { 1 }, { 2, -1 }, { 256, 0, -10517 }, { 465, 13, -89, MAXUINT32 / 2 } };
+  RunComputeRawBufferLdStTest<int32_t>(D3D_SHADER_MODEL_6_2, RawBufferLdStType::I32, "ComputeRawBufferLdSt32Bit", data);
 }
 
-TEST_F(ExecutionTest,    ComputeRawBufferLdStFloat)  {
-   RunRawBufferLdStTest(D3D_SHADER_MODEL_6_2, RawBufferLdStType::Float, "ComputeRawBufferLdStFloat");
+TEST_F(ExecutionTest, ComputeRawBufferLdStFloat)  {
+  RawBufferLdStTestData<float> data = { { 3e-10f }, { 1.5f, -1.99988f }, { 256.0f, 0.0f, -105.17f }, { 465.1652f, -1.5694e2f, -0.8543e-2f, 1333.5f } };
+  RunComputeRawBufferLdStTest<float>(D3D_SHADER_MODEL_6_2, RawBufferLdStType::Float, "ComputeRawBufferLdSt32Bit", data);
 }
 
 TEST_F(ExecutionTest,  ComputeRawBufferLdStI64)  {
-   RunRawBufferLdStTest(D3D_SHADER_MODEL_6_3, RawBufferLdStType::I64, "ComputeRawBufferLdStI64");
+  RawBufferLdStTestData<int64_t> data = { { 1 }, { 2, -1 }, { 256, 0, -105171532 }, { 465, 13, -89, MAXUINT64 / 2 } };
+  RunComputeRawBufferLdStTest<int64_t>(D3D_SHADER_MODEL_6_3, RawBufferLdStType::I64, "ComputeRawBufferLdSt64Bit", data);
 }
 
 TEST_F(ExecutionTest,  ComputeRawBufferLdStDouble)  {
-   RunRawBufferLdStTest(D3D_SHADER_MODEL_6_3, RawBufferLdStType::Double, "ComputeRawBufferLdStDouble");
+  RawBufferLdStTestData<double> data = { { 3e-10 }, { 1.5, -1.99988 }, { 256.0, 0.0, -105.17 }, { 465.1652, -1.5694e2, -0.8543e-2, 1333.5 } };
+  RunComputeRawBufferLdStTest<double>(D3D_SHADER_MODEL_6_3, RawBufferLdStType::I64, "ComputeRawBufferLdSt64Bit", data);
 }
 
 TEST_F(ExecutionTest, ComputeRawBufferLdStI16) {
-  RunRawBufferLdStTest(D3D_SHADER_MODEL_6_2, RawBufferLdStType::I16, "ComputeRawBufferLdStI16");
+  RawBufferLdStTestData<int16_t> data = { { 1 }, { 2, -1 }, { 256, 0, -10517 }, { 465, 13, -89, MAXUINT16 / 2 } };
+  RunComputeRawBufferLdStTest<int16_t>(D3D_SHADER_MODEL_6_2, RawBufferLdStType::I16, "ComputeRawBufferLdSt16Bit", data);
 }
 
 TEST_F(ExecutionTest,  ComputeRawBufferLdStHalf)  {
-   RunRawBufferLdStTest(D3D_SHADER_MODEL_6_2, RawBufferLdStType::Half, "ComputeRawBufferLdStHalf");
+  RawBufferLdStTestData<float> floatData = { { 3e-10f }, { 1.5f, -1.99988f }, { 256.0f, 0.0f, -105.17f }, { 465.1652f, -1.5694e2f, -0.8543e-2f, 1333.5f } };
+  RawBufferLdStTestData<uint16_t> halfData;
+  for (int i = 0; i < sizeof(floatData)/sizeof(float); i++) {
+    ((uint16_t*)&halfData)[i] = ConvertFloat32ToFloat16(((float*)&floatData)[i]);
+  }
+  RunComputeRawBufferLdStTest<uint16_t>(D3D_SHADER_MODEL_6_2, RawBufferLdStType::Half, "ComputeRawBufferLdSt16Bit", halfData);
 }
 
 TEST_F(ExecutionTest,  GraphicsRawBufferLdStI32)  {
-   RunRawBufferLdStTest(D3D_SHADER_MODEL_6_2, RawBufferLdStType::I32, "GraphicsRawBufferLdStI32");
+  RunGraphicsRawBufferLdStTest(D3D_SHADER_MODEL_6_2, RawBufferLdStType::I32, "GraphicsRawBufferLdStI32");
 }
 
 TEST_F(ExecutionTest,  GraphicsRawBufferLdStFloat)  {
-   RunRawBufferLdStTest(D3D_SHADER_MODEL_6_2, RawBufferLdStType::Float, "GraphicsRawBufferLdStFloat");
+  RunGraphicsRawBufferLdStTest(D3D_SHADER_MODEL_6_2, RawBufferLdStType::Float, "GraphicsRawBufferLdStFloat");
 }
 
 TEST_F(ExecutionTest,  GraphicsRawBufferLdStI64)  {
-   RunRawBufferLdStTest(D3D_SHADER_MODEL_6_3, RawBufferLdStType::I64, "GraphicsRawBufferLdStI64");
+  RunGraphicsRawBufferLdStTest(D3D_SHADER_MODEL_6_3, RawBufferLdStType::I64, "GraphicsRawBufferLdStI64");
 }
 
 TEST_F(ExecutionTest,  GraphicsRawBufferLdStDouble)  {
-   RunRawBufferLdStTest(D3D_SHADER_MODEL_6_3, RawBufferLdStType::Double, "GraphicsRawBufferLdStDouble");
+  RunGraphicsRawBufferLdStTest(D3D_SHADER_MODEL_6_3, RawBufferLdStType::Double, "GraphicsRawBufferLdStDouble");
 }
 
 TEST_F(ExecutionTest, GraphicsRawBufferLdStI16) {
-  RunRawBufferLdStTest(D3D_SHADER_MODEL_6_2, RawBufferLdStType::I16, "GraphicsRawBufferLdStI16");
+  RunGraphicsRawBufferLdStTest(D3D_SHADER_MODEL_6_2, RawBufferLdStType::I16, "GraphicsRawBufferLdStI16");
 }
 
 TEST_F(ExecutionTest, GraphicsRawBufferLdStHalf) {
-   RunRawBufferLdStTest(D3D_SHADER_MODEL_6_2, RawBufferLdStType::Half, "GraphicsRawBufferLdStHalf");
+  RunGraphicsRawBufferLdStTest(D3D_SHADER_MODEL_6_2, RawBufferLdStType::Half, "GraphicsRawBufferLdStHalf");
 }
 
-void ExecutionTest::RunRawBufferLdStTest(D3D_SHADER_MODEL shaderModel, RawBufferLdStType dataType, char *shaderOpName) {
+template <class Ty>
+void ExecutionTest::RunComputeRawBufferLdStTest(D3D_SHADER_MODEL shaderModel, RawBufferLdStType dataType, 
+                                                const char *shaderOpName, const RawBufferLdStTestData<Ty> &testData) {
    WEX::TestExecution::SetVerifyOutput verifySettings(
    WEX::TestExecution::VerifyOutputSettings::LogOnlyFailures);
 
@@ -5930,6 +6062,9 @@ void ExecutionTest::RunRawBufferLdStTest(D3D_SHADER_MODEL shaderModel, RawBuffer
      return;
    }
 
+   char *sTy = nullptr;
+   char *additionalOptions = "";
+
    switch (dataType) {
    case RawBufferLdStType::I64:
      if (!DoesDeviceSupportInt64(pDevice)) {
@@ -5937,6 +6072,7 @@ void ExecutionTest::RunRawBufferLdStTest(D3D_SHADER_MODEL shaderModel, RawBuffer
        WEX::Logging::Log::Result(WEX::Logging::TestResults::Skipped);
        return;
      }
+     sTy = "int64_t";
      break;
    case RawBufferLdStType::Double:
      if (!DoesDeviceSupportDouble(pDevice)) {
@@ -5944,6 +6080,7 @@ void ExecutionTest::RunRawBufferLdStTest(D3D_SHADER_MODEL shaderModel, RawBuffer
        WEX::Logging::Log::Result(WEX::Logging::TestResults::Skipped);
        return;
      }
+     sTy = "double";
      break;
    case RawBufferLdStType::I16:
    case RawBufferLdStType::Half:
@@ -5952,25 +6089,92 @@ void ExecutionTest::RunRawBufferLdStTest(D3D_SHADER_MODEL shaderModel, RawBuffer
        WEX::Logging::Log::Result(WEX::Logging::TestResults::Skipped);
        return;
      }
+     additionalOptions = "-enable-16bit-types";
+     sTy = (dataType == RawBufferLdStType::I16 ? "int16_t" : "half");
      break;
    case RawBufferLdStType::I32:
+     sTy = "int32_t";
+     break;
    case RawBufferLdStType::Float:
+     sTy = "float";
      break;
    default:
      DXASSERT_NOMSG("Invalid RawBufferLdStType");
    }
 
-   if (shaderOpName == nullptr) {
-     // TODO: finish up all variations
-     WEX::Logging::Log::Result(WEX::Logging::TestResults::Skipped);
-     return;
-   }
-
+   // read shader config
    CComPtr<IStream> pStream;
    ReadHlslDataIntoNewStream(L"ShaderOpArith.xml", &pStream);
 
-   // TODO: finish up
-   WEX::Logging::Log::Result(WEX::Logging::TestResults::Skipped);
+   // format compiler args
+   char compilerOptions[256];
+   VERIFY_IS_TRUE(sprintf_s(compilerOptions, sizeof(compilerOptions), "-D COMPONENT_TYPE=%s -D COMPONENT_SIZE=%d %s", sTy, (int)sizeof(Ty), additionalOptions) != -1);
+
+   // run the shader
+   std::shared_ptr<ShaderOpTestResult> test = RunShaderOpTest(pDevice, m_support, pStream, shaderOpName,
+     [&](LPCSTR Name, std::vector<BYTE> &Data, st::ShaderOp *pShaderOp) {
+     VERIFY_IS_TRUE(((0 == strncmp(Name, "SRVBuffer", 9)) || (0 == strncmp(Name, "UAVBuffer", 9))) &&
+                    (Name[9] >= '0' && Name[9] <= '3'));
+     pShaderOp->Shaders.at(0).Arguments = compilerOptions;
+     pShaderOp->Shaders.at(0).Text = RawBufferTestComputeShader;
+
+     VERIFY_IS_TRUE(sizeof(RawBufferLdStTestData<Ty>) <= Data.size());
+     RawBufferLdStTestData<Ty> *pInData = (RawBufferLdStTestData<Ty>*)Data.data();
+     memcpy(pInData, &testData, sizeof(RawBufferLdStTestData<Ty>));
+   });
+
+   // read buffers back & verify expected values
+   static const int UavBufferCount = 4;
+   char bufferName[11] = "UAVBufferX";
+
+   for (unsigned i = 0; i < UavBufferCount; i++) {
+     MappedData dataUav;
+     RawBufferLdStUavData<Ty> *pOutData;
+
+     bufferName[sizeof(bufferName) - 2] = (char)(i + '0');
+     
+     test->Test->GetReadBackData(bufferName, &dataUav);
+     VERIFY_ARE_EQUAL(sizeof(RawBufferLdStUavData<Ty>), dataUav.size());
+     pOutData = (RawBufferLdStUavData<Ty> *)dataUav.data();
+     
+     LogCommentFmt(L"Verifying UAVBuffer%d Load -> UAVBuffer%d Store", i, i);
+     // scalarRunComputeRawBufferLdStTest
+     VERIFY_ARE_EQUAL(pOutData->output.v1,    testData.v1);
+     // vector 2
+     VERIFY_ARE_EQUAL(pOutData->output.v2[0], testData.v2[0]);
+     VERIFY_ARE_EQUAL(pOutData->output.v2[1], testData.v2[1]);
+     // vector 3
+     VERIFY_ARE_EQUAL(pOutData->output.v3[0], testData.v3[0]);
+     VERIFY_ARE_EQUAL(pOutData->output.v3[1], testData.v3[1]);
+     VERIFY_ARE_EQUAL(pOutData->output.v3[2], testData.v3[2]);
+     // vector 4
+     VERIFY_ARE_EQUAL(pOutData->output.v4[0], testData.v4[0]);
+     VERIFY_ARE_EQUAL(pOutData->output.v4[1], testData.v4[1]);
+     VERIFY_ARE_EQUAL(pOutData->output.v4[2], testData.v4[2]);
+     VERIFY_ARE_EQUAL(pOutData->output.v4[3], testData.v4[3]);
+
+     // verify SRV Store
+     LogCommentFmt(L"Verifying SRVBuffer%d Load -> UAVBuffer%d Store", i, i);
+     // scalar
+     VERIFY_ARE_EQUAL(pOutData->srvOut.v1,    testData.v1);
+     // vector 2
+     VERIFY_ARE_EQUAL(pOutData->srvOut.v2[0], testData.v2[0]);
+     VERIFY_ARE_EQUAL(pOutData->srvOut.v2[1], testData.v2[1]);
+     // vector 3
+     VERIFY_ARE_EQUAL(pOutData->srvOut.v3[0], testData.v3[0]);
+     VERIFY_ARE_EQUAL(pOutData->srvOut.v3[1], testData.v3[1]);
+     VERIFY_ARE_EQUAL(pOutData->srvOut.v3[2], testData.v3[2]);
+     // vector 4
+     VERIFY_ARE_EQUAL(pOutData->srvOut.v4[0], testData.v4[0]);
+     VERIFY_ARE_EQUAL(pOutData->srvOut.v4[1], testData.v4[1]);
+     VERIFY_ARE_EQUAL(pOutData->srvOut.v4[2], testData.v4[2]);
+     VERIFY_ARE_EQUAL(pOutData->srvOut.v4[3], testData.v4[3]);
+   }
+}
+
+void ExecutionTest::RunGraphicsRawBufferLdStTest(D3D_SHADER_MODEL shaderModel, RawBufferLdStType dataType,
+  const char *shaderOpName) {
+  WEX::Logging::Log::Result(WEX::Logging::TestResults::Skipped);
 }
 
 #ifndef _HLK_CONF