external/vulkancts/modules/vulkan/shaderexecutor/vktAtomicOperationTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 The Khronos Group Inc.
   6  * Copyright (c) 2017 Google Inc.
   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 Atomic operations (OpAtomic*) tests.
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktAtomicOperationTests.hpp"
  26 #include "vktShaderExecutor.hpp"
  27
  28 #include "vkRefUtil.hpp"
  29 #include "vkMemUtil.hpp"
  30 #include "vkQueryUtil.hpp"
  31 #include "vktTestGroupUtil.hpp"
  32
  33 #include "tcuTestLog.hpp"
  34 #include "tcuStringTemplate.hpp"
  35 #include "tcuResultCollector.hpp"
  36
  37 #include "deStringUtil.hpp"
  38 #include "deSharedPtr.hpp"
  39 #include "deRandom.hpp"
  40 #include "deArrayUtil.hpp"
  41
  42 #include <string>
  43
  44 namespace vkt
  45 {
  46 namespace shaderexecutor
  47 {
  48
  49 namespace
  50 {
  51
  52 using de::UniquePtr;
  53 using de::MovePtr;
  54 using std::vector;
  55
  56 using namespace vk;
  57
  58 // Buffer helper
  59 class Buffer
  60 {
  61 public:
  62                                                 Buffer                          (Context& context, VkBufferUsageFlags usage, size_t size);
  63
  64         VkBuffer                        getBuffer                       (void) const { return *m_buffer;                                        }
  65         void*                           getHostPtr                      (void) const { return m_allocation->getHostPtr();       }
  66         void                            flush                           (void);
  67         void                            invalidate                      (void);
  68
  69 private:
  70         const DeviceInterface&          m_vkd;
  71         const VkDevice                          m_device;
  72         const Unique<VkBuffer>          m_buffer;
  73         const UniquePtr<Allocation>     m_allocation;
  74 };
  75
  76 typedef de::SharedPtr<Buffer> BufferSp;
  77
  78 Move<VkBuffer> createBuffer (const DeviceInterface& vkd, VkDevice device, VkDeviceSize size, VkBufferUsageFlags usageFlags)
  79 {
  80         const VkBufferCreateInfo createInfo     =
  81         {
  82                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
  83                 DE_NULL,
  84                 (VkBufferCreateFlags)0,
  85                 size,
  86                 usageFlags,
  87                 VK_SHARING_MODE_EXCLUSIVE,
  88                 0u,
  89                 DE_NULL
  90         };
  91         return createBuffer(vkd, device, &createInfo);
  92 }
  93
  94 MovePtr<Allocation> allocateAndBindMemory (const DeviceInterface& vkd, VkDevice device, Allocator& allocator, VkBuffer buffer)
  95 {
  96         MovePtr<Allocation>     alloc(allocator.allocate(getBufferMemoryRequirements(vkd, device, buffer), MemoryRequirement::HostVisible));
  97
  98         VK_CHECK(vkd.bindBufferMemory(device, buffer, alloc->getMemory(), alloc->getOffset()));
  99
 100         return alloc;
 101 }
 102
 103 Buffer::Buffer (Context& context, VkBufferUsageFlags usage, size_t size)
 104         : m_vkd                 (context.getDeviceInterface())
 105         , m_device              (context.getDevice())
 106         , m_buffer              (createBuffer                   (context.getDeviceInterface(),
 107                                                                                          context.getDevice(),
 108                                                                                          (VkDeviceSize)size,
 109                                                                                          usage))
 110         , m_allocation  (allocateAndBindMemory  (context.getDeviceInterface(),
 111                                                                                          context.getDevice(),
 112                                                                                          context.getDefaultAllocator(),
 113                                                                                          *m_buffer))
 114 {
 115 }
 116
 117 void Buffer::flush (void)
 118 {
 119         flushMappedMemoryRange(m_vkd, m_device, m_allocation->getMemory(), m_allocation->getOffset(), VK_WHOLE_SIZE);
 120 }
 121
 122 void Buffer::invalidate (void)
 123 {
 124         invalidateMappedMemoryRange(m_vkd, m_device, m_allocation->getMemory(), m_allocation->getOffset(), VK_WHOLE_SIZE);
 125 }
 126
 127 // Tests
 128
 129 enum AtomicOperation
 130 {
 131         ATOMIC_OP_EXCHANGE = 0,
 132         ATOMIC_OP_COMP_SWAP,
 133         ATOMIC_OP_ADD,
 134         ATOMIC_OP_MIN,
 135         ATOMIC_OP_MAX,
 136         ATOMIC_OP_AND,
 137         ATOMIC_OP_OR,
 138         ATOMIC_OP_XOR,
 139
 140         ATOMIC_OP_LAST
 141 };
 142
 143 std::string atomicOp2Str (AtomicOperation op)
 144 {
 145         static const char* const s_names[] =
 146         {
 147                 "atomicExchange",
 148                 "atomicCompSwap",
 149                 "atomicAdd",
 150                 "atomicMin",
 151                 "atomicMax",
 152                 "atomicAnd",
 153                 "atomicOr",
 154                 "atomicXor"
 155         };
 156         return de::getSizedArrayElement<ATOMIC_OP_LAST>(s_names, op);
 157 }
 158
 159 enum
 160 {
 161         NUM_ELEMENTS = 32
 162 };
 163
 164 class AtomicOperationCaseInstance : public TestInstance
 165 {
 166 public:
 167                                                                         AtomicOperationCaseInstance             (Context&                       context,
 168                                                                                                                                          const ShaderSpec&      shaderSpec,
 169                                                                                                                                          glu::ShaderType        shaderType,
 170                                                                                                                                          bool                           sign,
 171                                                                                                                                          AtomicOperation        atomicOp);
 172         virtual                                                 ~AtomicOperationCaseInstance    (void);
 173
 174         virtual tcu::TestStatus                 iterate                                                 (void);
 175
 176 private:
 177         const ShaderSpec&                               m_shaderSpec;
 178         glu::ShaderType                                 m_shaderType;
 179         bool                                                    m_sign;
 180         AtomicOperation                                 m_atomicOp;
 181
 182         struct BufferInterface
 183         {
 184                 // Use half the number of elements for inout to cause overlap between atomic operations.
 185                 // Each inout element at index i will have two atomic operations using input from
 186                 // indices i and i + NUM_ELEMENTS / 2.
 187                 deInt32         index;
 188                 deUint32        inout[NUM_ELEMENTS / 2];
 189                 deUint32        input[NUM_ELEMENTS];
 190                 deUint32        compare[NUM_ELEMENTS];
 191                 deUint32        output[NUM_ELEMENTS];
 192         };
 193
 194         template<typename T>
 195         struct Expected
 196         {
 197                 T m_inout;
 198                 T m_output[2];
 199
 200                 Expected (T inout, T output0, T output1)
 201                 : m_inout(inout)
 202                 {
 203                         m_output[0] = output0;
 204                         m_output[1] = output1;
 205                 }
 206
 207                 bool compare (deUint32 inout, deUint32 output0, deUint32 output1)
 208                 {
 209                         return (deMemCmp((const void*)&m_inout, (const void*)&inout, sizeof(inout)) == 0
 210                                         && deMemCmp((const void*)&m_output[0], (const void*)&output0, sizeof(output0)) == 0
 211                                         && deMemCmp((const void*)&m_output[1], (const void*)&output1, sizeof(output1)) == 0);
 212                 }
 213         };
 214
 215         template<typename T> void checkOperation        (const BufferInterface& original,
 216                                                                                                  const BufferInterface& result,
 217                                                                                                  tcu::ResultCollector&  resultCollector);
 218
 219 };
 220
 221 AtomicOperationCaseInstance::AtomicOperationCaseInstance (Context&                      context,
 222                                                                                                                   const ShaderSpec&     shaderSpec,
 223                                                                                                                   glu::ShaderType       shaderType,
 224                                                                                                                   bool                          sign,
 225                                                                                                                   AtomicOperation       atomicOp)
 226         : TestInstance  (context)
 227         , m_shaderSpec  (shaderSpec)
 228         , m_shaderType  (shaderType)
 229         , m_sign                (sign)
 230         , m_atomicOp    (atomicOp)
 231 {
 232 }
 233
 234 AtomicOperationCaseInstance::~AtomicOperationCaseInstance (void)
 235 {
 236 }
 237
 238 // Use template to handle both signed and unsigned cases. SPIR-V should
 239 // have separate operations for both.
 240 template<typename T>
 241 void AtomicOperationCaseInstance::checkOperation (const BufferInterface&        original,
 242                                                                                                   const BufferInterface&        result,
 243                                                                                                   tcu::ResultCollector&         resultCollector)
 244 {
 245         // originalInout = original inout
 246         // input0 = input at index i
 247         // iinput1 = input at index i + NUM_ELEMENTS / 2
 248         //
 249         // atomic operation will return the memory contents before
 250         // the operation and this is stored as output. Two operations
 251         // are executed for each InOut value (using input0 and input1).
 252         //
 253         // Since there is an overlap of two operations per each
 254         // InOut element, the outcome of the resulting InOut and
 255         // the outputs of the operations have two result candidates
 256         // depending on the execution order. Verification passes
 257         // if the results match one of these options.
 258
 259         for (int elementNdx = 0; elementNdx < NUM_ELEMENTS / 2; elementNdx++)
 260         {
 261                 // Needed when reinterpeting the data as signed values.
 262                 const T originalInout   = *reinterpret_cast<const T*>(&original.inout[elementNdx]);
 263                 const T input0                  = *reinterpret_cast<const T*>(&original.input[elementNdx]);
 264                 const T input1                  = *reinterpret_cast<const T*>(&original.input[elementNdx + NUM_ELEMENTS / 2]);
 265
 266                 // Expected results are collected to this vector.
 267                 vector<Expected<T> > exp;
 268
 269                 switch (m_atomicOp)
 270                 {
 271                         case ATOMIC_OP_ADD:
 272                         {
 273                                 exp.push_back(Expected<T>(originalInout + input0 + input1, originalInout, originalInout + input0));
 274                                 exp.push_back(Expected<T>(originalInout + input0 + input1, originalInout + input1, originalInout));
 275                         }
 276                         break;
 277
 278                         case ATOMIC_OP_AND:
 279                         {
 280                                 exp.push_back(Expected<T>(originalInout & input0 & input1, originalInout, originalInout & input0));
 281                                 exp.push_back(Expected<T>(originalInout & input0 & input1, originalInout & input1, originalInout));
 282                         }
 283                         break;
 284
 285                         case ATOMIC_OP_OR:
 286                         {
 287                                 exp.push_back(Expected<T>(originalInout | input0 | input1, originalInout, originalInout | input0));
 288                                 exp.push_back(Expected<T>(originalInout | input0 | input1, originalInout | input1, originalInout));
 289                         }
 290                         break;
 291
 292                         case ATOMIC_OP_XOR:
 293                         {
 294                                 exp.push_back(Expected<T>(originalInout ^ input0 ^ input1, originalInout, originalInout ^ input0));
 295                                 exp.push_back(Expected<T>(originalInout ^ input0 ^ input1, originalInout ^ input1, originalInout));
 296                         }
 297                         break;
 298
 299                         case ATOMIC_OP_MIN:
 300                         {
 301                                 exp.push_back(Expected<T>(de::min(de::min(originalInout, input0), input1), originalInout, de::min(originalInout, input0)));
 302                                 exp.push_back(Expected<T>(de::min(de::min(originalInout, input0), input1), de::min(originalInout, input1), originalInout));
 303                         }
 304                         break;
 305
 306                         case ATOMIC_OP_MAX:
 307                         {
 308                                 exp.push_back(Expected<T>(de::max(de::max(originalInout, input0), input1), originalInout, de::max(originalInout, input0)));
 309                                 exp.push_back(Expected<T>(de::max(de::max(originalInout, input0), input1), de::max(originalInout, input1), originalInout));
 310                         }
 311                         break;
 312
 313                         case ATOMIC_OP_EXCHANGE:
 314                         {
 315                                 exp.push_back(Expected<T>(input1, originalInout, input0));
 316                                 exp.push_back(Expected<T>(input0, input1, originalInout));
 317                         }
 318                         break;
 319
 320                         case ATOMIC_OP_COMP_SWAP:
 321                         {
 322                                 if (elementNdx % 2 == 0)
 323                                 {
 324                                         exp.push_back(Expected<T>(input0, originalInout, input0));
 325                                         exp.push_back(Expected<T>(input0, originalInout, originalInout));
 326                                 }
 327                                 else
 328                                 {
 329                                         exp.push_back(Expected<T>(input1, input1, originalInout));
 330                                         exp.push_back(Expected<T>(input1, originalInout, originalInout));
 331                                 }
 332                         }
 333                         break;
 334
 335
 336                         default:
 337                                 DE_FATAL("Unexpected atomic operation.");
 338                                 break;
 339                 };
 340
 341                 const deUint32 resIo            = result.inout[elementNdx];
 342                 const deUint32 resOutput0       = result.output[elementNdx];
 343                 const deUint32 resOutput1       = result.output[elementNdx + NUM_ELEMENTS / 2];
 344
 345                 if (!exp[0].compare(resIo, resOutput0, resOutput1) && !exp[1].compare(resIo, resOutput0, resOutput1))
 346                 {
 347                         std::ostringstream errorMessage;
 348                         errorMessage    << "ERROR: Result value check failed at index " << elementNdx
 349                                                         << ". Expected one of the two outcomes: InOut = " << tcu::toHex(exp[0].m_inout)
 350                                                         << ", Output0 = " << tcu::toHex(exp[0].m_output[0]) << ", Output1 = "
 351                                                         << tcu::toHex(exp[0].m_output[1]) << ", or InOut = " << tcu::toHex(exp[1].m_inout)
 352                                                         << ", Output0 = " << tcu::toHex(exp[1].m_output[0]) << ", Output1 = "
 353                                                         << tcu::toHex(exp[1].m_output[1]) << ". Got: InOut = " << tcu::toHex(resIo)
 354                                                         << ", Output0 = " << tcu::toHex(resOutput0) << ", Output1 = "
 355                                                         << tcu::toHex(resOutput1) << ". Using Input0 = " << tcu::toHex(original.input[elementNdx])
 356                                                         << " and Input1 = " << tcu::toHex(original.input[elementNdx + NUM_ELEMENTS / 2]) << ".";
 357
 358                         resultCollector.fail(errorMessage.str());
 359                 }
 360         }
 361 }
 362
 363 tcu::TestStatus AtomicOperationCaseInstance::iterate (void)
 364 {
 365         //Check stores and atomic operation support.
 366         switch (m_shaderType)
 367         {
 368                 case glu::SHADERTYPE_VERTEX:
 369                 case glu::SHADERTYPE_TESSELLATION_CONTROL:
 370                 case glu::SHADERTYPE_TESSELLATION_EVALUATION:
 371                 case glu::SHADERTYPE_GEOMETRY:
 372                         if(!m_context.getDeviceFeatures().vertexPipelineStoresAndAtomics)
 373                                 TCU_THROW(NotSupportedError, "Stores and atomic operations are not supported in Vertex, Tessellation, and Geometry shader.");
 374                         break;
 375                 case glu::SHADERTYPE_FRAGMENT:
 376                         if(!m_context.getDeviceFeatures().fragmentStoresAndAtomics)
 377                                 TCU_THROW(NotSupportedError, "Stores and atomic operations are not supported in fragment shader.");
 378                         break;
 379                 case glu::SHADERTYPE_COMPUTE:
 380                         break;
 381                 default:
 382                         DE_FATAL("Unsupported shader type");
 383         }
 384
 385         tcu::TestLog&                           log                     = m_context.getTestContext().getLog();
 386         const DeviceInterface&          vkd                     = m_context.getDeviceInterface();
 387         const VkDevice                          device          = m_context.getDevice();
 388         de::Random                                      rnd                     (0x62a15e34);
 389         Buffer                                          buffer          (m_context, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, sizeof(BufferInterface));
 390         BufferInterface*                        ptr                     = (BufferInterface*)buffer.getHostPtr();
 391
 392         for (int i = 0; i < NUM_ELEMENTS / 2; i++)
 393         {
 394                 ptr->inout[i] = rnd.getUint32();
 395                 // The first half of compare elements match with every even index.
 396                 // The second half matches with odd indices. This causes the
 397                 // overlapping operations to only select one.
 398                 ptr->compare[i] = ptr->inout[i] + (i % 2);
 399                 ptr->compare[i + NUM_ELEMENTS / 2] = ptr->inout[i] + 1 - (i % 2);
 400         }
 401         for (int i = 0; i < NUM_ELEMENTS; i++)
 402         {
 403                 ptr->input[i] = rnd.getUint32();
 404                 ptr->output[i] = 0xcdcdcdcd;
 405         }
 406         ptr->index = 0;
 407
 408         // Take a copy to be used when calculating expected values.
 409         BufferInterface original = *ptr;
 410
 411         buffer.flush();
 412
 413         Move<VkDescriptorSetLayout>     extraResourcesLayout;
 414         Move<VkDescriptorPool>          extraResourcesSetPool;
 415         Move<VkDescriptorSet>           extraResourcesSet;
 416
 417         const VkDescriptorSetLayoutBinding bindings[] =
 418         {
 419                 { 0u, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_ALL, DE_NULL }
 420         };
 421
 422         const VkDescriptorSetLayoutCreateInfo   layoutInfo      =
 423         {
 424                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
 425                 DE_NULL,
 426                 (VkDescriptorSetLayoutCreateFlags)0u,
 427                 DE_LENGTH_OF_ARRAY(bindings),
 428                 bindings
 429         };
 430
 431         extraResourcesLayout = createDescriptorSetLayout(vkd, device, &layoutInfo);
 432
 433         const VkDescriptorPoolSize poolSizes[] =
 434         {
 435                 { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u }
 436         };
 437         const VkDescriptorPoolCreateInfo poolInfo =
 438         {
 439                 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
 440                 DE_NULL,
 441                 (VkDescriptorPoolCreateFlags)VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
 442                 1u,             // maxSets
 443                 DE_LENGTH_OF_ARRAY(poolSizes),
 444                 poolSizes
 445         };
 446
 447         extraResourcesSetPool = createDescriptorPool(vkd, device, &poolInfo);
 448
 449         const VkDescriptorSetAllocateInfo allocInfo =
 450         {
 451                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
 452                 DE_NULL,
 453                 *extraResourcesSetPool,
 454                 1u,
 455                 &extraResourcesLayout.get()
 456         };
 457
 458         extraResourcesSet = allocateDescriptorSet(vkd, device, &allocInfo);
 459
 460         VkDescriptorBufferInfo bufferInfo;
 461         bufferInfo.buffer       = buffer.getBuffer();
 462         bufferInfo.offset       = 0u;
 463         bufferInfo.range        = VK_WHOLE_SIZE;
 464
 465         const VkWriteDescriptorSet descriptorWrite =
 466         {
 467                 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
 468                 DE_NULL,
 469                 *extraResourcesSet,
 470                 0u,             // dstBinding
 471                 0u,             // dstArrayElement
 472                 1u,
 473                 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
 474                 (const VkDescriptorImageInfo*)DE_NULL,
 475                 &bufferInfo,
 476                 (const VkBufferView*)DE_NULL
 477         };
 478
 479
 480         vkd.updateDescriptorSets(device, 1u, &descriptorWrite, 0u, DE_NULL);
 481
 482         // Storage for output varying data.
 483         std::vector<deUint32>   outputs         (NUM_ELEMENTS);
 484         std::vector<void*>              outputPtr       (NUM_ELEMENTS);
 485
 486         for (size_t i = 0; i < NUM_ELEMENTS; i++)
 487         {
 488                 outputs[i] = 0xcdcdcdcd;
 489                 outputPtr[i] = &outputs[i];
 490         }
 491
 492         UniquePtr<ShaderExecutor> executor(createExecutor(m_context, m_shaderType, m_shaderSpec, *extraResourcesLayout));
 493         executor->execute(NUM_ELEMENTS, DE_NULL, &outputPtr[0], *extraResourcesSet);
 494         buffer.invalidate();
 495
 496         tcu::ResultCollector resultCollector(log);
 497
 498         // Check the results of the atomic operation
 499         if (m_sign)
 500                 checkOperation<deInt32>(original, *ptr, resultCollector);
 501         else
 502                 checkOperation<deUint32>(original, *ptr, resultCollector);
 503
 504         return tcu::TestStatus(resultCollector.getResult(), resultCollector.getMessage());
 505 }
 506
 507 class AtomicOperationCase : public TestCase
 508 {
 509 public:
 510                                                         AtomicOperationCase             (tcu::TestContext&              testCtx,
 511                                                                                                          const char*                    name,
 512                                                                                                          const char*                    description,
 513                                                                                                          glu::ShaderType                type,
 514                                                                                                          bool                                   sign,
 515                                                                                                          AtomicOperation                atomicOp);
 516         virtual                                 ~AtomicOperationCase    (void);
 517
 518         virtual TestInstance*   createInstance                  (Context& ctx) const;
 519         virtual void                    initPrograms                    (vk::SourceCollections& programCollection) const
 520         {
 521                 generateSources(m_shaderType, m_shaderSpec, programCollection);
 522         }
 523
 524 private:
 525
 526         void                                    createShaderSpec();
 527         ShaderSpec                              m_shaderSpec;
 528         const glu::ShaderType   m_shaderType;
 529         const bool                              m_sign;
 530         const AtomicOperation   m_atomicOp;
 531 };
 532
 533 AtomicOperationCase::AtomicOperationCase (tcu::TestContext&     testCtx,
 534                                                                                   const char*           name,
 535                                                                                   const char*           description,
 536                                                                                   glu::ShaderType       shaderType,
 537                                                                                   bool                          sign,
 538                                                                                   AtomicOperation       atomicOp)
 539         : TestCase                      (testCtx, name, description)
 540         , m_shaderType          (shaderType)
 541         , m_sign                        (sign)
 542         , m_atomicOp            (atomicOp)
 543 {
 544         createShaderSpec();
 545         init();
 546 }
 547
 548 AtomicOperationCase::~AtomicOperationCase (void)
 549 {
 550 }
 551
 552 TestInstance* AtomicOperationCase::createInstance (Context& ctx) const
 553 {
 554         return new AtomicOperationCaseInstance(ctx, m_shaderSpec, m_shaderType, m_sign, m_atomicOp);
 555 }
 556
 557 void AtomicOperationCase::createShaderSpec (void)
 558 {
 559         const tcu::StringTemplate shaderTemplateGlobal(
 560                 "layout (set = ${SETIDX}, binding = 0, std430) buffer AtomicBuffer\n"
 561                 "{\n"
 562                 "    highp int index;\n"
 563                 "    highp ${DATATYPE} inoutValues[${N}/2];\n"
 564                 "    highp ${DATATYPE} inputValues[${N}];\n"
 565                 "    highp ${DATATYPE} compareValues[${N}];\n"
 566                 "    highp ${DATATYPE} outputValues[${N}];\n"
 567                 "} buf;\n");
 568
 569         std::map<std::string, std::string> specializations;
 570         specializations["DATATYPE"] = m_sign ? "int" : "uint";
 571         specializations["ATOMICOP"] = atomicOp2Str(m_atomicOp);
 572         specializations["SETIDX"] = de::toString((int)EXTRA_RESOURCES_DESCRIPTOR_SET_INDEX);
 573         specializations["N"] = de::toString((int)NUM_ELEMENTS);
 574         specializations["COMPARE_ARG"] = m_atomicOp == ATOMIC_OP_COMP_SWAP ? "buf.compareValues[idx], " : "";
 575
 576         const tcu::StringTemplate shaderTemplateSrc(
 577                 "int idx = atomicAdd(buf.index, 1);\n"
 578                 "buf.outputValues[idx] = ${ATOMICOP}(buf.inoutValues[idx % (${N}/2)], ${COMPARE_ARG}buf.inputValues[idx]);\n");
 579
 580         m_shaderSpec.outputs.push_back(Symbol("outData", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));
 581         m_shaderSpec.globalDeclarations = shaderTemplateGlobal.specialize(specializations);
 582         m_shaderSpec.source = shaderTemplateSrc.specialize(specializations);
 583 }
 584
 585 void addAtomicOperationTests (tcu::TestCaseGroup* atomicOperationTestsGroup)
 586 {
 587         tcu::TestContext& testCtx = atomicOperationTestsGroup->getTestContext();
 588
 589         static const struct
 590         {
 591                 glu::ShaderType type;
 592                 const char*             name;
 593         } shaderTypes[] =
 594         {
 595                 { glu::SHADERTYPE_VERTEX,                                       "vertex"        },
 596                 { glu::SHADERTYPE_FRAGMENT,                                     "fragment"      },
 597                 { glu::SHADERTYPE_GEOMETRY,                                     "geometry"      },
 598                 { glu::SHADERTYPE_TESSELLATION_CONTROL,         "tess_ctrl"     },
 599                 { glu::SHADERTYPE_TESSELLATION_EVALUATION,      "tess_eval"     },
 600                 { glu::SHADERTYPE_COMPUTE,                                      "compute"       }
 601         };
 602
 603         static const struct
 604         {
 605                 bool                    value;
 606                 const char*             name;
 607                 const char*             description;
 608         } dataSign[] =
 609         {
 610                 { true,         "signed",       "Tests using signed data (int)"         },
 611                 { false,        "unsigned",     "Tests using unsigned data (uint)"      }
 612         };
 613
 614         static const struct
 615         {
 616                 AtomicOperation         value;
 617                 const char*                     name;
 618         } atomicOp[] =
 619         {
 620                 { ATOMIC_OP_EXCHANGE,   "exchange"      },
 621                 { ATOMIC_OP_COMP_SWAP,  "comp_swap"     },
 622                 { ATOMIC_OP_ADD,                "add"           },
 623                 { ATOMIC_OP_MIN,                "min"           },
 624                 { ATOMIC_OP_MAX,                "max"           },
 625                 { ATOMIC_OP_AND,                "and"           },
 626                 { ATOMIC_OP_OR,                 "or"            },
 627                 { ATOMIC_OP_XOR,                "xor"           }
 628         };
 629
 630         for (int opNdx = 0; opNdx < DE_LENGTH_OF_ARRAY(atomicOp); opNdx++)
 631         {
 632                 for (int signNdx = 0; signNdx < DE_LENGTH_OF_ARRAY(dataSign); signNdx++)
 633                 {
 634                         for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(shaderTypes); shaderTypeNdx++)
 635                         {
 636                                 const std::string description = std::string("Tests atomic operation ") + atomicOp2Str(atomicOp[opNdx].value) + std::string(".");
 637                                 std::string name = std::string(atomicOp[opNdx].name) + "_" + std::string(dataSign[signNdx].name) + "_" + std::string(shaderTypes[shaderTypeNdx].name);
 638                                 atomicOperationTestsGroup->addChild(new AtomicOperationCase(testCtx, name.c_str(), description.c_str(), shaderTypes[shaderTypeNdx].type, dataSign[signNdx].value, atomicOp[opNdx].value));
 639                         }
 640                 }
 641         }
 642 }
 643
 644 } // anonymous
 645
 646 tcu::TestCaseGroup* createAtomicOperationTests (tcu::TestContext& testCtx)
 647 {
 648         return createTestGroup(testCtx, "atomic_operations", "Atomic Operation Tests", addAtomicOperationTests);
 649 }
 650
 651 } // shaderexecutor
 652 } // vkt