external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmIndexingTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2018 Google Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief SPIR-V Assembly Tests for indexing with access chain operations.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktSpvAsmIndexingTests.hpp"
  25 #include "vktSpvAsmComputeShaderCase.hpp"
  26 #include "vktSpvAsmComputeShaderTestUtil.hpp"
  27 #include "vktSpvAsmGraphicsShaderTestUtil.hpp"
  28
  29 #include "tcuStringTemplate.hpp"
  30
  31 namespace vkt
  32 {
  33 namespace SpirVAssembly
  34 {
  35
  36 using namespace vk;
  37 using std::map;
  38 using std::string;
  39 using std::vector;
  40 using std::pair;
  41 using tcu::IVec3;
  42 using tcu::RGBA;
  43 using tcu::UVec4;
  44 using tcu::Vec4;
  45 using tcu::Mat4;
  46 using tcu::StringTemplate;
  47
  48 namespace
  49 {
  50
  51 enum ChainOp
  52 {
  53         CHAIN_OP_ACCESS_CHAIN = 0,
  54         CHAIN_OP_IN_BOUNDS_ACCESS_CHAIN,
  55         CHAIN_OP_PTR_ACCESS_CHAIN,
  56
  57         CHAIN_OP_LAST
  58 };
  59 static const int                                        idxSizes[]                              = { 16, 32, 64 };
  60 static const string                                     chainOpTestNames[]              = { "opaccesschain", "opinboundsaccesschain", "opptraccesschain" };
  61
  62 struct InputData
  63 {
  64         Mat4    matrix[32][32];
  65 };
  66
  67 void addComputeIndexingStructTests (tcu::TestCaseGroup* group)
  68 {
  69         tcu::TestContext&                               testCtx                         = group->getTestContext();
  70         de::MovePtr<tcu::TestCaseGroup> structGroup                     (new tcu::TestCaseGroup(testCtx, "struct", "Tests for indexing input struct."));
  71         de::Random                                              rnd                                     (deStringHash(group->getName()));
  72         const int                                               numItems                        = 128;
  73         const int                                               numStructs                      = 2;
  74         const int                                               numInputFloats          = (int)sizeof(InputData) / 4 * numStructs;
  75         vector<float>                                   inputData;
  76         vector<UVec4>                                   indexSelectorData;
  77
  78         inputData.reserve(numInputFloats);
  79         for (deUint32 numIdx = 0; numIdx < numInputFloats; ++numIdx)
  80                 inputData.push_back(rnd.getFloat());
  81
  82         indexSelectorData.reserve(numItems);
  83         for (deUint32 numIdx = 0; numIdx < numItems; ++numIdx)
  84                 indexSelectorData.push_back(UVec4(rnd.getUint32() % 32, rnd.getUint32() % 32, rnd.getUint32() % 4, rnd.getUint32() % 4));
  85
  86         for (int chainOpIdx = 0; chainOpIdx < CHAIN_OP_LAST; ++chainOpIdx)
  87         {
  88                 for (int idxSizeIdx = 0; idxSizeIdx < DE_LENGTH_OF_ARRAY(idxSizes); ++idxSizeIdx)
  89                 {
  90                         for (int sign = 0; sign < 2; ++sign)
  91                         {
  92                                 const int                                       idxSize                 = idxSizes[idxSizeIdx];
  93                                 const string                            testName                = chainOpTestNames[chainOpIdx] + string(sign == 0 ? "_u" : "_s") + de::toString(idxSize);
  94                                 VulkanFeatures                          vulkanFeatures;
  95                                 map<string, string>                     specs;
  96                                 vector<float>                           outputData;
  97                                 ComputeShaderSpec                       spec;
  98                                 int                                                     element                 = 0;
  99
 100                                 // Index an input buffer containing 2D array of 4x4 matrices. The indices are read from another
 101                                 // input and converted to the desired bit size and sign.
 102                                 const StringTemplate            shaderSource(
 103                                         "                             OpCapability Shader\n"
 104                                         "                             ${intcaps:opt}\n"
 105                                         "                             ${variablepointercaps:opt}\n"
 106                                         "                             ${extensions:opt}\n"
 107                                         "                        %1 = OpExtInstImport \"GLSL.std.450\"\n"
 108                                         "                             OpMemoryModel Logical GLSL450\n"
 109                                         "                             OpEntryPoint GLCompute %main \"main\" %gl_GlobalInvocationID\n"
 110                                         "                             OpExecutionMode %main LocalSize 1 1 1\n"
 111                                         "                             OpSource GLSL 430\n"
 112                                         "                             OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId\n"
 113                                         "                             OpDecorate %_arr_float_uint_128 ArrayStride 4\n"
 114                                         "                             OpMemberDecorate %Output 0 Offset 0\n"
 115                                         "                             OpDecorate %Output BufferBlock\n"
 116                                         "                             OpDecorate %dataOutput DescriptorSet 0\n"
 117                                         "                             OpDecorate %dataOutput Binding 2\n"
 118                                         "                             OpDecorate %_arr_mat4v4float_uint_32 ArrayStride 64\n"
 119                                         "                             OpDecorate %_arr__arr_mat4v4float_uint_32_uint_32 ArrayStride 2048\n"
 120                                         "                             OpMemberDecorate %InputStruct 0 ColMajor\n"
 121                                         "                             OpMemberDecorate %InputStruct 0 Offset 0\n"
 122                                         "                             OpMemberDecorate %InputStruct 0 MatrixStride 16\n"
 123                                         "                             OpDecorate %InputStructArr ArrayStride 65536\n"
 124                                         "                             OpDecorate %Input ${inputdecoration}\n"
 125                                         "                             OpMemberDecorate %Input 0 Offset 0\n"
 126                                         "                             OpDecorate %dataInput DescriptorSet 0\n"
 127                                         "                             OpDecorate %dataInput Binding 0\n"
 128                                         "                             OpDecorate %_ptr_buffer_InputStruct ArrayStride 65536\n"
 129                                         "                             OpDecorate %_arr_v4uint_uint_128 ArrayStride 16\n"
 130                                         "                             OpMemberDecorate %DataSelector 0 Offset 0\n"
 131                                         "                             OpDecorate %DataSelector BufferBlock\n"
 132                                         "                             OpDecorate %selector DescriptorSet 0\n"
 133                                         "                             OpDecorate %selector Binding 1\n"
 134                                         "                     %void = OpTypeVoid\n"
 135                                         "                        %3 = OpTypeFunction %void\n"
 136                                         "                      %u32 = OpTypeInt 32 0\n"
 137                                         "                      %i32 = OpTypeInt 32 1\n"
 138                                         "${intdecl:opt}"
 139                                         "                    %idx_0 = OpConstant ${idx_int} 0\n"
 140                                         "                    %idx_1 = OpConstant ${idx_int} 1\n"
 141                                         "                    %idx_2 = OpConstant ${idx_int} 2\n"
 142                                         "                    %idx_3 = OpConstant ${idx_int} 3\n"
 143                                         "     %_ptr_Function_uint32 = OpTypePointer Function %u32\n"
 144                                         "                 %v3uint32 = OpTypeVector %u32 3\n"
 145                                         "      %_ptr_Input_v3uint32 = OpTypePointer Input %v3uint32\n"
 146                                         "    %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint32 Input\n"
 147                                         "        %_ptr_Input_uint32 = OpTypePointer Input %u32\n"
 148                                         "                    %float = OpTypeFloat 32\n"
 149                                         "                 %uint_128 = OpConstant %u32 128\n"
 150                                         "                  %uint_32 = OpConstant %u32 32\n"
 151                                         "                   %uint_2 = OpConstant %u32 2\n"
 152                                         "      %_arr_float_uint_128 = OpTypeArray %float %uint_128\n"
 153                                         "                   %Output = OpTypeStruct %_arr_float_uint_128\n"
 154                                         "      %_ptr_Uniform_Output = OpTypePointer Uniform %Output\n"
 155                                         "               %dataOutput = OpVariable %_ptr_Uniform_Output Uniform\n"
 156                                         "                  %v4float = OpTypeVector %float 4\n"
 157                                         "              %mat4v4float = OpTypeMatrix %v4float 4\n"
 158                                         " %_arr_mat4v4float_uint_32 = OpTypeArray %mat4v4float %uint_32\n"
 159                                         " %_arr__arr_mat4v4float_uint_32_uint_32 = OpTypeArray %_arr_mat4v4float_uint_32 %uint_32\n"
 160                                         "              %InputStruct = OpTypeStruct %_arr__arr_mat4v4float_uint_32_uint_32\n"
 161                                         "           %InputStructArr = OpTypeArray %InputStruct %uint_2\n"
 162                                         "                    %Input = OpTypeStruct %InputStructArr\n"
 163                                         "        %_ptr_buffer_Input = OpTypePointer ${inputstorageclass} %Input\n"
 164                                         "                %dataInput = OpVariable %_ptr_buffer_Input ${inputstorageclass}\n"
 165                                         "  %_ptr_buffer_InputStruct = OpTypePointer ${inputstorageclass} %InputStruct\n"
 166                                         "                 %v4uint32 = OpTypeVector %u32 4\n"
 167                                         "     %_arr_v4uint_uint_128 = OpTypeArray %v4uint32 %uint_128\n"
 168                                         "             %DataSelector = OpTypeStruct %_arr_v4uint_uint_128\n"
 169                                         "%_ptr_Uniform_DataSelector = OpTypePointer Uniform %DataSelector\n"
 170                                         "                 %selector = OpVariable %_ptr_Uniform_DataSelector Uniform\n"
 171                                         "      %_ptr_Uniform_uint32 = OpTypePointer Uniform %u32\n"
 172                                         "       %_ptr_Uniform_float = OpTypePointer Uniform %float\n"
 173                                         "       ${ptr_buffer_float:opt}\n"
 174
 175                                         "                     %main = OpFunction %void None %3\n"
 176                                         "                        %5 = OpLabel\n"
 177                                         "                        %i = OpVariable %_ptr_Function_uint32 Function\n"
 178                                         "                       %14 = OpAccessChain %_ptr_Input_uint32 %gl_GlobalInvocationID %idx_0\n"
 179                                         "                       %15 = OpLoad %u32 %14\n"
 180                                         "                             OpStore %i %15\n"
 181                                         "                   %uint_i = OpLoad %u32 %i\n"
 182                                         "                       %39 = OpAccessChain %_ptr_Uniform_uint32 %selector %idx_0 %uint_i %idx_0\n"
 183                                         "                       %40 = OpLoad %u32 %39\n"
 184                                         "                       %43 = OpAccessChain %_ptr_Uniform_uint32 %selector %idx_0 %uint_i %idx_1\n"
 185                                         "                       %44 = OpLoad %u32 %43\n"
 186                                         "                       %47 = OpAccessChain %_ptr_Uniform_uint32 %selector %idx_0 %uint_i %idx_2\n"
 187                                         "                       %48 = OpLoad %u32 %47\n"
 188                                         "                       %51 = OpAccessChain %_ptr_Uniform_uint32 %selector %idx_0 %uint_i %idx_3\n"
 189                                         "                       %52 = OpLoad %u32 %51\n"
 190                                         "                       %i0 = ${convert} ${idx_int} %40\n"
 191                                         "                       %i1 = ${convert} ${idx_int} %44\n"
 192                                         "                       %i2 = ${convert} ${idx_int} %48\n"
 193                                         "                       %i3 = ${convert} ${idx_int} %52\n"
 194                                         "        %inputFirstElement = OpAccessChain %_ptr_buffer_InputStruct %dataInput %idx_0 %idx_0\n"
 195                                         "                       %54 = ${accesschain}\n"
 196                                         "                       %55 = OpLoad %float %54\n"
 197                                         "                       %56 = OpAccessChain %_ptr_Uniform_float %dataOutput %idx_0 %uint_i\n"
 198                                         "                             OpStore %56 %55\n"
 199                                         "                             OpReturn\n"
 200                                         "                             OpFunctionEnd\n");
 201
 202
 203                                 switch (chainOpIdx)
 204                                 {
 205                                         case CHAIN_OP_ACCESS_CHAIN:
 206                                                 specs["accesschain"]                    = "OpAccessChain %_ptr_Uniform_float %inputFirstElement %idx_0 %i0 %i1 %i2 %i3\n";
 207                                                 specs["inputdecoration"]                = "BufferBlock";
 208                                                 specs["inputstorageclass"]              = "Uniform";
 209                                                 break;
 210                                         case CHAIN_OP_IN_BOUNDS_ACCESS_CHAIN:
 211                                                 specs["accesschain"]                    = "OpInBoundsAccessChain %_ptr_Uniform_float %inputFirstElement %idx_0 %i0 %i1 %i2 %i3\n";
 212                                                 specs["inputdecoration"]                = "BufferBlock";
 213                                                 specs["inputstorageclass"]              = "Uniform";
 214                                                 break;
 215                                         default:
 216                                                 DE_ASSERT(chainOpIdx == CHAIN_OP_PTR_ACCESS_CHAIN);
 217                                                 specs["accesschain"]                    = "OpPtrAccessChain %_ptr_StorageBuffer_float %inputFirstElement %idx_1 %idx_0 %i0 %i1 %i2 %i3\n";
 218                                                 specs["inputdecoration"]                = "Block";
 219                                                 specs["inputstorageclass"]              = "StorageBuffer";
 220                                                 specs["variablepointercaps"]    = "OpCapability VariablePointersStorageBuffer";
 221                                                 specs["ptr_buffer_float"]               = "%_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float";
 222                                                 specs["extensions"]                             = "OpExtension \"SPV_KHR_variable_pointers\"\n                             "
 223                                                                                                                   "OpExtension \"SPV_KHR_storage_buffer_storage_class\"";
 224                                                 element = 1;
 225                                                 vulkanFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
 226                                                 spec.extensions.push_back("VK_KHR_variable_pointers");
 227                                                 break;
 228                                 };
 229
 230                                 spec.inputs.push_back(BufferSp(new Float32Buffer(inputData)));
 231                                 spec.inputs.push_back(BufferSp(new Buffer<UVec4>(indexSelectorData)));
 232
 233                                 outputData.reserve(numItems);
 234                                 for (deUint32 numIdx = 0; numIdx < numItems; ++numIdx)
 235                                 {
 236                                         // Determine the selected output float for the selected indices.
 237                                         const UVec4 vec = indexSelectorData[numIdx];
 238                                         outputData.push_back(inputData[element * sizeof(InputData) / 4 + vec.x() * (32 * 4 * 4) + vec.y() * 4 * 4 + vec.z() * 4 + vec.w()]);
 239                                 }
 240
 241                                 if (idxSize == 16)
 242                                 {
 243                                         specs["intcaps"] = "OpCapability Int16";
 244                                         specs["convert"] = "OpSConvert";
 245                                         specs["intdecl"] =      "                      %u16 = OpTypeInt 16 0\n"
 246                                                                 "                      %i16 = OpTypeInt 16 1\n";
 247                                 }
 248                                 else if (idxSize == 64)
 249                                 {
 250                                         specs["intcaps"] = "OpCapability Int64";
 251                                         specs["convert"] = "OpSConvert";
 252                                         specs["intdecl"] =      "                      %u64 = OpTypeInt 64 0\n"
 253                                                                 "                      %i64 = OpTypeInt 64 1\n";
 254                                 } else {
 255                                         specs["convert"] = "OpBitcast";
 256                                 }
 257
 258                                 specs["idx_uint"] = "%u" + de::toString(idxSize);
 259                                 specs["idx_int"] = (sign ? "%i" : "%u") + de::toString(idxSize);
 260
 261                                 spec.assembly                                   = shaderSource.specialize(specs);
 262                                 spec.numWorkGroups                              = IVec3(numItems, 1, 1);
 263                                 spec.requestedVulkanFeatures    = vulkanFeatures;
 264                                 spec.inputs[0].setDescriptorType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
 265                                 spec.inputs[1].setDescriptorType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
 266
 267                                 spec.outputs.push_back(BufferSp(new Float32Buffer(outputData)));
 268
 269                                 if (idxSize == 16)
 270                                         spec.requestedVulkanFeatures.coreFeatures.shaderInt16 = VK_TRUE;
 271
 272                                 if (idxSize == 64)
 273                                         spec.requestedVulkanFeatures.coreFeatures.shaderInt64 = VK_TRUE;
 274
 275                                 structGroup->addChild(new SpvAsmComputeShaderCase(testCtx, testName.c_str(), testName.c_str(), spec));
 276                         }
 277                 }
 278         }
 279         group->addChild(structGroup.release());
 280 }
 281
 282 void addGraphicsIndexingStructTests (tcu::TestCaseGroup* group)
 283 {
 284         tcu::TestContext&                               testCtx                         = group->getTestContext();
 285         de::MovePtr<tcu::TestCaseGroup> structGroup                     (new tcu::TestCaseGroup(testCtx, "struct", "Tests for indexing input struct."));
 286         de::Random                                              rnd                                     (deStringHash(group->getName()));
 287         const int                                               numItems                        = 128;
 288         const int                                               numStructs                      = 2;
 289         const int                                               numInputFloats          = (int)sizeof(InputData) / 4 * numStructs;
 290         RGBA                                                    defaultColors[4];
 291         vector<float>                                   inputData;
 292         vector<UVec4>                                   indexSelectorData;
 293
 294         inputData.reserve(numInputFloats);
 295         for (deUint32 numIdx = 0; numIdx < numInputFloats; ++numIdx)
 296                 inputData.push_back(rnd.getFloat());
 297
 298         indexSelectorData.reserve(numItems);
 299         for (deUint32 numIdx = 0; numIdx < numItems; ++numIdx)
 300                 indexSelectorData.push_back(UVec4(rnd.getUint32() % 32, rnd.getUint32() % 32, rnd.getUint32() % 4, rnd.getUint32() % 4));
 301
 302         getDefaultColors(defaultColors);
 303
 304         for (int chainOpIdx = 0; chainOpIdx < CHAIN_OP_LAST; ++chainOpIdx)
 305         {
 306                 for (int idxSizeIdx = 0; idxSizeIdx < DE_LENGTH_OF_ARRAY(idxSizes); ++idxSizeIdx)
 307                 {
 308                         for (int sign = 0; sign < 2; sign++)
 309                         {
 310                                 const int                                       idxSize                 = idxSizes[idxSizeIdx];
 311                                 const string                            testName                = chainOpTestNames[chainOpIdx] + string(sign == 0 ? "_u" : "_s") + de::toString(idxSize);
 312                                 VulkanFeatures                          vulkanFeatures;
 313                                 vector<string>                          extensions;
 314                                 SpecConstants                           noSpecConstants;
 315                                 PushConstants                           noPushConstants;
 316                                 GraphicsInterfaces                      noInterfaces;
 317                                 map<string, string>                     specs;
 318                                 map<string, string>                     fragments;
 319                                 vector<float>                           outputData;
 320                                 ComputeShaderSpec                       spec;
 321                                 int                                                     element                 = 0;
 322                                 GraphicsResources                       resources;
 323
 324                                 const StringTemplate            preMain(
 325                                         "${intdecl:opt}"
 326                                         "                %c_i32_128 = OpConstant %i32 128\n"
 327                                         "                   %uint_0 = OpConstant ${idx_uint} 0\n"
 328                                         "                 %uint_128 = OpConstant %u32 128\n"
 329                                         "                  %uint_32 = OpConstant %u32 32\n"
 330                                         "                   %uint_1 = OpConstant ${idx_uint} 1\n"
 331                                         "                   %uint_2 = OpConstant ${idx_uint} 2\n"
 332                                         "                   %uint_3 = OpConstant ${idx_uint} 3\n"
 333                                         "      %_arr_float_uint_128 = OpTypeArray %f32 %uint_128\n"
 334                                         "                   %Output = OpTypeStruct %_arr_float_uint_128\n"
 335                                         "      %_ptr_Uniform_Output = OpTypePointer Uniform %Output\n"
 336                                         "               %dataOutput = OpVariable %_ptr_Uniform_Output Uniform\n"
 337                                         "                    %int_0 = OpConstant ${idx_int} 0\n"
 338                                         "              %mat4v4float = OpTypeMatrix %v4f32 4\n"
 339                                         " %_arr_mat4v4float_uint_32 = OpTypeArray %mat4v4float %uint_32\n"
 340                                         " %_arr__arr_mat4v4float_uint_32_uint_32 = OpTypeArray %_arr_mat4v4float_uint_32 %uint_32\n"
 341                                         "              %InputStruct = OpTypeStruct %_arr__arr_mat4v4float_uint_32_uint_32\n"
 342                                         "           %InputStructArr = OpTypeArray %InputStruct %uint_2\n"
 343                                         "                    %Input = OpTypeStruct %InputStructArr\n"
 344                                         "        %_ptr_buffer_Input = OpTypePointer ${inputstorageclass} %Input\n"
 345                                         "                %dataInput = OpVariable %_ptr_buffer_Input ${inputstorageclass}\n"
 346                                         "  %_ptr_buffer_InputStruct = OpTypePointer ${inputstorageclass} %InputStruct\n"
 347                                         "     %_arr_v4uint_uint_128 = OpTypeArray %v4u32 %uint_128\n"
 348                                         "             %DataSelector = OpTypeStruct %_arr_v4uint_uint_128\n"
 349                                         "%_ptr_Uniform_DataSelector = OpTypePointer Uniform %DataSelector\n"
 350                                         "                 %selector = OpVariable %_ptr_Uniform_DataSelector Uniform\n"
 351                                         "      %_ptr_Uniform_uint32 = OpTypePointer Uniform %u32\n"
 352                                         "       %_ptr_Uniform_float = OpTypePointer Uniform %f32\n"
 353                                         "       ${ptr_buffer_float:opt}\n");
 354
 355
 356                                 const StringTemplate            decoration(
 357                                         "OpDecorate %_arr_float_uint_128 ArrayStride 4\n"
 358                                         "OpMemberDecorate %Output 0 Offset 0\n"
 359                                         "OpDecorate %Output BufferBlock\n"
 360                                         "OpDecorate %dataOutput DescriptorSet 0\n"
 361                                         "OpDecorate %dataOutput Binding 2\n"
 362                                         "OpDecorate %_arr_mat4v4float_uint_32 ArrayStride 64\n"
 363                                         "OpDecorate %_arr__arr_mat4v4float_uint_32_uint_32 ArrayStride 2048\n"
 364                                         "OpMemberDecorate %InputStruct 0 ColMajor\n"
 365                                         "OpMemberDecorate %InputStruct 0 Offset 0\n"
 366                                         "OpMemberDecorate %InputStruct 0 MatrixStride 16\n"
 367                                         "OpDecorate %InputStructArr ArrayStride 65536\n"
 368                                         "OpDecorate %Input ${inputdecoration}\n"
 369                                         "OpMemberDecorate %Input 0 Offset 0\n"
 370                                         "OpDecorate %dataInput DescriptorSet 0\n"
 371                                         "OpDecorate %dataInput Binding 0\n"
 372                                         "OpDecorate %_ptr_buffer_InputStruct ArrayStride 65536\n"
 373                                         "OpDecorate %_arr_v4uint_uint_128 ArrayStride 16\n"
 374                                         "OpMemberDecorate %DataSelector 0 Offset 0\n"
 375                                         "OpDecorate %DataSelector BufferBlock\n"
 376                                         "OpDecorate %selector DescriptorSet 0\n"
 377                                         "OpDecorate %selector Binding 1\n");
 378
 379                                 // Index an input buffer containing 2D array of 4x4 matrices. The indices are read from another
 380                                 // input and converted to the desired bit size and sign.
 381                                 const StringTemplate            testFun(
 382                                         "        %test_code = OpFunction %v4f32 None %v4f32_v4f32_function\n"
 383                                         "            %param = OpFunctionParameter %v4f32\n"
 384
 385                                         "            %entry = OpLabel\n"
 386                                         "                %i = OpVariable %fp_i32 Function\n"
 387                                         "                     OpStore %i %c_i32_0\n"
 388                                         "                     OpBranch %loop\n"
 389
 390                                         "             %loop = OpLabel\n"
 391                                         "               %15 = OpLoad %i32 %i\n"
 392                                         "               %lt = OpSLessThan %bool %15 %c_i32_128\n"
 393                                         "                     OpLoopMerge %merge %inc None\n"
 394                                         "                     OpBranchConditional %lt %write %merge\n"
 395
 396                                         "            %write = OpLabel\n"
 397                                         "            %int_i = OpLoad %i32 %i\n"
 398                                         "               %39 = OpAccessChain %_ptr_Uniform_uint32 %selector %int_0 %int_i %uint_0\n"
 399                                         "               %40 = OpLoad %u32 %39\n"
 400                                         "               %43 = OpAccessChain %_ptr_Uniform_uint32 %selector %int_0 %int_i %uint_1\n"
 401                                         "               %44 = OpLoad %u32 %43\n"
 402                                         "               %47 = OpAccessChain %_ptr_Uniform_uint32 %selector %int_0 %int_i %uint_2\n"
 403                                         "               %48 = OpLoad %u32 %47\n"
 404                                         "               %51 = OpAccessChain %_ptr_Uniform_uint32 %selector %int_0 %int_i %uint_3\n"
 405                                         "               %52 = OpLoad %u32 %51\n"
 406                                         "               %i0 = ${convert} ${idx_uint} %40\n"
 407                                         "               %i1 = ${convert} ${idx_uint} %44\n"
 408                                         "               %i2 = ${convert} ${idx_uint} %48\n"
 409                                         "               %i3 = ${convert} ${idx_uint} %52\n"
 410                                         "%inputFirstElement = OpAccessChain %_ptr_buffer_InputStruct %dataInput %uint_0 %uint_0\n"
 411                                         "               %54 = ${accesschain}\n"
 412                                         "               %55 = OpLoad %f32 %54\n"
 413                                         "               %56 = OpAccessChain %_ptr_Uniform_float %dataOutput %int_0 %int_i\n"
 414                                         "                     OpStore %56 %55\n"
 415                                         "                     OpBranch %inc\n"
 416
 417                                         "              %inc = OpLabel\n"
 418                                         "               %67 = OpLoad %i32 %i\n"
 419                                         "               %69 = OpIAdd %i32 %67 %c_i32_1\n"
 420                                         "                     OpStore %i %69\n"
 421                                         "                     OpBranch %loop\n"
 422
 423                                         "            %merge = OpLabel\n"
 424                                         "                     OpReturnValue %param\n"
 425
 426                                         "                     OpFunctionEnd\n");
 427
 428                                 resources.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputData)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
 429                                 resources.inputs.push_back(Resource(BufferSp(new Buffer<UVec4>(indexSelectorData)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
 430
 431                                 if (idxSize == 16)
 432                                 {
 433                                         fragments["capability"] = "OpCapability Int16\n";
 434                                         vulkanFeatures.coreFeatures.shaderInt16 = VK_TRUE;
 435                                         specs["convert"] = "OpUConvert";
 436                                         specs["intdecl"] =      "                      %u16 = OpTypeInt 16 0\n"
 437                                                                 "                      %i16 = OpTypeInt 16 1\n";
 438                                 }
 439                                 else if (idxSize == 64)
 440                                 {
 441                                         fragments["capability"] = "OpCapability Int64\n";
 442                                         vulkanFeatures.coreFeatures.shaderInt64 = VK_TRUE;
 443                                         specs["convert"] = "OpUConvert";
 444                                         specs["intdecl"] =      "                      %u64 = OpTypeInt 64 0\n"
 445                                                                 "                      %i64 = OpTypeInt 64 1\n";
 446                                 } else {
 447                                         specs["convert"] = "OpCopyObject";
 448                                 }
 449
 450                                 specs["idx_uint"] = "%u" + de::toString(idxSize);
 451                                 specs["idx_int"] = (sign ? "%i" : "%u") + de::toString(idxSize);
 452
 453                                 switch (chainOpIdx)
 454                                 {
 455                                         case CHAIN_OP_ACCESS_CHAIN:
 456                                                 specs["accesschain"]                            = "OpAccessChain %_ptr_Uniform_float %inputFirstElement %int_0 %i0 %i1 %i2 %i3\n";
 457                                                 specs["inputdecoration"]                        = "BufferBlock";
 458                                                 specs["inputstorageclass"]                      = "Uniform";
 459                                                 break;
 460                                         case CHAIN_OP_IN_BOUNDS_ACCESS_CHAIN:
 461                                                 specs["accesschain"]                            = "OpInBoundsAccessChain %_ptr_Uniform_float %inputFirstElement %int_0 %i0 %i1 %i2 %i3\n";
 462                                                 specs["inputdecoration"]                        = "BufferBlock";
 463                                                 specs["inputstorageclass"]                      = "Uniform";
 464                                                 break;
 465                                         default:
 466                                                 DE_ASSERT(chainOpIdx == CHAIN_OP_PTR_ACCESS_CHAIN);
 467                                                 specs["accesschain"]                            = "OpPtrAccessChain %_ptr_StorageBuffer_float %inputFirstElement %uint_1 %int_0 %i0 %i1 %i2 %i3\n";
 468                                                 specs["inputdecoration"]                        = "Block";
 469                                                 specs["inputstorageclass"]                      = "StorageBuffer";
 470                                                 specs["ptr_buffer_float"]                       = "%_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %f32";
 471                                                 fragments["capability"]                         += "OpCapability VariablePointersStorageBuffer";
 472                                                 fragments["extension"]                          = "OpExtension \"SPV_KHR_variable_pointers\"\nOpExtension \"SPV_KHR_storage_buffer_storage_class\"";
 473                                                 extensions.push_back                            ("VK_KHR_variable_pointers");
 474                                                 vulkanFeatures.extVariablePointers      = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
 475                                                 element = 1;
 476                                                 break;
 477                                 };
 478
 479                                 outputData.reserve(numItems);
 480                                 for (deUint32 numIdx = 0; numIdx < numItems; ++numIdx)
 481                                 {
 482                                         // Determine the selected output float for the selected indices.
 483                                         const UVec4 vec = indexSelectorData[numIdx];
 484                                         outputData.push_back(inputData[element * sizeof(InputData) / 4 + vec.x() * (32 * 4 * 4) + vec.y() * 4 * 4 + vec.z() * 4 + vec.w()]);
 485                                 }
 486
 487                                 resources.outputs.push_back(Resource(BufferSp(new Float32Buffer(outputData)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
 488
 489                                 fragments["pre_main"]   = preMain.specialize(specs);
 490                                 fragments["decoration"] = decoration.specialize(specs);
 491                                 fragments["testfun"]    = testFun.specialize(specs);
 492
 493                                 createTestsForAllStages(
 494                                                 testName.c_str(), defaultColors, defaultColors, fragments, noSpecConstants,
 495                                                 noPushConstants, resources, noInterfaces, extensions, vulkanFeatures, structGroup.get());
 496                         }
 497                 }
 498         }
 499         group->addChild(structGroup.release());
 500 }
 501
 502 void addGraphicsOutputComponentIndexingTests (tcu::TestCaseGroup* testGroup)
 503 {
 504         RGBA                            defaultColors[4];
 505         vector<string>          noExtensions;
 506         map<string, string>     fragments                       = passthruFragments();
 507         const deUint32          numItems                        = 4;
 508         vector<deInt32>         inputData;
 509         vector<float>           outputData;
 510         const deInt32           pattern[]                       = { 2, 0, 1, 3 };
 511
 512         for (deUint32 itemIdx = 0; itemIdx < numItems; ++itemIdx)
 513         {
 514                 Vec4 output(0.0f);
 515                 output[pattern[itemIdx]] = 1.0f;
 516                 outputData.push_back(output.x());
 517                 outputData.push_back(output.y());
 518                 outputData.push_back(output.z());
 519                 outputData.push_back(output.w());
 520                 inputData.push_back(pattern[itemIdx]);
 521         }
 522
 523         getDefaultColors(defaultColors);
 524
 525         fragments["pre_main"] =
 526                 "             %a3u32 = OpTypeArray %u32 %c_i32_3\n"
 527                 "          %ip_a3u32 = OpTypePointer Input %a3u32\n"
 528                 "%v4f32_u32_function = OpTypeFunction %v4f32 %u32\n";
 529
 530         fragments["interface_op_func"] =
 531                 "%interface_op_func = OpFunction %v4f32 None %v4f32_u32_function\n"
 532                 "        %io_param1 = OpFunctionParameter %u32\n"
 533                 "            %entry = OpLabel\n"
 534                 "              %ret = OpCompositeConstruct %v4f32 %c_f32_0 %c_f32_0 %c_f32_0 %c_f32_0\n"
 535                 "                     OpReturnValue %ret\n"
 536                 "                     OpFunctionEnd\n";
 537
 538         fragments["post_interface_op_vert"] = fragments["post_interface_op_frag"] =
 539                 "%cpntPtr = OpAccessChain %op_f32 %IF_output %IF_input_val\n"
 540                 "           OpStore %cpntPtr %c_f32_1\n";
 541
 542         fragments["post_interface_op_tessc"] =
 543                 "%cpntPtr0 = OpAccessChain %op_f32 %IF_output %c_i32_0 %IF_input_val0\n"
 544                 "           OpStore %cpntPtr0 %c_f32_1\n"
 545                 "%cpntPtr1 = OpAccessChain %op_f32 %IF_output %c_i32_1 %IF_input_val1\n"
 546                 "           OpStore %cpntPtr1 %c_f32_1\n"
 547                 "%cpntPtr2 = OpAccessChain %op_f32 %IF_output %c_i32_2 %IF_input_val2\n"
 548                 "           OpStore %cpntPtr2 %c_f32_1\n";
 549
 550         fragments["post_interface_op_tesse"] = fragments["post_interface_op_geom"] =
 551                 "%cpntPtr = OpAccessChain %op_f32 %IF_output %IF_input_val0\n"
 552                 "           OpStore %cpntPtr %c_f32_1\n";
 553
 554         fragments["input_type"]         = "u32";
 555         fragments["output_type"]        = "v4f32";
 556
 557         GraphicsInterfaces      interfaces;
 558
 559         interfaces.setInputOutput(std::make_pair(IFDataType(1, NUMBERTYPE_UINT32), BufferSp(new Int32Buffer(inputData))),
 560                                                           std::make_pair(IFDataType(4, NUMBERTYPE_FLOAT32), BufferSp(new Float32Buffer(outputData))));
 561
 562         createTestsForAllStages("component", defaultColors, defaultColors, fragments, interfaces, noExtensions, testGroup);
 563 }
 564
 565 void addComputeIndexingNon16BaseAlignmentTests (tcu::TestCaseGroup* group)
 566 {
 567         tcu::TestContext&                               testCtx                                 = group->getTestContext();
 568         de::MovePtr<tcu::TestCaseGroup> non16BaseAlignmentGroup (new tcu::TestCaseGroup(testCtx, "non16basealignment", "Tests for indexing array with base alignment less than 16."));
 569         de::Random                                              rnd                                             (deStringHash(group->getName()));
 570         const int                                               floatArraySize                  = 18;
 571         const int                                               numFloatArrays                  = 32;
 572
 573         const int                                               numInputFloats                  = floatArraySize * numFloatArrays;
 574         const int                                               numOutputFloats                 = numFloatArrays;
 575         vector<float>                                   inputData;
 576         VulkanFeatures                                  vulkanFeatures;
 577         vector<float>                                   outputData;
 578         ComputeShaderSpec                               spec;
 579         const ChainOp                                   chainOps[]                              = { CHAIN_OP_ACCESS_CHAIN, CHAIN_OP_PTR_ACCESS_CHAIN };
 580
 581         // Input is the following structure:
 582         //
 583         // struct
 584         // {
 585         //     struct
 586         //     {
 587         //         float f[18];
 588         //     } struct1[];
 589         // } struct 0;
 590         //
 591         // Each instance calculates a sum of f[0]..f[17] and outputs the result into float array.
 592         string                                                  shaderStr                               =
 593                         "                             OpCapability Shader\n"
 594                         "                             ${variablepointercaps:opt}\n"
 595                         "                             ${extensions:opt}\n"
 596                         "                        %1 = OpExtInstImport \"GLSL.std.450\"\n"
 597                         "                             OpMemoryModel Logical GLSL450\n"
 598                         "                             OpEntryPoint GLCompute %main \"main\" %gl_GlobalInvocationID\n"
 599                         "                             OpExecutionMode %main LocalSize 1 1 1\n"
 600                         "                             OpSource GLSL 430\n"
 601                         "                             OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId\n"
 602                         "                             OpDecorate %input_array ArrayStride 4\n"
 603                         "                             OpDecorate %output_array ArrayStride 4\n";
 604         shaderStr +=
 605                         "                             OpDecorate %runtimearr_struct1 ArrayStride " + de::toString(floatArraySize * 4) + "\n";
 606         shaderStr +=
 607                         "                             OpDecorate %_ptr_struct1_sb ArrayStride " + de::toString(floatArraySize * 4) + "\n";
 608         shaderStr +=
 609                         "                             OpMemberDecorate %Output 0 Offset 0\n"
 610                         "                             OpDecorate %Output Block\n"
 611                         "                             OpDecorate %dataOutput DescriptorSet 0\n"
 612                         "                             OpDecorate %dataOutput Binding 1\n"
 613                         "                             OpMemberDecorate %struct0 0 Offset 0\n"
 614                         "                             OpMemberDecorate %struct1 0 Offset 0\n"
 615                         "                             OpDecorate %struct0 Block\n"
 616                         "                             OpDecorate %dataInput DescriptorSet 0\n"
 617                         "                             OpDecorate %dataInput Binding 0\n"
 618                         "                     %void = OpTypeVoid\n"
 619                         "                        %3 = OpTypeFunction %void\n"
 620                         "                      %u32 = OpTypeInt 32 0\n"
 621                         "                      %i32 = OpTypeInt 32 1\n"
 622                         "     %_ptr_Function_uint32 = OpTypePointer Function %u32\n"
 623                         "                 %v3uint32 = OpTypeVector %u32 3\n"
 624                         "      %_ptr_Input_v3uint32 = OpTypePointer Input %v3uint32\n"
 625                         "    %gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint32 Input\n"
 626                         "        %_ptr_Input_uint32 = OpTypePointer Input %u32\n"
 627                         "                    %float = OpTypeFloat 32\n";
 628         for (deUint32 floatIdx = 0; floatIdx < floatArraySize + 1; ++floatIdx)
 629                 shaderStr += string("%uint_") + de::toString(floatIdx) + " = OpConstant %u32 " + de::toString(floatIdx) + "\n";
 630         shaderStr +=
 631                         "                  %uint_" + de::toString(numFloatArrays) + " = OpConstant %u32 " + de::toString(numFloatArrays) + "\n";
 632         shaderStr +=
 633                         "              %input_array = OpTypeArray %float %uint_" + de::toString(floatArraySize) + "\n";
 634         shaderStr +=
 635                         "             %output_array = OpTypeArray %float %uint_" + de::toString(numFloatArrays) + "\n";
 636         shaderStr +=
 637                         "                   %Output = OpTypeStruct %output_array\n"
 638                         "           %_ptr_sb_Output = OpTypePointer StorageBuffer %Output\n"
 639                         "               %dataOutput = OpVariable %_ptr_sb_Output StorageBuffer\n"
 640                         "                  %struct1 = OpTypeStruct %input_array\n"
 641                         "       %runtimearr_struct1 = OpTypeRuntimeArray %struct1\n"
 642                         "                  %struct0 = OpTypeStruct %runtimearr_struct1\n"
 643                         "          %_ptr_struct0_sb = OpTypePointer StorageBuffer %struct0\n"
 644                         "          %_ptr_struct1_sb = OpTypePointer StorageBuffer %struct1\n"
 645                         "            %_ptr_float_sb = OpTypePointer StorageBuffer %float\n"
 646                         "                %dataInput = OpVariable %_ptr_struct0_sb StorageBuffer\n"
 647                         "                     %main = OpFunction %void None %3\n"
 648                         "                    %entry = OpLabel\n"
 649                         "                     %base = OpAccessChain %_ptr_struct1_sb %dataInput %uint_0 %uint_0\n"
 650                         "                %invid_ptr = OpAccessChain %_ptr_Input_uint32 %gl_GlobalInvocationID %uint_0\n"
 651                         "                    %invid = OpLoad %u32 %invid_ptr\n";
 652         for (deUint32 floatIdx = 0; floatIdx < floatArraySize; ++floatIdx)
 653         {
 654                 shaderStr += string("%dataPtr") + de::toString(floatIdx) + " = ${chainop} %invid %uint_0 %uint_" + de::toString(floatIdx) + "\n";
 655                 if (floatIdx == 0)
 656                 {
 657                         shaderStr += "%acc0 = OpLoad %float %dataPtr0\n";
 658                 }
 659                 else
 660                 {
 661                         shaderStr += string("%tmp") + de::toString(floatIdx) + " = OpLoad %float %dataPtr" + de::toString(floatIdx) + "\n";
 662                         shaderStr += string("%acc") + de::toString(floatIdx) + " = OpFAdd %float %tmp" + de::toString(floatIdx) + " %acc" + de::toString(floatIdx - 1) + "\n";
 663                 }
 664         }
 665         shaderStr +=
 666                         "                   %outPtr = OpAccessChain %_ptr_float_sb %dataOutput %uint_0 %invid\n";
 667         shaderStr +=
 668                         "                             OpStore %outPtr %acc" + de::toString(floatArraySize - 1) + "\n";
 669         shaderStr +=
 670                         "                             OpReturn\n"
 671                         "                             OpFunctionEnd\n";
 672
 673         vulkanFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
 674         spec.extensions.push_back("VK_KHR_variable_pointers");
 675
 676         inputData.reserve(numInputFloats);
 677         for (deUint32 numIdx = 0; numIdx < numInputFloats; ++numIdx)
 678         {
 679                 float f = rnd.getFloat();
 680
 681                 // CPU might not use the same rounding mode as the GPU. Use whole numbers to avoid rounding differences.
 682                 f = deFloatFloor(f);
 683
 684                 inputData.push_back(f);
 685         }
 686
 687         spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputData)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
 688
 689         outputData.reserve(numOutputFloats);
 690         for (deUint32 outputIdx = 0; outputIdx < numOutputFloats; ++outputIdx)
 691         {
 692                 float f = 0.0f;
 693                 for (deUint32 arrIdx = 0; arrIdx < floatArraySize; ++arrIdx)
 694                         f += inputData[outputIdx * floatArraySize + arrIdx];
 695                 outputData.push_back(f);
 696         }
 697
 698         spec.numWorkGroups                              = IVec3(numFloatArrays, 1, 1);
 699         spec.requestedVulkanFeatures    = vulkanFeatures;
 700         spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(outputData)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
 701
 702         for (int chainOpIdx = 0; chainOpIdx < DE_LENGTH_OF_ARRAY(chainOps); ++chainOpIdx)
 703         {
 704                 const ChainOp           chainOp         = chainOps[chainOpIdx];
 705                 const string            testName        = chainOpTestNames[chainOp];
 706                 map<string, string>     specs;
 707
 708                 specs["variablepointercaps"]    = "OpCapability VariablePointersStorageBuffer";
 709                 specs["extensions"]                             = "OpExtension \"SPV_KHR_variable_pointers\"\n                             "
 710                                                                                   "OpExtension \"SPV_KHR_storage_buffer_storage_class\"";
 711                 switch(chainOp)
 712                 {
 713                         case CHAIN_OP_ACCESS_CHAIN:
 714                                 specs["chainop"] = "OpAccessChain %_ptr_float_sb %dataInput %uint_0 %uint_0";
 715                                 specs["chainop"] = "OpAccessChain %_ptr_float_sb %dataInput %uint_0";
 716                                 break;
 717                         case CHAIN_OP_PTR_ACCESS_CHAIN:
 718                                 specs["chainop"] = "OpPtrAccessChain %_ptr_float_sb %base";
 719                                 break;
 720                         default:
 721                                 DE_FATAL("Unexpected chain op");
 722                                 break;
 723                 }
 724
 725                 spec.assembly                                   = StringTemplate(shaderStr).specialize(specs);
 726
 727                 non16BaseAlignmentGroup->addChild(new SpvAsmComputeShaderCase(testCtx, testName.c_str(), testName.c_str(), spec));
 728         }
 729
 730         group->addChild(non16BaseAlignmentGroup.release());
 731 }
 732
 733 } // anonymous
 734
 735 tcu::TestCaseGroup* createIndexingComputeGroup (tcu::TestContext& testCtx)
 736 {
 737         de::MovePtr<tcu::TestCaseGroup> indexingGroup   (new tcu::TestCaseGroup(testCtx, "indexing", "Compute tests for data indexing."));
 738         de::MovePtr<tcu::TestCaseGroup> inputGroup              (new tcu::TestCaseGroup(testCtx, "input", "Tests for indexing input data."));
 739
 740         addComputeIndexingStructTests(inputGroup.get());
 741         addComputeIndexingNon16BaseAlignmentTests(inputGroup.get());
 742
 743         indexingGroup->addChild(inputGroup.release());
 744
 745         return indexingGroup.release();
 746 }
 747
 748 tcu::TestCaseGroup* createIndexingGraphicsGroup (tcu::TestContext& testCtx)
 749 {
 750         de::MovePtr<tcu::TestCaseGroup> indexingGroup   (new tcu::TestCaseGroup(testCtx, "indexing", "Graphics tests for data indexing."));
 751         de::MovePtr<tcu::TestCaseGroup> inputGroup              (new tcu::TestCaseGroup(testCtx, "input", "Tests for indexing input data."));
 752         de::MovePtr<tcu::TestCaseGroup> outputGroup             (new tcu::TestCaseGroup(testCtx, "output", "Tests for indexing output data."));
 753
 754         addGraphicsIndexingStructTests(inputGroup.get());
 755         addGraphicsOutputComponentIndexingTests(outputGroup.get());
 756
 757         indexingGroup->addChild(inputGroup.release());
 758         indexingGroup->addChild(outputGroup.release());
 759
 760         return indexingGroup.release();
 761 }
 762
 763 } // SpirVAssembly
 764 } // vkt