modules/glshared/glsStateChangePerfTestCases.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) Module
 * -----------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief State change performance tests.
 *//*--------------------------------------------------------------------*/

#include "glsStateChangePerfTestCases.hpp"

#include "tcuTestLog.hpp"

#include "gluDefs.hpp"
#include "gluRenderContext.hpp"
#include "gluShaderProgram.hpp"

#include "glwFunctions.hpp"
#include "glwEnums.hpp"

#include "deStringUtil.hpp"

#include "deClock.h"

#include <vector>
#include <algorithm>

using std::string;
using std::vector;
using tcu::TestLog;
using namespace glw;

namespace deqp
{
namespace gls
{

namespace
{

struct ResultStats
{
    double median;
    double mean;
    double variance;

    uint64_t min;
    uint64_t max;
};

ResultStats calculateStats(const vector<uint64_t> &values)
{
    ResultStats result = {0.0, 0.0, 0.0, 0xFFFFFFFFFFFFFFFFu, 0};

    uint64_t sum = 0;

    for (int i = 0; i < (int)values.size(); i++)
        sum += values[i];

    result.mean = ((double)sum) / (double)values.size();

    for (int i = 0; i < (int)values.size(); i++)
    {
        const double val = (double)values[i];
        result.variance += (val - result.mean) * (val - result.mean);
    }

    result.variance /= (double)values.size();

    {
        const int n = (int)(values.size() / 2);

        vector<uint64_t> sortedValues = values;

        std::sort(sortedValues.begin(), sortedValues.end());

        result.median = (double)sortedValues[n];
    }

    for (int i = 0; i < (int)values.size(); i++)
    {
        result.min = std::min(result.min, values[i]);
        result.max = std::max(result.max, values[i]);
    }

    return result;
}

void genIndices(vector<GLushort> &indices, int triangleCount)
{
    indices.reserve(triangleCount * 3);

    for (int triangleNdx = 0; triangleNdx < triangleCount; triangleNdx++)
    {
        indices.push_back((GLushort)(triangleNdx * 3));
        indices.push_back((GLushort)(triangleNdx * 3 + 1));
        indices.push_back((GLushort)(triangleNdx * 3 + 2));
    }
}

void genCoords(vector<GLfloat> &coords, int triangleCount)
{
    coords.reserve(triangleCount * 3 * 2);

    for (int triangleNdx = 0; triangleNdx < triangleCount; triangleNdx++)
    {
        if ((triangleNdx % 2) == 0)
        {
            // CW
            coords.push_back(-1.0f);
            coords.push_back(-1.0f);

            coords.push_back(1.0f);
            coords.push_back(-1.0f);

            coords.push_back(1.0f);
            coords.push_back(1.0f);
        }
        else
        {
            // CCW
            coords.push_back(-1.0f);
            coords.push_back(-1.0f);

            coords.push_back(-1.0f);
            coords.push_back(1.0f);

            coords.push_back(1.0f);
            coords.push_back(1.0f);
        }
    }
}

void genTextureData(vector<uint8_t> &data, int width, int height)
{
    data.clear();
    data.reserve(width * height * 4);

    for (int x = 0; x < width; x++)
    {
        for (int y = 0; y < height; y++)
        {
            data.push_back((uint8_t)((255 * x) / width));
            data.push_back((uint8_t)((255 * y) / width));
            data.push_back((uint8_t)((255 * x * y) / (width * height)));
            data.push_back(255);
        }
    }
}

double calculateVariance(const vector<uint64_t> &values, double avg)
{
    double sum = 0.0;

    for (int valueNdx = 0; valueNdx < (int)values.size(); valueNdx++)
    {
        double value = (double)values[valueNdx];
        sum += (value - avg) * (value - avg);
    }

    return sum / (double)values.size();
}

uint64_t findMin(const vector<uint64_t> &values)
{
    uint64_t min = ~0ull;

    for (int valueNdx = 0; valueNdx < (int)values.size(); valueNdx++)
        min = std::min(values[valueNdx], min);

    return min;
}

uint64_t findMax(const vector<uint64_t> &values)
{
    uint64_t max = 0;

    for (int valueNdx = 0; valueNdx < (int)values.size(); valueNdx++)
        max = std::max(values[valueNdx], max);

    return max;
}

uint64_t findMedian(const vector<uint64_t> &v)
{
    vector<uint64_t> values = v;
    size_t n                = values.size() / 2;

    std::nth_element(values.begin(), values.begin() + n, values.end());

    return values[n];
}

} // namespace

StateChangePerformanceCase::StateChangePerformanceCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx,
                                                       const char *name, const char *description, DrawType drawType,
                                                       int drawCallCount, int triangleCount)
    : tcu::TestCase(testCtx, tcu::NODETYPE_PERFORMANCE, name, description)
    , m_renderCtx(renderCtx)
    , m_drawType(drawType)
    , m_iterationCount(100)
    , m_callCount(drawCallCount)
    , m_triangleCount(triangleCount)
{
}

StateChangePerformanceCase::~StateChangePerformanceCase(void)
{
    StateChangePerformanceCase::deinit();
}

void StateChangePerformanceCase::init(void)
{
    if (m_drawType == DRAWTYPE_INDEXED_USER_PTR)
        genIndices(m_indices, m_triangleCount);
}

void StateChangePerformanceCase::requireIndexBuffers(int count)
{
    const glw::Functions &gl = m_renderCtx.getFunctions();

    if ((int)m_indexBuffers.size() >= count)
        return;

    m_indexBuffers.reserve(count);

    vector<GLushort> indices;
    genIndices(indices, m_triangleCount);

    while ((int)m_indexBuffers.size() < count)
    {
        GLuint buffer;

        gl.genBuffers(1, &buffer);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers()");

        gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
        gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(indices.size() * sizeof(GLushort)), &(indices[0]),
                      GL_STATIC_DRAW);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData()");
        gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");

        m_indexBuffers.push_back(buffer);
    }
}

