modules/gles2/performance/es2pDrawCallBatchingTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 2.0 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 Draw call batching performance tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es2pDrawCallBatchingTests.hpp"
  25
  26 #include "gluShaderProgram.hpp"
  27 #include "gluRenderContext.hpp"
  28
  29 #include "glwDefs.hpp"
  30 #include "glwFunctions.hpp"
  31 #include "glwEnums.hpp"
  32
  33 #include "tcuTestLog.hpp"
  34
  35 #include "deRandom.hpp"
  36 #include "deStringUtil.hpp"
  37
  38 #include "deFile.h"
  39 #include "deString.h"
  40 #include "deClock.h"
  41 #include "deThread.h"
  42
  43 #include <cmath>
  44 #include <vector>
  45 #include <string>
  46 #include <sstream>
  47
  48 using tcu::TestLog;
  49
  50 using namespace glw;
  51
  52 using std::vector;
  53 using std::string;
  54
  55 namespace deqp
  56 {
  57 namespace gles2
  58 {
  59 namespace Performance
  60 {
  61
  62 namespace
  63 {
  64 const int CALIBRATION_SAMPLE_COUNT = 34;
  65
  66 class DrawCallBatchingTest : public tcu::TestCase
  67 {
  68 public:
  69         struct TestSpec
  70         {
  71                 bool    useStaticBuffer;
  72                 int             staticAttributeCount;
  73
  74                 bool    useDynamicBuffer;
  75                 int             dynamicAttributeCount;
  76
  77                 int             triangleCount;
  78                 int             drawCallCount;
  79
  80                 bool    useDrawElements;
  81                 bool    useIndexBuffer;
  82                 bool    dynamicIndices;
  83         };
  84
  85                                         DrawCallBatchingTest    (Context& context, const char* name, const char* description, const TestSpec& spec);
  86                                         ~DrawCallBatchingTest   (void);
  87
  88         void                    init                                    (void);
  89         void                    deinit                                  (void);
  90         IterateResult   iterate                                 (void);
  91
  92 private:
  93         enum State
  94         {
  95                 STATE_LOG_INFO = 0,
  96                 STATE_WARMUP_BATCHED,
  97                 STATE_WARMUP_UNBATCHED,
  98                 STATE_CALC_CALIBRATION,
  99                 STATE_SAMPLE
 100         };
 101
 102         State                                           m_state;
 103
 104         glu::RenderContext&                     m_renderCtx;
 105         de::Random                                      m_rnd;
 106         int                                                     m_sampleIteration;
 107
 108         int                                                     m_unbatchedSampleCount;
 109         int                                                     m_batchedSampleCount;
 110
 111         TestSpec                                        m_spec;
 112
 113         glu::ShaderProgram*                     m_program;
 114
 115         vector<deUint8>                         m_dynamicIndexData;
 116         vector<deUint8>                         m_staticIndexData;
 117
 118         vector<GLuint>                          m_unbatchedDynamicIndexBuffers;
 119         GLuint                                          m_batchedDynamicIndexBuffer;
 120
 121         GLuint                                          m_unbatchedStaticIndexBuffer;
 122         GLuint                                          m_batchedStaticIndexBuffer;
 123
 124         vector<vector<deInt8> >         m_staticAttributeDatas;
 125         vector<vector<deInt8> >         m_dynamicAttributeDatas;
 126
 127         vector<GLuint>                          m_batchedStaticBuffers;
 128         vector<GLuint>                          m_unbatchedStaticBuffers;
 129
 130         vector<GLuint>                          m_batchedDynamicBuffers;
 131         vector<vector<GLuint> >         m_unbatchedDynamicBuffers;
 132
 133         vector<deUint64>                        m_unbatchedSamplesUs;
 134         vector<deUint64>                        m_batchedSamplesUs;
 135
 136         void                                            logTestInfo                             (void);
 137
 138         deUint64                                        renderUnbatched                 (void);
 139         deUint64                                        renderBatched                   (void);
 140
 141         void                                            createIndexData                 (void);
 142         void                                            createIndexBuffer               (void);
 143
 144         void                                            createShader                    (void);
 145         void                                            createAttributeDatas    (void);
 146         void                                            createArrayBuffers              (void);
 147 };
 148
 149 DrawCallBatchingTest::DrawCallBatchingTest (Context& context, const char* name, const char* description, const TestSpec& spec)
 150         : tcu::TestCase                                 (context.getTestContext(), tcu::NODETYPE_PERFORMANCE, name, description)
 151         , m_state                                               (STATE_LOG_INFO)
 152         , m_renderCtx                                   (context.getRenderContext())
 153         , m_rnd                                                 (deStringHash(name))
 154         , m_sampleIteration                             (0)
 155         , m_unbatchedSampleCount                (CALIBRATION_SAMPLE_COUNT)
 156         , m_batchedSampleCount                  (CALIBRATION_SAMPLE_COUNT)
 157         , m_spec                                                (spec)
 158         , m_program                                             (NULL)
 159         , m_batchedDynamicIndexBuffer   (0)
 160         , m_unbatchedStaticIndexBuffer  (0)
 161         , m_batchedStaticIndexBuffer    (0)
 162 {
 163 }
 164
 165 DrawCallBatchingTest::~DrawCallBatchingTest (void)
 166 {
 167         deinit();
 168 }
 169
 170 void DrawCallBatchingTest::createIndexData (void)
 171 {
 172         if (m_spec.dynamicIndices)
 173         {
 174                 for (int drawNdx = 0; drawNdx < m_spec.drawCallCount; drawNdx++)
 175                 {
 176                         for (int triangleNdx = 0; triangleNdx < m_spec.triangleCount; triangleNdx++)
 177                         {
 178                                 m_dynamicIndexData.push_back(deUint8(triangleNdx * 3));
 179                                 m_dynamicIndexData.push_back(deUint8(triangleNdx * 3 + 1));
 180                                 m_dynamicIndexData.push_back(deUint8(triangleNdx * 3 + 2));
 181                         }
 182                 }
 183         }
 184         else
 185         {
 186                 for (int drawNdx = 0; drawNdx < m_spec.drawCallCount; drawNdx++)
 187                 {
 188                         for (int triangleNdx = 0; triangleNdx < m_spec.triangleCount; triangleNdx++)
 189                         {
 190                                 m_staticIndexData.push_back(deUint8(triangleNdx * 3));
 191                                 m_staticIndexData.push_back(deUint8(triangleNdx * 3 + 1));
 192                                 m_staticIndexData.push_back(deUint8(triangleNdx * 3 + 2));
 193                         }
 194                 }
 195         }
 196 }
 197
 198 void DrawCallBatchingTest::createShader (void)
 199 {
 200         std::ostringstream              vertexShader;
 201         std::ostringstream              fragmentShader;
 202
 203         for (int attributeNdx = 0; attributeNdx < m_spec.staticAttributeCount; attributeNdx++)
 204                 vertexShader << "attribute mediump vec4 a_static" << attributeNdx << ";\n";
 205
 206         if (m_spec.staticAttributeCount > 0 && m_spec.dynamicAttributeCount > 0)
 207                 vertexShader << "\n";
 208
 209         for (int attributeNdx = 0; attributeNdx < m_spec.dynamicAttributeCount; attributeNdx++)
 210                 vertexShader << "attribute mediump vec4 a_dyn" << attributeNdx << ";\n";
 211
 212         vertexShader
 213         << "\n"
 214         << "varying mediump vec4 v_color;\n"
 215         << "\n"
 216         << "void main (void)\n"
 217         << "{\n";
 218
 219         vertexShader << "\tv_color = ";
 220
 221         bool first = true;
 222
 223         for (int attributeNdx = 0; attributeNdx < m_spec.staticAttributeCount; attributeNdx++)
 224         {
 225                 if (!first)
 226                         vertexShader << " + ";
 227                 first = false;
 228
 229                 vertexShader << "a_static" << attributeNdx;
 230         }
 231
 232         for (int attributeNdx = 0; attributeNdx < m_spec.dynamicAttributeCount; attributeNdx++)
 233         {
 234                 if (!first)
 235                         vertexShader << " + ";
 236                 first = false;
 237
 238                 vertexShader << "a_dyn" << attributeNdx;
 239         }
 240
 241         vertexShader << ";\n";
 242
 243         if (m_spec.dynamicAttributeCount > 0)
 244                 vertexShader << "\tgl_Position = a_dyn0;\n";
 245         else
 246                 vertexShader << "\tgl_Position = a_static0;\n";
 247
 248         vertexShader
 249         << "}";
 250
 251         fragmentShader
 252         << "varying mediump vec4 v_color;\n"
 253         << "\n"
 254         << "void main(void)\n"
 255         << "{\n"
 256         << "\tgl_FragColor = v_color;\n"
 257         << "}\n";
 258
 259         m_program = new glu::ShaderProgram(m_renderCtx, glu::ProgramSources() << glu::VertexSource(vertexShader.str()) << glu::FragmentSource(fragmentShader.str()));
 260
 261         m_testCtx.getLog() << (*m_program);
 262         TCU_CHECK(m_program->isOk());
 263 }
 264
 265 void DrawCallBatchingTest::createAttributeDatas (void)
 266 {
 267         // Generate data for static attributes
 268         for (int attribute = 0; attribute < m_spec.staticAttributeCount; attribute++)
 269         {
 270                 vector<deInt8> data;
 271
 272                 if (m_spec.dynamicAttributeCount == 0 && attribute == 0)
 273                 {
 274                         data.reserve(4 * 3 * m_spec.triangleCount * m_spec.drawCallCount);
 275
 276                         for (int i = 0; i < m_spec.triangleCount * m_spec.drawCallCount; i++)
 277                         {
 278                                 int sign = (m_spec.triangleCount % 2 == 1 || i % 2 == 0 ? 1 : -1);
 279
 280                                 data.push_back(deInt8(-127 * sign));
 281                                 data.push_back(deInt8(-127 * sign));
 282                                 data.push_back(0);
 283                                 data.push_back(127);
 284
 285                                 data.push_back(deInt8(127 * sign));
 286                                 data.push_back(deInt8(-127 * sign));
 287                                 data.push_back(0);
 288                                 data.push_back(127);
 289
 290                                 data.push_back(deInt8(127 * sign));
 291                                 data.push_back(deInt8(127 * sign));
 292                                 data.push_back(0);
 293                                 data.push_back(127);
 294                         }
 295                 }
 296                 else
 297                 {
 298                         data.reserve(4 * 3 * m_spec.triangleCount * m_spec.drawCallCount);
 299
 300                         for (int i = 0; i < 4 * 3 * m_spec.triangleCount * m_spec.drawCallCount; i++)
 301                                 data.push_back((deInt8)m_rnd.getUint32());
 302                 }
 303
 304                 m_staticAttributeDatas.push_back(data);
 305         }
 306
 307         // Generate data for dynamic attributes
 308         for (int attribute = 0; attribute < m_spec.dynamicAttributeCount; attribute++)
 309         {
 310                 vector<deInt8> data;
 311
 312                 if (attribute == 0)
 313                 {
 314                         data.reserve(4 * 3 * m_spec.triangleCount * m_spec.drawCallCount);
 315
 316                         for (int i = 0; i < m_spec.triangleCount * m_spec.drawCallCount; i++)
 317                         {
 318                                 int sign = (i % 2 == 0 ? 1 : -1);
 319
 320                                 data.push_back(deInt8(-127 * sign));
 321                                 data.push_back(deInt8(-127 * sign));
 322                                 data.push_back(0);
 323                                 data.push_back(127);
 324
 325                                 data.push_back(deInt8(127 * sign));
 326                                 data.push_back(deInt8(-127 * sign));
 327                                 data.push_back(0);
 328                                 data.push_back(127);
 329
 330                                 data.push_back(deInt8(127 * sign));
 331                                 data.push_back(deInt8(127 * sign));
 332                                 data.push_back(0);
 333                                 data.push_back(127);
 334                         }
 335                 }
 336                 else
 337                 {
 338                         data.reserve(4 * 3 * m_spec.triangleCount * m_spec.drawCallCount);
 339
 340                         for (int i = 0; i < 4 * 3 * m_spec.triangleCount * m_spec.drawCallCount; i++)
 341                                 data.push_back((deInt8)m_rnd.getUint32());
 342                 }
 343
 344                 m_dynamicAttributeDatas.push_back(data);
 345         }
 346 }
 347
 348 void DrawCallBatchingTest::createArrayBuffers (void)
 349 {
 350         const glw::Functions& gl = m_renderCtx.getFunctions();
 351
 352         if (m_spec.useStaticBuffer)
 353         {
 354                 // Upload static attributes for batched
 355                 for (int attribute = 0; attribute < m_spec.staticAttributeCount; attribute++)
 356                 {
 357                         GLuint buffer;
 358
 359                         gl.genBuffers(1, &buffer);
 360                         gl.bindBuffer(GL_ARRAY_BUFFER, buffer);
 361                         gl.bufferData(GL_ARRAY_BUFFER, 4 * 3 * m_spec.triangleCount * m_spec.drawCallCount, &(m_staticAttributeDatas[attribute][0]), GL_STATIC_DRAW);
 362                         gl.bindBuffer(GL_ARRAY_BUFFER, 0);
 363                         GLU_EXPECT_NO_ERROR(gl.getError(), "Creating static buffer failed");
 364
 365                         m_batchedStaticBuffers.push_back(buffer);
 366                 }
 367
 368                 // Upload static attributes for unbatched
 369                 for (int attribute = 0; attribute < m_spec.staticAttributeCount; attribute++)
 370                 {
 371                         GLuint buffer;
 372
 373                         gl.genBuffers(1, &buffer);
 374                         gl.bindBuffer(GL_ARRAY_BUFFER, buffer);
 375                         gl.bufferData(GL_ARRAY_BUFFER, 4 * 3 * m_spec.triangleCount, &(m_staticAttributeDatas[attribute][0]), GL_STATIC_DRAW);
 376                         gl.bindBuffer(GL_ARRAY_BUFFER, 0);
 377                         GLU_EXPECT_NO_ERROR(gl.getError(), "Creating static buffer failed");
 378
 379                         m_unbatchedStaticBuffers.push_back(buffer);
 380                 }
 381         }
 382
 383         if (m_spec.useDynamicBuffer)
 384         {
 385                 // Upload dynamic attributes for batched
 386                 for (int attribute = 0; attribute < m_spec.dynamicAttributeCount; attribute++)
 387                 {
 388                         GLuint buffer;
 389
 390                         gl.genBuffers(1, &buffer);
 391                         gl.bindBuffer(GL_ARRAY_BUFFER, buffer);
 392                         gl.bufferData(GL_ARRAY_BUFFER, 4 * 3 * m_spec.triangleCount * m_spec.drawCallCount, &(m_dynamicAttributeDatas[attribute][0]), GL_STATIC_DRAW);
 393                         gl.bindBuffer(GL_ARRAY_BUFFER, 0);
 394                         GLU_EXPECT_NO_ERROR(gl.getError(), "Creating dynamic buffer failed");
 395
 396                         m_batchedDynamicBuffers.push_back(buffer);
 397                 }
 398
 399                 // Upload dynamic attributes for unbatched
 400                 for (int attribute = 0; attribute < m_spec.dynamicAttributeCount; attribute++)
 401                 {
 402                         vector<GLuint> buffers;
 403
 404                         for (int drawNdx = 0; drawNdx < m_spec.drawCallCount; drawNdx++)
 405                         {
 406                                 GLuint buffer;
 407
 408                                 gl.genBuffers(1, &buffer);
 409                                 gl.bindBuffer(GL_ARRAY_BUFFER, buffer);
 410                                 gl.bufferData(GL_ARRAY_BUFFER, 4 * 3 * m_spec.triangleCount * m_spec.drawCallCount, &(m_dynamicAttributeDatas[attribute][0]), GL_STATIC_DRAW);
 411                                 gl.bindBuffer(GL_ARRAY_BUFFER, 0);
 412                                 GLU_EXPECT_NO_ERROR(gl.getError(), "Creating dynamic buffer failed");
 413
 414                                 buffers.push_back(buffer);
 415                         }
 416
 417                         m_unbatchedDynamicBuffers.push_back(buffers);
 418                 }
 419         }
 420 }
 421
 422 void DrawCallBatchingTest::createIndexBuffer (void)
 423 {
 424         const glw::Functions& gl = m_renderCtx.getFunctions();
 425
 426         if (m_spec.dynamicIndices)
 427         {
 428                 for (int drawNdx = 0; drawNdx < m_spec.drawCallCount; drawNdx++)
 429                 {
 430                         GLuint buffer;
 431
 432                         gl.genBuffers(1, &buffer);
 433                         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
 434                         gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, 3 * m_spec.triangleCount, &(m_dynamicIndexData[drawNdx * m_spec.triangleCount * 3]), GL_STATIC_DRAW);
 435                         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 436                         GLU_EXPECT_NO_ERROR(gl.getError(), "Creating dynamic index buffer failed");
 437
 438                         m_unbatchedDynamicIndexBuffers.push_back(buffer);
 439                 }
 440
 441                 {
 442                         GLuint buffer;
 443
 444                         gl.genBuffers(1, &buffer);
 445                         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
 446                         gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, 3 * m_spec.triangleCount * m_spec.drawCallCount, &(m_dynamicIndexData[0]), GL_STATIC_DRAW);
 447                         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 448                         GLU_EXPECT_NO_ERROR(gl.getError(), "Creating dynamic index buffer failed");
 449
 450                         m_batchedDynamicIndexBuffer = buffer;
 451                 }
 452         }
 453         else
 454         {
 455                 {
 456                         GLuint buffer;
 457
 458                         gl.genBuffers(1, &buffer);
 459                         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
 460                         gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, 3 * m_spec.triangleCount * m_spec.drawCallCount, &(m_staticIndexData[0]), GL_STATIC_DRAW);
 461                         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 462                         GLU_EXPECT_NO_ERROR(gl.getError(), "Creating dynamic index buffer failed");
 463
 464                         m_batchedStaticIndexBuffer = buffer;
 465                 }
 466
 467                 {
 468                         GLuint buffer;
 469
 470                         gl.genBuffers(1, &buffer);
 471                         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
 472                         gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, 3 * m_spec.triangleCount, &(m_staticIndexData[0]), GL_STATIC_DRAW);
 473                         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 474                         GLU_EXPECT_NO_ERROR(gl.getError(), "Creating dynamic index buffer failed");
 475
 476                         m_unbatchedStaticIndexBuffer = buffer;
 477                 }
 478         }
 479 }
 480
 481 void DrawCallBatchingTest::init (void)
 482 {
 483         createShader();
 484         createAttributeDatas();
 485         createArrayBuffers();
 486
 487         if (m_spec.useDrawElements)
 488         {
 489                 createIndexData();
 490
 491                 if (m_spec.useIndexBuffer)
 492                         createIndexBuffer();
 493         }
 494 }
 495
 496 void DrawCallBatchingTest::deinit (void)
 497 {
 498         const glw::Functions& gl = m_renderCtx.getFunctions();
 499
 500         delete m_program;
 501         m_program = NULL;
 502
 503         m_dynamicIndexData      = vector<deUint8>();
 504         m_staticIndexData       = vector<deUint8>();
 505
 506         if (!m_unbatchedDynamicIndexBuffers.empty())
 507         {
 508                 gl.deleteBuffers((GLsizei)m_unbatchedDynamicIndexBuffers.size(), &(m_unbatchedDynamicIndexBuffers[0]));
 509                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers()");
 510
 511                 m_unbatchedDynamicIndexBuffers = vector<GLuint>();
 512         }
 513
 514         if (m_batchedDynamicIndexBuffer)
 515         {
 516                 gl.deleteBuffers((GLsizei)1, &m_batchedDynamicIndexBuffer);
 517                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers()");
 518
 519                 m_batchedDynamicIndexBuffer = 0;
 520         }
 521
 522         if (m_unbatchedStaticIndexBuffer)
 523         {
 524                 gl.deleteBuffers((GLsizei)1, &m_unbatchedStaticIndexBuffer);
 525                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers()");
 526
 527                 m_unbatchedStaticIndexBuffer = 0;
 528         }
 529
 530         if (m_batchedStaticIndexBuffer)
 531         {
 532                 gl.deleteBuffers((GLsizei)1, &m_batchedStaticIndexBuffer);
 533                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers()");
 534
 535                 m_batchedStaticIndexBuffer = 0;
 536         }
 537
 538         m_staticAttributeDatas  = vector<vector<deInt8> >();
 539         m_dynamicAttributeDatas = vector<vector<deInt8> >();
 540
 541         if (!m_batchedStaticBuffers.empty())
 542         {
 543                 gl.deleteBuffers((GLsizei)m_batchedStaticBuffers.size(), &(m_batchedStaticBuffers[0]));
 544                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers()");
 545
 546                 m_batchedStaticBuffers = vector<GLuint>();
 547         }
 548
 549         if (!m_unbatchedStaticBuffers.empty())
 550         {
 551                 gl.deleteBuffers((GLsizei)m_unbatchedStaticBuffers.size(), &(m_unbatchedStaticBuffers[0]));
 552                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers()");
 553
 554                 m_unbatchedStaticBuffers = vector<GLuint>();
 555         }
 556
 557         if (!m_batchedDynamicBuffers.empty())
 558         {
 559                 gl.deleteBuffers((GLsizei)m_batchedDynamicBuffers.size(), &(m_batchedDynamicBuffers[0]));
 560                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers()");
 561
 562                 m_batchedDynamicBuffers = vector<GLuint>();
 563         }
 564
 565         for (int i = 0; i < (int)m_unbatchedDynamicBuffers.size(); i++)
 566         {
 567                 gl.deleteBuffers((GLsizei)m_unbatchedDynamicBuffers[i].size(), &(m_unbatchedDynamicBuffers[i][0]));
 568                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers()");
 569         }
 570
 571         m_unbatchedDynamicBuffers = vector<vector<GLuint> >();
 572
 573         m_unbatchedSamplesUs    = vector<deUint64>();
 574         m_batchedSamplesUs              = vector<deUint64>();
 575 }
 576
 577 deUint64 DrawCallBatchingTest::renderUnbatched (void)
 578 {
 579         const glw::Functions&   gl              = m_renderCtx.getFunctions();
 580         deUint64                                beginUs = 0;
 581         deUint64                                endUs   = 0;
 582         vector<GLint>                   dynamicAttributeLocations;
 583
 584         gl.viewport(0, 0, 32, 32);
 585         gl.useProgram(m_program->getProgram());
 586
 587         // Setup static buffers
 588         for (int attribNdx = 0; attribNdx < m_spec.staticAttributeCount; attribNdx++)
 589         {
 590                 GLint location = gl.getAttribLocation(m_program->getProgram(), ("a_static" + de::toString(attribNdx)).c_str());
 591
 592                 gl.enableVertexAttribArray(location);
 593
 594                 if (m_spec.useStaticBuffer)
 595                 {
 596                         gl.bindBuffer(GL_ARRAY_BUFFER, m_unbatchedStaticBuffers[attribNdx]);
 597                         gl.vertexAttribPointer(location, 4, GL_BYTE, GL_TRUE, 0, NULL);
 598                         gl.bindBuffer(GL_ARRAY_BUFFER, 0);
 599                 }
 600                 else
 601                         gl.vertexAttribPointer(location, 4, GL_BYTE, GL_TRUE, 0, &(m_staticAttributeDatas[attribNdx][0]));
 602         }
 603
 604         // Get locations of dynamic attributes
 605         for (int attribNdx = 0; attribNdx < m_spec.dynamicAttributeCount; attribNdx++)
 606         {
 607                 GLint location = gl.getAttribLocation(m_program->getProgram(), ("a_dyn" + de::toString(attribNdx)).c_str());
 608
 609                 gl.enableVertexAttribArray(location);
 610                 dynamicAttributeLocations.push_back(location);
 611         }
 612
 613         if (m_spec.useDrawElements && m_spec.useIndexBuffer && !m_spec.dynamicIndices)
 614                 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_unbatchedStaticIndexBuffer);
 615
 616         GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup initial state for rendering.");
 617
 618         gl.finish();
 619
 620         beginUs = deGetMicroseconds();
 621
 622         for (int drawNdx = 0; drawNdx < m_spec.drawCallCount; drawNdx++)
 623         {
 624                 for (int attribNdx = 0; attribNdx < m_spec.dynamicAttributeCount; attribNdx++)
 625                 {
 626                         if (m_spec.useDynamicBuffer)
 627                         {
 628                                 gl.bindBuffer(GL_ARRAY_BUFFER, m_unbatchedDynamicBuffers[attribNdx][drawNdx]);
 629                                 gl.vertexAttribPointer(dynamicAttributeLocations[attribNdx], 4, GL_BYTE, GL_TRUE, 0, NULL);
 630                                 gl.bindBuffer(GL_ARRAY_BUFFER, 0);
 631                         }
 632                         else
 633                                 gl.vertexAttribPointer(dynamicAttributeLocations[attribNdx], 4, GL_BYTE, GL_TRUE, 0, &(m_dynamicAttributeDatas[attribNdx][m_spec.triangleCount * 3 * drawNdx * 4]));
 634                 }
 635
 636                 if (m_spec.useDrawElements)
 637                 {
 638                         if (m_spec.useIndexBuffer)
 639                         {
 640                                 if (m_spec.dynamicIndices)
 641                                 {
 642                                         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_unbatchedDynamicIndexBuffers[drawNdx]);
 643                                         gl.drawElements(GL_TRIANGLES, m_spec.triangleCount * 3, GL_UNSIGNED_BYTE, NULL);
 644                                         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 645                                 }
 646                                 else
 647                                         gl.drawElements(GL_TRIANGLES, m_spec.triangleCount * 3, GL_UNSIGNED_BYTE, NULL);
 648                         }
 649                         else
 650                         {
 651                                 if (m_spec.dynamicIndices)
 652                                         gl.drawElements(GL_TRIANGLES, m_spec.triangleCount * 3, GL_UNSIGNED_BYTE, &(m_dynamicIndexData[drawNdx * m_spec.triangleCount * 3]));
 653                                 else
 654                                         gl.drawElements(GL_TRIANGLES, m_spec.triangleCount * 3, GL_UNSIGNED_BYTE, &(m_staticIndexData[0]));
 655                         }
 656                 }
 657                 else
 658                         gl.drawArrays(GL_TRIANGLES, 0, 3 * m_spec.triangleCount);
 659         }
 660
 661         gl.finish();
 662
 663         endUs = deGetMicroseconds();
 664
 665         GLU_EXPECT_NO_ERROR(gl.getError(), "Unbatched rendering failed");
 666
 667         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 668
 669         for (int attribNdx = 0; attribNdx < m_spec.staticAttributeCount; attribNdx++)
 670         {
 671                 GLint location = gl.getAttribLocation(m_program->getProgram(), ("a_static" + de::toString(attribNdx)).c_str());
 672                 gl.disableVertexAttribArray(location);
 673         }
 674
 675         for (int attribNdx = 0; attribNdx < m_spec.dynamicAttributeCount; attribNdx++)
 676                 gl.disableVertexAttribArray(dynamicAttributeLocations[attribNdx]);
 677
 678         GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to reset state after unbatched rendering");
 679
 680         return endUs - beginUs;
 681 }
 682
 683 deUint64 DrawCallBatchingTest::renderBatched (void)
 684 {
 685         const glw::Functions&   gl              = m_renderCtx.getFunctions();
 686         deUint64                                beginUs = 0;
 687         deUint64                                endUs   = 0;
 688         vector<GLint>                   dynamicAttributeLocations;
 689
 690         gl.viewport(0, 0, 32, 32);
 691         gl.useProgram(m_program->getProgram());
 692
 693         // Setup static buffers
 694         for (int attribNdx = 0; attribNdx < m_spec.staticAttributeCount; attribNdx++)
 695         {
 696                 GLint location = gl.getAttribLocation(m_program->getProgram(), ("a_static" + de::toString(attribNdx)).c_str());
 697
 698                 gl.enableVertexAttribArray(location);
 699
 700                 if (m_spec.useStaticBuffer)
 701                 {
 702                         gl.bindBuffer(GL_ARRAY_BUFFER, m_batchedStaticBuffers[attribNdx]);
 703                         gl.vertexAttribPointer(location, 4, GL_BYTE, GL_TRUE, 0, NULL);
 704                         gl.bindBuffer(GL_ARRAY_BUFFER, 0);
 705                 }
 706                 else
 707                         gl.vertexAttribPointer(location, 4, GL_BYTE, GL_TRUE, 0, &(m_staticAttributeDatas[attribNdx][0]));
 708         }
 709
 710         // Get locations of dynamic attributes
 711         for (int attribNdx = 0; attribNdx < m_spec.dynamicAttributeCount; attribNdx++)
 712         {
 713                 GLint location = gl.getAttribLocation(m_program->getProgram(), ("a_dyn" + de::toString(attribNdx)).c_str());
 714
 715                 gl.enableVertexAttribArray(location);
 716                 dynamicAttributeLocations.push_back(location);
 717         }
 718
 719         if (m_spec.useDrawElements && m_spec.useIndexBuffer && !m_spec.dynamicIndices)
 720                 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_batchedStaticIndexBuffer);
 721
 722         GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup initial state for rendering.");
 723
 724         gl.finish();
 725
 726         beginUs = deGetMicroseconds();
 727
 728         for (int attribute = 0; attribute < m_spec.dynamicAttributeCount; attribute++)
 729         {
 730                 if (m_spec.useDynamicBuffer)
 731                 {
 732                         gl.bindBuffer(GL_ARRAY_BUFFER, m_batchedDynamicBuffers[attribute]);
 733                         gl.vertexAttribPointer(dynamicAttributeLocations[attribute], 4, GL_BYTE, GL_TRUE, 0, NULL);
 734                         gl.bindBuffer(GL_ARRAY_BUFFER, 0);
 735                 }
 736                 else
 737                         gl.vertexAttribPointer(dynamicAttributeLocations[attribute], 4, GL_BYTE, GL_TRUE, 0, &(m_dynamicAttributeDatas[attribute][0]));
 738         }
 739
 740         if (m_spec.useDrawElements)
 741         {
 742                 if (m_spec.useIndexBuffer)
 743                 {
 744                         if (m_spec.dynamicIndices)
 745                         {
 746                                 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_batchedDynamicIndexBuffer);
 747                                 gl.drawElements(GL_TRIANGLES, m_spec.triangleCount * 3 * m_spec.drawCallCount, GL_UNSIGNED_BYTE, NULL);
 748                                 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 749                         }
 750                         else
 751                                 gl.drawElements(GL_TRIANGLES, m_spec.triangleCount * 3 * m_spec.drawCallCount, GL_UNSIGNED_BYTE, NULL);
 752                 }
 753                 else
 754                 {
 755                         if (m_spec.dynamicIndices)
 756                                 gl.drawElements(GL_TRIANGLES, m_spec.triangleCount * 3 * m_spec.drawCallCount, GL_UNSIGNED_BYTE, &(m_dynamicIndexData[0]));
 757                         else
 758                                 gl.drawElements(GL_TRIANGLES, m_spec.triangleCount * 3 * m_spec.drawCallCount, GL_UNSIGNED_BYTE, &(m_staticIndexData[0]));
 759                 }
 760         }
 761         else
 762                 gl.drawArrays(GL_TRIANGLES, 0, 3 * m_spec.triangleCount * m_spec.drawCallCount);
 763
 764         gl.finish();
 765
 766         endUs = deGetMicroseconds();
 767
 768         GLU_EXPECT_NO_ERROR(gl.getError(), "Batched rendering failed");
 769
 770         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 771
 772         for (int attribNdx = 0; attribNdx < m_spec.staticAttributeCount; attribNdx++)
 773         {
 774                 GLint location = gl.getAttribLocation(m_program->getProgram(), ("a_static" + de::toString(attribNdx)).c_str());
 775                 gl.disableVertexAttribArray(location);
 776         }
 777
 778         for (int attribNdx = 0; attribNdx < m_spec.dynamicAttributeCount; attribNdx++)
 779                 gl.disableVertexAttribArray(dynamicAttributeLocations[attribNdx]);
 780
 781         GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to reset state after batched rendering");
 782
 783         return endUs - beginUs;
 784 }
 785
 786 struct Statistics
 787 {
 788         double mean;
 789         double standardDeviation;
 790         double standardErrorOfMean;
 791 };
 792
 793 Statistics calculateStats (const vector<deUint64>& samples)
 794 {
 795         double mean = 0.0;
 796
 797         for (int i = 0; i < (int)samples.size(); i++)
 798                 mean += (double)samples[i];
 799
 800         mean /= (double)samples.size();
 801
 802         double standardDeviation = 0.0;
 803
 804         for (int i = 0; i < (int)samples.size(); i++)
 805         {
 806                 double x = (double)samples[i];
 807                 standardDeviation += (x - mean) * (x - mean);
 808         }
 809
 810         standardDeviation /= (double)samples.size();
 811         standardDeviation = std::sqrt(standardDeviation);
 812
 813         double standardErrorOfMean = standardDeviation / std::sqrt((double)samples.size());
 814
 815         Statistics stats;
 816
 817         stats.mean                                      = mean;
 818         stats.standardDeviation         = standardDeviation;
 819         stats.standardErrorOfMean       = standardErrorOfMean;
 820
 821         return stats;
 822 }
 823
 824 void DrawCallBatchingTest::logTestInfo (void)
 825 {
 826         TestLog&                                log             = m_testCtx.getLog();
 827         tcu::ScopedLogSection   section (log, "Test info", "Test info");
 828
 829         log << TestLog::Message << "Rendering using " << (m_spec.useDrawElements ? "glDrawElements()" : "glDrawArrays()") << "." << TestLog::EndMessage;
 830
 831         if (m_spec.useDrawElements)
 832                 log << TestLog::Message << "Using " << (m_spec.dynamicIndices ? "dynamic " : "") << "indices from " << (m_spec.useIndexBuffer ? "buffer" : "pointer") << "." << TestLog::EndMessage;
 833
 834         if (m_spec.staticAttributeCount > 0)
 835                 log << TestLog::Message << "Using " << m_spec.staticAttributeCount << " static attribute" << (m_spec.staticAttributeCount > 1 ? "s" : "") << " from " << (m_spec.useStaticBuffer ? "buffer" : "pointer") << "." << TestLog::EndMessage;
 836
 837         if (m_spec.dynamicAttributeCount > 0)
 838                 log << TestLog::Message << "Using " << m_spec.dynamicAttributeCount << " dynamic attribute" << (m_spec.dynamicAttributeCount > 1 ? "s" : "") << " from " << (m_spec.useDynamicBuffer ? "buffer" : "pointer") << "." << TestLog::EndMessage;
 839
 840         log << TestLog::Message << "Rendering " << m_spec.drawCallCount << " draw calls with " << m_spec.triangleCount << " triangles per call." << TestLog::EndMessage;
 841 }
 842
 843 tcu::TestCase::IterateResult DrawCallBatchingTest::iterate (void)
 844 {
 845         if (m_state == STATE_LOG_INFO)
 846         {
 847                 logTestInfo();
 848                 m_state = STATE_WARMUP_BATCHED;
 849         }
 850         else if (m_state == STATE_WARMUP_BATCHED)
 851         {
 852                 renderBatched();
 853                 m_state = STATE_WARMUP_UNBATCHED;
 854         }
 855         else if (m_state == STATE_WARMUP_UNBATCHED)
 856         {
 857                 renderUnbatched();
 858                 m_state = STATE_SAMPLE;
 859         }
 860         else if (m_state == STATE_SAMPLE)
 861         {
 862                 if ((int)m_unbatchedSamplesUs.size() < m_unbatchedSampleCount && ((double)m_unbatchedSamplesUs.size() / ((double)m_unbatchedSampleCount) < (double)m_batchedSamplesUs.size() / ((double)m_batchedSampleCount) || (int)m_batchedSamplesUs.size() >= m_batchedSampleCount))
 863                         m_unbatchedSamplesUs.push_back(renderUnbatched());
 864                 else if ((int)m_batchedSamplesUs.size() < m_batchedSampleCount)
 865                         m_batchedSamplesUs.push_back(renderBatched());
 866                 else
 867                         m_state = STATE_CALC_CALIBRATION;
 868         }
 869         else if (m_state == STATE_CALC_CALIBRATION)
 870         {
 871                 TestLog& log = m_testCtx.getLog();
 872
 873                 tcu::ScopedLogSection   section(log, ("Sampling iteration " + de::toString(m_sampleIteration)).c_str(), ("Sampling iteration " + de::toString(m_sampleIteration)).c_str());
 874                 const double targetSEM  = 0.02;
 875                 const double limitSEM   = 0.025;
 876
 877                 Statistics unbatchedStats       = calculateStats(m_unbatchedSamplesUs);
 878                 Statistics batchedStats         = calculateStats(m_batchedSamplesUs);
 879
 880                 log << TestLog::Message << "Batched samples; Count: " << m_batchedSamplesUs.size() << ", Mean: " << batchedStats.mean << "us, Standard deviation: " << batchedStats.standardDeviation << "us, Standard error of mean: " << batchedStats.standardErrorOfMean << "us(" << (batchedStats.standardErrorOfMean/batchedStats.mean) << ")" << TestLog::EndMessage;
 881                 log << TestLog::Message << "Unbatched samples; Count: " << m_unbatchedSamplesUs.size() << ", Mean: " << unbatchedStats.mean << "us, Standard deviation: " << unbatchedStats.standardDeviation << "us, Standard error of mean: " << unbatchedStats.standardErrorOfMean << "us(" << (unbatchedStats.standardErrorOfMean/unbatchedStats.mean) << ")" << TestLog::EndMessage;
 882
 883                 if (m_sampleIteration > 2 || (m_sampleIteration > 0 && (unbatchedStats.standardErrorOfMean/unbatchedStats.mean) + (batchedStats.standardErrorOfMean/batchedStats.mean) <= 2.0 * limitSEM))
 884                 {
 885                         if (m_sampleIteration > 2)
 886                                 log << TestLog::Message << "Maximum iteration count reached." << TestLog::EndMessage;
 887
 888                         log << TestLog::Message << "Standard errors in target range." << TestLog::EndMessage;
 889                         log << TestLog::Message << "Batched/Unbatched ratio: " << (batchedStats.mean / unbatchedStats.mean) << TestLog::EndMessage;
 890
 891                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::floatToString((float)(batchedStats.mean/unbatchedStats.mean), 1).c_str());
 892                         return STOP;
 893                 }
 894                 else
 895                 {
 896                         if ((unbatchedStats.standardErrorOfMean/unbatchedStats.mean) > targetSEM)
 897                                 log << TestLog::Message << "Unbatched standard error of mean outside of range." << TestLog::EndMessage;
 898
 899                         if ((batchedStats.standardErrorOfMean/batchedStats.mean) > targetSEM)
 900                                 log << TestLog::Message << "Batched standard error of mean outside of range." << TestLog::EndMessage;
 901
 902                         if (unbatchedStats.standardDeviation > 0.0)
 903                         {
 904                                 double x = (unbatchedStats.standardDeviation / unbatchedStats.mean) / targetSEM;
 905                                 m_unbatchedSampleCount = std::max((int)m_unbatchedSamplesUs.size(), (int)(x * x));
 906                         }
 907                         else
 908                                 m_unbatchedSampleCount = (int)m_unbatchedSamplesUs.size();
 909
 910                         if (batchedStats.standardDeviation > 0.0)
 911                         {
 912                                 double x = (batchedStats.standardDeviation / batchedStats.mean) / targetSEM;
 913                                 m_batchedSampleCount = std::max((int)m_batchedSamplesUs.size(), (int)(x * x));
 914                         }
 915                         else
 916                                 m_batchedSampleCount = (int)m_batchedSamplesUs.size();
 917
 918                         m_batchedSamplesUs.clear();
 919                         m_unbatchedSamplesUs.clear();
 920
 921                         m_sampleIteration++;
 922                         m_state = STATE_SAMPLE;
 923                 }
 924         }
 925         else
 926                 DE_ASSERT(false);
 927
 928         return CONTINUE;
 929 }
 930
 931 string specToName (const DrawCallBatchingTest::TestSpec& spec)
 932 {
 933         std::ostringstream stream;
 934
 935         DE_ASSERT(!spec.useStaticBuffer || spec.staticAttributeCount > 0);
 936         DE_ASSERT(!spec.useDynamicBuffer|| spec.dynamicAttributeCount > 0);
 937
 938         if (spec.staticAttributeCount > 0)
 939                 stream << spec.staticAttributeCount << "_static_";
 940
 941         if (spec.useStaticBuffer)
 942                 stream << (spec.staticAttributeCount == 1 ? "buffer_" : "buffers_");
 943
 944         if (spec.dynamicAttributeCount > 0)
 945                 stream << spec.dynamicAttributeCount << "_dynamic_";
 946
 947         if (spec.useDynamicBuffer)
 948                 stream << (spec.dynamicAttributeCount == 1 ? "buffer_" : "buffers_");
 949
 950         stream << spec.triangleCount << "_triangles";
 951
 952         return stream.str();
 953 }
 954
 955 string specToDescrpition (const DrawCallBatchingTest::TestSpec& spec)
 956 {
 957         DE_UNREF(spec);
 958         return "Test performance of batched rendering against non-batched rendering.";
 959 }
 960
 961 } // anonymous
 962
 963 DrawCallBatchingTests::DrawCallBatchingTests (Context& context)
 964         : TestCaseGroup(context, "draw_call_batching", "Draw call batching performance tests.")
 965 {
 966 }
 967
 968 DrawCallBatchingTests::~DrawCallBatchingTests (void)
 969 {
 970 }
 971
 972 void DrawCallBatchingTests::init (void)
 973 {
 974         int drawCallCounts[] = {
 975                 10, 100
 976         };
 977
 978         int triangleCounts[] = {
 979                 2, 10
 980         };
 981
 982         int staticAttributeCounts[] = {
 983                 1, 0, 4, 8, 0
 984         };
 985
 986         int dynamicAttributeCounts[] = {
 987                 0, 1, 4, 0, 8
 988         };
 989
 990         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(staticAttributeCounts) == DE_LENGTH_OF_ARRAY(dynamicAttributeCounts));
 991
 992         for (int drawType = 0; drawType < 2; drawType++)
 993         {
 994                 bool drawElements = (drawType == 1);
 995
 996                 for (int indexBufferNdx = 0; indexBufferNdx < 2; indexBufferNdx++)
 997                 {
 998                         bool useIndexBuffer = (indexBufferNdx == 1);
 999
1000                         if (useIndexBuffer && !drawElements)
1001                                 continue;
1002
1003                         for (int dynamicIndexNdx = 0; dynamicIndexNdx < 2; dynamicIndexNdx++)
1004                         {
1005                                 bool dynamicIndices = (dynamicIndexNdx == 1);
1006
1007                                 if (dynamicIndices && !drawElements)
1008                                         continue;
1009
1010                                 if (dynamicIndices && !useIndexBuffer)
1011                                         continue;
1012
1013                                 TestCaseGroup* drawTypeGroup = new TestCaseGroup(m_context, (string(dynamicIndices ? "dynamic_" : "") + (useIndexBuffer ? "buffer_" : "" ) + (drawElements ? "draw_elements" : "draw_arrays")).c_str(), (string("Test batched rendering with ") + (drawElements ? "draw_elements" : "draw_arrays")).c_str());
1014
1015                                 addChild(drawTypeGroup);
1016
1017                                 for (int drawCallCountNdx = 0; drawCallCountNdx < DE_LENGTH_OF_ARRAY(drawCallCounts); drawCallCountNdx++)
1018                                 {
1019                                         int drawCallCount = drawCallCounts[drawCallCountNdx];
1020
1021                                         TestCaseGroup*  callCountGroup                  = new TestCaseGroup(m_context, (de::toString(drawCallCount) + (drawCallCount == 1 ? "_draw" : "_draws")).c_str(), ("Test batched rendering performance with " + de::toString(drawCallCount) + " draw calls.").c_str());
1022                                         TestCaseGroup*  attributeCount1Group    = new TestCaseGroup(m_context, "1_attribute", "Test draw call batching with 1 attribute.");
1023                                         TestCaseGroup*  attributeCount8Group    = new TestCaseGroup(m_context, "8_attributes", "Test draw call batching with 8 attributes.");
1024
1025                                         callCountGroup->addChild(attributeCount1Group);
1026                                         callCountGroup->addChild(attributeCount8Group);
1027
1028                                         drawTypeGroup->addChild(callCountGroup);
1029
1030                                         for (int attributeCountNdx = 0; attributeCountNdx < DE_LENGTH_OF_ARRAY(dynamicAttributeCounts); attributeCountNdx++)
1031                                         {
1032                                                 TestCaseGroup*  attributeCountGroup             = NULL;
1033
1034                                                 int                             staticAttributeCount    = staticAttributeCounts[attributeCountNdx];
1035                                                 int                             dynamicAttributeCount   = dynamicAttributeCounts[attributeCountNdx];
1036
1037                                                 if (staticAttributeCount + dynamicAttributeCount == 1)
1038                                                         attributeCountGroup = attributeCount1Group;
1039                                                 else if (staticAttributeCount + dynamicAttributeCount == 8)
1040                                                         attributeCountGroup = attributeCount8Group;
1041                                                 else
1042                                                         DE_ASSERT(false);
1043
1044                                                 for (int triangleCountNdx = 0; triangleCountNdx < DE_LENGTH_OF_ARRAY(triangleCounts); triangleCountNdx++)
1045                                                 {
1046                                                         int triangleCount = triangleCounts[triangleCountNdx];
1047
1048                                                         for (int dynamicBufferNdx = 0; dynamicBufferNdx < 2; dynamicBufferNdx++)
1049                                                         {
1050                                                                 bool useDynamicBuffer = (dynamicBufferNdx != 0);
1051
1052                                                                 for (int staticBufferNdx = 0; staticBufferNdx < 2; staticBufferNdx++)
1053                                                                 {
1054                                                                         bool useStaticBuffer = (staticBufferNdx != 0);
1055
1056                                                                         DrawCallBatchingTest::TestSpec spec;
1057
1058                                                                         spec.useStaticBuffer            = useStaticBuffer;
1059                                                                         spec.staticAttributeCount       = staticAttributeCount;
1060
1061                                                                         spec.useDynamicBuffer           = useDynamicBuffer;
1062                                                                         spec.dynamicAttributeCount      = dynamicAttributeCount;
1063
1064                                                                         spec.drawCallCount                      = drawCallCount;
1065                                                                         spec.triangleCount                      = triangleCount;
1066
1067                                                                         spec.useDrawElements            = drawElements;
1068                                                                         spec.useIndexBuffer                     = useIndexBuffer;
1069                                                                         spec.dynamicIndices                     = dynamicIndices;
1070
1071                                                                         if (spec.useStaticBuffer && spec.staticAttributeCount == 0)
1072                                                                                 continue;
1073
1074                                                                         if (spec.useDynamicBuffer && spec.dynamicAttributeCount == 0)
1075                                                                                 continue;
1076
1077                                                                         attributeCountGroup->addChild(new DrawCallBatchingTest(m_context, specToName(spec).c_str(), specToDescrpition(spec).c_str(), spec));
1078                                                                 }
1079                                                         }
1080                                                 }
1081                                         }
1082                                 }
1083                         }
1084                 }
1085         }
1086 }
1087
1088 } // Performance
1089 } // gles2
1090 } // deqp