1 /*------------------------------------------------------------------------ 2 * Vulkan Conformance Tests 3 * ------------------------ 4 * 5 * Copyright (c) 2017 The Khronos Group Inc. 6 * Copyright (c) 2017 Codeplay Software Ltd. 7 * 8 * Licensed under the Apache License, Version 2.0 (the "License"); 9 * you may not use this file except in compliance with the License. 10 * You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, software 15 * distributed under the License is distributed on an "AS IS" BASIS, 16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 * See the License for the specific language governing permissions and 18 * limitations under the License. 19 * 20 */ /*! 21 * \file 22 * \brief Subgroups Tests 23 */ /*--------------------------------------------------------------------*/ 24 25 #include "vktSubgroupsBasicTests.hpp" 26 #include "vktSubgroupsTestsUtils.hpp" 27 28 #include <string> 29 #include <vector> 30 31 using namespace tcu; 32 using namespace std; 33 using namespace vk; 34 using namespace vkt; 35 36 namespace 37 { 38 static const deUint32 ELECTED_VALUE = 42u; 39 static const deUint32 UNELECTED_VALUE = 13u; 40 static const vk::VkDeviceSize SHADER_BUFFER_SIZE = 4096ull; // min(maxUniformBufferRange, maxImageDimension1D) 41 42 static bool checkFragmentSubgroupElect(std::vector<const void*> datas, 43 deUint32 width, deUint32 height, deUint32) 44 { 45 const deUint32* const resultData = 46 reinterpret_cast<const deUint32*>(datas[0]); 47 deUint32 poisonValuesFound = 0; 48 49 for (deUint32 x = 0; x < width; ++x) 50 { 51 for (deUint32 y = 0; y < height; ++y) 52 { 53 deUint32 val = resultData[y * width + x]; 54 55 switch (val) 56 { 57 default: 58 // some garbage value was found! 59 return false; 60 case UNELECTED_VALUE: 61 break; 62 case ELECTED_VALUE: 63 poisonValuesFound++; 64 break; 65 } 66 } 67 } 68 69 // we used an atomicly incremented counter to note how many subgroups we used for the fragment shader 70 const deUint32 numSubgroupsUsed = 71 *reinterpret_cast<const deUint32*>(datas[1]); 72 73 return numSubgroupsUsed == poisonValuesFound; 74 } 75 76 static bool checkFragmentSubgroupBarriers(std::vector<const void*> datas, 77 deUint32 width, deUint32 height, deUint32) 78 { 79 const deUint32* const resultData = reinterpret_cast<const deUint32*>(datas[0]); 80 81 // We used this SSBO to generate our unique value! 82 const deUint32 ref = *reinterpret_cast<const deUint32*>(datas[3]); 83 84 for (deUint32 x = 0; x < width; ++x) 85 { 86 for (deUint32 y = 0; y < height; ++y) 87 { 88 deUint32 val = resultData[x * height + y]; 89 90 if (val != ref) 91 { 92 return false; 93 } 94 } 95 } 96 97 return true; 98 } 99 100 static bool checkFragmentSubgroupBarriersNoSSBO(std::vector<const void*> datas, 101 deUint32 width, deUint32 height, deUint32) 102 { 103 const float* const resultData = reinterpret_cast<const float*>(datas[0]); 104 105 for (deUint32 x = 0u; x < width; ++x) 106 { 107 for (deUint32 y = 0u; y < height; ++y) 108 { 109 const deUint32 ndx = (x * height + y) * 4u; 110 if (1.0f == resultData[ndx +2]) 111 { 112 if(resultData[ndx] != resultData[ndx +1]) 113 { 114 return false; 115 } 116 } 117 else if (resultData[ndx] != resultData[ndx +3]) 118 { 119 return false; 120 } 121 } 122 } 123 124 return true; 125 } 126 127 static bool checkVertexPipelineStagesSubgroupElectNoSSBO(std::vector<const void*> datas, 128 deUint32 width, deUint32) 129 { 130 const float* const resultData = reinterpret_cast<const float*>(datas[0]); 131 float poisonValuesFound = 0.0f; 132 float numSubgroupsUsed = 0.0f; 133 134 for (deUint32 x = 0; x < width; ++x) 135 { 136 deUint32 val = static_cast<deUint32>(resultData[x * 2]); 137 numSubgroupsUsed += resultData[x * 2 + 1]; 138 139 switch (val) 140 { 141 default: 142 // some garbage value was found! 143 return false; 144 case UNELECTED_VALUE: 145 break; 146 case ELECTED_VALUE: 147 poisonValuesFound += 1.0f; 148 break; 149 } 150 } 151 return numSubgroupsUsed == poisonValuesFound; 152 } 153 154 static bool checkVertexPipelineStagesSubgroupElect(std::vector<const void*> datas, 155 deUint32 width, deUint32) 156 { 157 const deUint32* const resultData = 158 reinterpret_cast<const deUint32*>(datas[0]); 159 deUint32 poisonValuesFound = 0; 160 161 for (deUint32 x = 0; x < width; ++x) 162 { 163 deUint32 val = resultData[x]; 164 165 switch (val) 166 { 167 default: 168 // some garbage value was found! 169 return false; 170 case UNELECTED_VALUE: 171 break; 172 case ELECTED_VALUE: 173 poisonValuesFound++; 174 break; 175 } 176 } 177 178 // we used an atomicly incremented counter to note how many subgroups we used for the vertex shader 179 const deUint32 numSubgroupsUsed = 180 *reinterpret_cast<const deUint32*>(datas[1]); 181 182 return numSubgroupsUsed == poisonValuesFound; 183 } 184 185 static bool checkVertexPipelineStagesSubgroupBarriers(std::vector<const void*> datas, 186 deUint32 width, deUint32) 187 { 188 const deUint32* const resultData = reinterpret_cast<const deUint32*>(datas[0]); 189 190 // We used this SSBO to generate our unique value! 191 const deUint32 ref = *reinterpret_cast<const deUint32*>(datas[3]); 192 193 for (deUint32 x = 0; x < width; ++x) 194 { 195 deUint32 val = resultData[x]; 196 197 if (val != ref) 198 { 199 return false; 200 } 201 } 202 203 return true; 204 } 205 206 static bool checkVertexPipelineStagesSubgroupBarriersNoSSBO(std::vector<const void*> datas, 207 deUint32 width, deUint32) 208 { 209 const float* const resultData = reinterpret_cast<const float*>(datas[0]); 210 211 for (deUint32 x = 0u; x < width; ++x) 212 { 213 const deUint32 ndx = x*4u; 214 if (1.0f == resultData[ndx +2]) 215 { 216 if(resultData[ndx] != resultData[ndx +1]) 217 { 218 return false; 219 } 220 } 221 else if (resultData[ndx] != resultData[ndx +3]) 222 { 223 return false; 224 } 225 226 } 227 228 return true; 229 } 230 231 static bool checkComputeSubgroupElect(std::vector<const void*> datas, 232 const deUint32 numWorkgroups[3], const deUint32 localSize[3], 233 deUint32) 234 { 235 const deUint32* data = reinterpret_cast<const deUint32*>(datas[0]); 236 237 for (deUint32 nX = 0; nX < numWorkgroups[0]; ++nX) 238 { 239 for (deUint32 nY = 0; nY < numWorkgroups[1]; ++nY) 240 { 241 for (deUint32 nZ = 0; nZ < numWorkgroups[2]; ++nZ) 242 { 243 for (deUint32 lX = 0; lX < localSize[0]; ++lX) 244 { 245 for (deUint32 lY = 0; lY < localSize[1]; ++lY) 246 { 247 for (deUint32 lZ = 0; lZ < localSize[2]; 248 ++lZ) 249 { 250 const deUint32 globalInvocationX = 251 nX * localSize[0] + lX; 252 const deUint32 globalInvocationY = 253 nY * localSize[1] + lY; 254 const deUint32 globalInvocationZ = 255 nZ * localSize[2] + lZ; 256 257 const deUint32 globalSizeX = 258 numWorkgroups[0] * localSize[0]; 259 const deUint32 globalSizeY = 260 numWorkgroups[1] * localSize[1]; 261 262 const deUint32 offset = 263 globalSizeX * 264 ((globalSizeY * 265 globalInvocationZ) + 266 globalInvocationY) + 267 globalInvocationX; 268 if (1 != data[offset]) 269 { 270 return false; 271 } 272 } 273 } 274 } 275 } 276 } 277 } 278 279 return true; 280 } 281 282 static bool checkComputeSubgroupBarriers(std::vector<const void*> datas, 283 const deUint32 numWorkgroups[3], const deUint32 localSize[3], 284 deUint32) 285 { 286 const deUint32* data = reinterpret_cast<const deUint32*>(datas[0]); 287 288 // We used this SSBO to generate our unique value! 289 const deUint32 ref = *reinterpret_cast<const deUint32*>(datas[2]); 290 291 for (deUint32 nX = 0; nX < numWorkgroups[0]; ++nX) 292 { 293 for (deUint32 nY = 0; nY < numWorkgroups[1]; ++nY) 294 { 295 for (deUint32 nZ = 0; nZ < numWorkgroups[2]; ++nZ) 296 { 297 for (deUint32 lX = 0; lX < localSize[0]; ++lX) 298 { 299 for (deUint32 lY = 0; lY < localSize[1]; ++lY) 300 { 301 for (deUint32 lZ = 0; lZ < localSize[2]; 302 ++lZ) 303 { 304 const deUint32 globalInvocationX = 305 nX * localSize[0] + lX; 306 const deUint32 globalInvocationY = 307 nY * localSize[1] + lY; 308 const deUint32 globalInvocationZ = 309 nZ * localSize[2] + lZ; 310 311 const deUint32 globalSizeX = 312 numWorkgroups[0] * localSize[0]; 313 const deUint32 globalSizeY = 314 numWorkgroups[1] * localSize[1]; 315 316 const deUint32 offset = 317 globalSizeX * 318 ((globalSizeY * 319 globalInvocationZ) + 320 globalInvocationY) + 321 globalInvocationX; 322 323 if (ref != data[offset]) 324 { 325 return false; 326 } 327 } 328 } 329 } 330 } 331 } 332 } 333 334 return true; 335 } 336 337 enum OpType 338 { 339 OPTYPE_ELECT = 0, 340 OPTYPE_SUBGROUP_BARRIER, 341 OPTYPE_SUBGROUP_MEMORY_BARRIER, 342 OPTYPE_SUBGROUP_MEMORY_BARRIER_BUFFER, 343 OPTYPE_SUBGROUP_MEMORY_BARRIER_SHARED, 344 OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE, 345 OPTYPE_LAST 346 }; 347 348 std::string getOpTypeName(int opType) 349 { 350 switch (opType) 351 { 352 default: 353 DE_FATAL("Unsupported op type"); 354 case OPTYPE_ELECT: 355 return "subgroupElect"; 356 case OPTYPE_SUBGROUP_BARRIER: 357 return "subgroupBarrier"; 358 case OPTYPE_SUBGROUP_MEMORY_BARRIER: 359 return "subgroupMemoryBarrier"; 360 case OPTYPE_SUBGROUP_MEMORY_BARRIER_BUFFER: 361 return "subgroupMemoryBarrierBuffer"; 362 case OPTYPE_SUBGROUP_MEMORY_BARRIER_SHARED: 363 return "subgroupMemoryBarrierShared"; 364 case OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE: 365 return "subgroupMemoryBarrierImage"; 366 } 367 } 368 369 struct CaseDefinition 370 { 371 int opType; 372 VkShaderStageFlags shaderStage; 373 bool noSSBO; 374 }; 375 376 void initFrameBufferPrograms(SourceCollections& programCollection, CaseDefinition caseDef) 377 { 378 std::ostringstream vertexSrc; 379 std::ostringstream fragmentSrc; 380 if(VK_SHADER_STAGE_VERTEX_BIT == caseDef.shaderStage) 381 { 382 fragmentSrc << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450)<<"\n" 383 << "layout(location = 0) in vec4 in_color;\n" 384 << "layout(location = 0) out vec4 out_color;\n" 385 << "void main()\n" 386 <<"{\n" 387 << " out_color = in_color;\n" 388 << "}\n"; 389 programCollection.glslSources.add("fragment") << glu::FragmentSource(fragmentSrc.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 390 } 391 else if (VK_SHADER_STAGE_FRAGMENT_BIT == caseDef.shaderStage) 392 { 393 programCollection.glslSources.add("vert") << glu::VertexSource(subgroups::getVertShaderForStage(caseDef.shaderStage)) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 394 } 395 396 if (OPTYPE_ELECT == caseDef.opType) 397 { 398 if (VK_SHADER_STAGE_VERTEX_BIT == caseDef.shaderStage) 399 { 400 vertexSrc << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450)<<"\n" 401 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 402 << "layout(location = 0) out vec4 out_color;\n" 403 << "layout(location = 0) in highp vec4 in_position;\n" 404 << "\n" 405 << "void main (void)\n" 406 << "{\n" 407 << " if (subgroupElect())\n" 408 << " {\n" 409 << " out_color.r = " << ELECTED_VALUE << ";\n" 410 << " out_color.g = 1.0f;\n" 411 << " }\n" 412 << " else\n" 413 << " {\n" 414 << " out_color.r = " << UNELECTED_VALUE << ";\n" 415 << " out_color.g = 0.0f;\n" 416 << " }\n" 417 << " gl_Position = in_position;\n" 418 << " gl_PointSize = 1.0f;\n" 419 << "}\n"; 420 programCollection.glslSources.add("vert") 421 << glu::VertexSource(vertexSrc.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 422 } 423 else 424 { 425 DE_FATAL("Unsupported shader stage"); 426 } 427 } 428 else 429 { 430 std::ostringstream bdy; 431 switch (caseDef.opType) 432 { 433 default: 434 DE_FATAL("Unhandled op type!"); 435 case OPTYPE_SUBGROUP_BARRIER: 436 case OPTYPE_SUBGROUP_MEMORY_BARRIER: 437 case OPTYPE_SUBGROUP_MEMORY_BARRIER_BUFFER: 438 bdy << " tempResult2 = tempBuffer[id];\n" 439 << " if (subgroupElect())\n" 440 << " {\n" 441 << " tempResult = value;\n" 442 << " out_color.b = 1.0f;\n" 443 << " }\n" 444 << " else\n" 445 << " {\n" 446 << " tempResult = tempBuffer[id];\n" 447 << " }\n" 448 << " " << getOpTypeName(caseDef.opType) << "();\n"; 449 break; 450 case OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE: 451 bdy <<"tempResult2 = imageLoad(tempImage, ivec2(id, 0)).x;\n" 452 << " if (subgroupElect())\n" 453 << " {\n" 454 << " tempResult = value;\n" 455 << " out_color.b = 1.0f;\n" 456 << " }\n" 457 << " else\n" 458 << " {\n" 459 << " tempResult = imageLoad(tempImage, ivec2(id, 0)).x;\n" 460 << " }\n" 461 << " subgroupMemoryBarrierImage();\n"; 462 463 break; 464 } 465 466 if (VK_SHADER_STAGE_FRAGMENT_BIT == caseDef.shaderStage) 467 { 468 fragmentSrc << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450)<<"\n" 469 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 470 << "#extension GL_KHR_shader_subgroup_ballot: enable\n" 471 << "layout(location = 0) out vec4 out_color;\n" 472 << "\n" 473 << "layout(set = 0, binding = 0) uniform Buffer1\n" 474 << "{\n" 475 << " uint tempBuffer["<<SHADER_BUFFER_SIZE/4ull<<"];\n" 476 << "};\n" 477 << "\n" 478 << "layout(set = 0, binding = 1) uniform Buffer2\n" 479 << "{\n" 480 << " uint value;\n" 481 << "};\n" 482 << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(set = 0, binding = 2, r32ui) readonly uniform highp uimage2D tempImage;\n" : "\n") 483 << "void main (void)\n" 484 << "{\n" 485 << " if (gl_HelperInvocation) return;\n" 486 << " uint id = 0;\n" 487 << " if (subgroupElect())\n" 488 << " {\n" 489 << " id = uint(gl_FragCoord.x);\n" 490 << " }\n" 491 << " id = subgroupBroadcastFirst(id);\n" 492 << " uint localId = id;\n" 493 << " uint tempResult = 0u;\n" 494 << " uint tempResult2 = 0u;\n" 495 << " out_color.b = 0.0f;\n" 496 << bdy.str() 497 << " out_color.r = float(tempResult);\n" 498 << " out_color.g = float(value);\n" 499 << " out_color.a = float(tempResult2);\n" 500 << "}\n"; 501 502 programCollection.glslSources.add("fragment") << glu::FragmentSource(fragmentSrc.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 503 } 504 else if (VK_SHADER_STAGE_VERTEX_BIT == caseDef.shaderStage) 505 { 506 vertexSrc << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450)<<"\n" 507 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 508 << "#extension GL_KHR_shader_subgroup_ballot: enable\n" 509 <<"\n" 510 << "layout(location = 0) out vec4 out_color;\n" 511 << "layout(location = 0) in highp vec4 in_position;\n" 512 << "\n" 513 << "layout(set = 0, binding = 0) uniform Buffer1\n" 514 << "{\n" 515 << " uint tempBuffer["<<SHADER_BUFFER_SIZE/4ull<<"];\n" 516 << "};\n" 517 << "\n" 518 << "layout(set = 0, binding = 1) uniform Buffer2\n" 519 << "{\n" 520 << " uint value;\n" 521 << "};\n" 522 << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(set = 0, binding = 2, r32ui) readonly uniform highp uimage2D tempImage;\n" : "\n") 523 << "void main (void)\n" 524 << "{\n" 525 << " uint id = 0;\n" 526 << " if (subgroupElect())\n" 527 << " {\n" 528 << " id = gl_VertexIndex;\n" 529 << " }\n" 530 << " id = subgroupBroadcastFirst(id);\n" 531 << " uint tempResult = 0u;\n" 532 << " uint tempResult2 = 0u;\n" 533 << " out_color.b = 0.0f;\n" 534 << bdy.str() 535 << " out_color.r = float(tempResult);\n" 536 << " out_color.g = float(value);\n" 537 << " out_color.a = float(tempResult2);\n" 538 << " gl_Position = in_position;\n" 539 << " gl_PointSize = 1.0f;\n" 540 << "}\n"; 541 542 programCollection.glslSources.add("vert") << glu::VertexSource(vertexSrc.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 543 } 544 else 545 { 546 DE_FATAL("Unsupported shader stage"); 547 } 548 } 549 } 550 551 void initPrograms(SourceCollections& programCollection, CaseDefinition caseDef) 552 { 553 if (OPTYPE_ELECT == caseDef.opType) 554 { 555 if (VK_SHADER_STAGE_COMPUTE_BIT == caseDef.shaderStage) 556 { 557 std::ostringstream src; 558 559 src << "#version 450\n" 560 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 561 << "layout (local_size_x_id = 0, local_size_y_id = 1, " 562 "local_size_z_id = 2) in;\n" 563 << "layout(set = 0, binding = 0, std430) buffer Buffer1\n" 564 << "{\n" 565 << " uint result[];\n" 566 << "};\n" 567 << "\n" 568 << subgroups::getSharedMemoryBallotHelper() 569 << "void main (void)\n" 570 << "{\n" 571 << " uvec3 globalSize = gl_NumWorkGroups * gl_WorkGroupSize;\n" 572 << " highp uint offset = globalSize.x * ((globalSize.y * " 573 "gl_GlobalInvocationID.z) + gl_GlobalInvocationID.y) + " 574 "gl_GlobalInvocationID.x;\n" 575 << " uint value = " << UNELECTED_VALUE << ";\n" 576 << " if (subgroupElect())\n" 577 << " {\n" 578 << " value = " << ELECTED_VALUE << ";\n" 579 << " }\n" 580 << " uvec4 bits = bitCount(sharedMemoryBallot(value == " << ELECTED_VALUE << "));\n" 581 << " result[offset] = bits.x + bits.y + bits.z + bits.w;\n" 582 << "}\n"; 583 584 programCollection.glslSources.add("comp") 585 << glu::ComputeSource(src.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 586 } 587 else if (VK_SHADER_STAGE_FRAGMENT_BIT == caseDef.shaderStage) 588 { 589 programCollection.glslSources.add("vert") 590 << glu::VertexSource(subgroups::getVertShaderForStage(caseDef.shaderStage)) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 591 592 std::ostringstream frag; 593 594 frag << "#version 450\n" 595 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 596 << "layout(location = 0) out uint data;\n" 597 << "layout(set = 0, binding = 0, std430) buffer Buffer\n" 598 << "{\n" 599 << " uint numSubgroupsExecuted;\n" 600 << "};\n" 601 << "void main (void)\n" 602 << "{\n" 603 << " if (gl_HelperInvocation) return;\n" 604 << " if (subgroupElect())\n" 605 << " {\n" 606 << " data = " << ELECTED_VALUE << ";\n" 607 << " atomicAdd(numSubgroupsExecuted, 1);\n" 608 << " }\n" 609 << " else\n" 610 << " {\n" 611 << " data = " << UNELECTED_VALUE << ";\n" 612 << " }\n" 613 << "}\n"; 614 615 programCollection.glslSources.add("frag") 616 << glu::FragmentSource(frag.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 617 } 618 else if (VK_SHADER_STAGE_VERTEX_BIT == caseDef.shaderStage) 619 { 620 std::ostringstream src; 621 622 src << "#version 450\n" 623 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 624 << "layout(set = 0, binding = 0, std430) buffer Buffer1\n" 625 << "{\n" 626 << " uint result[];\n" 627 << "};\n" 628 << "layout(set = 0, binding = 1, std430) buffer Buffer2\n" 629 << "{\n" 630 << " uint numSubgroupsExecuted;\n" 631 << "};\n" 632 << "\n" 633 << "void main (void)\n" 634 << "{\n" 635 << " if (subgroupElect())\n" 636 << " {\n" 637 << " result[gl_VertexIndex] = " << ELECTED_VALUE << ";\n" 638 << " atomicAdd(numSubgroupsExecuted, 1);\n" 639 << " }\n" 640 << " else\n" 641 << " {\n" 642 << " result[gl_VertexIndex] = " << UNELECTED_VALUE << ";\n" 643 << " }\n" 644 << " gl_PointSize = 1.0f;\n" 645 << "}\n"; 646 647 programCollection.glslSources.add("vert") 648 << glu::VertexSource(src.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 649 } 650 else if (VK_SHADER_STAGE_GEOMETRY_BIT == caseDef.shaderStage) 651 { 652 programCollection.glslSources.add("vert") 653 << glu::VertexSource(subgroups::getVertShaderForStage(caseDef.shaderStage)) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 654 655 std::ostringstream src; 656 657 src << "#version 450\n" 658 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 659 << "layout(points) in;\n" 660 << "layout(points, max_vertices = 1) out;\n" 661 << "layout(set = 0, binding = 0, std430) buffer Buffer1\n" 662 << "{\n" 663 << " uint result[];\n" 664 << "};\n" 665 << "layout(set = 0, binding = 1, std430) buffer Buffer2\n" 666 << "{\n" 667 << " uint numSubgroupsExecuted;\n" 668 << "};\n" 669 << "\n" 670 << "void main (void)\n" 671 << "{\n" 672 << " if (subgroupElect())\n" 673 << " {\n" 674 << " result[gl_PrimitiveIDIn] = " << ELECTED_VALUE << ";\n" 675 << " atomicAdd(numSubgroupsExecuted, 1);\n" 676 << " }\n" 677 << " else\n" 678 << " {\n" 679 << " result[gl_PrimitiveIDIn] = " << UNELECTED_VALUE << ";\n" 680 << " }\n" 681 << "}\n"; 682 683 programCollection.glslSources.add("geom") 684 << glu::GeometrySource(src.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 685 } 686 else if (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT == caseDef.shaderStage) 687 { 688 programCollection.glslSources.add("vert") 689 << glu::VertexSource(subgroups::getVertShaderForStage(caseDef.shaderStage)) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 690 691 programCollection.glslSources.add("tese") 692 << glu::TessellationEvaluationSource("#version 450\nlayout(isolines) in;\nvoid main (void) {}\n"); 693 694 std::ostringstream src; 695 696 src << "#version 450\n" 697 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 698 << "layout(vertices=1) out;\n" 699 << "layout(set = 0, binding = 0, std430) buffer Buffer1\n" 700 << "{\n" 701 << " uint result[];\n" 702 << "};\n" 703 << "layout(set = 0, binding = 1, std430) buffer Buffer2\n" 704 << "{\n" 705 << " uint numSubgroupsExecuted;\n" 706 << "};\n" 707 << "\n" 708 << "void main (void)\n" 709 << "{\n" 710 << " if (subgroupElect())\n" 711 << " {\n" 712 << " result[gl_PrimitiveID] = " << ELECTED_VALUE << ";\n" 713 << " atomicAdd(numSubgroupsExecuted, 1);\n" 714 << " }\n" 715 << " else\n" 716 << " {\n" 717 << " result[gl_PrimitiveID] = " << UNELECTED_VALUE << ";\n" 718 << " }\n" 719 << "}\n"; 720 721 programCollection.glslSources.add("tesc") 722 << glu::TessellationControlSource(src.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 723 } 724 else if (VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT == caseDef.shaderStage) 725 { 726 programCollection.glslSources.add("vert") 727 << glu::VertexSource(subgroups::getVertShaderForStage(caseDef.shaderStage)) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 728 729 programCollection.glslSources.add("tesc") 730 << glu::TessellationControlSource("#version 450\nlayout(vertices=1) out;\nvoid main (void) { for(uint i = 0; i < 4; i++) { gl_TessLevelOuter[i] = 1.0f; } }\n"); 731 732 std::ostringstream src; 733 734 src << "#version 450\n" 735 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 736 << "layout(isolines) in;\n" 737 << "layout(set = 0, binding = 0, std430) buffer Buffer1\n" 738 << "{\n" 739 << " uint result[];\n" 740 << "};\n" 741 << "layout(set = 0, binding = 1, std430) buffer Buffer2\n" 742 << "{\n" 743 << " uint numSubgroupsExecuted;\n" 744 << "};\n" 745 << "\n" 746 << "void main (void)\n" 747 << "{\n" 748 << " if (subgroupElect())\n" 749 << " {\n" 750 << " result[gl_PrimitiveID * 2 + uint(gl_TessCoord.x + 0.5)] = " << ELECTED_VALUE << ";\n" 751 << " atomicAdd(numSubgroupsExecuted, 1);\n" 752 << " }\n" 753 << " else\n" 754 << " {\n" 755 << " result[gl_PrimitiveID * 2 + uint(gl_TessCoord.x + 0.5)] = " << UNELECTED_VALUE << ";\n" 756 << " }\n" 757 << "}\n"; 758 759 programCollection.glslSources.add("tese") 760 << glu::TessellationEvaluationSource(src.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 761 } 762 else 763 { 764 DE_FATAL("Unsupported shader stage"); 765 } 766 } 767 else 768 { 769 std::ostringstream bdy; 770 771 switch (caseDef.opType) 772 { 773 default: 774 DE_FATAL("Unhandled op type!"); 775 case OPTYPE_SUBGROUP_BARRIER: 776 case OPTYPE_SUBGROUP_MEMORY_BARRIER: 777 case OPTYPE_SUBGROUP_MEMORY_BARRIER_BUFFER: 778 bdy << " if (subgroupElect())\n" 779 << " {\n" 780 << " tempBuffer[id] = value;\n" 781 << " }\n" 782 << " " << getOpTypeName(caseDef.opType) << "();\n" 783 << " tempResult = tempBuffer[id];\n"; 784 break; 785 case OPTYPE_SUBGROUP_MEMORY_BARRIER_SHARED: 786 bdy << " if (subgroupElect())\n" 787 << " {\n" 788 << " tempShared[localId] = value;\n" 789 << " }\n" 790 << " subgroupMemoryBarrierShared();\n" 791 << " tempResult = tempShared[localId];\n"; 792 break; 793 case OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE: 794 bdy << " if (subgroupElect())\n" 795 << " {\n" 796 << " imageStore(tempImage, ivec2(id, 0), ivec4(value));\n" 797 << " }\n" 798 << " subgroupMemoryBarrierImage();\n" 799 << " tempResult = imageLoad(tempImage, ivec2(id, 0)).x;\n"; 800 break; 801 } 802 803 if (VK_SHADER_STAGE_COMPUTE_BIT == caseDef.shaderStage) 804 { 805 std::ostringstream src; 806 807 src << "#version 450\n" 808 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 809 << "layout (local_size_x_id = 0, local_size_y_id = 1, " 810 "local_size_z_id = 2) in;\n" 811 << "layout(set = 0, binding = 0, std430) buffer Buffer1\n" 812 << "{\n" 813 << " uint result[];\n" 814 << "};\n" 815 << "layout(set = 0, binding = 1, std430) buffer Buffer2\n" 816 << "{\n" 817 << " uint tempBuffer[];\n" 818 << "};\n" 819 << "layout(set = 0, binding = 2, std430) buffer Buffer3\n" 820 << "{\n" 821 << " uint value;\n" 822 << "};\n" 823 << "layout(set = 0, binding = 3, r32ui) uniform uimage2D tempImage;\n" 824 << "shared uint tempShared[gl_WorkGroupSize.x * gl_WorkGroupSize.y * gl_WorkGroupSize.z];\n" 825 << "\n" 826 << "void main (void)\n" 827 << "{\n" 828 << " uvec3 globalSize = gl_NumWorkGroups * gl_WorkGroupSize;\n" 829 << " highp uint offset = globalSize.x * ((globalSize.y * " 830 "gl_GlobalInvocationID.z) + gl_GlobalInvocationID.y) + " 831 "gl_GlobalInvocationID.x;\n" 832 << " uint localId = gl_SubgroupID;\n" 833 << " uint id = globalSize.x * ((globalSize.y * " 834 "gl_WorkGroupID.z) + gl_WorkGroupID.y) + " 835 "gl_WorkGroupID.x + localId;\n" 836 << " uint tempResult = 0;\n" 837 << bdy.str() 838 << " result[offset] = tempResult;\n" 839 << "}\n"; 840 841 programCollection.glslSources.add("comp") 842 << glu::ComputeSource(src.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 843 } 844 else if (VK_SHADER_STAGE_FRAGMENT_BIT == caseDef.shaderStage) 845 { 846 programCollection.glslSources.add("vert") 847 << glu::VertexSource(subgroups::getVertShaderForStage(caseDef.shaderStage)) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 848 849 std::ostringstream frag; 850 851 frag << "#version 450\n" 852 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 853 << "#extension GL_KHR_shader_subgroup_ballot: enable\n" 854 << "layout(location = 0) out uint result;\n" 855 << "layout(set = 0, binding = 0, std430) buffer Buffer1\n" 856 << "{\n" 857 << " uint tempBuffer[];\n" 858 << "};\n" 859 << "layout(set = 0, binding = 1, std430) buffer Buffer2\n" 860 << "{\n" 861 << " uint subgroupID;\n" 862 << "};\n" 863 << "layout(set = 0, binding = 2, std430) buffer Buffer3\n" 864 << "{\n" 865 << " uint value;\n" 866 << "};\n" 867 << "layout(set = 0, binding = 3, r32ui) uniform uimage2D tempImage;\n" 868 << "void main (void)\n" 869 << "{\n" 870 << " if (gl_HelperInvocation) return;\n" 871 << " uint id = 0;\n" 872 << " if (subgroupElect())\n" 873 << " {\n" 874 << " id = atomicAdd(subgroupID, 1);\n" 875 << " }\n" 876 << " id = subgroupBroadcastFirst(id);\n" 877 << " uint localId = id;\n" 878 << " uint tempResult = 0;\n" 879 << bdy.str() 880 << " result = tempResult;\n" 881 << "}\n"; 882 883 programCollection.glslSources.add("frag") 884 << glu::FragmentSource(frag.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 885 } 886 else if (VK_SHADER_STAGE_VERTEX_BIT == caseDef.shaderStage) 887 { 888 std::ostringstream src; 889 890 src << "#version 450\n" 891 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 892 << "#extension GL_KHR_shader_subgroup_ballot: enable\n" 893 << "layout(set = 0, binding = 0, std430) buffer Buffer1\n" 894 << "{\n" 895 << " uint result[];\n" 896 << "};\n" 897 << "layout(set = 0, binding = 1, std430) buffer Buffer2\n" 898 << "{\n" 899 << " uint tempBuffer[];\n" 900 << "};\n" 901 << "layout(set = 0, binding = 2, std430) buffer Buffer3\n" 902 << "{\n" 903 << " uint subgroupID;\n" 904 << "};\n" 905 << "layout(set = 0, binding = 3, std430) buffer Buffer4\n" 906 << "{\n" 907 << " uint value;\n" 908 << "};\n" 909 << "layout(set = 0, binding = 4, r32ui) uniform uimage2D tempImage;\n" 910 << "void main (void)\n" 911 << "{\n" 912 << " uint id = 0;\n" 913 << " if (subgroupElect())\n" 914 << " {\n" 915 << " id = atomicAdd(subgroupID, 1);\n" 916 << " }\n" 917 << " id = subgroupBroadcastFirst(id);\n" 918 << " uint localId = id;\n" 919 << " uint tempResult = 0;\n" 920 << bdy.str() 921 << " result[gl_VertexIndex] = tempResult;\n" 922 << " gl_PointSize = 1.0f;\n" 923 << "}\n"; 924 925 programCollection.glslSources.add("vert") 926 << glu::VertexSource(src.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 927 } 928 else if (VK_SHADER_STAGE_GEOMETRY_BIT == caseDef.shaderStage) 929 { 930 programCollection.glslSources.add("vert") 931 << glu::VertexSource(subgroups::getVertShaderForStage(caseDef.shaderStage)) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 932 933 std::ostringstream src; 934 935 src << "#version 450\n" 936 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 937 << "#extension GL_KHR_shader_subgroup_ballot: enable\n" 938 << "layout(points) in;\n" 939 << "layout(points, max_vertices = 1) out;\n" 940 << "layout(set = 0, binding = 0, std430) buffer Buffer1\n" 941 << "{\n" 942 << " uint result[];\n" 943 << "};\n" 944 << "layout(set = 0, binding = 1, std430) buffer Buffer2\n" 945 << "{\n" 946 << " uint tempBuffer[];\n" 947 << "};\n" 948 << "layout(set = 0, binding = 2, std430) buffer Buffer3\n" 949 << "{\n" 950 << " uint subgroupID;\n" 951 << "};\n" 952 << "layout(set = 0, binding = 3, std430) buffer Buffer4\n" 953 << "{\n" 954 << " uint value;\n" 955 << "};\n" 956 << "layout(set = 0, binding = 4, r32ui) uniform uimage2D tempImage;\n" 957 << "void main (void)\n" 958 << "{\n" 959 << " uint id = 0;\n" 960 << " if (subgroupElect())\n" 961 << " {\n" 962 << " id = atomicAdd(subgroupID, 1);\n" 963 << " }\n" 964 << " id = subgroupBroadcastFirst(id);\n" 965 << " uint localId = id;\n" 966 << " uint tempResult = 0;\n" 967 << bdy.str() 968 << " result[gl_PrimitiveIDIn] = tempResult;\n" 969 << "}\n"; 970 971 programCollection.glslSources.add("geom") 972 << glu::GeometrySource(src.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 973 } 974 else if (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT == caseDef.shaderStage) 975 { 976 programCollection.glslSources.add("vert") 977 << glu::VertexSource(subgroups::getVertShaderForStage(caseDef.shaderStage)) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 978 979 programCollection.glslSources.add("tese") 980 << glu::TessellationEvaluationSource("#version 450\nlayout(isolines) in;\nvoid main (void) {}\n"); 981 982 std::ostringstream src; 983 984 src << "#version 450\n" 985 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 986 << "#extension GL_KHR_shader_subgroup_ballot: enable\n" 987 << "layout(vertices=1) out;\n" 988 << "layout(set = 0, binding = 0, std430) buffer Buffer1\n" 989 << "{\n" 990 << " uint result[];\n" 991 << "};\n" 992 << "layout(set = 0, binding = 1, std430) buffer Buffer2\n" 993 << "{\n" 994 << " uint tempBuffer[];\n" 995 << "};\n" 996 << "layout(set = 0, binding = 2, std430) buffer Buffer3\n" 997 << "{\n" 998 << " uint subgroupID;\n" 999 << "};\n" 1000 << "layout(set = 0, binding = 3, std430) buffer Buffer4\n" 1001 << "{\n" 1002 << " uint value;\n" 1003 << "};\n" 1004 << "layout(set = 0, binding = 4, r32ui) uniform uimage2D tempImage;\n" 1005 << "void main (void)\n" 1006 << "{\n" 1007 << " uint id = 0;\n" 1008 << " if (subgroupElect())\n" 1009 << " {\n" 1010 << " id = atomicAdd(subgroupID, 1);\n" 1011 << " }\n" 1012 << " id = subgroupBroadcastFirst(id);\n" 1013 << " uint localId = id;\n" 1014 << " uint tempResult = 0;\n" 1015 << bdy.str() 1016 << " result[gl_PrimitiveID] = tempResult;\n" 1017 << "}\n"; 1018 1019 programCollection.glslSources.add("tesc") 1020 << glu::TessellationControlSource(src.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 1021 } 1022 else if (VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT == caseDef.shaderStage) 1023 { 1024 programCollection.glslSources.add("vert") 1025 << glu::VertexSource(subgroups::getVertShaderForStage(caseDef.shaderStage)) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 1026 1027 programCollection.glslSources.add("tesc") 1028 << glu::TessellationControlSource("#version 450\nlayout(vertices=1) out;\nvoid main (void) { for(uint i = 0; i < 4; i++) { gl_TessLevelOuter[i] = 1.0f; } }\n"); 1029 1030 std::ostringstream src; 1031 1032 src << "#version 450\n" 1033 << "#extension GL_KHR_shader_subgroup_basic: enable\n" 1034 << "#extension GL_KHR_shader_subgroup_ballot: enable\n" 1035 << "layout(isolines) in;\n" 1036 << "layout(set = 0, binding = 0, std430) buffer Buffer1\n" 1037 << "{\n" 1038 << " uint result[];\n" 1039 << "};\n" 1040 << "layout(set = 0, binding = 1, std430) buffer Buffer2\n" 1041 << "{\n" 1042 << " uint tempBuffer[];\n" 1043 << "};\n" 1044 << "layout(set = 0, binding = 2, std430) buffer Buffer3\n" 1045 << "{\n" 1046 << " uint subgroupID;\n" 1047 << "};\n" 1048 << "layout(set = 0, binding = 3, std430) buffer Buffer4\n" 1049 << "{\n" 1050 << " uint value;\n" 1051 << "};\n" 1052 << "layout(set = 0, binding = 4, r32ui) uniform uimage2D tempImage;\n" 1053 << "void main (void)\n" 1054 << "{\n" 1055 << " uint id = 0;\n" 1056 << " if (subgroupElect())\n" 1057 << " {\n" 1058 << " id = atomicAdd(subgroupID, 1);\n" 1059 << " }\n" 1060 << " id = subgroupBroadcastFirst(id);\n" 1061 << " uint localId = id;\n" 1062 << " uint tempResult = 0;\n" 1063 << bdy.str() 1064 << " result[gl_PrimitiveID * 2 + uint(gl_TessCoord.x + 0.5)] = tempResult;\n" 1065 << "}\n"; 1066 1067 programCollection.glslSources.add("tese") 1068 << glu::TessellationEvaluationSource(src.str()) << vk::ShaderBuildOptions(vk::SPIRV_VERSION_1_3, 0u); 1069 } 1070 else 1071 { 1072 DE_FATAL("Unsupported shader stage"); 1073 } 1074 } 1075 } 1076 1077 tcu::TestStatus test(Context& context, const CaseDefinition caseDef) 1078 { 1079 if (!subgroups::isSubgroupSupported(context)) 1080 TCU_THROW(NotSupportedError, "Subgroup operations are not supported"); 1081 1082 if (!subgroups::areSubgroupOperationsSupportedForStage( 1083 context, caseDef.shaderStage)) 1084 { 1085 if (subgroups::areSubgroupOperationsRequiredForStage( 1086 caseDef.shaderStage)) 1087 { 1088 return tcu::TestStatus::fail( 1089 "Shader stage " + 1090 subgroups::getShaderStageName(caseDef.shaderStage) + 1091 " is required to support subgroup operations!"); 1092 } 1093 else 1094 { 1095 TCU_THROW(NotSupportedError, "Device does not support subgroup operations for this stage"); 1096 } 1097 } 1098 1099 if (!subgroups::isSubgroupFeatureSupportedForDevice(context, VK_SUBGROUP_FEATURE_BASIC_BIT)) 1100 { 1101 return tcu::TestStatus::fail( 1102 "Subgroup feature " + 1103 subgroups::getSubgroupFeatureName(VK_SUBGROUP_FEATURE_BASIC_BIT) + 1104 " is a required capability!"); 1105 } 1106 1107 if (OPTYPE_ELECT != caseDef.opType && VK_SHADER_STAGE_COMPUTE_BIT != caseDef.shaderStage) 1108 { 1109 if (!subgroups::isSubgroupFeatureSupportedForDevice(context, VK_SUBGROUP_FEATURE_BALLOT_BIT)) 1110 { 1111 TCU_THROW(NotSupportedError, "Subgroup basic operation non-compute stage test required that ballot operations are supported!"); 1112 } 1113 } 1114 1115 //Tests which don't use the SSBO 1116 if(caseDef.noSSBO) 1117 { 1118 if (VK_SHADER_STAGE_VERTEX_BIT == caseDef.shaderStage) 1119 { 1120 if (OPTYPE_ELECT == caseDef.opType) 1121 { 1122 return subgroups::makeVertexFrameBufferTest(context, VK_FORMAT_R32G32_SFLOAT, 1123 DE_NULL, 0u, checkVertexPipelineStagesSubgroupElectNoSSBO); 1124 } 1125 else 1126 { 1127 const deUint32 inputDatasCount = OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? 3u : 2u; 1128 std::vector<subgroups::SSBOData> inputDatas (inputDatasCount); 1129 1130 inputDatas[0].format = VK_FORMAT_R32_UINT; 1131 inputDatas[0].numElements = SHADER_BUFFER_SIZE/4ull; 1132 inputDatas[0].initializeType = subgroups::SSBOData::InitializeNonZero; 1133 1134 inputDatas[1].format = VK_FORMAT_R32_UINT; 1135 inputDatas[1].numElements = 1ull; 1136 inputDatas[1].initializeType = subgroups::SSBOData::InitializeNonZero; 1137 1138 if(OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ) 1139 { 1140 inputDatas[2].format = VK_FORMAT_R32_UINT; 1141 inputDatas[2].numElements = SHADER_BUFFER_SIZE; 1142 inputDatas[2].initializeType = subgroups::SSBOData::InitializeNone; 1143 inputDatas[2].isImage = true; 1144 } 1145 1146 DE_ASSERT(SHADER_BUFFER_SIZE/4ull > subgroups::getSubgroupSize(context)); 1147 return subgroups::makeVertexFrameBufferTest(context, VK_FORMAT_R32G32B32A32_SFLOAT, 1148 &inputDatas[0], inputDatasCount, checkVertexPipelineStagesSubgroupBarriersNoSSBO); 1149 } 1150 } 1151 1152 if (VK_SHADER_STAGE_FRAGMENT_BIT == caseDef.shaderStage) 1153 { 1154 const deUint32 inputDatasCount = OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? 3u : 2u; 1155 std::vector<subgroups::SSBOData> inputDatas (inputDatasCount); 1156 1157 inputDatas[0].format = VK_FORMAT_R32_UINT; 1158 inputDatas[0].numElements = SHADER_BUFFER_SIZE/4ull; 1159 inputDatas[0].initializeType = subgroups::SSBOData::InitializeNonZero; 1160 1161 inputDatas[1].format = VK_FORMAT_R32_UINT; 1162 inputDatas[1].numElements = 1ull; 1163 inputDatas[1].initializeType = subgroups::SSBOData::InitializeNonZero; 1164 1165 if(OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ) 1166 { 1167 inputDatas[2].format = VK_FORMAT_R32_UINT; 1168 inputDatas[2].numElements = SHADER_BUFFER_SIZE; 1169 inputDatas[2].initializeType = subgroups::SSBOData::InitializeNone; 1170 inputDatas[2].isImage = true; 1171 } 1172 1173 return subgroups::makeFragmentFrameBufferTest(context, VK_FORMAT_R32G32B32A32_SFLOAT, 1174 &inputDatas[0], inputDatasCount, checkFragmentSubgroupBarriersNoSSBO); 1175 } 1176 } 1177 1178 if ((VK_SHADER_STAGE_FRAGMENT_BIT != caseDef.shaderStage) && 1179 (VK_SHADER_STAGE_COMPUTE_BIT != caseDef.shaderStage)) 1180 { 1181 if (!subgroups::isVertexSSBOSupportedForDevice(context)) 1182 { 1183 TCU_THROW(NotSupportedError, "Device does not support vertex stage SSBO writes"); 1184 } 1185 } 1186 1187 if (VK_SHADER_STAGE_FRAGMENT_BIT == caseDef.shaderStage) 1188 { 1189 if (!subgroups::isFragmentSSBOSupportedForDevice(context)) 1190 { 1191 TCU_THROW(NotSupportedError, "Subgroup basic operation require that the fragment stage be able to write to SSBOs!"); 1192 } 1193 1194 if (OPTYPE_ELECT == caseDef.opType) 1195 { 1196 subgroups::SSBOData inputData; 1197 inputData.format = VK_FORMAT_R32_UINT; 1198 inputData.numElements = 1; 1199 inputData.initializeType = subgroups::SSBOData::InitializeZero; 1200 1201 return subgroups::makeFragmentTest(context, VK_FORMAT_R32_UINT, 1202 &inputData, 1, checkFragmentSubgroupElect); 1203 } 1204 else 1205 { 1206 const deUint32 inputDatasCount = 4; 1207 subgroups::SSBOData inputDatas[inputDatasCount]; 1208 inputDatas[0].format = VK_FORMAT_R32_UINT; 1209 inputDatas[0].numElements = SHADER_BUFFER_SIZE; 1210 inputDatas[0].initializeType = subgroups::SSBOData::InitializeNonZero; 1211 1212 inputDatas[1].format = VK_FORMAT_R32_UINT; 1213 inputDatas[1].numElements = 1; 1214 inputDatas[1].initializeType = subgroups::SSBOData::InitializeZero; 1215 1216 inputDatas[2].format = VK_FORMAT_R32_UINT; 1217 inputDatas[2].numElements = 1; 1218 inputDatas[2].initializeType = subgroups::SSBOData::InitializeNonZero; 1219 1220 inputDatas[3].format = VK_FORMAT_R32_UINT; 1221 inputDatas[3].numElements = SHADER_BUFFER_SIZE; 1222 inputDatas[3].initializeType = subgroups::SSBOData::InitializeNone; 1223 inputDatas[3].isImage = true; 1224 1225 return subgroups::makeFragmentTest(context, VK_FORMAT_R32_UINT, 1226 inputDatas, inputDatasCount, checkFragmentSubgroupBarriers); 1227 1228 } 1229 } 1230 else if (VK_SHADER_STAGE_COMPUTE_BIT == caseDef.shaderStage) 1231 { 1232 if (OPTYPE_ELECT == caseDef.opType) 1233 { 1234 return subgroups::makeComputeTest(context, VK_FORMAT_R32_UINT, 1235 DE_NULL, 0, checkComputeSubgroupElect); 1236 } 1237 else 1238 { 1239 const deUint32 inputDatasCount = 3; 1240 subgroups::SSBOData inputDatas[inputDatasCount]; 1241 inputDatas[0].format = VK_FORMAT_R32_UINT; 1242 inputDatas[0].numElements = SHADER_BUFFER_SIZE; 1243 inputDatas[0].initializeType = subgroups::SSBOData::InitializeNone; 1244 1245 inputDatas[1].format = VK_FORMAT_R32_UINT; 1246 inputDatas[1].numElements = 1; 1247 inputDatas[1].initializeType = subgroups::SSBOData::InitializeNonZero; 1248 1249 inputDatas[2].format = VK_FORMAT_R32_UINT; 1250 inputDatas[2].numElements = SHADER_BUFFER_SIZE; 1251 inputDatas[2].initializeType = subgroups::SSBOData::InitializeNone; 1252 inputDatas[2].isImage = true; 1253 1254 return subgroups::makeComputeTest(context, VK_FORMAT_R32_UINT, 1255 inputDatas, inputDatasCount, checkComputeSubgroupBarriers); 1256 } 1257 } 1258 else if (VK_SHADER_STAGE_VERTEX_BIT == caseDef.shaderStage) 1259 { 1260 if (OPTYPE_ELECT == caseDef.opType) 1261 { 1262 subgroups::SSBOData inputData; 1263 inputData.format = VK_FORMAT_R32_UINT; 1264 inputData.numElements = 1; 1265 inputData.initializeType = subgroups::SSBOData::InitializeZero; 1266 1267 return subgroups::makeVertexTest(context, VK_FORMAT_R32_UINT, 1268 &inputData, 1, checkVertexPipelineStagesSubgroupElect); 1269 } 1270 else 1271 { 1272 const deUint32 inputDatasCount = 4; 1273 subgroups::SSBOData inputDatas[inputDatasCount]; 1274 inputDatas[0].format = VK_FORMAT_R32_UINT; 1275 inputDatas[0].numElements = SHADER_BUFFER_SIZE; 1276 inputDatas[0].initializeType = subgroups::SSBOData::InitializeNonZero; 1277 1278 inputDatas[1].format = VK_FORMAT_R32_UINT; 1279 inputDatas[1].numElements = 1; 1280 inputDatas[1].initializeType = subgroups::SSBOData::InitializeZero; 1281 1282 inputDatas[2].format = VK_FORMAT_R32_UINT; 1283 inputDatas[2].numElements = 1; 1284 inputDatas[2].initializeType = subgroups::SSBOData::InitializeNonZero; 1285 1286 inputDatas[3].format = VK_FORMAT_R32_UINT; 1287 inputDatas[3].numElements = SHADER_BUFFER_SIZE; 1288 inputDatas[3].initializeType = subgroups::SSBOData::InitializeNone; 1289 inputDatas[3].isImage = true; 1290 1291 return subgroups::makeVertexTest(context, VK_FORMAT_R32_UINT, 1292 inputDatas, inputDatasCount, checkVertexPipelineStagesSubgroupBarriers); 1293 } 1294 } 1295 else if (VK_SHADER_STAGE_GEOMETRY_BIT == caseDef.shaderStage) 1296 { 1297 if (OPTYPE_ELECT == caseDef.opType) 1298 { 1299 subgroups::SSBOData inputData; 1300 inputData.format = VK_FORMAT_R32_UINT; 1301 inputData.numElements = 1; 1302 inputData.initializeType = subgroups::SSBOData::InitializeZero; 1303 1304 return subgroups::makeGeometryTest(context, VK_FORMAT_R32_UINT, 1305 &inputData, 1, checkVertexPipelineStagesSubgroupElect); 1306 } 1307 else 1308 { 1309 const deUint32 inputDatasCount = 4; 1310 subgroups::SSBOData inputDatas[inputDatasCount]; 1311 inputDatas[0].format = VK_FORMAT_R32_UINT; 1312 inputDatas[0].numElements = SHADER_BUFFER_SIZE; 1313 inputDatas[0].initializeType = subgroups::SSBOData::InitializeNonZero; 1314 1315 inputDatas[1].format = VK_FORMAT_R32_UINT; 1316 inputDatas[1].numElements = 1; 1317 inputDatas[1].initializeType = subgroups::SSBOData::InitializeZero; 1318 1319 inputDatas[2].format = VK_FORMAT_R32_UINT; 1320 inputDatas[2].numElements = 1; 1321 inputDatas[2].initializeType = subgroups::SSBOData::InitializeNonZero; 1322 1323 inputDatas[3].format = VK_FORMAT_R32_UINT; 1324 inputDatas[3].numElements = SHADER_BUFFER_SIZE; 1325 inputDatas[3].initializeType = subgroups::SSBOData::InitializeNone; 1326 inputDatas[3].isImage = true; 1327 1328 return subgroups::makeGeometryTest(context, VK_FORMAT_R32_UINT, 1329 inputDatas, inputDatasCount, checkVertexPipelineStagesSubgroupBarriers); 1330 } 1331 } 1332 else if (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT == caseDef.shaderStage) 1333 { 1334 if (OPTYPE_ELECT == caseDef.opType) 1335 { 1336 subgroups::SSBOData inputData; 1337 inputData.format = VK_FORMAT_R32_UINT; 1338 inputData.numElements = 1; 1339 inputData.initializeType = subgroups::SSBOData::InitializeZero; 1340 1341 return subgroups::makeTessellationControlTest(context, VK_FORMAT_R32_UINT, 1342 &inputData, 1, checkVertexPipelineStagesSubgroupElect); 1343 } 1344 else 1345 { 1346 const deUint32 inputDatasCount = 4; 1347 subgroups::SSBOData inputDatas[inputDatasCount]; 1348 inputDatas[0].format = VK_FORMAT_R32_UINT; 1349 inputDatas[0].numElements = SHADER_BUFFER_SIZE; 1350 inputDatas[0].initializeType = subgroups::SSBOData::InitializeNonZero; 1351 1352 inputDatas[1].format = VK_FORMAT_R32_UINT; 1353 inputDatas[1].numElements = 1; 1354 inputDatas[1].initializeType = subgroups::SSBOData::InitializeZero; 1355 1356 inputDatas[2].format = VK_FORMAT_R32_UINT; 1357 inputDatas[2].numElements = 1; 1358 inputDatas[2].initializeType = subgroups::SSBOData::InitializeNonZero; 1359 1360 inputDatas[3].format = VK_FORMAT_R32_UINT; 1361 inputDatas[3].numElements = SHADER_BUFFER_SIZE; 1362 inputDatas[3].initializeType = subgroups::SSBOData::InitializeNone; 1363 inputDatas[3].isImage = true; 1364 1365 return subgroups::makeTessellationControlTest(context, VK_FORMAT_R32_UINT, 1366 inputDatas, inputDatasCount, checkVertexPipelineStagesSubgroupBarriers); 1367 } 1368 } 1369 else if (VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT == caseDef.shaderStage) 1370 { 1371 if (OPTYPE_ELECT == caseDef.opType) 1372 { 1373 subgroups::SSBOData inputData; 1374 inputData.format = VK_FORMAT_R32_UINT; 1375 inputData.numElements = 1; 1376 inputData.initializeType = subgroups::SSBOData::InitializeZero; 1377 1378 return subgroups::makeTessellationEvaluationTest(context, VK_FORMAT_R32_UINT, 1379 &inputData, 1, checkVertexPipelineStagesSubgroupElect); 1380 } 1381 else 1382 { 1383 const deUint32 inputDatasCount = 4; 1384 subgroups::SSBOData inputDatas[inputDatasCount]; 1385 inputDatas[0].format = VK_FORMAT_R32_UINT; 1386 inputDatas[0].numElements = SHADER_BUFFER_SIZE; 1387 inputDatas[0].initializeType = subgroups::SSBOData::InitializeNonZero; 1388 1389 inputDatas[1].format = VK_FORMAT_R32_UINT; 1390 inputDatas[1].numElements = 1; 1391 inputDatas[1].initializeType = subgroups::SSBOData::InitializeZero; 1392 1393 inputDatas[2].format = VK_FORMAT_R32_UINT; 1394 inputDatas[2].numElements = 1; 1395 inputDatas[2].initializeType = subgroups::SSBOData::InitializeNonZero; 1396 1397 inputDatas[3].format = VK_FORMAT_R32_UINT; 1398 inputDatas[3].numElements = SHADER_BUFFER_SIZE; 1399 inputDatas[3].initializeType = subgroups::SSBOData::InitializeNone; 1400 inputDatas[3].isImage = true; 1401 1402 return subgroups::makeTessellationEvaluationTest(context, VK_FORMAT_R32_UINT, 1403 inputDatas, inputDatasCount, checkVertexPipelineStagesSubgroupBarriers); 1404 } 1405 } 1406 else 1407 { 1408 TCU_THROW(InternalError, "Unhandled shader stage"); 1409 } 1410 } 1411 } 1412 1413 namespace vkt 1414 { 1415 namespace subgroups 1416 { 1417 tcu::TestCaseGroup* createSubgroupsBasicTests(tcu::TestContext& testCtx) 1418 { 1419 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup( 1420 testCtx, "basic", "Subgroup basic category tests")); 1421 1422 const VkShaderStageFlags stages[] = 1423 { 1424 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, 1425 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, 1426 VK_SHADER_STAGE_GEOMETRY_BIT, 1427 VK_SHADER_STAGE_VERTEX_BIT, 1428 VK_SHADER_STAGE_FRAGMENT_BIT, 1429 VK_SHADER_STAGE_COMPUTE_BIT 1430 }; 1431 1432 for (int stageIndex = 0; stageIndex < DE_LENGTH_OF_ARRAY(stages); ++stageIndex) 1433 { 1434 const VkShaderStageFlags stage = stages[stageIndex]; 1435 1436 for (int opTypeIndex = 0; opTypeIndex < OPTYPE_LAST; ++opTypeIndex) 1437 { 1438 if ((OPTYPE_SUBGROUP_MEMORY_BARRIER_SHARED == opTypeIndex) && 1439 (VK_SHADER_STAGE_COMPUTE_BIT != stage)) 1440 { 1441 // Shared isn't available in non compute shaders. 1442 continue; 1443 } 1444 1445 CaseDefinition caseDef = {opTypeIndex, stage, false}; 1446 1447 std::string op = getOpTypeName(opTypeIndex); 1448 1449 addFunctionCaseWithPrograms(group.get(), 1450 de::toLower(op) + 1451 "_" + getShaderStageName(stage), "", 1452 initPrograms, test, caseDef); 1453 1454 if ((VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT) & stage ) 1455 { 1456 if (OPTYPE_ELECT != caseDef.opType || VK_SHADER_STAGE_FRAGMENT_BIT != stage) 1457 { 1458 caseDef.noSSBO = true; 1459 addFunctionCaseWithPrograms(group.get(), 1460 de::toLower(op) + "_" + 1461 getShaderStageName(stage)+"_framebuffer", "", 1462 initFrameBufferPrograms, test, caseDef); 1463 } 1464 } 1465 } 1466 } 1467 1468 return group.release(); 1469 } 1470 1471 } // subgroups 1472 } // vkt 1473