void StateChangePerformanceCase::requireCoordBuffers(int count)
{
    const glw::Functions &gl = m_renderCtx.getFunctions();

    if ((int)m_coordBuffers.size() >= count)
        return;

    m_coordBuffers.reserve(count);

    vector<GLfloat> coords;
    genCoords(coords, m_triangleCount);

    while ((int)m_coordBuffers.size() < count)
    {
        GLuint buffer;

        gl.genBuffers(1, &buffer);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers()");

        gl.bindBuffer(GL_ARRAY_BUFFER, buffer);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
        gl.bufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(coords.size() * sizeof(GLfloat)), &(coords[0]), GL_STATIC_DRAW);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData()");
        gl.bindBuffer(GL_ARRAY_BUFFER, 0);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");

        m_coordBuffers.push_back(buffer);
    }
}

void StateChangePerformanceCase::requirePrograms(int count)
{
    if ((int)m_programs.size() >= count)
        return;

    m_programs.reserve(count);

    while ((int)m_programs.size() < count)
    {
        string vertexShaderSource = "attribute mediump vec2 a_coord;\n"
                                    "varying mediump vec2 v_texCoord;\n"
                                    "void main (void)\n"
                                    "{\n"
                                    "\tv_texCoord = vec2(0.5) + 0.5" +
                                    de::toString(m_programs.size()) +
                                    " * a_coord.xy;\n"
                                    "\tgl_Position = vec4(a_coord, 0.5, 1.0);\n"
                                    "}";

        string fragmentShaderSource = "uniform sampler2D u_sampler;\n"
                                      "varying mediump vec2 v_texCoord;\n"
                                      "void main (void)\n"
                                      "{\n"
                                      "\tgl_FragColor = vec4(1.0" +
                                      de::toString(m_programs.size()) +
                                      " * texture2D(u_sampler, v_texCoord).xyz, 1.0);\n"
                                      "}";

        glu::ShaderProgram *program =
            new glu::ShaderProgram(m_renderCtx, glu::ProgramSources() << glu::VertexSource(vertexShaderSource)
                                                                      << glu::FragmentSource(fragmentShaderSource));

        if (!program->isOk())
        {
            m_testCtx.getLog() << *program;
            delete program;
            TCU_FAIL("Compile failed");
        }

        m_programs.push_back(program);
    }
}

