modules/gles31/functional/es31fIndirectComputeDispatchTests.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 Indirect compute dispatch tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fIndirectComputeDispatchTests.hpp"
  25 #include "gluObjectWrapper.hpp"
  26 #include "gluRenderContext.hpp"
  27 #include "gluShaderProgram.hpp"
  28 #include "glwFunctions.hpp"
  29 #include "glwEnums.hpp"
  30 #include "tcuVector.hpp"
  31 #include "tcuStringTemplate.hpp"
  32 #include "tcuTestLog.hpp"
  33 #include "deStringUtil.hpp"
  34
  35 #include <vector>
  36 #include <string>
  37 #include <map>
  38
  39 namespace deqp
  40 {
  41 namespace gles31
  42 {
  43 namespace Functional
  44 {
  45
  46 using tcu::UVec3;
  47 using tcu::TestLog;
  48 using std::vector;
  49 using std::string;
  50 using std::map;
  51
  52 // \todo [2014-02-17 pyry] Should be extended with following:
  53
  54 // Negative:
  55 //  - no active shader program
  56 //  - indirect negative or not aligned
  57 //  - indirect + size outside buffer bounds
  58 //  - no buffer bound to DRAW_INDIRECT_BUFFER
  59 //  - (implict) buffer mapped
  60
  61 // Robustness:
  62 //  - lot of small work group launches
  63 //  - very large work group size
  64 //  - no synchronization, touched by gpu
  65 //  - compute program overwiting buffer
  66
  67 namespace
  68 {
  69
  70 enum
  71 {
  72         RESULT_BLOCK_BASE_SIZE                          = (3+1)*(int)sizeof(deUint32),          // uvec3 + uint
  73         RESULT_BLOCK_EXPECTED_COUNT_OFFSET      = 0,
  74         RESULT_BLOCK_NUM_PASSED_OFFSET          = 3*(int)sizeof(deUint32),
  75
  76         INDIRECT_COMMAND_SIZE                           = 3*(int)sizeof(deUint32)
  77 };
  78
  79 enum GenBuffer
  80 {
  81         GEN_BUFFER_UPLOAD               = 0,
  82         GEN_BUFFER_COMPUTE,
  83
  84         GEN_BUFFER_LAST
  85 };
  86
  87 glu::ProgramSources genVerifySources (const UVec3& workGroupSize)
  88 {
  89         static const char* s_verifyDispatchTmpl =
  90                 "#version 310 es\n"
  91                 "layout(local_size_x = ${LOCAL_SIZE_X}, local_size_y = ${LOCAL_SIZE_Y}, local_size_z = ${LOCAL_SIZE_Z}) in;\n"
  92                 "layout(binding = 0, std430) buffer Result\n"
  93                 "{\n"
  94                 "    uvec3           expectedGroupCount;\n"
  95                 "    coherent uint   numPassed;\n"
  96                 "} result;\n"
  97                 "void main (void)\n"
  98                 "{\n"
  99                 "    if (all(equal(result.expectedGroupCount, gl_NumWorkGroups)))\n"
 100                 "        atomicAdd(result.numPassed, 1u);\n"
 101                 "}\n";
 102
 103         map<string, string> args;
 104
 105         args["LOCAL_SIZE_X"] = de::toString(workGroupSize.x());
 106         args["LOCAL_SIZE_Y"] = de::toString(workGroupSize.y());
 107         args["LOCAL_SIZE_Z"] = de::toString(workGroupSize.z());
 108
 109         return glu::ProgramSources() << glu::ComputeSource(tcu::StringTemplate(s_verifyDispatchTmpl).specialize(args));
 110 }
 111
 112 class IndirectDispatchCase : public TestCase
 113 {
 114 public:
 115                                                         IndirectDispatchCase    (Context& context, const char* name, const char* description, GenBuffer genBuffer);
 116                                                         ~IndirectDispatchCase   (void);
 117
 118         IterateResult                   iterate                                 (void);
 119
 120 protected:
 121         struct DispatchCommand
 122         {
 123                 deIntptr        offset;
 124                 UVec3           numWorkGroups;
 125
 126                 DispatchCommand (void) : offset(0) {}
 127                 DispatchCommand (deIntptr offset_, const UVec3& numWorkGroups_) : offset(offset_), numWorkGroups(numWorkGroups_) {}
 128         };
 129
 130         GenBuffer                               m_genBuffer;
 131         deUintptr                               m_bufferSize;
 132         UVec3                                   m_workGroupSize;
 133         vector<DispatchCommand> m_commands;
 134
 135         void                                    createCommandBuffer             (deUint32 buffer) const;
 136         void                                    createResultBuffer              (deUint32 buffer) const;
 137
 138         bool                                    verifyResultBuffer              (deUint32 buffer);
 139
 140         void                                    createCmdBufferUpload   (deUint32 buffer) const;
 141         void                                    createCmdBufferCompute  (deUint32 buffer) const;
 142
 143 private:
 144                                                         IndirectDispatchCase    (const IndirectDispatchCase&);
 145         IndirectDispatchCase&   operator=                               (const IndirectDispatchCase&);
 146 };
 147
 148 IndirectDispatchCase::IndirectDispatchCase (Context& context, const char* name, const char* description, GenBuffer genBuffer)
 149         : TestCase              (context, name, description)
 150         , m_genBuffer   (genBuffer)
 151         , m_bufferSize  (0)
 152 {
 153 }
 154
 155 IndirectDispatchCase::~IndirectDispatchCase (void)
 156 {
 157 }
 158
 159 static int getResultBlockAlignedSize (const glw::Functions& gl)
 160 {
 161         const int       baseSize        = RESULT_BLOCK_BASE_SIZE;
 162         int                     alignment       = 0;
 163         gl.getIntegerv(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, &alignment);
 164
 165         if (alignment == 0 || (baseSize % alignment == 0))
 166                 return baseSize;
 167         else
 168                 return (baseSize/alignment + 1)*alignment;
 169 }
 170
 171 void IndirectDispatchCase::createCommandBuffer (deUint32 buffer) const
 172 {
 173         switch (m_genBuffer)
 174         {
 175                 case GEN_BUFFER_UPLOAD:         createCmdBufferUpload   (buffer);               break;
 176                 case GEN_BUFFER_COMPUTE:        createCmdBufferCompute  (buffer);               break;
 177                 default:
 178                         DE_ASSERT(false);
 179         }
 180 }
 181
 182 void IndirectDispatchCase::createCmdBufferUpload (deUint32 buffer) const
 183 {
 184         const glw::Functions&   gl              = m_context.getRenderContext().getFunctions();
 185         vector<deUint8>                 data    (m_bufferSize);
 186
 187         for (vector<DispatchCommand>::const_iterator cmdIter = m_commands.begin(); cmdIter != m_commands.end(); ++cmdIter)
 188         {
 189                 DE_STATIC_ASSERT(INDIRECT_COMMAND_SIZE >= sizeof(deUint32)*3);
 190                 DE_ASSERT(cmdIter->offset >= 0);
 191                 DE_ASSERT(cmdIter->offset%sizeof(deUint32) == 0);
 192                 DE_ASSERT(cmdIter->offset + INDIRECT_COMMAND_SIZE <= (deIntptr)m_bufferSize);
 193
 194                 deUint32* const dstPtr = (deUint32*)&data[cmdIter->offset];
 195
 196                 dstPtr[0] = cmdIter->numWorkGroups[0];
 197                 dstPtr[1] = cmdIter->numWorkGroups[1];
 198                 dstPtr[2] = cmdIter->numWorkGroups[2];
 199         }
 200
 201         gl.bindBuffer(GL_DISPATCH_INDIRECT_BUFFER, buffer);
 202         gl.bufferData(GL_DISPATCH_INDIRECT_BUFFER, (glw::GLsizeiptr)data.size(), &data[0], GL_STATIC_DRAW);
 203 }
 204
 205 void IndirectDispatchCase::createCmdBufferCompute (deUint32 buffer) const
 206 {
 207         std::ostringstream src;
 208
 209         // Header
 210         src <<
 211                 "#version 310 es\n"
 212                 "layout(local_size_x = 1) in;\n"
 213                 "layout(std430, binding = 1) buffer Out\n"
 214                 "{\n"
 215                 "       highp uint data[];\n"
 216                 "};\n"
 217                 "void writeCmd (uint offset, uvec3 numWorkGroups)\n"
 218                 "{\n"
 219                 "       data[offset+0u] = numWorkGroups.x;\n"
 220                 "       data[offset+1u] = numWorkGroups.y;\n"
 221                 "       data[offset+2u] = numWorkGroups.z;\n"
 222                 "}\n"
 223                 "void main (void)\n"
 224                 "{\n";
 225
 226         // Commands
 227         for (vector<DispatchCommand>::const_iterator cmdIter = m_commands.begin(); cmdIter != m_commands.end(); ++cmdIter)
 228         {
 229                 const deUint32 offs = (deUint32)(cmdIter->offset/4);
 230                 DE_ASSERT((deIntptr)offs*4 == cmdIter->offset);
 231
 232                 src << "\twriteCmd(" << offs << "u, uvec3("
 233                         << cmdIter->numWorkGroups.x() << "u, "
 234                         << cmdIter->numWorkGroups.y() << "u, "
 235                         << cmdIter->numWorkGroups.z() << "u));\n";
 236         }
 237
 238         src << "}\n";
 239
 240         {
 241                 const glw::Functions&   gl                      = m_context.getRenderContext().getFunctions();
 242                 glu::ShaderProgram              program         (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(src.str()));
 243
 244                 m_testCtx.getLog() << program;
 245                 if (!program.isOk())
 246                         TCU_FAIL("Compile failed");
 247
 248                 gl.useProgram(program.getProgram());
 249
 250                 gl.bindBuffer(GL_DISPATCH_INDIRECT_BUFFER, buffer);
 251                 gl.bufferData(GL_DISPATCH_INDIRECT_BUFFER, (glw::GLsizeiptr)m_bufferSize, DE_NULL, GL_STATIC_DRAW);
 252                 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, buffer);
 253                 GLU_EXPECT_NO_ERROR(gl.getError(), "Buffer setup failed");
 254
 255                 gl.dispatchCompute(1,1,1);
 256                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute() failed");
 257
 258                 gl.memoryBarrier(GL_COMMAND_BARRIER_BIT);
 259                 GLU_EXPECT_NO_ERROR(gl.getError(), "glMemoryBarrier(GL_COMMAND_BARRIER_BIT) failed");
 260         }
 261 }
 262
 263 void IndirectDispatchCase::createResultBuffer (deUint32 buffer) const
 264 {
 265         const glw::Functions&   gl                                      = m_context.getRenderContext().getFunctions();
 266         const int                               resultBlockSize         = getResultBlockAlignedSize(gl);
 267         const int                               resultBufferSize        = resultBlockSize*(int)m_commands.size();
 268         vector<deUint8>                 data                            (resultBufferSize);
 269
 270         for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++)
 271         {
 272                 deUint8* const  dstPtr  = &data[resultBlockSize*cmdNdx];
 273
 274                 *(deUint32*)(dstPtr + RESULT_BLOCK_EXPECTED_COUNT_OFFSET + 0*4) = m_commands[cmdNdx].numWorkGroups[0];
 275                 *(deUint32*)(dstPtr + RESULT_BLOCK_EXPECTED_COUNT_OFFSET + 1*4) = m_commands[cmdNdx].numWorkGroups[1];
 276                 *(deUint32*)(dstPtr + RESULT_BLOCK_EXPECTED_COUNT_OFFSET + 2*4) = m_commands[cmdNdx].numWorkGroups[2];
 277                 *(deUint32*)(dstPtr + RESULT_BLOCK_NUM_PASSED_OFFSET)                   = 0;
 278         }
 279
 280         gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
 281         gl.bufferData(GL_SHADER_STORAGE_BUFFER, (glw::GLsizei)data.size(), &data[0], GL_STATIC_READ);
 282 }
 283
 284 deUint32 computeInvocationCount (const UVec3& workGroupSize, const UVec3& numWorkGroups)
 285 {
 286         const int       numInvocationsPerGroup  = workGroupSize[0]*workGroupSize[1]*workGroupSize[2];
 287         const int       numGroups                               = numWorkGroups[0]*numWorkGroups[1]*numWorkGroups[2];
 288
 289         return numInvocationsPerGroup*numGroups;
 290 }
 291
 292 bool IndirectDispatchCase::verifyResultBuffer (deUint32 buffer)
 293 {
 294         const glw::Functions&   gl                                      = m_context.getRenderContext().getFunctions();
 295
 296         const int                               resultBlockSize         = getResultBlockAlignedSize(gl);
 297         const int                               resultBufferSize        = resultBlockSize*(int)m_commands.size();
 298
 299         void*                                   mapPtr                          = DE_NULL;
 300         bool                                    allOk                           = true;
 301
 302         try
 303         {
 304                 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
 305                 mapPtr = gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, resultBufferSize, GL_MAP_READ_BIT);
 306
 307                 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() failed");
 308                 TCU_CHECK(mapPtr);
 309
 310                 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++)
 311                 {
 312                         const DispatchCommand&  cmd                             = m_commands[cmdNdx];
 313                         const deUint8* const    srcPtr                  = (const deUint8*)mapPtr + cmdNdx*resultBlockSize;
 314                         const deUint32                  numPassed               = *(const deUint32*)(srcPtr + RESULT_BLOCK_NUM_PASSED_OFFSET);
 315                         const deUint32                  expectedCount   = computeInvocationCount(m_workGroupSize, cmd.numWorkGroups);
 316
 317                         // Verify numPassed.
 318                         if (numPassed != expectedCount)
 319                         {
 320                                 m_testCtx.getLog() << TestLog::Message << "ERROR: got invalid result for invocation " << cmdNdx
 321                                                                                                            << ": got numPassed = " << numPassed << ", expected " << expectedCount
 322                                                                    << TestLog::EndMessage;
 323                                 allOk = false;
 324                         }
 325                 }
 326         }
 327         catch (...)
 328         {
 329                 if (mapPtr)
 330                         gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER);
 331         }
 332
 333         gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER);
 334         GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() failed");
 335
 336         return allOk;
 337 }
 338
 339 IndirectDispatchCase::IterateResult IndirectDispatchCase::iterate (void)
 340 {
 341         const glu::RenderContext&               renderCtx                       = m_context.getRenderContext();
 342         const glw::Functions&                   gl                                      = renderCtx.getFunctions();
 343
 344         const glu::ShaderProgram                program                         (renderCtx, genVerifySources(m_workGroupSize));
 345
 346         glu::Buffer                                             cmdBuffer                       (renderCtx);
 347         glu::Buffer                                             resultBuffer            (renderCtx);
 348
 349         m_testCtx.getLog() << program;
 350         TCU_CHECK_MSG(program.isOk(), "Compile failed");
 351
 352         m_testCtx.getLog() << TestLog::Message << "GL_DISPATCH_INDIRECT_BUFFER size = " << m_bufferSize << TestLog::EndMessage;
 353         {
 354                 tcu::ScopedLogSection section(m_testCtx.getLog(), "Commands", "Indirect Dispatch Commands (" + de::toString(m_commands.size()) + " in total)");
 355
 356                 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++)
 357                         m_testCtx.getLog() << TestLog::Message << cmdNdx << ": " << "offset = " << m_commands[cmdNdx].offset
 358                                                                                                    << ", numWorkGroups = " << m_commands[cmdNdx].numWorkGroups
 359                                                            << TestLog::EndMessage;
 360         }
 361
 362         createResultBuffer(*resultBuffer);
 363         createCommandBuffer(*cmdBuffer);
 364
 365         gl.useProgram(program.getProgram());
 366         gl.bindBuffer(GL_DISPATCH_INDIRECT_BUFFER, *cmdBuffer);
 367         GLU_EXPECT_NO_ERROR(gl.getError(), "State setup failed");
 368
 369         {
 370                 const int       resultBlockAlignedSize          = getResultBlockAlignedSize(gl);
 371                 deIntptr        curOffset                                       = 0;
 372
 373                 for (vector<DispatchCommand>::const_iterator cmdIter = m_commands.begin(); cmdIter != m_commands.end(); ++cmdIter)
 374                 {
 375                         gl.bindBufferRange(GL_SHADER_STORAGE_BUFFER, 0, *resultBuffer, (glw::GLintptr)curOffset, resultBlockAlignedSize);
 376                         gl.dispatchComputeIndirect((glw::GLintptr)cmdIter->offset);
 377
 378                         curOffset += resultBlockAlignedSize;
 379                 }
 380         }
 381
 382         GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchComputeIndirect() failed");
 383
 384         if (verifyResultBuffer(*resultBuffer))
 385                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 386         else
 387                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid values in result buffer");
 388
 389         return STOP;
 390 }
 391
 392 class SingleDispatchCase : public IndirectDispatchCase
 393 {
 394 public:
 395         SingleDispatchCase (Context& context, const char* name, const char* description, GenBuffer genBuffer, deUintptr bufferSize, deUintptr offset, const UVec3& workGroupSize, const UVec3& numWorkGroups)
 396                 : IndirectDispatchCase(context, name, description, genBuffer)
 397         {
 398                 m_bufferSize    = bufferSize;
 399                 m_workGroupSize = workGroupSize;
 400                 m_commands.push_back(DispatchCommand(offset, numWorkGroups));
 401         }
 402 };
 403
 404 class MultiDispatchCase : public IndirectDispatchCase
 405 {
 406 public:
 407         MultiDispatchCase (Context& context, GenBuffer genBuffer)
 408                 : IndirectDispatchCase(context, "multi_dispatch", "Dispatch multiple compute commands from single buffer", genBuffer)
 409         {
 410                 m_bufferSize    = 1<<10;
 411                 m_workGroupSize = UVec3(3,1,2);
 412
 413                 m_commands.push_back(DispatchCommand(0,                                         UVec3(1,1,1)));
 414                 m_commands.push_back(DispatchCommand(INDIRECT_COMMAND_SIZE,     UVec3(2,1,1)));
 415                 m_commands.push_back(DispatchCommand(104,                                       UVec3(1,3,1)));
 416                 m_commands.push_back(DispatchCommand(40,                                        UVec3(1,1,7)));
 417                 m_commands.push_back(DispatchCommand(52,                                        UVec3(1,1,4)));
 418         }
 419 };
 420
 421 class MultiDispatchReuseCommandCase : public IndirectDispatchCase
 422 {
 423 public:
 424         MultiDispatchReuseCommandCase (Context& context, GenBuffer genBuffer)
 425                 : IndirectDispatchCase(context, "multi_dispatch_reuse_command", "Dispatch multiple compute commands from single buffer", genBuffer)
 426         {
 427                 m_bufferSize    = 1<<10;
 428                 m_workGroupSize = UVec3(3,1,2);
 429
 430                 m_commands.push_back(DispatchCommand(0,                                         UVec3(1,1,1)));
 431                 m_commands.push_back(DispatchCommand(0,                                         UVec3(1,1,1)));
 432                 m_commands.push_back(DispatchCommand(0,                                         UVec3(1,1,1)));
 433                 m_commands.push_back(DispatchCommand(104,                                       UVec3(1,3,1)));
 434                 m_commands.push_back(DispatchCommand(104,                                       UVec3(1,3,1)));
 435                 m_commands.push_back(DispatchCommand(52,                                        UVec3(1,1,4)));
 436                 m_commands.push_back(DispatchCommand(52,                                        UVec3(1,1,4)));
 437         }
 438 };
 439
 440 } // anonymous
 441
 442 IndirectComputeDispatchTests::IndirectComputeDispatchTests (Context& context)
 443         : TestCaseGroup(context, "indirect_dispatch", "Indirect dispatch tests")
 444 {
 445 }
 446
 447 IndirectComputeDispatchTests::~IndirectComputeDispatchTests (void)
 448 {
 449 }
 450
 451 void IndirectComputeDispatchTests::init (void)
 452 {
 453         static const struct
 454         {
 455                 const char*             name;
 456                 GenBuffer               gen;
 457         } s_genBuffer[] =
 458         {
 459                 { "upload_buffer",              GEN_BUFFER_UPLOAD       },
 460                 { "gen_in_compute",             GEN_BUFFER_COMPUTE      }
 461         };
 462
 463         static const struct
 464         {
 465                 const char*     name;
 466                 const char*     description;
 467                 deUintptr       bufferSize;
 468                 deUintptr       offset;
 469                 UVec3           workGroupSize;
 470                 UVec3           numWorkGroups;
 471         } s_singleDispatchCases[] =
 472         {
 473         //      Name                                                                            Desc                                                                                    BufferSize                                      Offs                    WorkGroupSize   NumWorkGroups
 474                 { "single_invocation",                                          "Single invocation only from offset 0",                 INDIRECT_COMMAND_SIZE,          0,                              UVec3(1,1,1),   UVec3(1,1,1) },
 475                 { "multiple_groups",                                            "Multiple groups dispatched from offset 0",             INDIRECT_COMMAND_SIZE,          0,                              UVec3(1,1,1),   UVec3(2,3,5) },
 476                 { "multiple_groups_multiple_invocations",       "Multiple groups of size 2x3x1 from offset 0",  INDIRECT_COMMAND_SIZE,          0,                              UVec3(2,3,1),   UVec3(1,2,3) },
 477                 { "small_offset",                                                       "Small offset",                                                                 16+INDIRECT_COMMAND_SIZE,       16,                             UVec3(1,1,1),   UVec3(1,1,1) },
 478                 { "large_offset",                                                       "Large offset",                                                                 (2<<20),                                        (1<<20) + 12,   UVec3(1,1,1),   UVec3(1,1,1) },
 479                 { "large_offset_multiple_invocations",          "Large offset, multiple invocations",                   (2<<20),                                        (1<<20) + 12,   UVec3(2,3,1),   UVec3(1,2,3) },
 480                 { "empty_command",                                                      "Empty command",                                                                INDIRECT_COMMAND_SIZE,          0,                              UVec3(1,1,1),   UVec3(0,0,0) },
 481         };
 482
 483         for (int genNdx = 0; genNdx < DE_LENGTH_OF_ARRAY(s_genBuffer); genNdx++)
 484         {
 485                 const GenBuffer                         genBuf          = s_genBuffer[genNdx].gen;
 486                 tcu::TestCaseGroup* const       genGroup        = new tcu::TestCaseGroup(m_testCtx, s_genBuffer[genNdx].name, "");
 487                 addChild(genGroup);
 488
 489                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_singleDispatchCases); ndx++)
 490                         genGroup->addChild(new SingleDispatchCase(m_context,
 491                                                                                                           s_singleDispatchCases[ndx].name,
 492                                                                                                           s_singleDispatchCases[ndx].description,
 493                                                                                                           genBuf,
 494                                                                                                           s_singleDispatchCases[ndx].bufferSize,
 495                                                                                                           s_singleDispatchCases[ndx].offset,
 496                                                                                                           s_singleDispatchCases[ndx].workGroupSize,
 497                                                                                                           s_singleDispatchCases[ndx].numWorkGroups));
 498
 499                 genGroup->addChild(new MultiDispatchCase                                (m_context, genBuf));
 500                 genGroup->addChild(new MultiDispatchReuseCommandCase    (m_context, genBuf));
 501         }
 502 }
 503
 504 } // Functional
 505 } // gles31
 506 } // deqp