modules/gles31/functional/es31fSynchronizationTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   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 Synchronization Tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fSynchronizationTests.hpp"
  25 #include "tcuTestLog.hpp"
  26 #include "tcuSurface.hpp"
  27 #include "tcuRenderTarget.hpp"
  28 #include "gluRenderContext.hpp"
  29 #include "gluShaderProgram.hpp"
  30 #include "gluObjectWrapper.hpp"
  31 #include "gluPixelTransfer.hpp"
  32 #include "gluContextInfo.hpp"
  33 #include "glwFunctions.hpp"
  34 #include "glwEnums.hpp"
  35 #include "deStringUtil.hpp"
  36 #include "deSharedPtr.hpp"
  37 #include "deMemory.h"
  38 #include "deRandom.hpp"
  39
  40 #include <map>
  41
  42 namespace deqp
  43 {
  44 namespace gles31
  45 {
  46 namespace Functional
  47 {
  48 namespace
  49 {
  50
  51
  52 static bool validateSortedAtomicRampAdditionValueChain (const std::vector<deUint32>& valueChain, deUint32 sumValue, int& invalidOperationNdx, deUint32& errorDelta, deUint32& errorExpected)
  53 {
  54         std::vector<deUint32> chainDelta(valueChain.size());
  55
  56         for (int callNdx = 0; callNdx < (int)valueChain.size(); ++callNdx)
  57                 chainDelta[callNdx] = ((callNdx + 1 == (int)valueChain.size()) ? (sumValue) : (valueChain[callNdx+1])) - valueChain[callNdx];
  58
  59         // chainDelta contains now the actual additions applied to the value
  60         // check there exists an addition ramp form 1 to ...
  61         std::sort(chainDelta.begin(), chainDelta.end());
  62
  63         for (int callNdx = 0; callNdx < (int)valueChain.size(); ++callNdx)
  64         {
  65                 if ((int)chainDelta[callNdx] != callNdx+1)
  66                 {
  67                         invalidOperationNdx = callNdx;
  68                         errorDelta = chainDelta[callNdx];
  69                         errorExpected = callNdx+1;
  70
  71                         return false;
  72                 }
  73         }
  74
  75         return true;
  76 }
  77
  78 static void readBuffer (const glw::Functions& gl, deUint32 target, int numElements, std::vector<deUint32>& result)
  79 {
  80         const void* ptr = gl.mapBufferRange(target, 0, (int)(sizeof(deUint32) * numElements), GL_MAP_READ_BIT);
  81         GLU_EXPECT_NO_ERROR(gl.getError(), "map");
  82
  83         if (!ptr)
  84                 throw tcu::TestError("mapBufferRange returned NULL");
  85
  86         result.resize(numElements);
  87         memcpy(&result[0], ptr, sizeof(deUint32) * numElements);
  88
  89         if (gl.unmapBuffer(target) == GL_FALSE)
  90                 throw tcu::TestError("unmapBuffer returned false");
  91 }
  92
  93 static deUint32 readBufferUint32 (const glw::Functions& gl, deUint32 target)
  94 {
  95         std::vector<deUint32> vec;
  96
  97         readBuffer(gl, target, 1, vec);
  98
  99         return vec[0];
 100 }
 101
 102 //! Generate a ramp of values from 1 to numElements, and shuffle it
 103 void generateShuffledRamp (int numElements, std::vector<int>& ramp)
 104 {
 105         de::Random rng(0xabcd);
 106
 107         // some positive (non-zero) unique values
 108         ramp.resize(numElements);
 109         for (int callNdx = 0; callNdx < numElements; ++callNdx)
 110                 ramp[callNdx] = callNdx + 1;
 111
 112         rng.shuffle(ramp.begin(), ramp.end());
 113 }
 114
 115 class InterInvocationTestCase : public TestCase
 116 {
 117 public:
 118         enum StorageType
 119         {
 120                 STORAGE_BUFFER = 0,
 121                 STORAGE_IMAGE,
 122
 123                 STORAGE_LAST
 124         };
 125         enum CaseFlags
 126         {
 127                 FLAG_ATOMIC                             = 0x1,
 128                 FLAG_ALIASING_STORAGES  = 0x2,
 129                 FLAG_IN_GROUP                   = 0x4,
 130         };
 131
 132                                                 InterInvocationTestCase         (Context& context, const char* name, const char* desc, StorageType storage, int flags = 0);
 133                                                 ~InterInvocationTestCase        (void);
 134
 135 private:
 136         void                            init                                            (void);
 137         void                            deinit                                          (void);
 138         IterateResult           iterate                                         (void);
 139
 140         void                            runCompute                                      (void);
 141         bool                            verifyResults                           (void);
 142         virtual std::string     genShaderSource                         (void) const = 0;
 143
 144 protected:
 145         std::string                     genBarrierSource                        (void) const;
 146
 147         const StorageType       m_storage;
 148         const bool                      m_useAtomic;
 149         const bool                      m_aliasingStorages;
 150         const bool                      m_syncWithGroup;
 151         const int                       m_workWidth;                            // !< total work width
 152         const int                       m_workHeight;                           // !<     ...    height
 153         const int                       m_localWidth;                           // !< group width
 154         const int                       m_localHeight;                          // !< group height
 155         const int                       m_elementsPerInvocation;        // !< elements accessed by a single invocation
 156
 157 private:
 158         glw::GLuint                     m_storageBuf;
 159         glw::GLuint                     m_storageTex;
 160         glw::GLuint                     m_resultBuf;
 161         glu::ShaderProgram*     m_program;
 162 };
 163
 164 InterInvocationTestCase::InterInvocationTestCase (Context& context, const char* name, const char* desc, StorageType storage, int flags)
 165         : TestCase                                      (context, name, desc)
 166         , m_storage                                     (storage)
 167         , m_useAtomic                           ((flags & FLAG_ATOMIC) != 0)
 168         , m_aliasingStorages            ((flags & FLAG_ALIASING_STORAGES) != 0)
 169         , m_syncWithGroup                       ((flags & FLAG_IN_GROUP) != 0)
 170         , m_workWidth                           (256)
 171         , m_workHeight                          (256)
 172         , m_localWidth                          (16)
 173         , m_localHeight                         (8)
 174         , m_elementsPerInvocation       (8)
 175         , m_storageBuf                          (0)
 176         , m_storageTex                          (0)
 177         , m_resultBuf                           (0)
 178         , m_program                                     (DE_NULL)
 179 {
 180         DE_ASSERT(m_storage < STORAGE_LAST);
 181         DE_ASSERT(m_localWidth*m_localHeight <= 128); // minimum MAX_COMPUTE_WORK_GROUP_INVOCATIONS value
 182 }
 183
 184 InterInvocationTestCase::~InterInvocationTestCase (void)
 185 {
 186         deinit();
 187 }
 188
 189 void InterInvocationTestCase::init (void)
 190 {
 191         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 192
 193         // requirements
 194
 195         if (m_useAtomic && m_storage == STORAGE_IMAGE && !m_context.getContextInfo().isExtensionSupported("GL_OES_shader_image_atomic"))
 196                 throw tcu::NotSupportedError("Test requires GL_OES_shader_image_atomic extension");
 197
 198         // program
 199
 200         m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(genShaderSource()));
 201         m_testCtx.getLog() << *m_program;
 202         if (!m_program->isOk())
 203                 throw tcu::TestError("could not build program");
 204
 205         // source
 206
 207         if (m_storage == STORAGE_BUFFER)
 208         {
 209                 const int                               bufferElements  = m_workWidth * m_workHeight * m_elementsPerInvocation;
 210                 const int                               bufferSize              = bufferElements * (int)sizeof(deUint32);
 211                 std::vector<deUint32>   zeroBuffer              (bufferElements, 0);
 212
 213                 m_testCtx.getLog() << tcu::TestLog::Message << "Allocating zero-filled buffer for storage, size " << bufferElements << " elements, " << bufferSize << " bytes." << tcu::TestLog::EndMessage;
 214
 215                 gl.genBuffers(1, &m_storageBuf);
 216                 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_storageBuf);
 217                 gl.bufferData(GL_SHADER_STORAGE_BUFFER, bufferSize, &zeroBuffer[0], GL_STATIC_DRAW);
 218                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen storage buf");
 219         }
 220         else if (m_storage == STORAGE_IMAGE)
 221         {
 222                 const int                               bufferElements  = m_workWidth * m_workHeight * m_elementsPerInvocation;
 223                 const int                               bufferSize              = bufferElements * (int)sizeof(deUint32);
 224
 225                 m_testCtx.getLog() << tcu::TestLog::Message << "Allocating image for storage, size " << m_workWidth << "x" << m_workHeight * m_elementsPerInvocation << ", " << bufferSize << " bytes." << tcu::TestLog::EndMessage;
 226
 227                 gl.genTextures(1, &m_storageTex);
 228                 gl.bindTexture(GL_TEXTURE_2D, m_storageTex);
 229                 gl.texStorage2D(GL_TEXTURE_2D, 1, GL_R32I, m_workWidth, m_workHeight * m_elementsPerInvocation);
 230                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 231                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 232                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen storage image");
 233
 234                 // Zero-fill
 235                 m_testCtx.getLog() << tcu::TestLog::Message << "Filling image with 0." << tcu::TestLog::EndMessage;
 236
 237                 {
 238                         const std::vector<deInt32> zeroBuffer(m_workWidth * m_workHeight * m_elementsPerInvocation, 0);
 239                         gl.texSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_workWidth, m_workHeight * m_elementsPerInvocation, GL_RED_INTEGER, GL_INT, &zeroBuffer[0]);
 240                         GLU_EXPECT_NO_ERROR(gl.getError(), "specify image contents");
 241                 }
 242         }
 243         else
 244                 DE_ASSERT(DE_FALSE);
 245
 246         // destination
 247
 248         {
 249                 const int                               bufferElements  = m_workWidth * m_workHeight;
 250                 const int                               bufferSize              = bufferElements * (int)sizeof(deUint32);
 251                 std::vector<deInt32>    negativeBuffer  (bufferElements, -1);
 252
 253                 m_testCtx.getLog() << tcu::TestLog::Message << "Allocating -1 filled buffer for results, size " << bufferElements << " elements, " << bufferSize << " bytes." << tcu::TestLog::EndMessage;
 254
 255                 gl.genBuffers(1, &m_resultBuf);
 256                 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_resultBuf);
 257                 gl.bufferData(GL_SHADER_STORAGE_BUFFER, bufferSize, &negativeBuffer[0], GL_STATIC_DRAW);
 258                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen storage buf");
 259         }
 260 }
 261
 262 void InterInvocationTestCase::deinit (void)
 263 {
 264         if (m_storageBuf)
 265         {
 266                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_storageBuf);
 267                 m_storageBuf = DE_NULL;
 268         }
 269
 270         if (m_storageTex)
 271         {
 272                 m_context.getRenderContext().getFunctions().deleteTextures(1, &m_storageTex);
 273                 m_storageTex = DE_NULL;
 274         }
 275
 276         if (m_resultBuf)
 277         {
 278                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_resultBuf);
 279                 m_resultBuf = DE_NULL;
 280         }
 281
 282         delete m_program;
 283         m_program = DE_NULL;
 284 }
 285
 286 InterInvocationTestCase::IterateResult InterInvocationTestCase::iterate (void)
 287 {
 288         // Dispatch
 289         runCompute();
 290
 291         // Verify buffer contents
 292         if (verifyResults())
 293                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 294         else
 295                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, (std::string((m_storage == STORAGE_BUFFER) ? ("buffer") : ("image")) + " content verification failed").c_str());
 296
 297         return STOP;
 298 }
 299
 300 void InterInvocationTestCase::runCompute (void)
 301 {
 302         const glw::Functions&   gl              = m_context.getRenderContext().getFunctions();
 303         const int                               groupsX = m_workWidth / m_localWidth;
 304         const int                               groupsY = m_workHeight / m_localHeight;
 305
 306         DE_ASSERT((m_workWidth % m_localWidth) == 0);
 307         DE_ASSERT((m_workHeight % m_localHeight) == 0);
 308
 309         m_testCtx.getLog()
 310                 << tcu::TestLog::Message
 311                 << "Dispatching compute.\n"
 312                 << "    group size: " << m_localWidth << "x" << m_localHeight << "\n"
 313                 << "    dispatch size: " << groupsX << "x" << groupsY << "\n"
 314                 << "    total work size: " << m_workWidth << "x" << m_workHeight << "\n"
 315                 << tcu::TestLog::EndMessage;
 316
 317         gl.useProgram(m_program->getProgram());
 318
 319         // source
 320         if (m_storage == STORAGE_BUFFER && !m_aliasingStorages)
 321         {
 322                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_storageBuf);
 323                 GLU_EXPECT_NO_ERROR(gl.getError(), "bind source buf");
 324         }
 325         else if (m_storage == STORAGE_BUFFER && m_aliasingStorages)
 326         {
 327                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_storageBuf);
 328                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_storageBuf);
 329                 GLU_EXPECT_NO_ERROR(gl.getError(), "bind source buf");
 330
 331                 m_testCtx.getLog() << tcu::TestLog::Message << "Binding same buffer object to buffer storages." << tcu::TestLog::EndMessage;
 332         }
 333         else if (m_storage == STORAGE_IMAGE && !m_aliasingStorages)
 334         {
 335                 gl.bindImageTexture(1, m_storageTex, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32I);
 336                 GLU_EXPECT_NO_ERROR(gl.getError(), "bind result buf");
 337         }
 338         else if (m_storage == STORAGE_IMAGE && m_aliasingStorages)
 339         {
 340                 gl.bindImageTexture(1, m_storageTex, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32I);
 341                 gl.bindImageTexture(2, m_storageTex, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32I);
 342
 343                 GLU_EXPECT_NO_ERROR(gl.getError(), "bind result buf");
 344
 345                 m_testCtx.getLog() << tcu::TestLog::Message << "Binding same texture level to image storages." << tcu::TestLog::EndMessage;
 346         }
 347         else
 348                 DE_ASSERT(DE_FALSE);
 349
 350         // destination
 351         gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_resultBuf);
 352         GLU_EXPECT_NO_ERROR(gl.getError(), "bind result buf");
 353
 354         // dispatch
 355         gl.dispatchCompute(groupsX, groupsY, 1);
 356         GLU_EXPECT_NO_ERROR(gl.getError(), "dispatchCompute");
 357 }
 358
 359 bool InterInvocationTestCase::verifyResults (void)
 360 {
 361         const glw::Functions&   gl                                      = m_context.getRenderContext().getFunctions();
 362         const int                               errorFloodThreshold     = 5;
 363         int                                             numErrorsLogged         = 0;
 364         const void*                             mapped                          = DE_NULL;
 365         std::vector<deInt32>    results                         (m_workWidth * m_workHeight);
 366         bool                                    error                           = false;
 367
 368         gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_resultBuf);
 369         mapped = gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, m_workWidth * m_workHeight * sizeof(deInt32), GL_MAP_READ_BIT);
 370         GLU_EXPECT_NO_ERROR(gl.getError(), "map buffer");
 371
 372         // copy to properly aligned array
 373         deMemcpy(&results[0], mapped, m_workWidth * m_workHeight * sizeof(deUint32));
 374
 375         if (gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER) != GL_TRUE)
 376                 throw tcu::TestError("memory map store corrupted");
 377
 378         // check the results
 379         for (int ndx = 0; ndx < (int)results.size(); ++ndx)
 380         {
 381                 if (results[ndx] != 1)
 382                 {
 383                         error = true;
 384
 385                         if (numErrorsLogged == 0)
 386                                 m_testCtx.getLog() << tcu::TestLog::Message << "Result buffer failed, got unexpected values.\n" << tcu::TestLog::EndMessage;
 387                         if (numErrorsLogged++ < errorFloodThreshold)
 388                                 m_testCtx.getLog() << tcu::TestLog::Message << "        Error at index " << ndx << ": expected 1, got " << results[ndx] << ".\n" << tcu::TestLog::EndMessage;
 389                         else
 390                         {
 391                                 // after N errors, no point continuing verification
 392                                 m_testCtx.getLog() << tcu::TestLog::Message << "        -- too many errors, skipping verification --\n" << tcu::TestLog::EndMessage;
 393                                 break;
 394                         }
 395                 }
 396         }
 397
 398         if (!error)
 399                 m_testCtx.getLog() << tcu::TestLog::Message << "Result buffer ok." << tcu::TestLog::EndMessage;
 400         return !error;
 401 }
 402
 403 std::string InterInvocationTestCase::genBarrierSource (void) const
 404 {
 405         std::ostringstream buf;
 406
 407         if (m_syncWithGroup)
 408         {
 409                 // Wait until all invocations in this work group have their texture/buffer read/write operations complete
 410                 // \note We could also use memoryBarrierBuffer() or memoryBarrierImage() in place of groupMemoryBarrier() but
 411                 //       we only require intra-workgroup synchronization.
 412                 buf << "\n"
 413                         << "    groupMemoryBarrier();\n"
 414                         << "    barrier();\n"
 415                         << "\n";
 416         }
 417         else if (m_storage == STORAGE_BUFFER)
 418         {
 419                 DE_ASSERT(!m_syncWithGroup);
 420
 421                 // Waiting only for data written by this invocation. Since all buffer reads and writes are
 422                 // processed in order (within a single invocation), we don't have to do anything.
 423                 buf << "\n";
 424         }
 425         else if (m_storage == STORAGE_IMAGE)
 426         {
 427                 DE_ASSERT(!m_syncWithGroup);
 428
 429                 // Waiting only for data written by this invocation. But since operations complete in undefined
 430                 // order, we have to wait for them to complete.
 431                 buf << "\n"
 432                         << "    memoryBarrierImage();\n"
 433                         << "\n";
 434         }
 435         else
 436                 DE_ASSERT(DE_FALSE);
 437
 438         return buf.str();
 439 }
 440
 441 class InvocationBasicCase : public InterInvocationTestCase
 442 {
 443 public:
 444                                                         InvocationBasicCase             (Context& context, const char* name, const char* desc, StorageType storage, int flags);
 445 private:
 446         std::string                             genShaderSource                 (void) const;
 447         virtual std::string             genShaderMainBlock              (void) const = 0;
 448 };
 449
 450 InvocationBasicCase::InvocationBasicCase (Context& context, const char* name, const char* desc, StorageType storage, int flags)
 451         : InterInvocationTestCase(context, name, desc, storage, flags)
 452 {
 453 }
 454
 455 std::string InvocationBasicCase::genShaderSource (void) const
 456 {
 457         const bool                      useImageAtomics = m_useAtomic && m_storage == STORAGE_IMAGE;
 458         std::ostringstream      buf;
 459
 460         buf << "#version 310 es\n"
 461                 << ((useImageAtomics) ? ("#extension GL_OES_shader_image_atomic : require\n") : (""))
 462                 << "layout (local_size_x=" << m_localWidth << ", local_size_y=" << m_localHeight << ") in;\n"
 463                 << "layout(binding=0, std430) buffer Output\n"
 464                 << "{\n"
 465                 << "    highp int values[];\n"
 466                 << "} sb_result;\n";
 467
 468         if (m_storage == STORAGE_BUFFER)
 469                 buf << "layout(binding=1, std430) coherent buffer Storage\n"
 470                         << "{\n"
 471                         << "    highp int values[];\n"
 472                         << "} sb_store;\n"
 473                         << "\n"
 474                         << "highp int getIndex (in highp uvec2 localID, in highp int element)\n"
 475                         << "{\n"
 476                         << "    highp uint groupNdx = gl_NumWorkGroups.x * gl_WorkGroupID.y + gl_WorkGroupID.x;\n"
 477                         << "    return int((localID.y * gl_NumWorkGroups.x * gl_NumWorkGroups.y * gl_WorkGroupSize.x) + (groupNdx * gl_WorkGroupSize.x) + localID.x) * " << m_elementsPerInvocation << " + element;\n"
 478                         << "}\n";
 479         else if (m_storage == STORAGE_IMAGE)
 480                 buf << "layout(r32i, binding=1) coherent uniform highp iimage2D u_image;\n"
 481                         << "\n"
 482                         << "highp ivec2 getCoord (in highp uvec2 localID, in highp int element)\n"
 483                         << "{\n"
 484                         << "    return ivec2(int(gl_WorkGroupID.x * gl_WorkGroupSize.x + localID.x), int(gl_WorkGroupID.y * gl_WorkGroupSize.y + localID.y) + element * " << m_workHeight << ");\n"
 485                         << "}\n";
 486         else
 487                 DE_ASSERT(DE_FALSE);
 488
 489         buf << "\n"
 490                 << "void main (void)\n"
 491                 << "{\n"
 492                 << "    int resultNdx   = int(gl_GlobalInvocationID.y * gl_NumWorkGroups.x * gl_WorkGroupSize.x + gl_GlobalInvocationID.x);\n"
 493                 << "    int groupNdx    = int(gl_NumWorkGroups.x * gl_WorkGroupID.y + gl_WorkGroupID.x);\n"
 494                 << "    bool allOk      = true;\n"
 495                 << "\n"
 496                 << genShaderMainBlock()
 497                 << "\n"
 498                 << "    sb_result.values[resultNdx] = (allOk) ? (1) : (0);\n"
 499                 << "}\n";
 500
 501         return buf.str();
 502 }
 503
 504 class InvocationWriteReadCase : public InvocationBasicCase
 505 {
 506 public:
 507                                         InvocationWriteReadCase         (Context& context, const char* name, const char* desc, StorageType storage, int flags);
 508 private:
 509         std::string             genShaderMainBlock                      (void) const;
 510 };
 511
 512 InvocationWriteReadCase::InvocationWriteReadCase (Context& context, const char* name, const char* desc, StorageType storage, int flags)
 513         : InvocationBasicCase(context, name, desc, storage, flags)
 514 {
 515 }
 516
 517 std::string InvocationWriteReadCase::genShaderMainBlock (void) const
 518 {
 519         std::ostringstream buf;
 520
 521         // write
 522
 523         for (int ndx = 0; ndx < m_elementsPerInvocation; ++ndx)
 524         {
 525                 if (m_storage == STORAGE_BUFFER && m_useAtomic)
 526                         buf << "\tatomicAdd(sb_store.values[getIndex(gl_LocalInvocationID.xy, " << ndx << ")], groupNdx);\n";
 527                 else if (m_storage == STORAGE_BUFFER && !m_useAtomic)
 528                         buf << "\tsb_store.values[getIndex(gl_LocalInvocationID.xy, " << ndx << ")] = groupNdx;\n";
 529                 else if (m_storage == STORAGE_IMAGE && m_useAtomic)
 530                         buf << "\timageAtomicAdd(u_image, getCoord(gl_LocalInvocationID.xy, " << ndx << "), int(groupNdx));\n";
 531                 else if (m_storage == STORAGE_IMAGE && !m_useAtomic)
 532                         buf << "\timageStore(u_image, getCoord(gl_LocalInvocationID.xy, " << ndx << "), ivec4(int(groupNdx), 0, 0, 0));\n";
 533                 else
 534                         DE_ASSERT(DE_FALSE);
 535         }
 536
 537         // barrier
 538
 539         buf << genBarrierSource();
 540
 541         // read
 542
 543         for (int ndx = 0; ndx < m_elementsPerInvocation; ++ndx)
 544         {
 545                 const std::string localID = (m_syncWithGroup) ? ("(gl_LocalInvocationID.xy + uvec2(" + de::toString(ndx+1) + ", " + de::toString(2*ndx) + ")) % gl_WorkGroupSize.xy") : ("gl_LocalInvocationID.xy");
 546
 547                 if (m_storage == STORAGE_BUFFER && m_useAtomic)
 548                         buf << "\tallOk = allOk && (atomicExchange(sb_store.values[getIndex(" << localID << ", " << ndx << ")], 0) == groupNdx);\n";
 549                 else if (m_storage == STORAGE_BUFFER && !m_useAtomic)
 550                         buf << "\tallOk = allOk && (sb_store.values[getIndex(" << localID << ", " << ndx << ")] == groupNdx);\n";
 551                 else if (m_storage == STORAGE_IMAGE && m_useAtomic)
 552                         buf << "\tallOk = allOk && (imageAtomicExchange(u_image, getCoord(" << localID << ", " << ndx << "), 0) == groupNdx);\n";
 553                 else if (m_storage == STORAGE_IMAGE && !m_useAtomic)
 554                         buf << "\tallOk = allOk && (imageLoad(u_image, getCoord(" << localID << ", " << ndx << ")).x == groupNdx);\n";
 555                 else
 556                         DE_ASSERT(DE_FALSE);
 557         }
 558
 559         return buf.str();
 560 }
 561
 562 class InvocationReadWriteCase : public InvocationBasicCase
 563 {
 564 public:
 565                                         InvocationReadWriteCase         (Context& context, const char* name, const char* desc, StorageType storage, int flags);
 566 private:
 567         std::string             genShaderMainBlock                      (void) const;
 568 };
 569
 570 InvocationReadWriteCase::InvocationReadWriteCase (Context& context, const char* name, const char* desc, StorageType storage, int flags)
 571         : InvocationBasicCase(context, name, desc, storage, flags)
 572 {
 573 }
 574
 575 std::string InvocationReadWriteCase::genShaderMainBlock (void) const
 576 {
 577         std::ostringstream buf;
 578
 579         // read
 580
 581         for (int ndx = 0; ndx < m_elementsPerInvocation; ++ndx)
 582         {
 583                 const std::string localID = (m_syncWithGroup) ? ("(gl_LocalInvocationID.xy + uvec2(" + de::toString(ndx+1) + ", " + de::toString(2*ndx) + ")) % gl_WorkGroupSize.xy") : ("gl_LocalInvocationID.xy");
 584
 585                 if (m_storage == STORAGE_BUFFER && m_useAtomic)
 586                         buf << "\tallOk = allOk && (atomicExchange(sb_store.values[getIndex(" << localID << ", " << ndx << ")], 123) == 0);\n";
 587                 else if (m_storage == STORAGE_BUFFER && !m_useAtomic)
 588                         buf << "\tallOk = allOk && (sb_store.values[getIndex(" << localID << ", " << ndx << ")] == 0);\n";
 589                 else if (m_storage == STORAGE_IMAGE && m_useAtomic)
 590                         buf << "\tallOk = allOk && (imageAtomicExchange(u_image, getCoord(" << localID << ", " << ndx << "), 123) == 0);\n";
 591                 else if (m_storage == STORAGE_IMAGE && !m_useAtomic)
 592                         buf << "\tallOk = allOk && (imageLoad(u_image, getCoord(" << localID << ", " << ndx << ")).x == 0);\n";
 593                 else
 594                         DE_ASSERT(DE_FALSE);
 595         }
 596
 597         // barrier
 598
 599         buf << genBarrierSource();
 600
 601         // write
 602
 603         for (int ndx = 0; ndx < m_elementsPerInvocation; ++ndx)
 604         {
 605                 if (m_storage == STORAGE_BUFFER && m_useAtomic)
 606                         buf << "\tatomicAdd(sb_store.values[getIndex(gl_LocalInvocationID.xy, " << ndx << ")], groupNdx);\n";
 607                 else if (m_storage == STORAGE_BUFFER && !m_useAtomic)
 608                         buf << "\tsb_store.values[getIndex(gl_LocalInvocationID.xy, " << ndx << ")] = groupNdx;\n";
 609                 else if (m_storage == STORAGE_IMAGE && m_useAtomic)
 610                         buf << "\timageAtomicAdd(u_image, getCoord(gl_LocalInvocationID.xy, " << ndx << "), int(groupNdx));\n";
 611                 else if (m_storage == STORAGE_IMAGE && !m_useAtomic)
 612                         buf << "\timageStore(u_image, getCoord(gl_LocalInvocationID.xy, " << ndx << "), ivec4(int(groupNdx), 0, 0, 0));\n";
 613                 else
 614                         DE_ASSERT(DE_FALSE);
 615         }
 616
 617         return buf.str();
 618 }
 619
 620 class InvocationOverWriteCase : public InvocationBasicCase
 621 {
 622 public:
 623                                         InvocationOverWriteCase         (Context& context, const char* name, const char* desc, StorageType storage, int flags);
 624 private:
 625         std::string             genShaderMainBlock                      (void) const;
 626 };
 627
 628 InvocationOverWriteCase::InvocationOverWriteCase (Context& context, const char* name, const char* desc, StorageType storage, int flags)
 629         : InvocationBasicCase(context, name, desc, storage, flags)
 630 {
 631 }
 632
 633 std::string InvocationOverWriteCase::genShaderMainBlock (void) const
 634 {
 635         std::ostringstream buf;
 636
 637         // write
 638
 639         for (int ndx = 0; ndx < m_elementsPerInvocation; ++ndx)
 640         {
 641                 if (m_storage == STORAGE_BUFFER && m_useAtomic)
 642                         buf << "\tatomicAdd(sb_store.values[getIndex(gl_LocalInvocationID.xy, " << ndx << ")], 456);\n";
 643                 else if (m_storage == STORAGE_BUFFER && !m_useAtomic)
 644                         buf << "\tsb_store.values[getIndex(gl_LocalInvocationID.xy, " << ndx << ")] = 456;\n";
 645                 else if (m_storage == STORAGE_IMAGE && m_useAtomic)
 646                         buf << "\timageAtomicAdd(u_image, getCoord(gl_LocalInvocationID.xy, " << ndx << "), 456);\n";
 647                 else if (m_storage == STORAGE_IMAGE && !m_useAtomic)
 648                         buf << "\timageStore(u_image, getCoord(gl_LocalInvocationID.xy, " << ndx << "), ivec4(456, 0, 0, 0));\n";
 649                 else
 650                         DE_ASSERT(DE_FALSE);
 651         }
 652
 653         // barrier
 654
 655         buf << genBarrierSource();
 656
 657         // write over
 658
 659         for (int ndx = 0; ndx < m_elementsPerInvocation; ++ndx)
 660         {
 661                 // write another invocation's value or our own value depending on test type
 662                 const std::string localID = (m_syncWithGroup) ? ("(gl_LocalInvocationID.xy + uvec2(" + de::toString(ndx+4) + ", " + de::toString(3*ndx) + ")) % gl_WorkGroupSize.xy") : ("gl_LocalInvocationID.xy");
 663
 664                 if (m_storage == STORAGE_BUFFER && m_useAtomic)
 665                         buf << "\tatomicExchange(sb_store.values[getIndex(" << localID << ", " << ndx << ")], groupNdx);\n";
 666                 else if (m_storage == STORAGE_BUFFER && !m_useAtomic)
 667                         buf << "\tsb_store.values[getIndex(" << localID << ", " << ndx << ")] = groupNdx;\n";
 668                 else if (m_storage == STORAGE_IMAGE && m_useAtomic)
 669                         buf << "\timageAtomicExchange(u_image, getCoord(" << localID << ", " << ndx << "), groupNdx);\n";
 670                 else if (m_storage == STORAGE_IMAGE && !m_useAtomic)
 671                         buf << "\timageStore(u_image, getCoord(" << localID << ", " << ndx << "), ivec4(groupNdx, 0, 0, 0));\n";
 672                 else
 673                         DE_ASSERT(DE_FALSE);
 674         }
 675
 676         // barrier
 677
 678         buf << genBarrierSource();
 679
 680         // read
 681
 682         for (int ndx = 0; ndx < m_elementsPerInvocation; ++ndx)
 683         {
 684                 // check another invocation's value or our own value depending on test type
 685                 const std::string localID = (m_syncWithGroup) ? ("(gl_LocalInvocationID.xy + uvec2(" + de::toString(ndx+1) + ", " + de::toString(2*ndx) + ")) % gl_WorkGroupSize.xy") : ("gl_LocalInvocationID.xy");
 686
 687                 if (m_storage == STORAGE_BUFFER && m_useAtomic)
 688                         buf << "\tallOk = allOk && (atomicExchange(sb_store.values[getIndex(" << localID << ", " << ndx << ")], 123) == groupNdx);\n";
 689                 else if (m_storage == STORAGE_BUFFER && !m_useAtomic)
 690                         buf << "\tallOk = allOk && (sb_store.values[getIndex(" << localID << ", " << ndx << ")] == groupNdx);\n";
 691                 else if (m_storage == STORAGE_IMAGE && m_useAtomic)
 692                         buf << "\tallOk = allOk && (imageAtomicExchange(u_image, getCoord(" << localID << ", " << ndx << "), 123) == groupNdx);\n";
 693                 else if (m_storage == STORAGE_IMAGE && !m_useAtomic)
 694                         buf << "\tallOk = allOk && (imageLoad(u_image, getCoord(" << localID << ", " << ndx << ")).x == groupNdx);\n";
 695                 else
 696                         DE_ASSERT(DE_FALSE);
 697         }
 698
 699         return buf.str();
 700 }
 701
 702 class InvocationAliasWriteCase : public InterInvocationTestCase
 703 {
 704 public:
 705         enum TestType
 706         {
 707                 TYPE_WRITE = 0,
 708                 TYPE_OVERWRITE,
 709
 710                 TYPE_LAST
 711         };
 712
 713                                         InvocationAliasWriteCase        (Context& context, const char* name, const char* desc, TestType type, StorageType storage, int flags);
 714 private:
 715         std::string             genShaderSource                         (void) const;
 716
 717         const TestType  m_type;
 718 };
 719
 720 InvocationAliasWriteCase::InvocationAliasWriteCase (Context& context, const char* name, const char* desc, TestType type, StorageType storage, int flags)
 721         : InterInvocationTestCase       (context, name, desc, storage, flags | FLAG_ALIASING_STORAGES)
 722         , m_type                                        (type)
 723 {
 724         DE_ASSERT(type < TYPE_LAST);
 725 }
 726
 727 std::string InvocationAliasWriteCase::genShaderSource (void) const
 728 {
 729         const bool                      useImageAtomics = m_useAtomic && m_storage == STORAGE_IMAGE;
 730         std::ostringstream      buf;
 731
 732         buf << "#version 310 es\n"
 733                 << ((useImageAtomics) ? ("#extension GL_OES_shader_image_atomic : require\n") : (""))
 734                 << "layout (local_size_x=" << m_localWidth << ", local_size_y=" << m_localHeight << ") in;\n"
 735                 << "layout(binding=0, std430) buffer Output\n"
 736                 << "{\n"
 737                 << "    highp int values[];\n"
 738                 << "} sb_result;\n";
 739
 740         if (m_storage == STORAGE_BUFFER)
 741                 buf << "layout(binding=1, std430) coherent buffer Storage0\n"
 742                         << "{\n"
 743                         << "    highp int values[];\n"
 744                         << "} sb_store0;\n"
 745                         << "layout(binding=2, std430) coherent buffer Storage1\n"
 746                         << "{\n"
 747                         << "    highp int values[];\n"
 748                         << "} sb_store1;\n"
 749                         << "\n"
 750                         << "highp int getIndex (in highp uvec2 localID, in highp int element)\n"
 751                         << "{\n"
 752                         << "    highp uint groupNdx = gl_NumWorkGroups.x * gl_WorkGroupID.y + gl_WorkGroupID.x;\n"
 753                         << "    return int((localID.y * gl_NumWorkGroups.x * gl_NumWorkGroups.y * gl_WorkGroupSize.x) + (groupNdx * gl_WorkGroupSize.x) + localID.x) * " << m_elementsPerInvocation << " + element;\n"
 754                         << "}\n";
 755         else if (m_storage == STORAGE_IMAGE)
 756                 buf << "layout(r32i, binding=1) coherent uniform highp iimage2D u_image0;\n"
 757                         << "layout(r32i, binding=2) coherent uniform highp iimage2D u_image1;\n"
 758                         << "\n"
 759                         << "highp ivec2 getCoord (in highp uvec2 localID, in highp int element)\n"
 760                         << "{\n"
 761                         << "    return ivec2(int(gl_WorkGroupID.x * gl_WorkGroupSize.x + localID.x), int(gl_WorkGroupID.y * gl_WorkGroupSize.y + localID.y) + element * " << m_workHeight << ");\n"
 762                         << "}\n";
 763         else
 764                 DE_ASSERT(DE_FALSE);
 765
 766         buf << "\n"
 767                 << "void main (void)\n"
 768                 << "{\n"
 769                 << "    int resultNdx   = int(gl_GlobalInvocationID.y * gl_NumWorkGroups.x * gl_WorkGroupSize.x + gl_GlobalInvocationID.x);\n"
 770                 << "    int groupNdx    = int(gl_NumWorkGroups.x * gl_WorkGroupID.y + gl_WorkGroupID.x);\n"
 771                 << "    bool allOk      = true;\n"
 772                 << "\n";
 773
 774         if (m_type == TYPE_OVERWRITE)
 775         {
 776                 // write
 777
 778                 for (int ndx = 0; ndx < m_elementsPerInvocation; ++ndx)
 779                 {
 780                         if (m_storage == STORAGE_BUFFER && m_useAtomic)
 781                                 buf << "\tatomicAdd(sb_store0.values[getIndex(gl_LocalInvocationID.xy, " << ndx << ")], 456);\n";
 782                         else if (m_storage == STORAGE_BUFFER && !m_useAtomic)
 783                                 buf << "\tsb_store0.values[getIndex(gl_LocalInvocationID.xy, " << ndx << ")] = 456;\n";
 784                         else if (m_storage == STORAGE_IMAGE && m_useAtomic)
 785                                 buf << "\timageAtomicAdd(u_image0, getCoord(gl_LocalInvocationID.xy, " << ndx << "), 456);\n";
 786                         else if (m_storage == STORAGE_IMAGE && !m_useAtomic)
 787                                 buf << "\timageStore(u_image0, getCoord(gl_LocalInvocationID.xy, " << ndx << "), ivec4(456, 0, 0, 0));\n";
 788                         else
 789                                 DE_ASSERT(DE_FALSE);
 790                 }
 791
 792                 // barrier
 793
 794                 buf << genBarrierSource();
 795         }
 796         else
 797                 DE_ASSERT(m_type == TYPE_WRITE);
 798
 799         // write (again)
 800
 801         for (int ndx = 0; ndx < m_elementsPerInvocation; ++ndx)
 802         {
 803                 const std::string localID = (m_syncWithGroup) ? ("(gl_LocalInvocationID.xy + uvec2(" + de::toString(ndx+2) + ", " + de::toString(2*ndx) + ")) % gl_WorkGroupSize.xy") : ("gl_LocalInvocationID.xy");
 804
 805                 if (m_storage == STORAGE_BUFFER && m_useAtomic)
 806                         buf << "\tatomicExchange(sb_store1.values[getIndex(" << localID << ", " << ndx << ")], groupNdx);\n";
 807                 else if (m_storage == STORAGE_BUFFER && !m_useAtomic)
 808                         buf << "\tsb_store1.values[getIndex(" << localID << ", " << ndx << ")] = groupNdx;\n";
 809                 else if (m_storage == STORAGE_IMAGE && m_useAtomic)
 810                         buf << "\timageAtomicExchange(u_image1, getCoord(" << localID << ", " << ndx << "), groupNdx);\n";
 811                 else if (m_storage == STORAGE_IMAGE && !m_useAtomic)
 812                         buf << "\timageStore(u_image1, getCoord(" << localID << ", " << ndx << "), ivec4(groupNdx, 0, 0, 0));\n";
 813                 else
 814                         DE_ASSERT(DE_FALSE);
 815         }
 816
 817         // barrier
 818
 819         buf << genBarrierSource();
 820
 821         // read
 822
 823         for (int ndx = 0; ndx < m_elementsPerInvocation; ++ndx)
 824         {
 825                 if (m_storage == STORAGE_BUFFER && m_useAtomic)
 826                         buf << "\tallOk = allOk && (atomicExchange(sb_store0.values[getIndex(gl_LocalInvocationID.xy, " << ndx << ")], 123) == groupNdx);\n";
 827                 else if (m_storage == STORAGE_BUFFER && !m_useAtomic)
 828                         buf << "\tallOk = allOk && (sb_store0.values[getIndex(gl_LocalInvocationID.xy, " << ndx << ")] == groupNdx);\n";
 829                 else if (m_storage == STORAGE_IMAGE && m_useAtomic)
 830                         buf << "\tallOk = allOk && (imageAtomicExchange(u_image0, getCoord(gl_LocalInvocationID.xy, " << ndx << "), 123) == groupNdx);\n";
 831                 else if (m_storage == STORAGE_IMAGE && !m_useAtomic)
 832                         buf << "\tallOk = allOk && (imageLoad(u_image0, getCoord(gl_LocalInvocationID.xy, " << ndx << ")).x == groupNdx);\n";
 833                 else
 834                         DE_ASSERT(DE_FALSE);
 835         }
 836
 837         // return result
 838
 839         buf << "\n"
 840                 << "    sb_result.values[resultNdx] = (allOk) ? (1) : (0);\n"
 841                 << "}\n";
 842
 843         return buf.str();
 844 }
 845
 846 namespace op
 847 {
 848
 849 struct WriteData
 850 {
 851         int targetHandle;
 852         int seed;
 853
 854         static WriteData Generate(int targetHandle, int seed)
 855         {
 856                 WriteData retVal;
 857
 858                 retVal.targetHandle = targetHandle;
 859                 retVal.seed = seed;
 860
 861                 return retVal;
 862         }
 863 };
 864
 865 struct ReadData
 866 {
 867         int targetHandle;
 868         int seed;
 869
 870         static ReadData Generate(int targetHandle, int seed)
 871         {
 872                 ReadData retVal;
 873
 874                 retVal.targetHandle = targetHandle;
 875                 retVal.seed = seed;
 876
 877                 return retVal;
 878         }
 879 };
 880
 881 struct Barrier
 882 {
 883 };
 884
 885 struct WriteDataInterleaved
 886 {
 887         int             targetHandle;
 888         int             seed;
 889         bool    evenOdd;
 890
 891         static WriteDataInterleaved Generate(int targetHandle, int seed, bool evenOdd)
 892         {
 893                 WriteDataInterleaved retVal;
 894
 895                 retVal.targetHandle = targetHandle;
 896                 retVal.seed = seed;
 897                 retVal.evenOdd = evenOdd;
 898
 899                 return retVal;
 900         }
 901 };
 902
 903 struct ReadDataInterleaved
 904 {
 905         int targetHandle;
 906         int seed0;
 907         int seed1;
 908
 909         static ReadDataInterleaved Generate(int targetHandle, int seed0, int seed1)
 910         {
 911                 ReadDataInterleaved retVal;
 912
 913                 retVal.targetHandle = targetHandle;
 914                 retVal.seed0 = seed0;
 915                 retVal.seed1 = seed1;
 916
 917                 return retVal;
 918         }
 919 };
 920
 921 struct ReadMultipleData
 922 {
 923         int targetHandle0;
 924         int seed0;
 925         int targetHandle1;
 926         int seed1;
 927
 928         static ReadMultipleData Generate(int targetHandle0, int seed0, int targetHandle1, int seed1)
 929         {
 930                 ReadMultipleData retVal;
 931
 932                 retVal.targetHandle0 = targetHandle0;
 933                 retVal.seed0 = seed0;
 934                 retVal.targetHandle1 = targetHandle1;
 935                 retVal.seed1 = seed1;
 936
 937                 return retVal;
 938         }
 939 };
 940
 941 struct ReadZeroData
 942 {
 943         int targetHandle;
 944
 945         static ReadZeroData Generate(int targetHandle)
 946         {
 947                 ReadZeroData retVal;
 948
 949                 retVal.targetHandle = targetHandle;
 950
 951                 return retVal;
 952         }
 953 };
 954
 955 } // namespace op
 956
 957 class InterCallTestCase;
 958
 959 class InterCallOperations
 960 {
 961 public:
 962         InterCallOperations& operator<< (const op::WriteData&);
 963         InterCallOperations& operator<< (const op::ReadData&);
 964         InterCallOperations& operator<< (const op::Barrier&);
 965         InterCallOperations& operator<< (const op::ReadMultipleData&);
 966         InterCallOperations& operator<< (const op::WriteDataInterleaved&);
 967         InterCallOperations& operator<< (const op::ReadDataInterleaved&);
 968         InterCallOperations& operator<< (const op::ReadZeroData&);
 969
 970 private:
 971         struct Command
 972         {
 973                 enum CommandType
 974                 {
 975                         TYPE_WRITE = 0,
 976                         TYPE_READ,
 977                         TYPE_BARRIER,
 978                         TYPE_READ_MULTIPLE,
 979                         TYPE_WRITE_INTERLEAVE,
 980                         TYPE_READ_INTERLEAVE,
 981                         TYPE_READ_ZERO,
 982
 983                         TYPE_LAST
 984                 };
 985
 986                 CommandType type;
 987
 988                 union CommandUnion
 989                 {
 990                         op::WriteData                           write;
 991                         op::ReadData                            read;
 992                         op::Barrier                                     barrier;
 993                         op::ReadMultipleData            readMulti;
 994                         op::WriteDataInterleaved        writeInterleave;
 995                         op::ReadDataInterleaved         readInterleave;
 996                         op::ReadZeroData                        readZero;
 997                 } u_cmd;
 998         };
 999
1000         friend class InterCallTestCase;
1001
1002         std::vector<Command> m_cmds;
1003 };
1004
1005 InterCallOperations& InterCallOperations::operator<< (const op::WriteData& cmd)
1006 {
1007         m_cmds.push_back(Command());
1008         m_cmds.back().type = Command::TYPE_WRITE;
1009         m_cmds.back().u_cmd.write = cmd;
1010
1011         return *this;
1012 }
1013
1014 InterCallOperations& InterCallOperations::operator<< (const op::ReadData& cmd)
1015 {
1016         m_cmds.push_back(Command());
1017         m_cmds.back().type = Command::TYPE_READ;
1018         m_cmds.back().u_cmd.read = cmd;
1019
1020         return *this;
1021 }
1022
1023 InterCallOperations& InterCallOperations::operator<< (const op::Barrier& cmd)
1024 {
1025         m_cmds.push_back(Command());
1026         m_cmds.back().type = Command::TYPE_BARRIER;
1027         m_cmds.back().u_cmd.barrier = cmd;
1028
1029         return *this;
1030 }
1031
1032 InterCallOperations& InterCallOperations::operator<< (const op::ReadMultipleData& cmd)
1033 {
1034         m_cmds.push_back(Command());
1035         m_cmds.back().type = Command::TYPE_READ_MULTIPLE;
1036         m_cmds.back().u_cmd.readMulti = cmd;
1037
1038         return *this;
1039 }
1040
1041 InterCallOperations& InterCallOperations::operator<< (const op::WriteDataInterleaved& cmd)
1042 {
1043         m_cmds.push_back(Command());
1044         m_cmds.back().type = Command::TYPE_WRITE_INTERLEAVE;
1045         m_cmds.back().u_cmd.writeInterleave = cmd;
1046
1047         return *this;
1048 }
1049
1050 InterCallOperations& InterCallOperations::operator<< (const op::ReadDataInterleaved& cmd)
1051 {
1052         m_cmds.push_back(Command());
1053         m_cmds.back().type = Command::TYPE_READ_INTERLEAVE;
1054         m_cmds.back().u_cmd.readInterleave = cmd;
1055
1056         return *this;
1057 }
1058
1059 InterCallOperations& InterCallOperations::operator<< (const op::ReadZeroData& cmd)
1060 {
1061         m_cmds.push_back(Command());
1062         m_cmds.back().type = Command::TYPE_READ_ZERO;
1063         m_cmds.back().u_cmd.readZero = cmd;
1064
1065         return *this;
1066 }
1067
1068 class InterCallTestCase : public TestCase
1069 {
1070 public:
1071         enum StorageType
1072         {
1073                 STORAGE_BUFFER = 0,
1074                 STORAGE_IMAGE,
1075
1076                 STORAGE_LAST
1077         };
1078         enum Flags
1079         {
1080                 FLAG_USE_ATOMIC = 1,
1081                 FLAG_USE_INT    = 2,
1082         };
1083                                                                                                         InterCallTestCase                       (Context& context, const char* name, const char* desc, StorageType storage, int flags, const InterCallOperations& ops);
1084                                                                                                         ~InterCallTestCase                      (void);
1085
1086 private:
1087         void                                                                                    init                                            (void);
1088         void                                                                                    deinit                                          (void);
1089         IterateResult                                                                   iterate                                         (void);
1090         bool                                                                                    verifyResults                           (void);
1091
1092         void                                                                                    runCommand                                      (const op::WriteData& cmd, int stepNdx, int& programFriendlyName);
1093         void                                                                                    runCommand                                      (const op::ReadData& cmd, int stepNdx, int& programFriendlyName, int& resultStorageFriendlyName);
1094         void                                                                                    runCommand                                      (const op::Barrier&);
1095         void                                                                                    runCommand                                      (const op::ReadMultipleData& cmd, int stepNdx, int& programFriendlyName, int& resultStorageFriendlyName);
1096         void                                                                                    runCommand                                      (const op::WriteDataInterleaved& cmd, int stepNdx, int& programFriendlyName);
1097         void                                                                                    runCommand                                      (const op::ReadDataInterleaved& cmd, int stepNdx, int& programFriendlyName, int& resultStorageFriendlyName);
1098         void                                                                                    runCommand                                      (const op::ReadZeroData& cmd, int stepNdx, int& programFriendlyName, int& resultStorageFriendlyName);
1099         void                                                                                    runSingleRead                           (int targetHandle, int stepNdx, int& programFriendlyName, int& resultStorageFriendlyName);
1100
1101         glw::GLuint                                                                             genStorage                                      (int friendlyName);
1102         glw::GLuint                                                                             genResultStorage                        (void);
1103         glu::ShaderProgram*                                                             genWriteProgram                         (int seed);
1104         glu::ShaderProgram*                                                             genReadProgram                          (int seed);
1105         glu::ShaderProgram*                                                             genReadMultipleProgram          (int seed0, int seed1);
1106         glu::ShaderProgram*                                                             genWriteInterleavedProgram      (int seed, bool evenOdd);
1107         glu::ShaderProgram*                                                             genReadInterleavedProgram       (int seed0, int seed1);
1108         glu::ShaderProgram*                                                             genReadZeroProgram                      (void);
1109
1110         const StorageType                                                               m_storage;
1111         const int                                                                               m_invocationGridSize;   // !< width and height of the two dimensional work dispatch
1112         const int                                                                               m_perInvocationSize;    // !< number of elements accessed in single invocation
1113         const std::vector<InterCallOperations::Command> m_cmds;
1114         const bool                                                                              m_useAtomic;
1115         const bool                                                                              m_formatInteger;
1116
1117         std::vector<glu::ShaderProgram*>                                m_operationPrograms;
1118         std::vector<glw::GLuint>                                                m_operationResultStorages;
1119         std::map<int, glw::GLuint>                                              m_storageIDs;
1120 };
1121
1122 InterCallTestCase::InterCallTestCase (Context& context, const char* name, const char* desc, StorageType storage, int flags, const InterCallOperations& ops)
1123         : TestCase                                      (context, name, desc)
1124         , m_storage                                     (storage)
1125         , m_invocationGridSize          (512)
1126         , m_perInvocationSize           (2)
1127         , m_cmds                                        (ops.m_cmds)
1128         , m_useAtomic                           ((flags & FLAG_USE_ATOMIC) != 0)
1129         , m_formatInteger                       ((flags & FLAG_USE_INT) != 0)
1130 {
1131 }
1132
1133 InterCallTestCase::~InterCallTestCase (void)
1134 {
1135         deinit();
1136 }
1137
1138 void InterCallTestCase::init (void)
1139 {
1140         int programFriendlyName = 0;
1141
1142         // requirements
1143
1144         if (m_useAtomic && m_storage == STORAGE_IMAGE && !m_context.getContextInfo().isExtensionSupported("GL_OES_shader_image_atomic"))
1145                 throw tcu::NotSupportedError("Test requires GL_OES_shader_image_atomic extension");
1146
1147         // generate resources and validate command list
1148
1149         m_operationPrograms.resize(m_cmds.size(), DE_NULL);
1150         m_operationResultStorages.resize(m_cmds.size(), 0);
1151
1152         for (int step = 0; step < (int)m_cmds.size(); ++step)
1153         {
1154                 switch (m_cmds[step].type)
1155                 {
1156                         case InterCallOperations::Command::TYPE_WRITE:
1157                         {
1158                                 const op::WriteData& cmd = m_cmds[step].u_cmd.write;
1159
1160                                 // new storage handle?
1161                                 if (m_storageIDs.find(cmd.targetHandle) == m_storageIDs.end())
1162                                         m_storageIDs[cmd.targetHandle] = genStorage(cmd.targetHandle);
1163
1164                                 // program
1165                                 {
1166                                         glu::ShaderProgram* program = genWriteProgram(cmd.seed);
1167
1168                                         m_testCtx.getLog() << tcu::TestLog::Message << "Program #" << ++programFriendlyName << tcu::TestLog::EndMessage;
1169                                         m_testCtx.getLog() << *program;
1170
1171                                         if (!program->isOk())
1172                                                 throw tcu::TestError("could not build program");
1173
1174                                         m_operationPrograms[step] = program;
1175                                 }
1176                                 break;
1177                         }
1178
1179                         case InterCallOperations::Command::TYPE_READ:
1180                         {
1181                                 const op::ReadData& cmd = m_cmds[step].u_cmd.read;
1182                                 DE_ASSERT(m_storageIDs.find(cmd.targetHandle) != m_storageIDs.end());
1183
1184                                 // program and result storage
1185                                 {
1186                                         glu::ShaderProgram* program = genReadProgram(cmd.seed);
1187
1188                                         m_testCtx.getLog() << tcu::TestLog::Message << "Program #" << ++programFriendlyName << tcu::TestLog::EndMessage;
1189                                         m_testCtx.getLog() << *program;
1190
1191                                         if (!program->isOk())
1192                                                 throw tcu::TestError("could not build program");
1193
1194                                         m_operationPrograms[step] = program;
1195                                         m_operationResultStorages[step] = genResultStorage();
1196                                 }
1197                                 break;
1198                         }
1199
1200                         case InterCallOperations::Command::TYPE_BARRIER:
1201                         {
1202                                 break;
1203                         }
1204
1205                         case InterCallOperations::Command::TYPE_READ_MULTIPLE:
1206                         {
1207                                 const op::ReadMultipleData& cmd = m_cmds[step].u_cmd.readMulti;
1208                                 DE_ASSERT(m_storageIDs.find(cmd.targetHandle0) != m_storageIDs.end());
1209                                 DE_ASSERT(m_storageIDs.find(cmd.targetHandle1) != m_storageIDs.end());
1210
1211                                 // program
1212                                 {
1213                                         glu::ShaderProgram* program = genReadMultipleProgram(cmd.seed0, cmd.seed1);
1214
1215                                         m_testCtx.getLog() << tcu::TestLog::Message << "Program #" << ++programFriendlyName << tcu::TestLog::EndMessage;
1216                                         m_testCtx.getLog() << *program;
1217
1218                                         if (!program->isOk())
1219                                                 throw tcu::TestError("could not build program");
1220
1221                                         m_operationPrograms[step] = program;
1222                                         m_operationResultStorages[step] = genResultStorage();
1223                                 }
1224                                 break;
1225                         }
1226
1227                         case InterCallOperations::Command::TYPE_WRITE_INTERLEAVE:
1228                         {
1229                                 const op::WriteDataInterleaved& cmd = m_cmds[step].u_cmd.writeInterleave;
1230
1231                                 // new storage handle?
1232                                 if (m_storageIDs.find(cmd.targetHandle) == m_storageIDs.end())
1233                                         m_storageIDs[cmd.targetHandle] = genStorage(cmd.targetHandle);
1234
1235                                 // program
1236                                 {
1237                                         glu::ShaderProgram* program = genWriteInterleavedProgram(cmd.seed, cmd.evenOdd);
1238
1239                                         m_testCtx.getLog() << tcu::TestLog::Message << "Program #" << ++programFriendlyName << tcu::TestLog::EndMessage;
1240                                         m_testCtx.getLog() << *program;
1241
1242                                         if (!program->isOk())
1243                                                 throw tcu::TestError("could not build program");
1244
1245                                         m_operationPrograms[step] = program;
1246                                 }
1247                                 break;
1248                         }
1249
1250                         case InterCallOperations::Command::TYPE_READ_INTERLEAVE:
1251                         {
1252                                 const op::ReadDataInterleaved& cmd = m_cmds[step].u_cmd.readInterleave;
1253                                 DE_ASSERT(m_storageIDs.find(cmd.targetHandle) != m_storageIDs.end());
1254
1255                                 // program
1256                                 {
1257                                         glu::ShaderProgram* program = genReadInterleavedProgram(cmd.seed0, cmd.seed1);
1258
1259                                         m_testCtx.getLog() << tcu::TestLog::Message << "Program #" << ++programFriendlyName << tcu::TestLog::EndMessage;
1260                                         m_testCtx.getLog() << *program;
1261
1262                                         if (!program->isOk())
1263                                                 throw tcu::TestError("could not build program");
1264
1265                                         m_operationPrograms[step] = program;
1266                                         m_operationResultStorages[step] = genResultStorage();
1267                                 }
1268                                 break;
1269                         }
1270
1271                         case InterCallOperations::Command::TYPE_READ_ZERO:
1272                         {
1273                                 const op::ReadZeroData& cmd = m_cmds[step].u_cmd.readZero;
1274
1275                                 // new storage handle?
1276                                 if (m_storageIDs.find(cmd.targetHandle) == m_storageIDs.end())
1277                                         m_storageIDs[cmd.targetHandle] = genStorage(cmd.targetHandle);
1278
1279                                 // program
1280                                 {
1281                                         glu::ShaderProgram* program = genReadZeroProgram();
1282
1283                                         m_testCtx.getLog() << tcu::TestLog::Message << "Program #" << ++programFriendlyName << tcu::TestLog::EndMessage;
1284                                         m_testCtx.getLog() << *program;
1285
1286                                         if (!program->isOk())
1287                                                 throw tcu::TestError("could not build program");
1288
1289                                         m_operationPrograms[step] = program;
1290                                         m_operationResultStorages[step] = genResultStorage();
1291                                 }
1292                                 break;
1293                         }
1294
1295                         default:
1296                                 DE_ASSERT(DE_FALSE);
1297                 }
1298         }
1299 }
1300
1301 void InterCallTestCase::deinit (void)
1302 {
1303         // programs
1304         for (int ndx = 0; ndx < (int)m_operationPrograms.size(); ++ndx)
1305                 delete m_operationPrograms[ndx];
1306         m_operationPrograms.clear();
1307
1308         // result storages
1309         for (int ndx = 0; ndx < (int)m_operationResultStorages.size(); ++ndx)
1310         {
1311                 if (m_operationResultStorages[ndx])
1312                         m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_operationResultStorages[ndx]);
1313         }
1314         m_operationResultStorages.clear();
1315
1316         // storage
1317         for (std::map<int, glw::GLuint>::const_iterator it = m_storageIDs.begin(); it != m_storageIDs.end(); ++it)
1318         {
1319                 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1320
1321                 if (m_storage == STORAGE_BUFFER)
1322                         gl.deleteBuffers(1, &it->second);
1323                 else if (m_storage == STORAGE_IMAGE)
1324                         gl.deleteTextures(1, &it->second);
1325                 else
1326                         DE_ASSERT(DE_FALSE);
1327         }
1328         m_storageIDs.clear();
1329 }
1330
1331 InterCallTestCase::IterateResult InterCallTestCase::iterate (void)
1332 {
1333         int programFriendlyName                 = 0;
1334         int resultStorageFriendlyName   = 0;
1335
1336         m_testCtx.getLog() << tcu::TestLog::Message << "Running operations:" << tcu::TestLog::EndMessage;
1337
1338         // run steps
1339
1340         for (int step = 0; step < (int)m_cmds.size(); ++step)
1341         {
1342                 switch (m_cmds[step].type)
1343                 {
1344                         case InterCallOperations::Command::TYPE_WRITE:                          runCommand(m_cmds[step].u_cmd.write,                    step,   programFriendlyName);                                                           break;
1345                         case InterCallOperations::Command::TYPE_READ:                           runCommand(m_cmds[step].u_cmd.read,                             step,   programFriendlyName, resultStorageFriendlyName);        break;
1346                         case InterCallOperations::Command::TYPE_BARRIER:                        runCommand(m_cmds[step].u_cmd.barrier);                                                                                                                                         break;
1347                         case InterCallOperations::Command::TYPE_READ_MULTIPLE:          runCommand(m_cmds[step].u_cmd.readMulti,                step,   programFriendlyName, resultStorageFriendlyName);        break;
1348                         case InterCallOperations::Command::TYPE_WRITE_INTERLEAVE:       runCommand(m_cmds[step].u_cmd.writeInterleave,  step,   programFriendlyName);                                                           break;
1349                         case InterCallOperations::Command::TYPE_READ_INTERLEAVE:        runCommand(m_cmds[step].u_cmd.readInterleave,   step,   programFriendlyName, resultStorageFriendlyName);        break;
1350                         case InterCallOperations::Command::TYPE_READ_ZERO:                      runCommand(m_cmds[step].u_cmd.readZero,                 step,   programFriendlyName, resultStorageFriendlyName);        break;
1351                         default:
1352                                 DE_ASSERT(DE_FALSE);
1353                 }
1354         }
1355
1356         // read results from result buffers
1357         if (verifyResults())
1358                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1359         else
1360                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, (std::string((m_storage == STORAGE_BUFFER) ? ("buffer") : ("image")) + " content verification failed").c_str());
1361
1362         return STOP;
1363 }
1364
1365 bool InterCallTestCase::verifyResults (void)
1366 {
1367         int             resultBufferFriendlyName        = 0;
1368         bool    allResultsOk                            = true;
1369         bool    anyResult                                       = false;
1370
1371         m_testCtx.getLog() << tcu::TestLog::Message << "Reading verifier program results" << tcu::TestLog::EndMessage;
1372
1373         for (int step = 0; step < (int)m_cmds.size(); ++step)
1374         {
1375                 const int       errorFloodThreshold     = 5;
1376                 int                     numErrorsLogged         = 0;
1377
1378                 if (m_operationResultStorages[step])
1379                 {
1380                         const glw::Functions&   gl              = m_context.getRenderContext().getFunctions();
1381                         const void*                             mapped  = DE_NULL;
1382                         std::vector<deInt32>    results (m_invocationGridSize * m_invocationGridSize);
1383                         bool                                    error   = false;
1384
1385                         anyResult = true;
1386
1387                         gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_operationResultStorages[step]);
1388                         mapped = gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, m_invocationGridSize * m_invocationGridSize * sizeof(deUint32), GL_MAP_READ_BIT);
1389                         GLU_EXPECT_NO_ERROR(gl.getError(), "map buffer");
1390
1391                         // copy to properly aligned array
1392                         deMemcpy(&results[0], mapped, m_invocationGridSize * m_invocationGridSize * sizeof(deUint32));
1393
1394                         if (gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER) != GL_TRUE)
1395                                 throw tcu::TestError("memory map store corrupted");
1396
1397                         // check the results
1398                         for (int ndx = 0; ndx < (int)results.size(); ++ndx)
1399                         {
1400                                 if (results[ndx] != 1)
1401                                 {
1402                                         error = true;
1403
1404                                         if (numErrorsLogged == 0)
1405                                                 m_testCtx.getLog() << tcu::TestLog::Message << "Result storage #" << ++resultBufferFriendlyName << " failed, got unexpected values.\n" << tcu::TestLog::EndMessage;
1406                                         if (numErrorsLogged++ < errorFloodThreshold)
1407                                                 m_testCtx.getLog() << tcu::TestLog::Message << "        Error at index " << ndx << ": expected 1, got " << results[ndx] << ".\n" << tcu::TestLog::EndMessage;
1408                                         else
1409                                         {
1410                                                 // after N errors, no point continuing verification
1411                                                 m_testCtx.getLog() << tcu::TestLog::Message << "        -- too many errors, skipping verification --\n" << tcu::TestLog::EndMessage;
1412                                                 break;
1413                                         }
1414                                 }
1415                         }
1416
1417                         if (error)
1418                         {
1419                                 allResultsOk = false;
1420                         }
1421                         else
1422                                 m_testCtx.getLog() << tcu::TestLog::Message << "Result storage #" << ++resultBufferFriendlyName << " ok." << tcu::TestLog::EndMessage;
1423                 }
1424         }
1425
1426         DE_ASSERT(anyResult);
1427         DE_UNREF(anyResult);
1428
1429         return allResultsOk;
1430 }
1431
1432 void InterCallTestCase::runCommand (const op::WriteData& cmd, int stepNdx, int& programFriendlyName)
1433 {
1434         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1435
1436         m_testCtx.getLog()
1437                 << tcu::TestLog::Message
1438                 << "Running program #" << ++programFriendlyName << " to write " << ((m_storage == STORAGE_BUFFER) ? ("buffer") : ("image")) << " #" << cmd.targetHandle << ".\n"
1439                 << "    Dispatch size: " << m_invocationGridSize << "x" << m_invocationGridSize << "."
1440                 << tcu::TestLog::EndMessage;
1441
1442         gl.useProgram(m_operationPrograms[stepNdx]->getProgram());
1443
1444         // set destination
1445         if (m_storage == STORAGE_BUFFER)
1446         {
1447                 DE_ASSERT(m_storageIDs[cmd.targetHandle]);
1448
1449                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storageIDs[cmd.targetHandle]);
1450                 GLU_EXPECT_NO_ERROR(gl.getError(), "bind destination buffer");
1451         }
1452         else if (m_storage == STORAGE_IMAGE)
1453         {
1454                 DE_ASSERT(m_storageIDs[cmd.targetHandle]);
1455
1456                 gl.bindImageTexture(0, m_storageIDs[cmd.targetHandle], 0, GL_FALSE, 0, (m_useAtomic) ? (GL_READ_WRITE) : (GL_WRITE_ONLY), (m_formatInteger) ? (GL_R32I) : (GL_R32F));
1457                 GLU_EXPECT_NO_ERROR(gl.getError(), "bind destination image");
1458         }
1459         else
1460                 DE_ASSERT(DE_FALSE);
1461
1462         // calc
1463         gl.dispatchCompute(m_invocationGridSize, m_invocationGridSize, 1);
1464         GLU_EXPECT_NO_ERROR(gl.getError(), "dispatch write");
1465 }
1466
1467 void InterCallTestCase::runCommand (const op::ReadData& cmd, int stepNdx, int& programFriendlyName, int& resultStorageFriendlyName)
1468 {
1469         runSingleRead(cmd.targetHandle, stepNdx, programFriendlyName, resultStorageFriendlyName);
1470 }
1471
1472 void InterCallTestCase::runCommand (const op::Barrier& cmd)
1473 {
1474         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1475
1476         DE_UNREF(cmd);
1477
1478         if (m_storage == STORAGE_BUFFER)
1479         {
1480                 m_testCtx.getLog() << tcu::TestLog::Message << "Memory Barrier\n\tbits = GL_SHADER_STORAGE_BARRIER_BIT" << tcu::TestLog::EndMessage;
1481                 gl.memoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
1482         }
1483         else if (m_storage == STORAGE_IMAGE)
1484         {
1485                 m_testCtx.getLog() << tcu::TestLog::Message << "Memory Barrier\n\tbits = GL_SHADER_IMAGE_ACCESS_BARRIER_BIT" << tcu::TestLog::EndMessage;
1486                 gl.memoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
1487         }
1488         else
1489                 DE_ASSERT(DE_FALSE);
1490 }
1491
1492 void InterCallTestCase::runCommand (const op::ReadMultipleData& cmd, int stepNdx, int& programFriendlyName, int& resultStorageFriendlyName)
1493 {
1494         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1495
1496         m_testCtx.getLog()
1497                 << tcu::TestLog::Message
1498                 << "Running program #" << ++programFriendlyName << " to verify " << ((m_storage == STORAGE_BUFFER) ? ("buffers") : ("images")) << " #" << cmd.targetHandle0 << " and #" << cmd.targetHandle1 << ".\n"
1499                 << "    Writing results to result storage #" << ++resultStorageFriendlyName << ".\n"
1500                 << "    Dispatch size: " << m_invocationGridSize << "x" << m_invocationGridSize << "."
1501                 << tcu::TestLog::EndMessage;
1502
1503         gl.useProgram(m_operationPrograms[stepNdx]->getProgram());
1504
1505         // set sources
1506         if (m_storage == STORAGE_BUFFER)
1507         {
1508                 DE_ASSERT(m_storageIDs[cmd.targetHandle0]);
1509                 DE_ASSERT(m_storageIDs[cmd.targetHandle1]);
1510
1511                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_storageIDs[cmd.targetHandle0]);
1512                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_storageIDs[cmd.targetHandle1]);
1513                 GLU_EXPECT_NO_ERROR(gl.getError(), "bind source buffers");
1514         }
1515         else if (m_storage == STORAGE_IMAGE)
1516         {
1517                 DE_ASSERT(m_storageIDs[cmd.targetHandle0]);
1518                 DE_ASSERT(m_storageIDs[cmd.targetHandle1]);
1519
1520                 gl.bindImageTexture(1, m_storageIDs[cmd.targetHandle0], 0, GL_FALSE, 0, (m_useAtomic) ? (GL_READ_WRITE) : (GL_READ_ONLY), (m_formatInteger) ? (GL_R32I) : (GL_R32F));
1521                 gl.bindImageTexture(2, m_storageIDs[cmd.targetHandle1], 0, GL_FALSE, 0, (m_useAtomic) ? (GL_READ_WRITE) : (GL_READ_ONLY), (m_formatInteger) ? (GL_R32I) : (GL_R32F));
1522                 GLU_EXPECT_NO_ERROR(gl.getError(), "bind source images");
1523         }
1524         else
1525                 DE_ASSERT(DE_FALSE);
1526
1527         // set destination
1528         DE_ASSERT(m_operationResultStorages[stepNdx]);
1529         gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_operationResultStorages[stepNdx]);
1530         GLU_EXPECT_NO_ERROR(gl.getError(), "bind result buffer");
1531
1532         // calc
1533         gl.dispatchCompute(m_invocationGridSize, m_invocationGridSize, 1);
1534         GLU_EXPECT_NO_ERROR(gl.getError(), "dispatch read multi");
1535 }
1536
1537 void InterCallTestCase::runCommand (const op::WriteDataInterleaved& cmd, int stepNdx, int& programFriendlyName)
1538 {
1539         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1540
1541         m_testCtx.getLog()
1542                 << tcu::TestLog::Message
1543                 << "Running program #" << ++programFriendlyName << " to write " << ((m_storage == STORAGE_BUFFER) ? ("buffer") : ("image")) << " #" << cmd.targetHandle << ".\n"
1544                 << "    Writing to every " << ((cmd.evenOdd) ? ("even") : ("odd")) << " " << ((m_storage == STORAGE_BUFFER) ? ("element") : ("column")) << ".\n"
1545                 << "    Dispatch size: " << m_invocationGridSize / 2 << "x" << m_invocationGridSize << "."
1546                 << tcu::TestLog::EndMessage;
1547
1548         gl.useProgram(m_operationPrograms[stepNdx]->getProgram());
1549
1550         // set destination
1551         if (m_storage == STORAGE_BUFFER)
1552         {
1553                 DE_ASSERT(m_storageIDs[cmd.targetHandle]);
1554
1555                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storageIDs[cmd.targetHandle]);
1556                 GLU_EXPECT_NO_ERROR(gl.getError(), "bind destination buffer");
1557         }
1558         else if (m_storage == STORAGE_IMAGE)
1559         {
1560                 DE_ASSERT(m_storageIDs[cmd.targetHandle]);
1561
1562                 gl.bindImageTexture(0, m_storageIDs[cmd.targetHandle], 0, GL_FALSE, 0, (m_useAtomic) ? (GL_READ_WRITE) : (GL_WRITE_ONLY), (m_formatInteger) ? (GL_R32I) : (GL_R32F));
1563                 GLU_EXPECT_NO_ERROR(gl.getError(), "bind destination image");
1564         }
1565         else
1566                 DE_ASSERT(DE_FALSE);
1567
1568         // calc
1569         gl.dispatchCompute(m_invocationGridSize / 2, m_invocationGridSize, 1);
1570         GLU_EXPECT_NO_ERROR(gl.getError(), "dispatch write");
1571 }
1572
1573 void InterCallTestCase::runCommand (const op::ReadDataInterleaved& cmd, int stepNdx, int& programFriendlyName, int& resultStorageFriendlyName)
1574 {
1575         runSingleRead(cmd.targetHandle, stepNdx, programFriendlyName, resultStorageFriendlyName);
1576 }
1577
1578 void InterCallTestCase::runCommand (const op::ReadZeroData& cmd, int stepNdx, int& programFriendlyName, int& resultStorageFriendlyName)
1579 {
1580         runSingleRead(cmd.targetHandle, stepNdx, programFriendlyName, resultStorageFriendlyName);
1581 }
1582
1583 void InterCallTestCase::runSingleRead (int targetHandle, int stepNdx, int& programFriendlyName, int& resultStorageFriendlyName)
1584 {
1585         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1586
1587         m_testCtx.getLog()
1588                 << tcu::TestLog::Message
1589                 << "Running program #" << ++programFriendlyName << " to verify " << ((m_storage == STORAGE_BUFFER) ? ("buffer") : ("image")) << " #" << targetHandle << ".\n"
1590                 << "    Writing results to result storage #" << ++resultStorageFriendlyName << ".\n"
1591                 << "    Dispatch size: " << m_invocationGridSize << "x" << m_invocationGridSize << "."
1592                 << tcu::TestLog::EndMessage;
1593
1594         gl.useProgram(m_operationPrograms[stepNdx]->getProgram());
1595
1596         // set source
1597         if (m_storage == STORAGE_BUFFER)
1598         {
1599                 DE_ASSERT(m_storageIDs[targetHandle]);
1600
1601                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_storageIDs[targetHandle]);
1602                 GLU_EXPECT_NO_ERROR(gl.getError(), "bind source buffer");
1603         }
1604         else if (m_storage == STORAGE_IMAGE)
1605         {
1606                 DE_ASSERT(m_storageIDs[targetHandle]);
1607
1608                 gl.bindImageTexture(1, m_storageIDs[targetHandle], 0, GL_FALSE, 0, (m_useAtomic) ? (GL_READ_WRITE) : (GL_READ_ONLY), (m_formatInteger) ? (GL_R32I) : (GL_R32F));
1609                 GLU_EXPECT_NO_ERROR(gl.getError(), "bind source image");
1610         }
1611         else
1612                 DE_ASSERT(DE_FALSE);
1613
1614         // set destination
1615         DE_ASSERT(m_operationResultStorages[stepNdx]);
1616         gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_operationResultStorages[stepNdx]);
1617         GLU_EXPECT_NO_ERROR(gl.getError(), "bind result buffer");
1618
1619         // calc
1620         gl.dispatchCompute(m_invocationGridSize, m_invocationGridSize, 1);
1621         GLU_EXPECT_NO_ERROR(gl.getError(), "dispatch read");
1622 }
1623
1624 glw::GLuint InterCallTestCase::genStorage (int friendlyName)
1625 {
1626         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1627
1628         if (m_storage == STORAGE_BUFFER)
1629         {
1630                 const int               numElements             = m_invocationGridSize * m_invocationGridSize * m_perInvocationSize;
1631                 const int               bufferSize              = numElements * (int)((m_formatInteger) ? (sizeof(deInt32)) : (sizeof(glw::GLfloat)));
1632                 glw::GLuint             retVal                  = 0;
1633
1634                 m_testCtx.getLog() << tcu::TestLog::Message << "Creating buffer #" << friendlyName << ", size " << bufferSize << " bytes." << tcu::TestLog::EndMessage;
1635
1636                 gl.genBuffers(1, &retVal);
1637                 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, retVal);
1638
1639                 if (m_formatInteger)
1640                 {
1641                         const std::vector<deUint32> zeroBuffer(numElements, 0);
1642                         gl.bufferData(GL_SHADER_STORAGE_BUFFER, bufferSize, &zeroBuffer[0], GL_STATIC_DRAW);
1643                 }
1644                 else
1645                 {
1646                         const std::vector<float> zeroBuffer(numElements, 0.0f);
1647                         gl.bufferData(GL_SHADER_STORAGE_BUFFER, bufferSize, &zeroBuffer[0], GL_STATIC_DRAW);
1648                 }
1649                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen buffer");
1650
1651                 return retVal;
1652         }
1653         else if (m_storage == STORAGE_IMAGE)
1654         {
1655                 const int       imageWidth      = m_invocationGridSize;
1656                 const int       imageHeight     = m_invocationGridSize * m_perInvocationSize;
1657                 glw::GLuint     retVal          = 0;
1658
1659                 m_testCtx.getLog()
1660                         << tcu::TestLog::Message
1661                         << "Creating image #" << friendlyName << ", size " << imageWidth << "x" << imageHeight
1662                         << ", internalformat = " << ((m_formatInteger) ? ("r32i") : ("r32f"))
1663                         << ", size = " << (imageWidth*imageHeight*sizeof(deUint32)) << " bytes."
1664                         << tcu::TestLog::EndMessage;
1665
1666                 gl.genTextures(1, &retVal);
1667                 gl.bindTexture(GL_TEXTURE_2D, retVal);
1668
1669                 if (m_formatInteger)
1670                         gl.texStorage2D(GL_TEXTURE_2D, 1, GL_R32I, imageWidth, imageHeight);
1671                 else
1672                         gl.texStorage2D(GL_TEXTURE_2D, 1, GL_R32F, imageWidth, imageHeight);
1673
1674                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1675                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1676                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen image");
1677
1678                 m_testCtx.getLog()
1679                         << tcu::TestLog::Message
1680                         << "Filling image with 0"
1681                         << tcu::TestLog::EndMessage;
1682
1683                 if (m_formatInteger)
1684                 {
1685                         const std::vector<deInt32> zeroBuffer(imageWidth * imageHeight, 0);
1686                         gl.texSubImage2D(GL_TEXTURE_2D, 0, 0, 0, imageWidth, imageHeight, GL_RED_INTEGER, GL_INT, &zeroBuffer[0]);
1687                 }
1688                 else
1689                 {
1690                         const std::vector<float> zeroBuffer(imageWidth * imageHeight, 0.0f);
1691                         gl.texSubImage2D(GL_TEXTURE_2D, 0, 0, 0, imageWidth, imageHeight, GL_RED, GL_FLOAT, &zeroBuffer[0]);
1692                 }
1693
1694                 GLU_EXPECT_NO_ERROR(gl.getError(), "specify image contents");
1695
1696                 return retVal;
1697         }
1698         else
1699         {
1700                 DE_ASSERT(DE_FALSE);
1701                 return 0;
1702         }
1703 }
1704
1705 glw::GLuint InterCallTestCase::genResultStorage (void)
1706 {
1707         const glw::Functions&   gl              = m_context.getRenderContext().getFunctions();
1708         glw::GLuint                             retVal  = 0;
1709
1710         gl.genBuffers(1, &retVal);
1711         gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, retVal);
1712         gl.bufferData(GL_SHADER_STORAGE_BUFFER, m_invocationGridSize * m_invocationGridSize * sizeof(deUint32), DE_NULL, GL_STATIC_DRAW);
1713         GLU_EXPECT_NO_ERROR(gl.getError(), "gen buffer");
1714
1715         return retVal;
1716 }
1717
1718 glu::ShaderProgram* InterCallTestCase::genWriteProgram (int seed)
1719 {
1720         const bool                      useImageAtomics = m_useAtomic && m_storage == STORAGE_IMAGE;
1721         std::ostringstream      buf;
1722
1723         buf << "#version 310 es\n"
1724                 << ((useImageAtomics) ? ("#extension GL_OES_shader_image_atomic : require\n") : (""))
1725                 << "layout (local_size_x = 1, local_size_y = 1) in;\n";
1726
1727         if (m_storage == STORAGE_BUFFER)
1728                 buf << "layout(binding=0, std430) " << ((m_useAtomic) ? ("coherent ") : ("")) << "buffer Buffer\n"
1729                         << "{\n"
1730                         << "    highp " << ((m_formatInteger) ? ("int") : ("float")) << " values[];\n"
1731                         << "} sb_out;\n";
1732         else if (m_storage == STORAGE_IMAGE)
1733                 buf << "layout(" << ((m_formatInteger) ? ("r32i") : ("r32f")) << ", binding=0) " << ((m_useAtomic) ? ("coherent ") : ("writeonly ")) << "uniform highp " << ((m_formatInteger) ? ("iimage2D") : ("image2D")) << " u_imageOut;\n";
1734         else
1735                 DE_ASSERT(DE_FALSE);
1736
1737         buf << "\n"
1738                 << "void main (void)\n"
1739                 << "{\n"
1740                 << "    uvec3 size    = gl_NumWorkGroups * gl_WorkGroupSize;\n"
1741                 << "    int groupNdx  = int(size.x * size.y * gl_GlobalInvocationID.z + size.x*gl_GlobalInvocationID.y + gl_GlobalInvocationID.x);\n"
1742                 << "\n";
1743
1744         // Write to buffer/image m_perInvocationSize elements
1745         if (m_storage == STORAGE_BUFFER)
1746         {
1747                 for (int writeNdx = 0; writeNdx < m_perInvocationSize; ++writeNdx)
1748                 {
1749                         if (m_useAtomic)
1750                                 buf << "        atomicExchange(";
1751                         else
1752                                 buf << "        ";
1753
1754                         buf << "sb_out.values[(groupNdx + " << seed + writeNdx*m_invocationGridSize*m_invocationGridSize << ") % " << m_invocationGridSize*m_invocationGridSize*m_perInvocationSize << "]";
1755
1756                         if (m_useAtomic)
1757                                 buf << ", " << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx));\n";
1758                         else
1759                                 buf << " = " << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx);\n";
1760                 }
1761         }
1762         else if (m_storage == STORAGE_IMAGE)
1763         {
1764                 for (int writeNdx = 0; writeNdx < m_perInvocationSize; ++writeNdx)
1765                 {
1766                         if (m_useAtomic)
1767                                 buf << "        imageAtomicExchange";
1768                         else
1769                                 buf << "        imageStore";
1770
1771                         buf << "(u_imageOut, ivec2((int(gl_GlobalInvocationID.x) + " << (seed + writeNdx*100) << ") % " << m_invocationGridSize << ", int(gl_GlobalInvocationID.y) + " << writeNdx*m_invocationGridSize << "), ";
1772
1773                         if (m_useAtomic)
1774                                 buf << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx));\n";
1775                         else
1776                                 buf << ((m_formatInteger) ? ("ivec4(int(groupNdx), 0, 0, 0)") : ("vec4(float(groupNdx), 0.0, 0.0, 0.0)")) << ");\n";
1777                 }
1778         }
1779         else
1780                 DE_ASSERT(DE_FALSE);
1781
1782         buf << "}\n";
1783
1784         return new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(buf.str()));
1785 }
1786
1787 glu::ShaderProgram* InterCallTestCase::genReadProgram (int seed)
1788 {
1789         const bool                      useImageAtomics = m_useAtomic && m_storage == STORAGE_IMAGE;
1790         std::ostringstream      buf;
1791
1792         buf << "#version 310 es\n"
1793                 << ((useImageAtomics) ? ("#extension GL_OES_shader_image_atomic : require\n") : (""))
1794                 << "layout (local_size_x = 1, local_size_y = 1) in;\n";
1795
1796         if (m_storage == STORAGE_BUFFER)
1797                 buf << "layout(binding=1, std430) " << ((m_useAtomic) ? ("coherent ") : ("")) << "buffer Buffer\n"
1798                         << "{\n"
1799                         << "    highp " << ((m_formatInteger) ? ("int") : ("float")) << " values[];\n"
1800                         << "} sb_in;\n";
1801         else if (m_storage == STORAGE_IMAGE)
1802                 buf << "layout(" << ((m_formatInteger) ? ("r32i") : ("r32f")) << ", binding=1) " << ((m_useAtomic) ? ("coherent ") : ("readonly ")) << "uniform highp " << ((m_formatInteger) ? ("iimage2D") : ("image2D")) << " u_imageIn;\n";
1803         else
1804                 DE_ASSERT(DE_FALSE);
1805
1806         buf << "layout(binding=0, std430) buffer ResultBuffer\n"
1807                 << "{\n"
1808                 << "    highp int resultOk[];\n"
1809                 << "} sb_result;\n"
1810                 << "\n"
1811                 << "void main (void)\n"
1812                 << "{\n"
1813                 << "    uvec3 size = gl_NumWorkGroups * gl_WorkGroupSize;\n"
1814                 << "    int groupNdx = int(size.x * size.y * gl_GlobalInvocationID.z + size.x*gl_GlobalInvocationID.y + gl_GlobalInvocationID.x);\n"
1815                 << "    " << ((m_formatInteger) ? ("int") : ("float")) << " zero = " << ((m_formatInteger) ? ("0") : ("0.0")) << ";\n"
1816                 << "    bool allOk = true;\n"
1817                 << "\n";
1818
1819         // Verify data
1820
1821         if (m_storage == STORAGE_BUFFER)
1822         {
1823                 for (int readNdx = 0; readNdx < m_perInvocationSize; ++readNdx)
1824                 {
1825                         if (!m_useAtomic)
1826                                 buf << "        allOk = allOk && (sb_in.values[(groupNdx + "
1827                                         << seed + readNdx*m_invocationGridSize*m_invocationGridSize << ") % " << m_invocationGridSize*m_invocationGridSize*m_perInvocationSize << "] == "
1828                                         << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx));\n";
1829                         else
1830                                 buf << "        allOk = allOk && (atomicExchange(sb_in.values[(groupNdx + "
1831                                         << seed + readNdx*m_invocationGridSize*m_invocationGridSize << ") % " << m_invocationGridSize*m_invocationGridSize*m_perInvocationSize << "], zero) == "
1832                                         << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx));\n";
1833                 }
1834         }
1835         else if (m_storage == STORAGE_IMAGE)
1836         {
1837                 for (int readNdx = 0; readNdx < m_perInvocationSize; ++readNdx)
1838                 {
1839                         if (!m_useAtomic)
1840                                 buf     << "    allOk = allOk && (imageLoad(u_imageIn, ivec2((gl_GlobalInvocationID.x + "
1841                                         << (seed + readNdx*100) << "u) % " << m_invocationGridSize << "u, gl_GlobalInvocationID.y + " << readNdx*m_invocationGridSize << "u)).x == "
1842                                         << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx));\n";
1843                         else
1844                                 buf << "        allOk = allOk && (imageAtomicExchange(u_imageIn, ivec2((gl_GlobalInvocationID.x + "
1845                                         << (seed + readNdx*100) << "u) % " << m_invocationGridSize << "u, gl_GlobalInvocationID.y + " << readNdx*m_invocationGridSize << "u), zero) == "
1846                                         << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx));\n";
1847                 }
1848         }
1849         else
1850                 DE_ASSERT(DE_FALSE);
1851
1852         buf << "        sb_result.resultOk[groupNdx] = (allOk) ? (1) : (0);\n"
1853                 << "}\n";
1854
1855         return new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(buf.str()));
1856 }
1857
1858 glu::ShaderProgram* InterCallTestCase::genReadMultipleProgram (int seed0, int seed1)
1859 {
1860         const bool                      useImageAtomics = m_useAtomic && m_storage == STORAGE_IMAGE;
1861         std::ostringstream      buf;
1862
1863         buf << "#version 310 es\n"
1864                 << ((useImageAtomics) ? ("#extension GL_OES_shader_image_atomic : require\n") : (""))
1865                 << "layout (local_size_x = 1, local_size_y = 1) in;\n";
1866
1867         if (m_storage == STORAGE_BUFFER)
1868                 buf << "layout(binding=1, std430) " << ((m_useAtomic) ? ("coherent ") : ("")) << "buffer Buffer0\n"
1869                         << "{\n"
1870                         << "    highp " << ((m_formatInteger) ? ("int") : ("float")) << " values[];\n"
1871                         << "} sb_in0;\n"
1872                         << "layout(binding=2, std430) " << ((m_useAtomic) ? ("coherent ") : ("")) << "buffer Buffer1\n"
1873                         << "{\n"
1874                         << "    highp " << ((m_formatInteger) ? ("int") : ("float")) << " values[];\n"
1875                         << "} sb_in1;\n";
1876         else if (m_storage == STORAGE_IMAGE)
1877                 buf << "layout(" << ((m_formatInteger) ? ("r32i") : ("r32f")) << ", binding=1) " << ((m_useAtomic) ? ("coherent ") : ("readonly ")) << "uniform highp " << ((m_formatInteger) ? ("iimage2D") : ("image2D")) << " u_imageIn0;\n"
1878                         << "layout(" << ((m_formatInteger) ? ("r32i") : ("r32f")) << ", binding=2) " << ((m_useAtomic) ? ("coherent ") : ("readonly ")) << "uniform highp " << ((m_formatInteger) ? ("iimage2D") : ("image2D")) << " u_imageIn1;\n";
1879         else
1880                 DE_ASSERT(DE_FALSE);
1881
1882         buf << "layout(binding=0, std430) buffer ResultBuffer\n"
1883                 << "{\n"
1884                 << "    highp int resultOk[];\n"
1885                 << "} sb_result;\n"
1886                 << "\n"
1887                 << "void main (void)\n"
1888                 << "{\n"
1889                 << "    uvec3 size = gl_NumWorkGroups * gl_WorkGroupSize;\n"
1890                 << "    int groupNdx = int(size.x * size.y * gl_GlobalInvocationID.z + size.x*gl_GlobalInvocationID.y + gl_GlobalInvocationID.x);\n"
1891                 << "    " << ((m_formatInteger) ? ("int") : ("float")) << " zero = " << ((m_formatInteger) ? ("0") : ("0.0")) << ";\n"
1892                 << "    bool allOk = true;\n"
1893                 << "\n";
1894
1895         // Verify data
1896
1897         if (m_storage == STORAGE_BUFFER)
1898         {
1899                 for (int readNdx = 0; readNdx < m_perInvocationSize; ++readNdx)
1900                         buf << "        allOk = allOk && (" << ((m_useAtomic) ? ("atomicExchange(") : ("")) << "sb_in0.values[(groupNdx + " << seed0 + readNdx*m_invocationGridSize*m_invocationGridSize << ") % " << m_invocationGridSize*m_invocationGridSize*m_perInvocationSize << "]" << ((m_useAtomic) ? (", zero)") : ("")) << " == " << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx));\n"
1901                                 << "    allOk = allOk && (" << ((m_useAtomic) ? ("atomicExchange(") : ("")) << "sb_in1.values[(groupNdx + " << seed1 + readNdx*m_invocationGridSize*m_invocationGridSize << ") % " << m_invocationGridSize*m_invocationGridSize*m_perInvocationSize << "]" << ((m_useAtomic) ? (", zero)") : ("")) << " == " << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx));\n";
1902         }
1903         else if (m_storage == STORAGE_IMAGE)
1904         {
1905                 for (int readNdx = 0; readNdx < m_perInvocationSize; ++readNdx)
1906                         buf << "        allOk = allOk && (" << ((m_useAtomic) ? ("imageAtomicExchange") : ("imageLoad")) << "(u_imageIn0, ivec2((gl_GlobalInvocationID.x + " << (seed0 + readNdx*100) << "u) % " << m_invocationGridSize << "u, gl_GlobalInvocationID.y + " << readNdx*m_invocationGridSize << "u)" << ((m_useAtomic) ? (", zero)") : (").x")) << " == " << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx));\n"
1907                                 << "    allOk = allOk && (" << ((m_useAtomic) ? ("imageAtomicExchange") : ("imageLoad")) << "(u_imageIn1, ivec2((gl_GlobalInvocationID.x + " << (seed1 + readNdx*100) << "u) % " << m_invocationGridSize << "u, gl_GlobalInvocationID.y + " << readNdx*m_invocationGridSize << "u)" << ((m_useAtomic) ? (", zero)") : (").x")) << " == " << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx));\n";
1908         }
1909         else
1910                 DE_ASSERT(DE_FALSE);
1911
1912         buf << "        sb_result.resultOk[groupNdx] = (allOk) ? (1) : (0);\n"
1913                 << "}\n";
1914
1915         return new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(buf.str()));
1916 }
1917
1918 glu::ShaderProgram* InterCallTestCase::genWriteInterleavedProgram (int seed, bool evenOdd)
1919 {
1920         const bool                      useImageAtomics = m_useAtomic && m_storage == STORAGE_IMAGE;
1921         std::ostringstream      buf;
1922
1923         buf << "#version 310 es\n"
1924                 << ((useImageAtomics) ? ("#extension GL_OES_shader_image_atomic : require\n") : (""))
1925                 << "layout (local_size_x = 1, local_size_y = 1) in;\n";
1926
1927         if (m_storage == STORAGE_BUFFER)
1928                 buf << "layout(binding=0, std430) " << ((m_useAtomic) ? ("coherent ") : ("")) << "buffer Buffer\n"
1929                         << "{\n"
1930                         << "    highp " << ((m_formatInteger) ? ("int") : ("float")) << " values[];\n"
1931                         << "} sb_out;\n";
1932         else if (m_storage == STORAGE_IMAGE)
1933                 buf << "layout(" << ((m_formatInteger) ? ("r32i") : ("r32f")) << ", binding=0) " << ((m_useAtomic) ? ("coherent ") : ("writeonly ")) << "uniform highp " << ((m_formatInteger) ? ("iimage2D") : ("image2D")) << " u_imageOut;\n";
1934         else
1935                 DE_ASSERT(DE_FALSE);
1936
1937         buf << "\n"
1938                 << "void main (void)\n"
1939                 << "{\n"
1940                 << "    uvec3 size    = gl_NumWorkGroups * gl_WorkGroupSize;\n"
1941                 << "    int groupNdx  = int(size.x * size.y * gl_GlobalInvocationID.z + size.x*gl_GlobalInvocationID.y + gl_GlobalInvocationID.x);\n"
1942                 << "\n";
1943
1944         // Write to buffer/image m_perInvocationSize elements
1945         if (m_storage == STORAGE_BUFFER)
1946         {
1947                 for (int writeNdx = 0; writeNdx < m_perInvocationSize; ++writeNdx)
1948                 {
1949                         if (m_useAtomic)
1950                                 buf << "        atomicExchange(";
1951                         else
1952                                 buf << "        ";
1953
1954                         buf << "sb_out.values[((groupNdx + " << seed + writeNdx*m_invocationGridSize*m_invocationGridSize / 2 << ") % " << m_invocationGridSize*m_invocationGridSize / 2 * m_perInvocationSize  << ") * 2 + " << ((evenOdd) ? (0) : (1)) << "]";
1955
1956                         if (m_useAtomic)
1957                                 buf << ", " << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx));\n";
1958                         else
1959                                 buf << "= " << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx);\n";
1960                 }
1961         }
1962         else if (m_storage == STORAGE_IMAGE)
1963         {
1964                 for (int writeNdx = 0; writeNdx < m_perInvocationSize; ++writeNdx)
1965                 {
1966                         if (m_useAtomic)
1967                                 buf << "        imageAtomicExchange";
1968                         else
1969                                 buf << "        imageStore";
1970
1971                         buf << "(u_imageOut, ivec2(((int(gl_GlobalInvocationID.x) + " << (seed + writeNdx*100) << ") % " << m_invocationGridSize / 2 << ") * 2 + " << ((evenOdd) ? (0) : (1)) << ", int(gl_GlobalInvocationID.y) + " << writeNdx*m_invocationGridSize << "), ";
1972
1973                         if (m_useAtomic)
1974                                 buf << ((m_formatInteger) ? ("int") : ("float")) << "(groupNdx));\n";
1975                         else
1976                                 buf << ((m_formatInteger) ? ("ivec4(int(groupNdx), 0, 0, 0)") : ("vec4(float(groupNdx), 0.0, 0.0, 0.0)")) << ");\n";
1977                 }
1978         }
1979         else
1980                 DE_ASSERT(DE_FALSE);
1981
1982         buf << "}\n";
1983
1984         return new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(buf.str()));
1985 }
1986
1987 glu::ShaderProgram* InterCallTestCase::genReadInterleavedProgram (int seed0, int seed1)
1988 {
1989         const bool                      useImageAtomics = m_useAtomic && m_storage == STORAGE_IMAGE;
1990         std::ostringstream      buf;
1991
1992         buf << "#version 310 es\n"
1993                 << ((useImageAtomics) ? ("#extension GL_OES_shader_image_atomic : require\n") : (""))
1994                 << "layout (local_size_x = 1, local_size_y = 1) in;\n";
1995
1996         if (m_storage == STORAGE_BUFFER)
1997                 buf << "layout(binding=1, std430) " << ((m_useAtomic) ? ("coherent ") : ("")) << "buffer Buffer\n"
1998                         << "{\n"
1999                         << "    highp " << ((m_formatInteger) ? ("int") : ("float")) << " values[];\n"
2000                         << "} sb_in;\n";
2001         else if (m_storage == STORAGE_IMAGE)
2002                 buf << "layout(" << ((m_formatInteger) ? ("r32i") : ("r32f")) << ", binding=1) " << ((m_useAtomic) ? ("coherent ") : ("readonly ")) << "uniform highp " << ((m_formatInteger) ? ("iimage2D") : ("image2D")) << " u_imageIn;\n";
2003         else
2004                 DE_ASSERT(DE_FALSE);
2005
2006         buf << "layout(binding=0, std430) buffer ResultBuffer\n"
2007                 << "{\n"
2008                 << "    highp int resultOk[];\n"
2009                 << "} sb_result;\n"
2010                 << "\n"
2011                 << "void main (void)\n"
2012                 << "{\n"
2013                 << "    uvec3 size = gl_NumWorkGroups * gl_WorkGroupSize;\n"
2014                 << "    int groupNdx = int(size.x * size.y * gl_GlobalInvocationID.z + size.x*gl_GlobalInvocationID.y + gl_GlobalInvocationID.x);\n"
2015                 << "    int interleavedGroupNdx = int((size.x >> 1U) * size.y * gl_GlobalInvocationID.z + (size.x >> 1U) * gl_GlobalInvocationID.y + (gl_GlobalInvocationID.x >> 1U));\n"
2016                 << "    " << ((m_formatInteger) ? ("int") : ("float")) << " zero = " << ((m_formatInteger) ? ("0") : ("0.0")) << ";\n"
2017                 << "    bool allOk = true;\n"
2018                 << "\n";
2019
2020         // Verify data
2021
2022         if (m_storage == STORAGE_BUFFER)
2023         {
2024                 buf << "        if (groupNdx % 2 == 0)\n"
2025                         << "    {\n";
2026                 for (int readNdx = 0; readNdx < m_perInvocationSize; ++readNdx)
2027                         buf << "                allOk = allOk && ("
2028                                 << ((m_useAtomic) ? ("atomicExchange(") : ("")) << "sb_in.values[((interleavedGroupNdx + " << seed0 + readNdx*m_invocationGridSize*m_invocationGridSize / 2 << ") % " << m_invocationGridSize*m_invocationGridSize*m_perInvocationSize / 2 << ") * 2 + 0]"
2029                                 << ((m_useAtomic) ? (", zero)") : ("")) << " == " << ((m_formatInteger) ? ("int") : ("float")) << "(interleavedGroupNdx));\n";
2030                 buf << "        }\n"
2031                         << "    else\n"
2032                         << "    {\n";
2033                 for (int readNdx = 0; readNdx < m_perInvocationSize; ++readNdx)
2034                         buf << "                allOk = allOk && ("
2035                                 << ((m_useAtomic) ? ("atomicExchange(") : ("")) << "sb_in.values[((interleavedGroupNdx + " << seed1 + readNdx*m_invocationGridSize*m_invocationGridSize / 2 << ") % " << m_invocationGridSize*m_invocationGridSize*m_perInvocationSize / 2 << ") * 2 + 1]"
2036                                 << ((m_useAtomic) ? (", zero)") : ("")) << " == " << ((m_formatInteger) ? ("int") : ("float")) << "(interleavedGroupNdx));\n";
2037                 buf << "        }\n";
2038         }
2039         else if (m_storage == STORAGE_IMAGE)
2040         {
2041                 buf << "        if (groupNdx % 2 == 0)\n"
2042                         << "    {\n";
2043                 for (int readNdx = 0; readNdx < m_perInvocationSize; ++readNdx)
2044                         buf << "                allOk = allOk && ("
2045                                 << ((m_useAtomic) ? ("imageAtomicExchange") : ("imageLoad"))
2046                                 << "(u_imageIn, ivec2(((int(gl_GlobalInvocationID.x >> 1U) + " << (seed0 + readNdx*100) << ") % " << m_invocationGridSize / 2 << ") * 2 + 0, int(gl_GlobalInvocationID.y) + " << readNdx*m_invocationGridSize << ")"
2047                                 << ((m_useAtomic) ? (", zero)") : (").x")) << " == " << ((m_formatInteger) ? ("int") : ("float")) << "(interleavedGroupNdx));\n";
2048                 buf << "        }\n"
2049                         << "    else\n"
2050                         << "    {\n";
2051                 for (int readNdx = 0; readNdx < m_perInvocationSize; ++readNdx)
2052                         buf << "                allOk = allOk && ("
2053                                 << ((m_useAtomic) ? ("imageAtomicExchange") : ("imageLoad"))
2054                                 << "(u_imageIn, ivec2(((int(gl_GlobalInvocationID.x >> 1U) + " << (seed1 + readNdx*100) << ") % " << m_invocationGridSize / 2 << ") * 2 + 1, int(gl_GlobalInvocationID.y) + " << readNdx*m_invocationGridSize << ")"
2055                                 << ((m_useAtomic) ? (", zero)") : (").x")) << " == " << ((m_formatInteger) ? ("int") : ("float")) << "(interleavedGroupNdx));\n";
2056                 buf << "        }\n";
2057         }
2058         else
2059                 DE_ASSERT(DE_FALSE);
2060
2061         buf << "        sb_result.resultOk[groupNdx] = (allOk) ? (1) : (0);\n"
2062                 << "}\n";
2063
2064         return new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(buf.str()));
2065 }
2066
2067 glu::ShaderProgram*     InterCallTestCase::genReadZeroProgram (void)
2068 {
2069         const bool                      useImageAtomics = m_useAtomic && m_storage == STORAGE_IMAGE;
2070         std::ostringstream      buf;
2071
2072         buf << "#version 310 es\n"
2073                 << ((useImageAtomics) ? ("#extension GL_OES_shader_image_atomic : require\n") : (""))
2074                 << "layout (local_size_x = 1, local_size_y = 1) in;\n";
2075
2076         if (m_storage == STORAGE_BUFFER)
2077                 buf << "layout(binding=1, std430) " << ((m_useAtomic) ? ("coherent ") : ("")) << "buffer Buffer\n"
2078                         << "{\n"
2079                         << "    highp " << ((m_formatInteger) ? ("int") : ("float")) << " values[];\n"
2080                         << "} sb_in;\n";
2081         else if (m_storage == STORAGE_IMAGE)
2082                 buf << "layout(" << ((m_formatInteger) ? ("r32i") : ("r32f")) << ", binding=1) " << ((m_useAtomic) ? ("coherent ") : ("readonly ")) << "uniform highp " << ((m_formatInteger) ? ("iimage2D") : ("image2D")) << " u_imageIn;\n";
2083         else
2084                 DE_ASSERT(DE_FALSE);
2085
2086         buf << "layout(binding=0, std430) buffer ResultBuffer\n"
2087                 << "{\n"
2088                 << "    highp int resultOk[];\n"
2089                 << "} sb_result;\n"
2090                 << "\n"
2091                 << "void main (void)\n"
2092                 << "{\n"
2093                 << "    uvec3 size = gl_NumWorkGroups * gl_WorkGroupSize;\n"
2094                 << "    int groupNdx = int(size.x * size.y * gl_GlobalInvocationID.z + size.x*gl_GlobalInvocationID.y + gl_GlobalInvocationID.x);\n"
2095                 << "    " << ((m_formatInteger) ? ("int") : ("float")) << " anything = " << ((m_formatInteger) ? ("5") : ("5.0")) << ";\n"
2096                 << "    bool allOk = true;\n"
2097                 << "\n";
2098
2099         // Verify data
2100
2101         if (m_storage == STORAGE_BUFFER)
2102         {
2103                 for (int readNdx = 0; readNdx < m_perInvocationSize; ++readNdx)
2104                         buf << "        allOk = allOk && ("
2105                                 << ((m_useAtomic) ? ("atomicExchange(") : ("")) << "sb_in.values[groupNdx * " << m_perInvocationSize << " + " << readNdx << "]"
2106                                 << ((m_useAtomic) ? (", anything)") : ("")) << " == " << ((m_formatInteger) ? ("0") : ("0.0")) << ");\n";
2107         }
2108         else if (m_storage == STORAGE_IMAGE)
2109         {
2110                 for (int readNdx = 0; readNdx < m_perInvocationSize; ++readNdx)
2111                         buf << "        allOk = allOk && ("
2112                         << ((m_useAtomic) ? ("imageAtomicExchange") : ("imageLoad")) << "(u_imageIn, ivec2(gl_GlobalInvocationID.x, gl_GlobalInvocationID.y + " << (readNdx*m_invocationGridSize) << "u)"
2113                         << ((m_useAtomic) ? (", anything)") : (").x")) << " == " << ((m_formatInteger) ? ("0") : ("0.0")) << ");\n";
2114         }
2115         else
2116                 DE_ASSERT(DE_FALSE);
2117
2118         buf << "        sb_result.resultOk[groupNdx] = (allOk) ? (1) : (0);\n"
2119                 << "}\n";
2120
2121         return new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(buf.str()));
2122 }
2123
2124 class SSBOConcurrentAtomicCase : public TestCase
2125 {
2126 public:
2127
2128                                                         SSBOConcurrentAtomicCase        (Context& context, const char* name, const char* description, int numCalls, int workSize);
2129                                                         ~SSBOConcurrentAtomicCase       (void);
2130
2131         void                                    init                                            (void);
2132         void                                    deinit                                          (void);
2133         IterateResult                   iterate                                         (void);
2134
2135 private:
2136         std::string                             genComputeSource                        (void) const;
2137
2138         const int                               m_numCalls;
2139         const int                               m_workSize;
2140         glu::ShaderProgram*             m_program;
2141         deUint32                                m_bufferID;
2142         std::vector<deUint32>   m_intermediateResultBuffers;
2143 };
2144
2145 SSBOConcurrentAtomicCase::SSBOConcurrentAtomicCase (Context& context, const char* name, const char* description, int numCalls, int workSize)
2146         : TestCase              (context, name, description)
2147         , m_numCalls    (numCalls)
2148         , m_workSize    (workSize)
2149         , m_program             (DE_NULL)
2150         , m_bufferID    (DE_NULL)
2151 {
2152 }
2153
2154 SSBOConcurrentAtomicCase::~SSBOConcurrentAtomicCase (void)
2155 {
2156         deinit();
2157 }
2158
2159 void SSBOConcurrentAtomicCase::init (void)
2160 {
2161         const glw::Functions&   gl                                      = m_context.getRenderContext().getFunctions();
2162         std::vector<deUint32>   zeroData                        (m_workSize, 0);
2163
2164         // gen buffers
2165
2166         gl.genBuffers(1, &m_bufferID);
2167         gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_bufferID);
2168         gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(deUint32) * m_workSize, &zeroData[0], GL_DYNAMIC_COPY);
2169
2170         for (int ndx = 0; ndx < m_numCalls; ++ndx)
2171         {
2172                 deUint32 buffer = 0;
2173
2174                 gl.genBuffers(1, &buffer);
2175                 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
2176                 gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(deUint32) * m_workSize, &zeroData[0], GL_DYNAMIC_COPY);
2177
2178                 m_intermediateResultBuffers.push_back(buffer);
2179                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen buffers");
2180         }
2181
2182         // gen program
2183
2184         m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(genComputeSource()));
2185         m_testCtx.getLog() << *m_program;
2186         if (!m_program->isOk())
2187                 throw tcu::TestError("could not build program");
2188 }
2189
2190 void SSBOConcurrentAtomicCase::deinit (void)
2191 {
2192         if (m_bufferID)
2193         {
2194                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_bufferID);
2195                 m_bufferID = 0;
2196         }
2197
2198         for (int ndx = 0; ndx < (int)m_intermediateResultBuffers.size(); ++ndx)
2199                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_intermediateResultBuffers[ndx]);
2200         m_intermediateResultBuffers.clear();
2201
2202         delete m_program;
2203         m_program = DE_NULL;
2204 }
2205
2206 TestCase::IterateResult SSBOConcurrentAtomicCase::iterate (void)
2207 {
2208         const glw::Functions&   gl                              = m_context.getRenderContext().getFunctions();
2209         const deUint32                  sumValue                = (deUint32)(m_numCalls * (m_numCalls + 1) / 2);
2210         std::vector<int>                deltas;
2211
2212         // generate unique deltas
2213         generateShuffledRamp(m_numCalls, deltas);
2214
2215         // invoke program N times, each with a different delta
2216         {
2217                 const int deltaLocation = gl.getUniformLocation(m_program->getProgram(), "u_atomicDelta");
2218
2219                 m_testCtx.getLog()
2220                         << tcu::TestLog::Message
2221                         << "Running shader " << m_numCalls << " times.\n"
2222                         << "Num groups = (" << m_workSize << ", 1, 1)\n"
2223                         << "Setting u_atomicDelta to a unique value for each call.\n"
2224                         << tcu::TestLog::EndMessage;
2225
2226                 if (deltaLocation == -1)
2227                         throw tcu::TestError("u_atomicDelta location was -1");
2228
2229                 gl.useProgram(m_program->getProgram());
2230                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_bufferID);
2231
2232                 for (int callNdx = 0; callNdx < m_numCalls; ++callNdx)
2233                 {
2234                         m_testCtx.getLog()
2235                                 << tcu::TestLog::Message
2236                                 << "Call " << callNdx << ": u_atomicDelta = " << deltas[callNdx]
2237                                 << tcu::TestLog::EndMessage;
2238
2239                         gl.uniform1ui(deltaLocation, deltas[callNdx]);
2240                         gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_intermediateResultBuffers[callNdx]);
2241                         gl.dispatchCompute(m_workSize, 1, 1);
2242                 }
2243
2244                 GLU_EXPECT_NO_ERROR(gl.getError(), "post dispatch");
2245         }
2246
2247         // Verify result
2248         {
2249                 std::vector<deUint32> result;
2250
2251                 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying work buffer, it should be filled with value " << sumValue << tcu::TestLog::EndMessage;
2252
2253                 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_bufferID);
2254                 readBuffer(gl, GL_SHADER_STORAGE_BUFFER, m_workSize, result);
2255
2256                 for (int ndx = 0; ndx < m_workSize; ++ndx)
2257                 {
2258                         if (result[ndx] != sumValue)
2259                         {
2260                                 m_testCtx.getLog()
2261                                         << tcu::TestLog::Message
2262                                         << "Work buffer error, at index " << ndx << " expected value " << (sumValue) << ", got " << result[ndx] << "\n"
2263                                         << "Work buffer contains invalid values."
2264                                         << tcu::TestLog::EndMessage;
2265
2266                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Buffer contents invalid");
2267                                 return STOP;
2268                         }
2269                 }
2270
2271                 m_testCtx.getLog() << tcu::TestLog::Message << "Work buffer contents are valid." << tcu::TestLog::EndMessage;
2272         }
2273
2274         // verify steps
2275         {
2276                 std::vector<std::vector<deUint32> >     intermediateResults     (m_numCalls);
2277                 std::vector<deUint32>                           valueChain                      (m_numCalls);
2278
2279                 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying intermediate results. " << tcu::TestLog::EndMessage;
2280
2281                 // collect results
2282
2283                 for (int callNdx = 0; callNdx < m_numCalls; ++callNdx)
2284                 {
2285                         gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_intermediateResultBuffers[callNdx]);
2286                         readBuffer(gl, GL_SHADER_STORAGE_BUFFER, m_workSize, intermediateResults[callNdx]);
2287                 }
2288
2289                 // verify values
2290
2291                 for (int valueNdx = 0; valueNdx < m_workSize; ++valueNdx)
2292                 {
2293                         int                     invalidOperationNdx;
2294                         deUint32        errorDelta;
2295                         deUint32        errorExpected;
2296
2297                         // collect result chain for each element
2298                         for (int callNdx = 0; callNdx < m_numCalls; ++callNdx)
2299                                 valueChain[callNdx] = intermediateResults[callNdx][valueNdx];
2300
2301                         // check there exists a path from 0 to sumValue using each addition once
2302                         // decompose cumulative results to addition operations (all additions positive => this works)
2303
2304                         std::sort(valueChain.begin(), valueChain.end());
2305
2306                         // validate chain
2307                         if (!validateSortedAtomicRampAdditionValueChain(valueChain, sumValue, invalidOperationNdx, errorDelta, errorExpected))
2308                         {
2309                                 m_testCtx.getLog()
2310                                         << tcu::TestLog::Message
2311                                         << "Intermediate buffer error, at value index " << valueNdx << ", applied operation index " << invalidOperationNdx << ", value was increased by " << errorDelta << ", but expected " << errorExpected << ".\n"
2312                                         << "Intermediate buffer contains invalid values. Values at index " << valueNdx << "\n"
2313                                         << tcu::TestLog::EndMessage;
2314
2315                                 for (int logCallNdx = 0; logCallNdx < m_numCalls; ++logCallNdx)
2316                                         m_testCtx.getLog() << tcu::TestLog::Message << "Value[" << logCallNdx << "] = " << intermediateResults[logCallNdx][valueNdx] << tcu::TestLog::EndMessage;
2317                                 m_testCtx.getLog() << tcu::TestLog::Message << "Result = " << sumValue << tcu::TestLog::EndMessage;
2318
2319                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Buffer contents invalid");
2320                                 return STOP;
2321                         }
2322                 }
2323
2324                 m_testCtx.getLog() << tcu::TestLog::Message << "Intermediate buffers are valid." << tcu::TestLog::EndMessage;
2325         }
2326
2327         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2328         return STOP;
2329 }
2330
2331 std::string SSBOConcurrentAtomicCase::genComputeSource (void) const
2332 {
2333         std::ostringstream buf;
2334
2335         buf     << "#version 310 es\n"
2336                 << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
2337                 << "layout (binding = 1, std430) writeonly buffer IntermediateResults\n"
2338                 << "{\n"
2339                 << "    highp uint values[" << m_workSize << "];\n"
2340                 << "} sb_ires;\n"
2341                 << "\n"
2342                 << "layout (binding = 2, std430) volatile buffer WorkBuffer\n"
2343                 << "{\n"
2344                 << "    highp uint values[" << m_workSize << "];\n"
2345                 << "} sb_work;\n"
2346                 << "uniform highp uint u_atomicDelta;\n"
2347                 << "\n"
2348                 << "void main ()\n"
2349                 << "{\n"
2350                 << "    highp uint invocationIndex = gl_GlobalInvocationID.x;\n"
2351                 << "    sb_ires.values[invocationIndex] = atomicAdd(sb_work.values[invocationIndex], u_atomicDelta);\n"
2352                 << "}";
2353
2354         return buf.str();
2355 }
2356
2357 class ConcurrentAtomicCounterCase : public TestCase
2358 {
2359 public:
2360
2361                                                         ConcurrentAtomicCounterCase             (Context& context, const char* name, const char* description, int numCalls, int workSize);
2362                                                         ~ConcurrentAtomicCounterCase    (void);
2363
2364         void                                    init                                                    (void);
2365         void                                    deinit                                                  (void);
2366         IterateResult                   iterate                                                 (void);
2367
2368 private:
2369         std::string                             genComputeSource                                (bool evenOdd) const;
2370
2371         const int                               m_numCalls;
2372         const int                               m_workSize;
2373         glu::ShaderProgram*             m_evenProgram;
2374         glu::ShaderProgram*             m_oddProgram;
2375         deUint32                                m_counterBuffer;
2376         deUint32                                m_intermediateResultBuffer;
2377 };
2378
2379 ConcurrentAtomicCounterCase::ConcurrentAtomicCounterCase (Context& context, const char* name, const char* description, int numCalls, int workSize)
2380         : TestCase                                      (context, name, description)
2381         , m_numCalls                            (numCalls)
2382         , m_workSize                            (workSize)
2383         , m_evenProgram                         (DE_NULL)
2384         , m_oddProgram                          (DE_NULL)
2385         , m_counterBuffer                       (DE_NULL)
2386         , m_intermediateResultBuffer(DE_NULL)
2387 {
2388 }
2389
2390 ConcurrentAtomicCounterCase::~ConcurrentAtomicCounterCase (void)
2391 {
2392         deinit();
2393 }
2394
2395 void ConcurrentAtomicCounterCase::init (void)
2396 {
2397         const glw::Functions&           gl                      = m_context.getRenderContext().getFunctions();
2398         const std::vector<deUint32>     zeroData        (m_numCalls * m_workSize, 0);
2399
2400         // gen buffer
2401
2402         gl.genBuffers(1, &m_counterBuffer);
2403         gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_counterBuffer);
2404         gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(deUint32), &zeroData[0], GL_DYNAMIC_COPY);
2405
2406         gl.genBuffers(1, &m_intermediateResultBuffer);
2407         gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_intermediateResultBuffer);
2408         gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(deUint32) * m_numCalls * m_workSize, &zeroData[0], GL_DYNAMIC_COPY);
2409
2410         GLU_EXPECT_NO_ERROR(gl.getError(), "gen buffers");
2411
2412         // gen programs
2413
2414         {
2415                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "EvenProgram", "Even program");
2416
2417                 m_evenProgram = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(genComputeSource(true)));
2418                 m_testCtx.getLog() << *m_evenProgram;
2419                 if (!m_evenProgram->isOk())
2420                         throw tcu::TestError("could not build program");
2421         }
2422         {
2423                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "OddProgram", "Odd program");
2424
2425                 m_oddProgram = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(genComputeSource(false)));
2426                 m_testCtx.getLog() << *m_oddProgram;
2427                 if (!m_oddProgram->isOk())
2428                         throw tcu::TestError("could not build program");
2429         }
2430 }
2431
2432 void ConcurrentAtomicCounterCase::deinit (void)
2433 {
2434         if (m_counterBuffer)
2435         {
2436                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_counterBuffer);
2437                 m_counterBuffer = 0;
2438         }
2439         if (m_intermediateResultBuffer)
2440         {
2441                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_intermediateResultBuffer);
2442                 m_intermediateResultBuffer = 0;
2443         }
2444
2445         delete m_evenProgram;
2446         m_evenProgram = DE_NULL;
2447
2448         delete m_oddProgram;
2449         m_oddProgram = DE_NULL;
2450 }
2451
2452 TestCase::IterateResult ConcurrentAtomicCounterCase::iterate (void)
2453 {
2454         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2455
2456         // invoke program N times, each with a different delta
2457         {
2458                 const int evenCallNdxLocation   = gl.getUniformLocation(m_evenProgram->getProgram(), "u_callNdx");
2459                 const int oddCallNdxLocation    = gl.getUniformLocation(m_oddProgram->getProgram(), "u_callNdx");
2460
2461                 m_testCtx.getLog()
2462                         << tcu::TestLog::Message
2463                         << "Running shader pair (even & odd) " << m_numCalls << " times.\n"
2464                         << "Num groups = (" << m_workSize << ", 1, 1)\n"
2465                         << tcu::TestLog::EndMessage;
2466
2467                 if (evenCallNdxLocation == -1)
2468                         throw tcu::TestError("u_callNdx location was -1");
2469                 if (oddCallNdxLocation == -1)
2470                         throw tcu::TestError("u_callNdx location was -1");
2471
2472                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_intermediateResultBuffer);
2473                 gl.bindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 2, m_counterBuffer);
2474
2475                 for (int callNdx = 0; callNdx < m_numCalls; ++callNdx)
2476                 {
2477                         gl.useProgram(m_evenProgram->getProgram());
2478                         gl.uniform1ui(evenCallNdxLocation, (deUint32)callNdx);
2479                         gl.dispatchCompute(m_workSize, 1, 1);
2480
2481                         gl.useProgram(m_oddProgram->getProgram());
2482                         gl.uniform1ui(oddCallNdxLocation, (deUint32)callNdx);
2483                         gl.dispatchCompute(m_workSize, 1, 1);
2484                 }
2485
2486                 GLU_EXPECT_NO_ERROR(gl.getError(), "post dispatch");
2487         }
2488
2489         // Verify result
2490         {
2491                 deUint32 result;
2492
2493                 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying work buffer, it should be " << m_numCalls*m_workSize << tcu::TestLog::EndMessage;
2494
2495                 gl.bindBuffer(GL_ATOMIC_COUNTER_BUFFER, m_counterBuffer);
2496                 result = readBufferUint32(gl, GL_ATOMIC_COUNTER_BUFFER);
2497
2498                 if ((int)result != m_numCalls*m_workSize)
2499                 {
2500                         m_testCtx.getLog()
2501                                 << tcu::TestLog::Message
2502                                 << "Counter buffer error, expected value " << (m_numCalls*m_workSize) << ", got " << result << "\n"
2503                                 << tcu::TestLog::EndMessage;
2504
2505                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Buffer contents invalid");
2506                         return STOP;
2507                 }
2508
2509                 m_testCtx.getLog() << tcu::TestLog::Message << "Counter buffer is valid." << tcu::TestLog::EndMessage;
2510         }
2511
2512         // verify steps
2513         {
2514                 std::vector<deUint32> intermediateResults;
2515
2516                 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying intermediate results. " << tcu::TestLog::EndMessage;
2517
2518                 // collect results
2519
2520                 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_intermediateResultBuffer);
2521                 readBuffer(gl, GL_SHADER_STORAGE_BUFFER, m_numCalls * m_workSize, intermediateResults);
2522
2523                 // verify values
2524
2525                 std::sort(intermediateResults.begin(), intermediateResults.end());
2526
2527                 for (int valueNdx = 0; valueNdx < m_workSize * m_numCalls; ++valueNdx)
2528                 {
2529                         if ((int)intermediateResults[valueNdx] != valueNdx)
2530                         {
2531                                 m_testCtx.getLog()
2532                                         << tcu::TestLog::Message
2533                                         << "Intermediate buffer error, at value index " << valueNdx << ", expected " << valueNdx << ", got " << intermediateResults[valueNdx] << ".\n"
2534                                         << "Intermediate buffer contains invalid values. Intermediate results:\n"
2535                                         << tcu::TestLog::EndMessage;
2536
2537                                 for (int logCallNdx = 0; logCallNdx < m_workSize * m_numCalls; ++logCallNdx)
2538                                         m_testCtx.getLog() << tcu::TestLog::Message << "Value[" << logCallNdx << "] = " << intermediateResults[logCallNdx] << tcu::TestLog::EndMessage;
2539
2540                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Buffer contents invalid");
2541                                 return STOP;
2542                         }
2543                 }
2544
2545                 m_testCtx.getLog() << tcu::TestLog::Message << "Intermediate buffers are valid." << tcu::TestLog::EndMessage;
2546         }
2547
2548         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2549         return STOP;
2550 }
2551
2552 std::string ConcurrentAtomicCounterCase::genComputeSource (bool evenOdd) const
2553 {
2554         std::ostringstream buf;
2555
2556         buf     << "#version 310 es\n"
2557                 << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
2558                 << "layout (binding = 1, std430) writeonly buffer IntermediateResults\n"
2559                 << "{\n"
2560                 << "    highp uint values[" << m_workSize * m_numCalls << "];\n"
2561                 << "} sb_ires;\n"
2562                 << "\n"
2563                 << "layout (binding = 2, offset = 0) uniform atomic_uint u_counter;\n"
2564                 << "uniform highp uint u_callNdx;\n"
2565                 << "\n"
2566                 << "void main ()\n"
2567                 << "{\n"
2568                 << "    highp uint dataNdx = u_callNdx * " << m_workSize << "u + gl_GlobalInvocationID.x;\n"
2569                 << "    if ((dataNdx % 2u) == " << ((evenOdd) ? (0) : (1)) << "u)\n"
2570                 << "            sb_ires.values[dataNdx] = atomicCounterIncrement(u_counter);\n"
2571                 << "}";
2572
2573         return buf.str();
2574 }
2575
2576 class ConcurrentImageAtomicCase : public TestCase
2577 {
2578 public:
2579
2580                                                         ConcurrentImageAtomicCase       (Context& context, const char* name, const char* description, int numCalls, int workSize);
2581                                                         ~ConcurrentImageAtomicCase      (void);
2582
2583         void                                    init                                            (void);
2584         void                                    deinit                                          (void);
2585         IterateResult                   iterate                                         (void);
2586
2587 private:
2588         void                                    readWorkImage                           (std::vector<deUint32>& result);
2589
2590         std::string                             genComputeSource                        (void) const;
2591         std::string                             genImageReadSource                      (void) const;
2592         std::string                             genImageClearSource                     (void) const;
2593
2594         const int                               m_numCalls;
2595         const int                               m_workSize;
2596         glu::ShaderProgram*             m_program;
2597         glu::ShaderProgram*             m_imageReadProgram;
2598         glu::ShaderProgram*             m_imageClearProgram;
2599         deUint32                                m_imageID;
2600         std::vector<deUint32>   m_intermediateResultBuffers;
2601 };
2602
2603 ConcurrentImageAtomicCase::ConcurrentImageAtomicCase (Context& context, const char* name, const char* description, int numCalls, int workSize)
2604         : TestCase                              (context, name, description)
2605         , m_numCalls                    (numCalls)
2606         , m_workSize                    (workSize)
2607         , m_program                             (DE_NULL)
2608         , m_imageReadProgram    (DE_NULL)
2609         , m_imageClearProgram   (DE_NULL)
2610         , m_imageID                             (DE_NULL)
2611 {
2612 }
2613
2614 ConcurrentImageAtomicCase::~ConcurrentImageAtomicCase (void)
2615 {
2616         deinit();
2617 }
2618
2619 void ConcurrentImageAtomicCase::init (void)
2620 {
2621         const glw::Functions&   gl                                      = m_context.getRenderContext().getFunctions();
2622         std::vector<deUint32>   zeroData                        (m_workSize * m_workSize, 0);
2623
2624         if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_image_atomic"))
2625                 throw tcu::NotSupportedError("Test requires GL_OES_shader_image_atomic");
2626
2627         // gen image
2628
2629         gl.genTextures(1, &m_imageID);
2630         gl.bindTexture(GL_TEXTURE_2D, m_imageID);
2631         gl.texStorage2D(GL_TEXTURE_2D, 1, GL_R32UI, m_workSize, m_workSize);
2632         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2633         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2634         GLU_EXPECT_NO_ERROR(gl.getError(), "gen tex");
2635
2636         // gen buffers
2637
2638         for (int ndx = 0; ndx < m_numCalls; ++ndx)
2639         {
2640                 deUint32 buffer = 0;
2641
2642                 gl.genBuffers(1, &buffer);
2643                 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
2644                 gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(deUint32) * m_workSize * m_workSize, &zeroData[0], GL_DYNAMIC_COPY);
2645
2646                 m_intermediateResultBuffers.push_back(buffer);
2647                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen buffers");
2648         }
2649
2650         // gen programs
2651
2652         m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(genComputeSource()));
2653         m_testCtx.getLog() << *m_program;
2654         if (!m_program->isOk())
2655                 throw tcu::TestError("could not build program");
2656
2657         m_imageReadProgram = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(genImageReadSource()));
2658         if (!m_imageReadProgram->isOk())
2659         {
2660                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "ImageReadProgram", "Image read program");
2661
2662                 m_testCtx.getLog() << *m_imageReadProgram;
2663                 throw tcu::TestError("could not build program");
2664         }
2665
2666         m_imageClearProgram = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(genImageClearSource()));
2667         if (!m_imageClearProgram->isOk())
2668         {
2669                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "ImageClearProgram", "Image read program");
2670
2671                 m_testCtx.getLog() << *m_imageClearProgram;
2672                 throw tcu::TestError("could not build program");
2673         }
2674 }
2675
2676 void ConcurrentImageAtomicCase::deinit (void)
2677 {
2678         if (m_imageID)
2679         {
2680                 m_context.getRenderContext().getFunctions().deleteTextures(1, &m_imageID);
2681                 m_imageID = 0;
2682         }
2683
2684         for (int ndx = 0; ndx < (int)m_intermediateResultBuffers.size(); ++ndx)
2685                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_intermediateResultBuffers[ndx]);
2686         m_intermediateResultBuffers.clear();
2687
2688         delete m_program;
2689         m_program = DE_NULL;
2690
2691         delete m_imageReadProgram;
2692         m_imageReadProgram = DE_NULL;
2693
2694         delete m_imageClearProgram;
2695         m_imageClearProgram = DE_NULL;
2696 }
2697
2698 TestCase::IterateResult ConcurrentImageAtomicCase::iterate (void)
2699 {
2700         const glw::Functions&   gl                              = m_context.getRenderContext().getFunctions();
2701         const deUint32                  sumValue                = (deUint32)(m_numCalls * (m_numCalls + 1) / 2);
2702         std::vector<int>                deltas;
2703
2704         // generate unique deltas
2705         generateShuffledRamp(m_numCalls, deltas);
2706
2707         // clear image
2708         {
2709                 m_testCtx.getLog() << tcu::TestLog::Message << "Clearing image contents" << tcu::TestLog::EndMessage;
2710
2711                 gl.useProgram(m_imageClearProgram->getProgram());
2712                 gl.bindImageTexture(2, m_imageID, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32UI);
2713                 gl.dispatchCompute(m_workSize, m_workSize, 1);
2714                 gl.memoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
2715
2716                 GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
2717         }
2718
2719         // invoke program N times, each with a different delta
2720         {
2721                 const int deltaLocation = gl.getUniformLocation(m_program->getProgram(), "u_atomicDelta");
2722
2723                 m_testCtx.getLog()
2724                         << tcu::TestLog::Message
2725                         << "Running shader " << m_numCalls << " times.\n"
2726                         << "Num groups = (" << m_workSize << ", " << m_workSize << ", 1)\n"
2727                         << "Setting u_atomicDelta to a unique value for each call.\n"
2728                         << tcu::TestLog::EndMessage;
2729
2730                 if (deltaLocation == -1)
2731                         throw tcu::TestError("u_atomicDelta location was -1");
2732
2733                 gl.useProgram(m_program->getProgram());
2734                 gl.bindImageTexture(2, m_imageID, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32UI);
2735
2736                 for (int callNdx = 0; callNdx < m_numCalls; ++callNdx)
2737                 {
2738                         m_testCtx.getLog()
2739                                 << tcu::TestLog::Message
2740                                 << "Call " << callNdx << ": u_atomicDelta = " << deltas[callNdx]
2741                                 << tcu::TestLog::EndMessage;
2742
2743                         gl.uniform1ui(deltaLocation, deltas[callNdx]);
2744                         gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_intermediateResultBuffers[callNdx]);
2745                         gl.dispatchCompute(m_workSize, m_workSize, 1);
2746                 }
2747
2748                 GLU_EXPECT_NO_ERROR(gl.getError(), "post dispatch");
2749         }
2750
2751         // Verify result
2752         {
2753                 std::vector<deUint32> result;
2754
2755                 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying work image, it should be filled with value " << sumValue << tcu::TestLog::EndMessage;
2756
2757                 readWorkImage(result);
2758
2759                 for (int ndx = 0; ndx < m_workSize * m_workSize; ++ndx)
2760                 {
2761                         if (result[ndx] != sumValue)
2762                         {
2763                                 m_testCtx.getLog()
2764                                         << tcu::TestLog::Message
2765                                         << "Work image error, at index (" << ndx % m_workSize << ", " << ndx / m_workSize << ") expected value " << (sumValue) << ", got " << result[ndx] << "\n"
2766                                         << "Work image contains invalid values."
2767                                         << tcu::TestLog::EndMessage;
2768
2769                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image contents invalid");
2770                                 return STOP;
2771                         }
2772                 }
2773
2774                 m_testCtx.getLog() << tcu::TestLog::Message << "Work image contents are valid." << tcu::TestLog::EndMessage;
2775         }
2776
2777         // verify steps
2778         {
2779                 std::vector<std::vector<deUint32> >     intermediateResults     (m_numCalls);
2780                 std::vector<deUint32>                           valueChain                      (m_numCalls);
2781                 std::vector<deUint32>                           chainDelta                      (m_numCalls);
2782
2783                 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying intermediate results. " << tcu::TestLog::EndMessage;
2784
2785                 // collect results
2786
2787                 for (int callNdx = 0; callNdx < m_numCalls; ++callNdx)
2788                 {
2789                         gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_intermediateResultBuffers[callNdx]);
2790                         readBuffer(gl, GL_SHADER_STORAGE_BUFFER, m_workSize * m_workSize, intermediateResults[callNdx]);
2791                 }
2792
2793                 // verify values
2794
2795                 for (int valueNdx = 0; valueNdx < m_workSize; ++valueNdx)
2796                 {
2797                         int                     invalidOperationNdx;
2798                         deUint32        errorDelta;
2799                         deUint32        errorExpected;
2800
2801                         // collect result chain for each element
2802                         for (int callNdx = 0; callNdx < m_numCalls; ++callNdx)
2803                                 valueChain[callNdx] = intermediateResults[callNdx][valueNdx];
2804
2805                         // check there exists a path from 0 to sumValue using each addition once
2806                         // decompose cumulative results to addition operations (all additions positive => this works)
2807
2808                         std::sort(valueChain.begin(), valueChain.end());
2809
2810                         for (int callNdx = 0; callNdx < m_numCalls; ++callNdx)
2811                                 chainDelta[callNdx] = ((callNdx + 1 == m_numCalls) ? (sumValue) : (valueChain[callNdx+1])) - valueChain[callNdx];
2812
2813                         // chainDelta contains now the actual additions applied to the value
2814                         std::sort(chainDelta.begin(), chainDelta.end());
2815
2816                         // validate chain
2817                         if (!validateSortedAtomicRampAdditionValueChain(valueChain, sumValue, invalidOperationNdx, errorDelta, errorExpected))
2818                         {
2819                                 m_testCtx.getLog()
2820                                         << tcu::TestLog::Message
2821                                         << "Intermediate buffer error, at index (" << valueNdx % m_workSize << ", " << valueNdx / m_workSize << "), applied operation index "
2822                                         << invalidOperationNdx << ", value was increased by " << errorDelta << ", but expected " << errorExpected << ".\n"
2823                                         << "Intermediate buffer contains invalid values. Values at index (" << valueNdx % m_workSize << ", " << valueNdx / m_workSize << ")\n"
2824                                         << tcu::TestLog::EndMessage;
2825
2826                                 for (int logCallNdx = 0; logCallNdx < m_numCalls; ++logCallNdx)
2827                                         m_testCtx.getLog() << tcu::TestLog::Message << "Value[" << logCallNdx << "] = " << intermediateResults[logCallNdx][valueNdx] << tcu::TestLog::EndMessage;
2828                                 m_testCtx.getLog() << tcu::TestLog::Message << "Result = " << sumValue << tcu::TestLog::EndMessage;
2829
2830                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Buffer contents invalid");
2831                                 return STOP;
2832                         }
2833                 }
2834
2835                 m_testCtx.getLog() << tcu::TestLog::Message << "Intermediate buffers are valid." << tcu::TestLog::EndMessage;
2836         }
2837
2838         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2839         return STOP;
2840 }
2841
2842 void ConcurrentImageAtomicCase::readWorkImage (std::vector<deUint32>& result)
2843 {
2844         const glw::Functions&   gl                              = m_context.getRenderContext().getFunctions();
2845         glu::Buffer                             resultBuffer    (m_context.getRenderContext());
2846
2847         // Read image to an ssbo
2848
2849         {
2850                 const std::vector<deUint32> zeroData(m_workSize*m_workSize, 0);
2851
2852                 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *resultBuffer);
2853                 gl.bufferData(GL_SHADER_STORAGE_BUFFER, (int)(sizeof(deUint32) * m_workSize * m_workSize), &zeroData[0], GL_DYNAMIC_COPY);
2854
2855                 gl.memoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
2856                 gl.useProgram(m_imageReadProgram->getProgram());
2857
2858                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, *resultBuffer);
2859                 gl.bindImageTexture(2, m_imageID, 0, GL_FALSE, 0, GL_READ_ONLY, GL_R32UI);
2860                 gl.dispatchCompute(m_workSize, m_workSize, 1);
2861
2862                 GLU_EXPECT_NO_ERROR(gl.getError(), "read");
2863         }
2864
2865         // Read ssbo
2866         {
2867                 const void* ptr = gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, (int)(sizeof(deUint32) * m_workSize * m_workSize), GL_MAP_READ_BIT);
2868                 GLU_EXPECT_NO_ERROR(gl.getError(), "map");
2869
2870                 if (!ptr)
2871                         throw tcu::TestError("mapBufferRange returned NULL");
2872
2873                 result.resize(m_workSize * m_workSize);
2874                 memcpy(&result[0], ptr, sizeof(deUint32) * m_workSize * m_workSize);
2875
2876                 if (gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER) == GL_FALSE)
2877                         throw tcu::TestError("unmapBuffer returned false");
2878         }
2879 }
2880
2881 std::string ConcurrentImageAtomicCase::genComputeSource (void) const
2882 {
2883         std::ostringstream buf;
2884
2885         buf     << "#version 310 es\n"
2886                 << "#extension GL_OES_shader_image_atomic : require\n"
2887                 << "\n"
2888                 << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
2889                 << "layout (binding = 1, std430) writeonly buffer IntermediateResults\n"
2890                 << "{\n"
2891                 << "    highp uint values[" << m_workSize * m_workSize << "];\n"
2892                 << "} sb_ires;\n"
2893                 << "\n"
2894                 << "layout (binding = 2, r32ui) volatile uniform highp uimage2D u_workImage;\n"
2895                 << "uniform highp uint u_atomicDelta;\n"
2896                 << "\n"
2897                 << "void main ()\n"
2898                 << "{\n"
2899                 << "    highp uint invocationIndex = gl_GlobalInvocationID.x + gl_GlobalInvocationID.y * uint(" << m_workSize <<");\n"
2900                 << "    sb_ires.values[invocationIndex] = imageAtomicAdd(u_workImage, ivec2(gl_GlobalInvocationID.xy), u_atomicDelta);\n"
2901                 << "}";
2902
2903         return buf.str();
2904 }
2905
2906 std::string ConcurrentImageAtomicCase::genImageReadSource (void) const
2907 {
2908         std::ostringstream buf;
2909
2910         buf     << "#version 310 es\n"
2911                 << "\n"
2912                 << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
2913                 << "layout (binding = 1, std430) writeonly buffer ImageValues\n"
2914                 << "{\n"
2915                 << "    highp uint values[" << m_workSize * m_workSize << "];\n"
2916                 << "} sb_res;\n"
2917                 << "\n"
2918                 << "layout (binding = 2, r32ui) readonly uniform highp uimage2D u_workImage;\n"
2919                 << "\n"
2920                 << "void main ()\n"
2921                 << "{\n"
2922                 << "    highp uint invocationIndex = gl_GlobalInvocationID.x + gl_GlobalInvocationID.y * uint(" << m_workSize <<");\n"
2923                 << "    sb_res.values[invocationIndex] = imageLoad(u_workImage, ivec2(gl_GlobalInvocationID.xy)).x;\n"
2924                 << "}";
2925
2926         return buf.str();
2927 }
2928
2929 std::string ConcurrentImageAtomicCase::genImageClearSource (void) const
2930 {
2931         std::ostringstream buf;
2932
2933         buf     << "#version 310 es\n"
2934                 << "\n"
2935                 << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
2936                 << "layout (binding = 2, r32ui) writeonly uniform highp uimage2D u_workImage;\n"
2937                 << "\n"
2938                 << "void main ()\n"
2939                 << "{\n"
2940                 << "    imageStore(u_workImage, ivec2(gl_GlobalInvocationID.xy), uvec4(0, 0, 0, 0));\n"
2941                 << "}";
2942
2943         return buf.str();
2944 }
2945
2946 class ConcurrentSSBOAtomicCounterMixedCase : public TestCase
2947 {
2948 public:
2949                                                         ConcurrentSSBOAtomicCounterMixedCase    (Context& context, const char* name, const char* description, int numCalls, int workSize);
2950                                                         ~ConcurrentSSBOAtomicCounterMixedCase   (void);
2951
2952         void                                    init                                                                    (void);
2953         void                                    deinit                                                                  (void);
2954         IterateResult                   iterate                                                                 (void);
2955
2956 private:
2957         std::string                             genSSBOComputeSource                                    (void) const;
2958         std::string                             genAtomicCounterComputeSource                   (void) const;
2959
2960         const int                               m_numCalls;
2961         const int                               m_workSize;
2962         deUint32                                m_bufferID;
2963         glu::ShaderProgram*             m_ssboAtomicProgram;
2964         glu::ShaderProgram*             m_atomicCounterProgram;
2965 };
2966
2967 ConcurrentSSBOAtomicCounterMixedCase::ConcurrentSSBOAtomicCounterMixedCase (Context& context, const char* name, const char* description, int numCalls, int workSize)
2968         : TestCase                                      (context, name, description)
2969         , m_numCalls                            (numCalls)
2970         , m_workSize                            (workSize)
2971         , m_bufferID                            (DE_NULL)
2972         , m_ssboAtomicProgram           (DE_NULL)
2973         , m_atomicCounterProgram        (DE_NULL)
2974 {
2975         // SSBO atomic XORs cancel out
2976         DE_ASSERT((workSize * numCalls) % (16 * 2) == 0);
2977 }
2978
2979 ConcurrentSSBOAtomicCounterMixedCase::~ConcurrentSSBOAtomicCounterMixedCase (void)
2980 {
2981         deinit();
2982 }
2983
2984 void ConcurrentSSBOAtomicCounterMixedCase::init (void)
2985 {
2986         const glw::Functions&           gl                      = m_context.getRenderContext().getFunctions();
2987         const deUint32                          zeroBuf[2]      = { 0, 0 };
2988
2989         // gen buffer
2990
2991         gl.genBuffers(1, &m_bufferID);
2992         gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_bufferID);
2993         gl.bufferData(GL_SHADER_STORAGE_BUFFER, (int)(sizeof(deUint32) * 2), zeroBuf, GL_DYNAMIC_COPY);
2994
2995         GLU_EXPECT_NO_ERROR(gl.getError(), "gen buffers");
2996
2997         // gen programs
2998
2999         {
3000                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "SSBOProgram", "SSBO atomic program");
3001
3002                 m_ssboAtomicProgram = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(genSSBOComputeSource()));
3003                 m_testCtx.getLog() << *m_ssboAtomicProgram;
3004                 if (!m_ssboAtomicProgram->isOk())
3005                         throw tcu::TestError("could not build program");
3006         }
3007         {
3008                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "AtomicCounterProgram", "Atomic counter program");
3009
3010                 m_atomicCounterProgram = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(genAtomicCounterComputeSource()));
3011                 m_testCtx.getLog() << *m_atomicCounterProgram;
3012                 if (!m_atomicCounterProgram->isOk())
3013                         throw tcu::TestError("could not build program");
3014         }
3015 }
3016
3017 void ConcurrentSSBOAtomicCounterMixedCase::deinit (void)
3018 {
3019         if (m_bufferID)
3020         {
3021                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_bufferID);
3022                 m_bufferID = 0;
3023         }
3024
3025         delete m_ssboAtomicProgram;
3026         m_ssboAtomicProgram = DE_NULL;
3027
3028         delete m_atomicCounterProgram;
3029         m_atomicCounterProgram = DE_NULL;
3030 }
3031
3032 TestCase::IterateResult ConcurrentSSBOAtomicCounterMixedCase::iterate (void)
3033 {
3034         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
3035
3036         m_testCtx.getLog() << tcu::TestLog::Message << "Testing atomic counters and SSBO atomic operations with both backed by the same buffer." << tcu::TestLog::EndMessage;
3037
3038         // invoke programs N times
3039         {
3040                 m_testCtx.getLog()
3041                         << tcu::TestLog::Message
3042                         << "Running SSBO atomic program and atomic counter program " << m_numCalls << " times. (interleaved)\n"
3043                         << "Num groups = (" << m_workSize << ", 1, 1)\n"
3044                         << tcu::TestLog::EndMessage;
3045
3046                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_bufferID);
3047                 gl.bindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 2, m_bufferID);
3048
3049                 for (int callNdx = 0; callNdx < m_numCalls; ++callNdx)
3050                 {
3051                         gl.useProgram(m_atomicCounterProgram->getProgram());
3052                         gl.dispatchCompute(m_workSize, 1, 1);
3053
3054                         gl.useProgram(m_ssboAtomicProgram->getProgram());
3055                         gl.dispatchCompute(m_workSize, 1, 1);
3056                 }
3057
3058                 GLU_EXPECT_NO_ERROR(gl.getError(), "post dispatch");
3059         }
3060
3061         // Verify result
3062         {
3063                 deUint32 result;
3064
3065                 // XORs cancel out, only addition is left
3066                 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying work buffer, it should be " << m_numCalls*m_workSize << tcu::TestLog::EndMessage;
3067
3068                 gl.bindBuffer(GL_ATOMIC_COUNTER_BUFFER, m_bufferID);
3069                 result = readBufferUint32(gl, GL_ATOMIC_COUNTER_BUFFER);
3070
3071                 if ((int)result != m_numCalls*m_workSize)
3072                 {
3073                         m_testCtx.getLog()
3074                                 << tcu::TestLog::Message
3075                                 << "Buffer value error, expected value " << (m_numCalls*m_workSize) << ", got " << result << "\n"
3076                                 << tcu::TestLog::EndMessage;
3077
3078                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Buffer contents invalid");
3079                         return STOP;
3080                 }
3081
3082                 m_testCtx.getLog() << tcu::TestLog::Message << "Buffer is valid." << tcu::TestLog::EndMessage;
3083         }
3084
3085         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
3086         return STOP;
3087 }
3088
3089 std::string ConcurrentSSBOAtomicCounterMixedCase::genSSBOComputeSource (void) const
3090 {
3091         std::ostringstream buf;
3092
3093         buf     << "#version 310 es\n"
3094                 << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
3095                 << "layout (binding = 1, std430) volatile buffer WorkBuffer\n"
3096                 << "{\n"
3097                 << "    highp uint targetValue;\n"
3098                 << "    highp uint dummy;\n"
3099                 << "} sb_work;\n"
3100                 << "\n"
3101                 << "void main ()\n"
3102                 << "{\n"
3103                 << "    // flip high bits\n"
3104                 << "    highp uint mask = uint(1) << (16u + (gl_GlobalInvocationID.x % 16u));\n"
3105                 << "    sb_work.dummy = atomicXor(sb_work.targetValue, mask);\n"
3106                 << "}";
3107
3108         return buf.str();
3109 }
3110
3111 std::string ConcurrentSSBOAtomicCounterMixedCase::genAtomicCounterComputeSource (void) const
3112 {
3113         std::ostringstream buf;
3114
3115         buf     << "#version 310 es\n"
3116                 << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
3117                 << "\n"
3118                 << "layout (binding = 2, offset = 0) uniform atomic_uint u_counter;\n"
3119                 << "\n"
3120                 << "void main ()\n"
3121                 << "{\n"
3122                 << "    atomicCounterIncrement(u_counter);\n"
3123                 << "}";
3124
3125         return buf.str();
3126 }
3127
3128 } // anonymous
3129
3130 SynchronizationTests::SynchronizationTests (Context& context)
3131         : TestCaseGroup(context, "synchronization", "Synchronization tests")
3132 {
3133 }
3134
3135 SynchronizationTests::~SynchronizationTests (void)
3136 {
3137 }
3138
3139 void SynchronizationTests::init (void)
3140 {
3141         tcu::TestCaseGroup* const inInvocationGroup             = new tcu::TestCaseGroup(m_testCtx, "in_invocation",    "Test intra-invocation synchronization");
3142         tcu::TestCaseGroup* const interInvocationGroup  = new tcu::TestCaseGroup(m_testCtx, "inter_invocation", "Test inter-invocation synchronization");
3143         tcu::TestCaseGroup* const interCallGroup                = new tcu::TestCaseGroup(m_testCtx, "inter_call",       "Test inter-call synchronization");
3144
3145         addChild(inInvocationGroup);
3146         addChild(interInvocationGroup);
3147         addChild(interCallGroup);
3148
3149         // .in_invocation & .inter_invocation
3150         {
3151                 static const struct CaseConfig
3152                 {
3153                         const char*                                                                     namePrefix;
3154                         const InterInvocationTestCase::StorageType      storage;
3155                         const int                                                                       flags;
3156                 } configs[] =
3157                 {
3158                         { "image",                      InterInvocationTestCase::STORAGE_IMAGE,         0                                                                               },
3159                         { "image_atomic",       InterInvocationTestCase::STORAGE_IMAGE,         InterInvocationTestCase::FLAG_ATOMIC    },
3160                         { "ssbo",                       InterInvocationTestCase::STORAGE_BUFFER,        0                                                                               },
3161                         { "ssbo_atomic",        InterInvocationTestCase::STORAGE_BUFFER,        InterInvocationTestCase::FLAG_ATOMIC    },
3162                 };
3163
3164                 for (int groupNdx = 0; groupNdx < 2; ++groupNdx)
3165                 {
3166                         tcu::TestCaseGroup* const       targetGroup     = (groupNdx == 0) ? (inInvocationGroup) : (interInvocationGroup);
3167                         const int                                       extraFlags      = (groupNdx == 0) ? (0) : (InterInvocationTestCase::FLAG_IN_GROUP);
3168
3169                         for (int configNdx = 0; configNdx < DE_LENGTH_OF_ARRAY(configs); ++configNdx)
3170                         {
3171                                 const char* const target = (configs[configNdx].storage == InterInvocationTestCase::STORAGE_BUFFER) ? ("buffer") : ("image");
3172
3173                                 targetGroup->addChild(new InvocationWriteReadCase(m_context,
3174                                                                                                                                   (std::string(configs[configNdx].namePrefix) + "_write_read").c_str(),
3175                                                                                                                                   (std::string("Write to ") + target + " and read it").c_str(),
3176                                                                                                                                   configs[configNdx].storage,
3177                                                                                                                                   configs[configNdx].flags | extraFlags));
3178
3179                                 targetGroup->addChild(new InvocationReadWriteCase(m_context,
3180                                                                                                                                   (std::string(configs[configNdx].namePrefix) + "_read_write").c_str(),
3181                                                                                                                                   (std::string("Read form ") + target + " and then write to it").c_str(),
3182                                                                                                                                   configs[configNdx].storage,
3183                                                                                                                                   configs[configNdx].flags | extraFlags));
3184
3185                                 targetGroup->addChild(new InvocationOverWriteCase(m_context,
3186                                                                                                                                   (std::string(configs[configNdx].namePrefix) + "_overwrite").c_str(),
3187                                                                                                                                   (std::string("Write to ") + target + " twice and read it").c_str(),
3188                                                                                                                                   configs[configNdx].storage,
3189                                                                                                                                   configs[configNdx].flags | extraFlags));
3190
3191                                 targetGroup->addChild(new InvocationAliasWriteCase(m_context,
3192                                                                                                                                    (std::string(configs[configNdx].namePrefix) + "_alias_write").c_str(),
3193                                                                                                                                    (std::string("Write to aliasing ") + target + " and read it").c_str(),
3194                                                                                                                                    InvocationAliasWriteCase::TYPE_WRITE,
3195                                                                                                                                    configs[configNdx].storage,
3196                                                                                                                                    configs[configNdx].flags | extraFlags));
3197
3198                                 targetGroup->addChild(new InvocationAliasWriteCase(m_context,
3199                                                                                                                                    (std::string(configs[configNdx].namePrefix) + "_alias_overwrite").c_str(),
3200                                                                                                                                    (std::string("Write to aliasing ") + target + "s and read it").c_str(),
3201                                                                                                                                    InvocationAliasWriteCase::TYPE_OVERWRITE,
3202                                                                                                                                    configs[configNdx].storage,
3203                                                                                                                                    configs[configNdx].flags | extraFlags));
3204                         }
3205                 }
3206         }
3207
3208         // .inter_call
3209         {
3210                 tcu::TestCaseGroup* const withBarrierGroup              = new tcu::TestCaseGroup(m_testCtx, "with_memory_barrier", "Synchronize with memory barrier");
3211                 tcu::TestCaseGroup* const withoutBarrierGroup   = new tcu::TestCaseGroup(m_testCtx, "without_memory_barrier", "Synchronize without memory barrier");
3212
3213                 interCallGroup->addChild(withBarrierGroup);
3214                 interCallGroup->addChild(withoutBarrierGroup);
3215
3216                 // .with_memory_barrier
3217                 {
3218                         static const struct CaseConfig
3219                         {
3220                                 const char*                                                             namePrefix;
3221                                 const InterCallTestCase::StorageType    storage;
3222                                 const int                                                               flags;
3223                         } configs[] =
3224                         {
3225                                 { "image",                      InterCallTestCase::STORAGE_IMAGE,       0                                                                                                                                               },
3226                                 { "image_atomic",       InterCallTestCase::STORAGE_IMAGE,       InterCallTestCase::FLAG_USE_ATOMIC | InterCallTestCase::FLAG_USE_INT    },
3227                                 { "ssbo",                       InterCallTestCase::STORAGE_BUFFER,      0                                                                                                                                               },
3228                                 { "ssbo_atomic",        InterCallTestCase::STORAGE_BUFFER,      InterCallTestCase::FLAG_USE_ATOMIC | InterCallTestCase::FLAG_USE_INT    },
3229                         };
3230
3231                         const int seed0 = 123;
3232                         const int seed1 = 457;
3233
3234                         for (int configNdx = 0; configNdx < DE_LENGTH_OF_ARRAY(configs); ++configNdx)
3235                         {
3236                                 const char* const target = (configs[configNdx].storage == InterCallTestCase::STORAGE_BUFFER) ? ("buffer") : ("image");
3237
3238                                 withBarrierGroup->addChild(new InterCallTestCase(m_context,
3239                                                                                                                                  (std::string(configs[configNdx].namePrefix) + "_write_read").c_str(),
3240                                                                                                                                  (std::string("Write to ") + target + " and read it").c_str(),
3241                                                                                                                                  configs[configNdx].storage,
3242                                                                                                                                  configs[configNdx].flags,
3243                                                                                                                                  InterCallOperations()
3244                                                                                                                                         << op::WriteData::Generate(1, seed0)
3245                                                                                                                                         << op::Barrier()
3246                                                                                                                                         << op::ReadData::Generate(1, seed0)));
3247
3248                                 withBarrierGroup->addChild(new InterCallTestCase(m_context,
3249                                                                                                                                  (std::string(configs[configNdx].namePrefix) + "_read_write").c_str(),
3250                                                                                                                                  (std::string("Read from ") + target + " and then write to it").c_str(),
3251                                                                                                                                  configs[configNdx].storage,
3252                                                                                                                                  configs[configNdx].flags,
3253                                                                                                                                  InterCallOperations()
3254                                                                                                                                         << op::ReadZeroData::Generate(1)
3255                                                                                                                                         << op::Barrier()
3256                                                                                                                                         << op::WriteData::Generate(1, seed0)));
3257
3258                                 withBarrierGroup->addChild(new InterCallTestCase(m_context,
3259                                                                                                                                  (std::string(configs[configNdx].namePrefix) + "_overwrite").c_str(),
3260                                                                                                                                  (std::string("Write to ") + target + " twice and read it").c_str(),
3261                                                                                                                                  configs[configNdx].storage,
3262                                                                                                                                  configs[configNdx].flags,
3263                                                                                                                                  InterCallOperations()
3264                                                                                                                                         << op::WriteData::Generate(1, seed0)
3265                                                                                                                                         << op::Barrier()
3266                                                                                                                                         << op::WriteData::Generate(1, seed1)
3267                                                                                                                                         << op::Barrier()
3268                                                                                                                                         << op::ReadData::Generate(1, seed1)));
3269
3270                                 withBarrierGroup->addChild(new InterCallTestCase(m_context,
3271                                                                                                                                  (std::string(configs[configNdx].namePrefix) + "_multiple_write_read").c_str(),
3272                                                                                                                                  (std::string("Write to multiple ") + target + "s and read them").c_str(),
3273                                                                                                                                  configs[configNdx].storage,
3274                                                                                                                                  configs[configNdx].flags,
3275                                                                                                                                  InterCallOperations()
3276                                                                                                                                         << op::WriteData::Generate(1, seed0)
3277                                                                                                                                         << op::WriteData::Generate(2, seed1)
3278                                                                                                                                         << op::Barrier()
3279                                                                                                                                         << op::ReadMultipleData::Generate(1, seed0, 2, seed1)));
3280
3281                                 withBarrierGroup->addChild(new InterCallTestCase(m_context,
3282                                                                                                                                  (std::string(configs[configNdx].namePrefix) + "_multiple_interleaved_write_read").c_str(),
3283                                                                                                                                  (std::string("Write to same ") + target + " in multiple calls and read it").c_str(),
3284                                                                                                                                  configs[configNdx].storage,
3285                                                                                                                                  configs[configNdx].flags,
3286                                                                                                                                  InterCallOperations()
3287                                                                                                                                         << op::WriteDataInterleaved::Generate(1, seed0, true)
3288                                                                                                                                         << op::WriteDataInterleaved::Generate(1, seed1, false)
3289                                                                                                                                         << op::Barrier()
3290                                                                                                                                         << op::ReadDataInterleaved::Generate(1, seed0, seed1)));
3291
3292                                 withBarrierGroup->addChild(new InterCallTestCase(m_context,
3293                                                                                                                                  (std::string(configs[configNdx].namePrefix) + "_multiple_unrelated_write_read_ordered").c_str(),
3294                                                                                                                                  (std::string("Two unrelated ") + target + " write-reads").c_str(),
3295                                                                                                                                  configs[configNdx].storage,
3296                                                                                                                                  configs[configNdx].flags,
3297                                                                                                                                  InterCallOperations()
3298                                                                                                                                         << op::WriteData::Generate(1, seed0)
3299                                                                                                                                         << op::WriteData::Generate(2, seed1)
3300                                                                                                                                         << op::Barrier()
3301                                                                                                                                         << op::ReadData::Generate(1, seed0)
3302                                                                                                                                         << op::ReadData::Generate(2, seed1)));
3303
3304                                 withBarrierGroup->addChild(new InterCallTestCase(m_context,
3305                                                                                                                                  (std::string(configs[configNdx].namePrefix) + "_multiple_unrelated_write_read_non_ordered").c_str(),
3306                                                                                                                                  (std::string("Two unrelated ") + target + " write-reads").c_str(),
3307                                                                                                                                  configs[configNdx].storage,
3308                                                                                                                                  configs[configNdx].flags,
3309                                                                                                                                  InterCallOperations()
3310                                                                                                                                         << op::WriteData::Generate(1, seed0)
3311                                                                                                                                         << op::WriteData::Generate(2, seed1)
3312                                                                                                                                         << op::Barrier()
3313                                                                                                                                         << op::ReadData::Generate(2, seed1)
3314                                                                                                                                         << op::ReadData::Generate(1, seed0)));
3315                         }
3316
3317                         // .without_memory_barrier
3318                         {
3319                                 struct InvocationConfig
3320                                 {
3321                                         const char*     name;
3322                                         int                     count;
3323                                 };
3324
3325                                 static const InvocationConfig ssboInvocations[] =
3326                                 {
3327                                         { "1k",         1024    },
3328                                         { "4k",         4096    },
3329                                         { "32k",        32768   },
3330                                 };
3331                                 static const InvocationConfig imageInvocations[] =
3332                                 {
3333                                         { "8x8",                8       },
3334                                         { "32x32",              32      },
3335                                         { "128x128",    128     },
3336                                 };
3337                                 static const InvocationConfig counterInvocations[] =
3338                                 {
3339                                         { "32",         32              },
3340                                         { "128",        128             },
3341                                         { "1k",         1024    },
3342                                 };
3343                                 static const int callCounts[] = { 2, 5, 100 };
3344
3345                                 for (int invocationNdx = 0; invocationNdx < DE_LENGTH_OF_ARRAY(ssboInvocations); ++invocationNdx)
3346                                         for (int callCountNdx = 0; callCountNdx < DE_LENGTH_OF_ARRAY(callCounts); ++callCountNdx)
3347                                                 withoutBarrierGroup->addChild(new SSBOConcurrentAtomicCase(m_context, (std::string("ssbo_atomic_dispatch_") + de::toString(callCounts[callCountNdx]) + "_calls_" + ssboInvocations[invocationNdx].name + "_invocations").c_str(),       "", callCounts[callCountNdx], ssboInvocations[invocationNdx].count));
3348
3349                                 for (int invocationNdx = 0; invocationNdx < DE_LENGTH_OF_ARRAY(imageInvocations); ++invocationNdx)
3350                                         for (int callCountNdx = 0; callCountNdx < DE_LENGTH_OF_ARRAY(callCounts); ++callCountNdx)
3351                                                 withoutBarrierGroup->addChild(new ConcurrentImageAtomicCase(m_context, (std::string("image_atomic_dispatch_") + de::toString(callCounts[callCountNdx]) + "_calls_" + imageInvocations[invocationNdx].name + "_invocations").c_str(),    "", callCounts[callCountNdx], imageInvocations[invocationNdx].count));
3352
3353                                 for (int invocationNdx = 0; invocationNdx < DE_LENGTH_OF_ARRAY(counterInvocations); ++invocationNdx)
3354                                         for (int callCountNdx = 0; callCountNdx < DE_LENGTH_OF_ARRAY(callCounts); ++callCountNdx)
3355                                                 withoutBarrierGroup->addChild(new ConcurrentAtomicCounterCase(m_context, (std::string("atomic_counter_dispatch_") + de::toString(callCounts[callCountNdx]) + "_calls_" + counterInvocations[invocationNdx].name + "_invocations").c_str(),      "", callCounts[callCountNdx], counterInvocations[invocationNdx].count));
3356
3357                                 for (int invocationNdx = 0; invocationNdx < DE_LENGTH_OF_ARRAY(counterInvocations); ++invocationNdx)
3358                                         for (int callCountNdx = 0; callCountNdx < DE_LENGTH_OF_ARRAY(callCounts); ++callCountNdx)
3359                                                 withoutBarrierGroup->addChild(new ConcurrentSSBOAtomicCounterMixedCase(m_context, (std::string("ssbo_atomic_counter_mixed_dispatch_") + de::toString(callCounts[callCountNdx]) + "_calls_" + counterInvocations[invocationNdx].name + "_invocations").c_str(),  "", callCounts[callCountNdx], counterInvocations[invocationNdx].count));
3360                         }
3361                 }
3362         }
3363 }
3364
3365 } // Functional
3366 } // gles31
3367 } // deqp