void StateChangePerformanceCase::requireTextures(int count)
{
    const glw::Functions &gl = m_renderCtx.getFunctions();

    const int textureWidth  = 64;
    const int textureHeight = 64;

    if ((int)m_textures.size() >= count)
        return;

    m_textures.reserve(count);

    vector<uint8_t> textureData;
    genTextureData(textureData, textureWidth, textureHeight);

    DE_ASSERT(textureData.size() == textureWidth * textureHeight * 4);

    while ((int)m_textures.size() < count)
    {
        GLuint texture;

        gl.genTextures(1, &texture);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures()");

        gl.bindTexture(GL_TEXTURE_2D, texture);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");

        gl.texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, textureWidth, textureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                      &(textureData[0]));
        GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D()");

        gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri()");
        gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri()");
        gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri()");
        gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri()");

        gl.bindTexture(GL_TEXTURE_2D, 0);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");

        m_textures.push_back(texture);
    }
}

void StateChangePerformanceCase::requireFramebuffers(int count)
{
    const glw::Functions &gl = m_renderCtx.getFunctions();

    if ((int)m_framebuffers.size() >= count)
        return;

    m_framebuffers.reserve(count);

    requireRenderbuffers(count);

    while ((int)m_framebuffers.size() < count)
    {
        GLuint framebuffer;

        gl.genFramebuffers(1, &framebuffer);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers()");

        gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer()");

        gl.bindRenderbuffer(GL_RENDERBUFFER, m_renderbuffers[m_framebuffers.size()]);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer()");

        gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
                                   m_renderbuffers[m_framebuffers.size()]);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer()");

        gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer()");

        gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer()");

        m_framebuffers.push_back(framebuffer);
    }
}

void StateChangePerformanceCase::requireRenderbuffers(int count)
{
    const glw::Functions &gl = m_renderCtx.getFunctions();

    if ((int)m_renderbuffers.size() >= count)
        return;

    m_renderbuffers.reserve(count);

    while ((int)m_renderbuffers.size() < count)
    {
        GLuint renderbuffer;

        gl.genRenderbuffers(1, &renderbuffer);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers()");

        gl.bindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer()");

        gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGB565, 24, 24);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage()");

        gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer()");

        m_renderbuffers.push_back(renderbuffer);
    }
}

void StateChangePerformanceCase::requireSamplers(int count)
{
    const glw::Functions &gl = m_renderCtx.getFunctions();

    if ((int)m_samplers.size() >= count)
        return;

    m_samplers.reserve(count);

    while ((int)m_samplers.size() < count)
    {
        GLuint sampler;
        gl.genSamplers(1, &sampler);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGenSamplers()");
        m_samplers.push_back(sampler);
    }
}

void StateChangePerformanceCase::requireVertexArrays(int count)
{
    const glw::Functions &gl = m_renderCtx.getFunctions();

    if ((int)m_vertexArrays.size() >= count)
        return;

    m_vertexArrays.reserve(count);

    while ((int)m_vertexArrays.size() < count)
    {
        GLuint vertexArray;
        gl.genVertexArrays(1, &vertexArray);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays()");
        m_vertexArrays.push_back(vertexArray);
    }
}

void StateChangePerformanceCase::deinit(void)
{
    m_indices.clear();
    m_interleavedResults.clear();
    m_batchedResults.clear();

    {
        const glw::Functions &gl = m_renderCtx.getFunctions();

        if (!m_indexBuffers.empty())
        {
            gl.deleteBuffers((GLsizei)m_indexBuffers.size(), &(m_indexBuffers[0]));
            m_indexBuffers.clear();
        }

        if (!m_coordBuffers.empty())
        {
            gl.deleteBuffers((GLsizei)m_coordBuffers.size(), &(m_coordBuffers[0]));
            m_coordBuffers.clear();
        }

        if (!m_textures.empty())
        {
            gl.deleteTextures((GLsizei)m_textures.size(), &(m_textures[0]));
            m_textures.clear();
        }

        if (!m_framebuffers.empty())
        {
            gl.deleteFramebuffers((GLsizei)m_framebuffers.size(), &(m_framebuffers[0]));
            m_framebuffers.clear();
        }

        if (!m_renderbuffers.empty())
        {
            gl.deleteRenderbuffers((GLsizei)m_renderbuffers.size(), &(m_renderbuffers[0]));
            m_renderbuffers.clear();
        }

        if (!m_samplers.empty())
        {
            gl.deleteSamplers((GLsizei)m_samplers.size(), &m_samplers[0]);
            m_samplers.clear();
        }

        if (!m_vertexArrays.empty())
        {
            gl.deleteVertexArrays((GLsizei)m_vertexArrays.size(), &m_vertexArrays[0]);
            m_vertexArrays.clear();
        }

        for (int programNdx = 0; programNdx < (int)m_programs.size(); programNdx++)
        {
            delete m_programs[programNdx];
            m_programs[programNdx] = NULL;
        }
        m_programs.clear();
    }
}

