Adding array operator long vector tests to HLK

tools/clang/unittests/HLSLExec/LongVectorOps.def

@@ -62,6 +62,13 @@ OP(Bitwise, FirstBitLow, 1, "firstbitlow", "", "", "LongVectorOp", Bitwise, Defa
 OP_DEFAULT_DEFINES(Unary, Initialize, 1, "TestInitialize", "",
                    " -DFUNC_INITIALIZE=1")
 
+OP_DEFAULT_DEFINES(ArrayOperator, ArrayOperator_SingleAccess, 1, "TestArrayOperatorSingleAccess", "",
+                   " -DFUNC_ARRAY_OPERATOR_SINGLE_ACCESS=1")
+OP_DEFAULT_DEFINES(ArrayOperator, ArrayOperator_Loop, 2, "TestArrayOperatorLoop", "",
+                   " -DFUNC_ARRAY_OPERATOR=1 -DLOOP_ATTRB=loop")
+OP_DEFAULT_DEFINES(ArrayOperator, ArrayOperator_Unroll, 2, "TestArrayOperatorUnroll", "",
+                   " -DFUNC_ARRAY_OPERATOR=1 -DLOOP_ATTRB=unroll")
+
 #define OP_CAST_DEFAULT(GROUP, SYMBOL)                                         \
   OP_DEFAULT_DEFINES(GROUP, SYMBOL, 1, "TestCast", "", "-DFUNC_TEST_CAST=1")
 #define OP_CAST(GROUP, SYMBOL, INPUT_SET_1)                                    \

tools/clang/unittests/HLSLExec/LongVectors.cpp

@@ -768,6 +768,60 @@ BITWISE_OP(OpType::FirstBitLow, (FirstBitLow(A)));
 
 DEFAULT_OP_1(OpType::Initialize, (A));
 
+template <typename T>
+struct Op<OpType::ArrayOperator_SingleAccess, T, 1> : DefaultValidation<T> {};
+
+template <typename T>
+struct ExpectedBuilder<OpType::ArrayOperator_SingleAccess, T> {
+  static std::vector<T>
+  buildExpected(Op<OpType::ArrayOperator_SingleAccess, T, 1>,
+                const InputSets<T> &Inputs) {
+    DXASSERT_NOMSG(Inputs.size() == 1);
+    const size_t VectorSize = Inputs[0].size();
+    std::vector<T> Expected = Inputs[0];
+    Expected[0] = Inputs[0][VectorSize - 1];
+    Expected[VectorSize - 1] = Expected[0];
+    return Expected;
+  }
+};
+
+template <typename T>
+static std::vector<T>
+buildExpectedArrayAccessOutput(const InputSets<T> &Inputs) {
+  DXASSERT_NOMSG(Inputs.size() == 2);
+  const size_t VectorSize = Inputs[0].size();
+  std::vector<T> Expected;
+  Expected.resize(VectorSize * 2);
+
+  for (size_t i = 0; i < VectorSize; i++)
+    Expected[i] = Inputs[0][i] + Inputs[1][i];
+
+  for (size_t i = 0; i < VectorSize; i++)
+    Expected[i + VectorSize] = Expected[i];
+
+  return Expected;
+}
+
+template <typename T>
+struct Op<OpType::ArrayOperator_Loop, T, 2> : DefaultValidation<T> {};
+
+template <typename T> struct ExpectedBuilder<OpType::ArrayOperator_Loop, T> {
+  static std::vector<T> buildExpected(Op<OpType::ArrayOperator_Loop, T, 2>,
+                                      const InputSets<T> &Inputs) {
+    return buildExpectedArrayAccessOutput(Inputs);
+  }
+};
+
+template <typename T>
+struct Op<OpType::ArrayOperator_Unroll, T, 2> : DefaultValidation<T> {};
+
+template <typename T> struct ExpectedBuilder<OpType::ArrayOperator_Unroll, T> {
+  static std::vector<T> buildExpected(Op<OpType::ArrayOperator_Unroll, T, 2>,
+                                      const InputSets<T> &Inputs) {
+    return buildExpectedArrayAccessOutput(Inputs);
+  }
+};
+
 //
 // Cast
 //
@@ -1586,15 +1640,45 @@ class DxilConf_SM69_Vectorized {
   // Unary
 
   HLK_TEST(Initialize, HLSLBool_t);
+  HLK_TEST(ArrayOperator_SingleAccess, HLSLBool_t);
+  HLK_TEST(ArrayOperator_Unroll, HLSLBool_t);
+  HLK_TEST(ArrayOperator_Loop, HLSLBool_t);
   HLK_TEST(Initialize, int16_t);
+  HLK_TEST(ArrayOperator_SingleAccess, int16_t);
+  HLK_TEST(ArrayOperator_Unroll, int16_t);
+  HLK_TEST(ArrayOperator_Loop, int16_t);
   HLK_TEST(Initialize, int32_t);
+  HLK_TEST(ArrayOperator_SingleAccess, int32_t);
+  HLK_TEST(ArrayOperator_Unroll, int32_t);
+  HLK_TEST(ArrayOperator_Loop, int32_t);
   HLK_TEST(Initialize, int64_t);
+  HLK_TEST(ArrayOperator_SingleAccess, int64_t);
+  HLK_TEST(ArrayOperator_Unroll, int64_t);
+  HLK_TEST(ArrayOperator_Loop, int64_t);
   HLK_TEST(Initialize, uint16_t);
+  HLK_TEST(ArrayOperator_SingleAccess, uint16_t);
+  HLK_TEST(ArrayOperator_Unroll, uint16_t);
+  HLK_TEST(ArrayOperator_Loop, uint16_t);
   HLK_TEST(Initialize, uint32_t);
+  HLK_TEST(ArrayOperator_SingleAccess, uint32_t);
+  HLK_TEST(ArrayOperator_Unroll, uint32_t);
+  HLK_TEST(ArrayOperator_Loop, uint32_t);
   HLK_TEST(Initialize, uint64_t);
+  HLK_TEST(ArrayOperator_SingleAccess, uint64_t);
+  HLK_TEST(ArrayOperator_Unroll, uint64_t);
+  HLK_TEST(ArrayOperator_Loop, uint64_t);
   HLK_TEST(Initialize, HLSLHalf_t);
+  HLK_TEST(ArrayOperator_SingleAccess, HLSLHalf_t);
+  HLK_TEST(ArrayOperator_Unroll, HLSLHalf_t);
+  HLK_TEST(ArrayOperator_Loop, HLSLHalf_t);
   HLK_TEST(Initialize, float);
+  HLK_TEST(ArrayOperator_SingleAccess, float);
+  HLK_TEST(ArrayOperator_Unroll, float);
+  HLK_TEST(ArrayOperator_Loop, float);
   HLK_TEST(Initialize, double);
+  HLK_TEST(ArrayOperator_SingleAccess, double);
+  HLK_TEST(ArrayOperator_Unroll, double);
+  HLK_TEST(ArrayOperator_Loop, double);
 
   HLK_TEST(ShuffleVector, HLSLBool_t);
   HLK_TEST(ShuffleVector, int16_t);

tools/clang/unittests/HLSLExec/ShaderOpArith.xml

@@ -3985,7 +3985,7 @@ void MSMain(uint GID : SV_GroupIndex,
     <Resource Name="InputVector1" Dimension="BUFFER" Width="8192" Flags="ALLOW_UNORDERED_ACCESS" InitialResourceState="COPY_DEST" TransitionTo="UNORDERED_ACCESS" Init="ByName" ReadBack="true" />
     <Resource Name="InputVector2" Dimension="BUFFER" Width="8192" Flags="ALLOW_UNORDERED_ACCESS" InitialResourceState="COPY_DEST" TransitionTo="UNORDERED_ACCESS" Init="ByName" ReadBack="true" />
     <Resource Name="InputVector3" Dimension="BUFFER" Width="8192" Flags="ALLOW_UNORDERED_ACCESS" InitialResourceState="COPY_DEST" TransitionTo="UNORDERED_ACCESS" Init="ByName" ReadBack="true" />
-    <Resource Name="OutputVector" Dimension="BUFFER" Width="8192"
+    <Resource Name="OutputVector" Dimension="BUFFER" Width="16384"
     Flags="ALLOW_UNORDERED_ACCESS" InitialResourceState="COPY_DEST"
     TransitionTo="UNORDERED_ACCESS" Init="ByName" ReadBack="true" />
     <RootValues>
@@ -4129,7 +4129,20 @@ void MSMain(uint GID : SV_GroupIndex,
             const uint32_t OutNum = NUM;
           #endif
 
-          #if IS_UNARY_OP
+          #if FUNC_ARRAY_OPERATOR_SINGLE_ACCESS
+            vector<OUT_TYPE, OutNum> OutputVector = g_InputVector1.Load< vector<TYPE,
+            NUM> >(0);
+            OutputVector[0] = Input1[OutNum - 1];
+            OutputVector[OutNum - 1] = OutputVector[0];
+          #elif FUNC_ARRAY_OPERATOR
+            vector<OUT_TYPE, OutNum> OutputVector;
+
+            [LOOP_ATTRB] for(uint i = 0; i < OutNum; i++)
+              OutputVector[i] = Input1[i] + Input2[i];
+
+            [LOOP_ATTRB] for(uint i = 0; i < OutNum; i++) 
+              g_OutputVector.Store<OUT_TYPE>(sizeof(OUT_TYPE) * (OutNum + i), OutputVector[i]);
+          #elif IS_UNARY_OP
             vector<OUT_TYPE, OutNum> OutputVector = FUNC(Input1);
           #elif IS_BINARY_OP
             vector<OUT_TYPE, OutNum> OutputVector = FUNC(Input1 OPERATOR