void StateChangePerformanceCase::logAndSetTestResult(void)
{
    TestLog &log = m_testCtx.getLog();

    ResultStats interleaved = calculateStats(m_interleavedResults);
    ResultStats batched     = calculateStats(m_batchedResults);

    log << TestLog::Message << "Interleaved mean: " << interleaved.mean << TestLog::EndMessage;
    log << TestLog::Message << "Interleaved median: " << interleaved.median << TestLog::EndMessage;
    log << TestLog::Message << "Interleaved variance: " << interleaved.variance << TestLog::EndMessage;
    log << TestLog::Message << "Interleaved min: " << interleaved.min << TestLog::EndMessage;
    log << TestLog::Message << "Interleaved max: " << interleaved.max << TestLog::EndMessage;

    log << TestLog::Message << "Batched mean: " << batched.mean << TestLog::EndMessage;
    log << TestLog::Message << "Batched median: " << batched.median << TestLog::EndMessage;
    log << TestLog::Message << "Batched variance: " << batched.variance << TestLog::EndMessage;
    log << TestLog::Message << "Batched min: " << batched.min << TestLog::EndMessage;
    log << TestLog::Message << "Batched max: " << batched.max << TestLog::EndMessage;

    log << TestLog::Message << "Batched/Interleaved mean ratio: " << (interleaved.mean / batched.mean)
        << TestLog::EndMessage;
    log << TestLog::Message << "Batched/Interleaved median ratio: " << (interleaved.median / batched.median)
        << TestLog::EndMessage;

    m_testCtx.setTestResult(QP_TEST_RESULT_PASS,
                            de::floatToString((float)(((double)interleaved.median) / batched.median), 2).c_str());
}

tcu::TestCase::IterateResult StateChangePerformanceCase::iterate(void)
{
    if (m_interleavedResults.empty() && m_batchedResults.empty())
    {
        TestLog &log = m_testCtx.getLog();

        log << TestLog::Message << "Draw call count: " << m_callCount << TestLog::EndMessage;
        log << TestLog::Message << "Per call triangle count: " << m_triangleCount << TestLog::EndMessage;
    }

    // \note [mika] Interleave sampling to balance effects of powerstate etc.
    if ((int)m_interleavedResults.size() < m_iterationCount && m_batchedResults.size() >= m_interleavedResults.size())
    {
        const glw::Functions &gl = m_renderCtx.getFunctions();
        uint64_t resBeginUs      = 0;
        uint64_t resEndUs        = 0;

        setupInitialState(gl);
        gl.finish();
        GLU_EXPECT_NO_ERROR(gl.getError(), "glFinish()");

        // Render result
        resBeginUs = deGetMicroseconds();

        renderTest(gl);

        gl.finish();
        resEndUs = deGetMicroseconds();
        GLU_EXPECT_NO_ERROR(gl.getError(), "glFinish()");

        m_interleavedResults.push_back(resEndUs - resBeginUs);

        return CONTINUE;
    }
    else if ((int)m_batchedResults.size() < m_iterationCount)
    {
        const glw::Functions &gl = m_renderCtx.getFunctions();
        uint64_t refBeginUs      = 0;
        uint64_t refEndUs        = 0;

        setupInitialState(gl);
        gl.finish();
        GLU_EXPECT_NO_ERROR(gl.getError(), "glFinish()");

        // Render reference
        refBeginUs = deGetMicroseconds();

        renderReference(gl);

        gl.finish();
        refEndUs = deGetMicroseconds();
        GLU_EXPECT_NO_ERROR(gl.getError(), "glFinish()");

        m_batchedResults.push_back(refEndUs - refBeginUs);

        return CONTINUE;
    }
    else
    {
        logAndSetTestResult();
        return STOP;
    }
}

void StateChangePerformanceCase::callDraw(const glw::Functions &gl)
{
    switch (m_drawType)
    {
    case DRAWTYPE_NOT_INDEXED:
        gl.drawArrays(GL_TRIANGLES, 0, m_triangleCount * 3);
        break;
    case DRAWTYPE_INDEXED_USER_PTR:
        gl.drawElements(GL_TRIANGLES, m_triangleCount * 3, GL_UNSIGNED_SHORT, &m_indices[0]);
        break;
    case DRAWTYPE_INDEXED_BUFFER:
        gl.drawElements(GL_TRIANGLES, m_triangleCount * 3, GL_UNSIGNED_SHORT, NULL);
        break;
    default:
        DE_ASSERT(false);
    }
}

// StateChangeCallPerformanceCase

StateChangeCallPerformanceCase::StateChangeCallPerformanceCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx,
                                                               const char *name, const char *description)
    : tcu::TestCase(testCtx, tcu::NODETYPE_PERFORMANCE, name, description)
    , m_renderCtx(renderCtx)
    , m_iterationCount(100)
    , m_callCount(1000)
{
}

StateChangeCallPerformanceCase::~StateChangeCallPerformanceCase(void)
{
}

void StateChangeCallPerformanceCase::executeTest(void)
{
    const glw::Functions &gl = m_renderCtx.getFunctions();
    uint64_t beginTimeUs     = 0;
    uint64_t endTimeUs       = 0;

    beginTimeUs = deGetMicroseconds();

    execCalls(gl, (int)m_results.size(), m_callCount);

    endTimeUs = deGetMicroseconds();

    m_results.push_back(endTimeUs - beginTimeUs);
}

void StateChangeCallPerformanceCase::logTestCase(void)
{
    TestLog &log = m_testCtx.getLog();

    log << TestLog::Message << "Iteration count: " << m_iterationCount << TestLog::EndMessage;
    log << TestLog::Message << "Per iteration call count: " << m_callCount << TestLog::EndMessage;
}

double calculateAverage(const vector<uint64_t> &values)
{
    uint64_t sum = 0;

    for (int valueNdx = 0; valueNdx < (int)values.size(); valueNdx++)
        sum += values[valueNdx];

    return ((double)sum) / (double)values.size();
}

void StateChangeCallPerformanceCase::logAndSetTestResult(void)
{
    TestLog &log = m_testCtx.getLog();

    uint64_t minUs         = findMin(m_results);
    uint64_t maxUs         = findMax(m_results);
    uint64_t medianUs      = findMedian(m_results);
    double avgIterationUs  = calculateAverage(m_results);
    double avgCallUs       = avgIterationUs / m_callCount;
    double varIteration    = calculateVariance(m_results, avgIterationUs);
    double avgMedianCallUs = ((double)medianUs) / m_callCount;

    log << TestLog::Message << "Min iteration time: " << minUs << "us" << TestLog::EndMessage;
    log << TestLog::Message << "Max iteration time: " << maxUs << "us" << TestLog::EndMessage;
    log << TestLog::Message << "Average iteration time: " << avgIterationUs << "us" << TestLog::EndMessage;
    log << TestLog::Message << "Iteration variance time: " << varIteration << TestLog::EndMessage;
    log << TestLog::Message << "Median iteration time: " << medianUs << "us" << TestLog::EndMessage;
    log << TestLog::Message << "Average call time: " << avgCallUs << "us" << TestLog::EndMessage;
    log << TestLog::Message << "Average call time for median iteration: " << avgMedianCallUs << "us"
        << TestLog::EndMessage;

    m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::floatToString((float)avgMedianCallUs, 3).c_str());
}

tcu::TestCase::IterateResult StateChangeCallPerformanceCase::iterate(void)
{
    if (m_results.empty())
        logTestCase();

    if ((int)m_results.size() < m_iterationCount)
    {
        executeTest();
        GLU_EXPECT_NO_ERROR(m_renderCtx.getFunctions().getError(), "Unexpected error");
        return CONTINUE;
    }
    else
    {
        logAndSetTestResult();
        return STOP;
    }
}

} // namespace gls
} // namespace deqp