/*-------------------------------------------------------------------------
 * 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 Parametrized, long-running stress case.
 *
 * \todo [2013-06-27 nuutti] Do certain things in a cleaner and less
 *                             confusing way, such as the "redundant buffer
 *                             factor" thing in LongStressCase.
 *//*--------------------------------------------------------------------*/

#include "glsLongStressCase.hpp"
#include "tcuTestLog.hpp"
#include "tcuCommandLine.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuVector.hpp"
#include "tcuVectorUtil.hpp"
#include "glsTextureTestUtil.hpp"
#include "gluPixelTransfer.hpp"
#include "gluTextureUtil.hpp"
#include "tcuStringTemplate.hpp"
#include "gluStrUtil.hpp"
#include "gluShaderProgram.hpp"
#include "deRandom.hpp"
#include "deStringUtil.hpp"
#include "deString.h"
#include "deSharedPtr.hpp"
#include "deClock.h"

#include "glw.h"

#include <limits>
#include <vector>
#include <iomanip>
#include <map>
#include <iomanip>

using de::Random;
using de::SharedPtr;
using de::toString;
using tcu::ConstPixelBufferAccess;
using tcu::CubeFace;
using tcu::IVec2;
using tcu::IVec3;
using tcu::IVec4;
using tcu::TestLog;
using tcu::TextureFormat;
using tcu::TextureLevel;
using tcu::Vec2;
using tcu::Vec3;
using tcu::Vec4;

using std::map;
using std::string;
using std::vector;

namespace deqp
{
namespace gls
{

using glu::TextureTestUtil::TextureType;
using glu::TextureTestUtil::TEXTURETYPE_2D;
using glu::TextureTestUtil::TEXTURETYPE_CUBE;

static const float Mi = (float)(1 << 20);

static const uint32_t bufferUsages[] = {GL_STATIC_DRAW, GL_STREAM_DRAW, GL_DYNAMIC_DRAW,

                                        GL_STATIC_READ, GL_STREAM_READ, GL_DYNAMIC_READ,

                                        GL_STATIC_COPY, GL_STREAM_COPY, GL_DYNAMIC_COPY};

static const uint32_t bufferUsagesGLES2[] = {GL_STATIC_DRAW, GL_DYNAMIC_DRAW, GL_STREAM_DRAW};

static const uint32_t bufferTargets[] = {GL_ARRAY_BUFFER,        GL_ELEMENT_ARRAY_BUFFER,

                                         GL_COPY_READ_BUFFER,    GL_COPY_WRITE_BUFFER,         GL_PIXEL_PACK_BUFFER,
                                         GL_PIXEL_UNPACK_BUFFER, GL_TRANSFORM_FEEDBACK_BUFFER, GL_UNIFORM_BUFFER};

static const uint32_t bufferTargetsGLES2[] = {GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER};

static inline int computePixelStore(const TextureFormat &format)
{
    const int pixelSize = format.getPixelSize();
    if (deIsPowerOfTwo32(pixelSize))
        return de::min(pixelSize, 8);
    else
        return 1;
}

static inline int getNumIterations(const tcu::TestContext &testCtx, const int defaultNumIterations)
{
    const int cmdLineVal = testCtx.getCommandLine().getTestIterationCount();
    return cmdLineVal == 0 ? defaultNumIterations : cmdLineVal;
}

static inline float triangleArea(const Vec2 &a, const Vec2 &b, const Vec2 &c)
{
    const Vec2 ab = b - a;
    const Vec2 ac = c - a;
    return 0.5f * tcu::length(ab.x() * ac.y() - ab.y() * ac.x());
}

static inline string mangleShaderNames(const string &source, const string &manglingSuffix)
{
    map<string, string> m;
    m["NS"] = manglingSuffix;
    return tcu::StringTemplate(source.c_str()).specialize(m);
}

template <typename T, int N>
static inline T randomChoose(Random &rnd, const T (&arr)[N])
{
    return rnd.choose<T>(DE_ARRAY_BEGIN(arr), DE_ARRAY_END(arr));
}

static inline int nextDivisible(const int x, const int div)
{
    DE_ASSERT(x >= 0);
    DE_ASSERT(div >= 1);
    return x == 0 ? 0 : x - 1 + div - (x - 1) % div;
}

static inline string getTimeStr(const uint64_t seconds)
{
    const uint64_t m = seconds / 60;
    const uint64_t h = m / 60;
    const uint64_t d = h / 24;
    std::ostringstream res;

    res << d << "d " << h % 24 << "h " << m % 60 << "m " << seconds % 60 << "s";
    return res.str();
}

static inline string probabilityStr(const float prob)
{
    return prob == 0.0f ? "never" : prob == 1.0f ? "ALWAYS" : de::floatToString(prob * 100.0f, 0) + "%";
}

static inline uint32_t randomBufferTarget(Random &rnd, const bool isGLES3)
{
    return isGLES3 ? randomChoose(rnd, bufferTargets) : randomChoose(rnd, bufferTargetsGLES2);
}

static inline uint32_t randomBufferUsage(Random &rnd, const bool isGLES3)
{
    return isGLES3 ? randomChoose(rnd, bufferUsages) : randomChoose(rnd, bufferUsagesGLES2);
}

static inline uint32_t cubeFaceToGLFace(tcu::CubeFace face)
{
    switch (face)
    {
    case tcu::CUBEFACE_NEGATIVE_X:
        return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
    case tcu::CUBEFACE_POSITIVE_X:
        return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
    case tcu::CUBEFACE_NEGATIVE_Y:
        return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
    case tcu::CUBEFACE_POSITIVE_Y:
        return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
    case tcu::CUBEFACE_NEGATIVE_Z:
        return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
    case tcu::CUBEFACE_POSITIVE_Z:
        return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
    default:
        DE_ASSERT(false);
        return GL_NONE;
    }
}

#if defined(DE_DEBUG)
static inline bool isMatchingGLInternalFormat(const uint32_t internalFormat, const TextureFormat &texFormat)
{
    switch (internalFormat)
    {
        // Unsized formats.

    case GL_RGBA:
        return texFormat.order == TextureFormat::RGBA &&
               (texFormat.type == TextureFormat::UNORM_INT8 || texFormat.type == TextureFormat::UNORM_SHORT_4444 ||
                texFormat.type == TextureFormat::UNORM_SHORT_5551);

    case GL_RGB:
        return texFormat.order == TextureFormat::RGB &&
               (texFormat.type == TextureFormat::UNORM_INT8 || texFormat.type == TextureFormat::UNORM_SHORT_565);

    case GL_LUMINANCE_ALPHA:
        return texFormat.order == TextureFormat::LA && texFormat.type == TextureFormat::UNORM_INT8;
    case GL_LUMINANCE:
        return texFormat.order == TextureFormat::L && texFormat.type == TextureFormat::UNORM_INT8;
    case GL_ALPHA:
        return texFormat.order == TextureFormat::A && texFormat.type == TextureFormat::UNORM_INT8;

        // Sized formats.

    default:
        return glu::mapGLInternalFormat(internalFormat) == texFormat;
    }
}
#endif // DE_DEBUG

static inline bool compileShader(const uint32_t shaderGL)
{
    glCompileShader(shaderGL);

    int success = GL_FALSE;
    glGetShaderiv(shaderGL, GL_COMPILE_STATUS, &success);

    return success == GL_TRUE;
}

static inline bool linkProgram(const uint32_t programGL)
{
    glLinkProgram(programGL);

    int success = GL_FALSE;
    glGetProgramiv(programGL, GL_LINK_STATUS, &success);

    return success == GL_TRUE;
}

static inline string getShaderInfoLog(const uint32_t shaderGL)
{
    int infoLogLen = 0;
    vector<char> infoLog;
    glGetShaderiv(shaderGL, GL_INFO_LOG_LENGTH, &infoLogLen);
    infoLog.resize(infoLogLen + 1);
    glGetShaderInfoLog(shaderGL, (int)infoLog.size(), DE_NULL, &infoLog[0]);
    return &infoLog[0];
}

static inline string getProgramInfoLog(const uint32_t programGL)
{
    int infoLogLen = 0;
    vector<char> infoLog;
    glGetProgramiv(programGL, GL_INFO_LOG_LENGTH, &infoLogLen);
    infoLog.resize(infoLogLen + 1);
    glGetProgramInfoLog(programGL, (int)infoLog.size(), DE_NULL, &infoLog[0]);
    return &infoLog[0];
}

namespace LongStressCaseInternal
{

// A hacky-ish class for drawing text on screen as GL quads.
class DebugInfoRenderer
{
public:
    DebugInfoRenderer(const glu::RenderContext &ctx);
    ~DebugInfoRenderer(void)
    {
        delete m_prog;
    }

    void drawInfo(uint64_t secondsElapsed, int texMem, int maxTexMem, int bufMem, int maxBufMem, int iterNdx);

private:
    DebugInfoRenderer(const DebugInfoRenderer &);
    DebugInfoRenderer &operator=(const DebugInfoRenderer &);

    void render(void);
    void addTextToBuffer(const string &text, int yOffset);

    const glu::RenderContext &m_ctx;
    const glu::ShaderProgram *m_prog;
    vector<float> m_posBuf;
    vector<uint16_t> m_ndxBuf;
};

void DebugInfoRenderer::drawInfo(const uint64_t secondsElapsed, const int texMem, const int maxTexMem, const int bufMem,
                                 const int maxBufMem, const int iterNdx)
{
    const uint64_t m = secondsElapsed / 60;
    const uint64_t h = m / 60;
    const uint64_t d = h / 24;

    {
        std::ostringstream text;

        text << std::setw(2) << std::setfill('0') << d << ":" << std::setw(2) << std::setfill('0') << h % 24 << ":"
             << std::setw(2) << std::setfill('0') << m % 60 << ":" << std::setw(2) << std::setfill('0')
             << secondsElapsed % 60;
        addTextToBuffer(text.str(), 0);
        text.str("");

        text << std::fixed << std::setprecision(2) << (float)texMem / Mi << "/" << (float)maxTexMem / Mi;
        addTextToBuffer(text.str(), 1);
        text.str("");

        text << std::fixed << std::setprecision(2) << (float)bufMem / Mi << "/" << (float)maxBufMem / Mi;
        addTextToBuffer(text.str(), 2);
        text.str("");

        text << std::setw(0) << iterNdx;
        addTextToBuffer(text.str(), 3);
    }

    render();
}

DebugInfoRenderer::DebugInfoRenderer(const glu::RenderContext &ctx) : m_ctx(ctx), m_prog(DE_NULL)
{
    DE_ASSERT(!m_prog);
    m_prog = new glu::ShaderProgram(ctx, glu::makeVtxFragSources("attribute highp vec2 a_pos;\n"
                                                                 "void main (void)\n"
                                                                 "{\n"
                                                                 "    gl_Position = vec4(a_pos, -1.0, 1.0);\n"
                                                                 "}\n",

                                                                 "void main(void)\n"
                                                                 "{\n"
                                                                 "    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
                                                                 "}\n"));
}

void DebugInfoRenderer::addTextToBuffer(const string &text, const int yOffset)
{
    static const char characters[] = "0123456789.:/";
    const int numCharacters        = DE_LENGTH_OF_ARRAY(characters) - 1; // \note -1 for null byte.
    const int charWid              = 6;
    const int charHei              = 6;
    static const string charsStr(characters);

    static const char font[numCharacters * charWid * charHei + 1] = " #### "
                                                                    "   #  "
                                                                    " #### "
                                                                    "##### "
                                                                    "   #  "
                                                                    "######"
                                                                    " #####"
                                                                    "######"
                                                                    " #### "
                                                                    " #### "
                                                                    "      "
                                                                    "  ##  "
                                                                    "     #"
                                                                    "#    #"
                                                                    "  ##  "
                                                                    "#    #"
                                                                    "     #"
                                                                    "  #   "
                                                                    "#     "
                                                                    "#     "
                                                                    "    # "
                                                                    "#    #"
                                                                    "#    #"
                                                                    "      "
                                                                    "  ##  "
                                                                    "    # "
                                                                    "#    #"
                                                                    "   #  "
                                                                    "    # "
                                                                    "  ### "
                                                                    " #  # "
                                                                    " #### "
                                                                    "# ### "
                                                                    "   #  "
                                                                    " #### "
                                                                    " #####"
                                                                    "      "
                                                                    "      "
                                                                    "   #  "
                                                                    "#    #"
                                                                    "   #  "
                                                                    "   #  "
                                                                    "     #"
                                                                    "######"
                                                                    "     #"
                                                                    "##   #"
                                                                    "  #   "
                                                                    "#    #"
                                                                    "     #"
                                                                    "      "
                                                                    "  ##  "
                                                                    "  #   "
                                                                    "#    #"
                                                                    "   #  "
                                                                    "  #   "
                                                                    "#    #"
                                                                    "    # "
                                                                    "#    #"
                                                                    "#    #"
                                                                    " #    "
                                                                    "#    #"
                                                                    "   ## "
                                                                    "  ##  "
                                                                    "  ##  "
                                                                    " #    "
                                                                    " #### "
                                                                    "  ### "
                                                                    "######"
                                                                    " #### "
                                                                    "    # "
                                                                    " #### "
                                                                    " #### "
                                                                    "#     "
                                                                    " #### "
                                                                    "###   "
                                                                    "  ##  "
                                                                    "      "
                                                                    "#     ";

    for (int ndxInText = 0; ndxInText < (int)text.size(); ndxInText++)
    {
        const int ndxInCharset = (int)charsStr.find(text[ndxInText]);
        DE_ASSERT(ndxInCharset < numCharacters);
        const int fontXStart = ndxInCharset * charWid;

        for (int y = 0; y < charHei; y++)
        {
            float ay = -1.0f + (float)(y + 0 + yOffset * (charHei + 2)) * 0.1f / (float)(charHei + 2);
            float by = -1.0f + (float)(y + 1 + yOffset * (charHei + 2)) * 0.1f / (float)(charHei + 2);
            for (int x = 0; x < charWid; x++)
            {
                // \note Text is mirrored in x direction since on most(?) mobile devices the image is mirrored(?).
                float ax = 1.0f - (float)(x + 0 + ndxInText * (charWid + 2)) * 0.1f / (float)(charWid + 2);
                float bx = 1.0f - (float)(x + 1 + ndxInText * (charWid + 2)) * 0.1f / (float)(charWid + 2);

                if (font[y * numCharacters * charWid + fontXStart + x] != ' ')
                {
                    const int vtxNdx = (int)m_posBuf.size() / 2;

                    m_ndxBuf.push_back(uint16_t(vtxNdx + 0));
                    m_ndxBuf.push_back(uint16_t(vtxNdx + 1));
                    m_ndxBuf.push_back(uint16_t(vtxNdx + 2));

                    m_ndxBuf.push_back(uint16_t(vtxNdx + 2));
                    m_ndxBuf.push_back(uint16_t(vtxNdx + 1));
                    m_ndxBuf.push_back(uint16_t(vtxNdx + 3));

                    m_posBuf.push_back(ax);
                    m_posBuf.push_back(ay);

                    m_posBuf.push_back(bx);
                    m_posBuf.push_back(ay);

                    m_posBuf.push_back(ax);
                    m_posBuf.push_back(by);

                    m_posBuf.push_back(bx);
                    m_posBuf.push_back(by);
                }
            }
        }
    }
}

void DebugInfoRenderer::render(void)
{
    const int prog   = m_prog->getProgram();
    const int posloc = glGetAttribLocation(prog, "a_pos");

    glUseProgram(prog);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    glEnableVertexAttribArray(posloc);
    glVertexAttribPointer(posloc, 2, GL_FLOAT, 0, 0, &m_posBuf[0]);
    glDrawElements(GL_TRIANGLES, (int)m_ndxBuf.size(), GL_UNSIGNED_SHORT, &m_ndxBuf[0]);
    glDisableVertexAttribArray(posloc);

    m_posBuf.clear();
    m_ndxBuf.clear();
}

/*--------------------------------------------------------------------*//*!
 * \brief Texture object helper class
 *
 * Each Texture owns a GL texture object that is created when the Texture
 * is constructed and deleted when it's destructed. The class provides some
 * convenience interface functions to e.g. upload texture data to the GL.
 *
 * In addition, the class tracks the approximate amount of GL memory likely
 * used by the corresponding GL texture object; get this with
 * getApproxMemUsage(). Also, getApproxMemUsageDiff() returns N-M, where N
 * is the value that getApproxMemUsage() would return after a call to
 * setData() with arguments corresponding to those given to
 * getApproxMemUsageDiff(), and M is the value currently returned by
 * getApproxMemUsage(). This can be used to check if we need to free some
 * other memory before performing the setData() call, in case we have an
 * upper limit on the amount of memory we want to use.
 *//*--------------------------------------------------------------------*/
class Texture
{
public:
    Texture(TextureType type);
    ~Texture(void);

    // Functions that may change the value returned by getApproxMemUsage().
    void setData(const ConstPixelBufferAccess &src, int width, int height, uint32_t internalFormat, bool useMipmap);

    // Functions that don't change the value returned by getApproxMemUsage().
    void setSubData(const ConstPixelBufferAccess &src, int xOff, int yOff, int width, int height) const;
    void toUnit(int unit) const;
    void setFilter(uint32_t min, uint32_t mag) const;
    void setWrap(uint32_t s, uint32_t t) const;

    int getApproxMemUsage(void) const
    {
        return m_dataSizeApprox;
    }
    int getApproxMemUsageDiff(int width, int height, uint32_t internalFormat, bool useMipmap) const;

private:
    Texture(const Texture &);            // Not allowed.
    Texture &operator=(const Texture &); // Not allowed.

    static uint32_t genTexture(void)
    {
        uint32_t tex = 0;
        glGenTextures(1, &tex);
        return tex;
    }

    uint32_t getGLBindTarget(void) const
    {
        DE_ASSERT(m_type == TEXTURETYPE_2D || m_type == TEXTURETYPE_CUBE);
        return m_type == TEXTURETYPE_2D ? GL_TEXTURE_2D : GL_TEXTURE_CUBE_MAP;
    }

    const TextureType m_type;
    const uint32_t m_textureGL;

    int m_numMipLevels;
    uint32_t m_internalFormat;
    int m_dataSizeApprox;
};

Texture::Texture(const TextureType type)
    : m_type(type)
    , m_textureGL(genTexture())
    , m_numMipLevels(0)
    , m_internalFormat(0)
    , m_dataSizeApprox(0)
{
}

Texture::~Texture(void)
{
    glDeleteTextures(1, &m_textureGL);
}

int Texture::getApproxMemUsageDiff(const int width, const int height, const uint32_t internalFormat,
                                   const bool useMipmap) const
{
    const int numLevels     = useMipmap ? deLog2Floor32(de::max(width, height)) + 1 : 1;
    const int pixelSize     = internalFormat == GL_RGBA  ? 4 :
                              internalFormat == GL_RGB   ? 3 :
                              internalFormat == GL_ALPHA ? 1 :
                                                           glu::mapGLInternalFormat(internalFormat).getPixelSize();
    int memUsageApproxAfter = 0;

    for (int level = 0; level < numLevels; level++)
        memUsageApproxAfter +=
            de::max(1, width >> level) * de::max(1, height >> level) * pixelSize * (m_type == TEXTURETYPE_CUBE ? 6 : 1);

    return memUsageApproxAfter - getApproxMemUsage();
}

void Texture::setData(const ConstPixelBufferAccess &src, const int width, const int height,
                      const uint32_t internalFormat, const bool useMipmap)
{
    DE_ASSERT(m_type != TEXTURETYPE_CUBE || width == height);
    DE_ASSERT(!useMipmap || (deIsPowerOfTwo32(width) && deIsPowerOfTwo32(height)));

    const TextureFormat &format        = src.getFormat();
    const glu::TransferFormat transfer = glu::getTransferFormat(format);

    m_numMipLevels = useMipmap ? deLog2Floor32(de::max(width, height)) + 1 : 1;

    m_internalFormat = internalFormat;
    m_dataSizeApprox = width * height * format.getPixelSize() * (m_type == TEXTURETYPE_CUBE ? 6 : 1);

    DE_ASSERT(src.getRowPitch() == format.getPixelSize() * src.getWidth());
    DE_ASSERT(isMatchingGLInternalFormat(internalFormat, format));
    DE_ASSERT(width <= src.getWidth() && height <= src.getHeight());

    glPixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(format));

    if (m_type == TEXTURETYPE_2D)
    {
        m_dataSizeApprox = 0;

        glBindTexture(GL_TEXTURE_2D, m_textureGL);
        for (int level = 0; level < m_numMipLevels; level++)
        {
            const int levelWid = de::max(1, width >> level);
            const int levelHei = de::max(1, height >> level);
            m_dataSizeApprox += levelWid * levelHei * format.getPixelSize();
            glTexImage2D(GL_TEXTURE_2D, level, internalFormat, levelWid, levelHei, 0, transfer.format,
                         transfer.dataType, src.getDataPtr());
        }
    }
    else if (m_type == TEXTURETYPE_CUBE)
    {
        m_dataSizeApprox = 0;

        glBindTexture(GL_TEXTURE_CUBE_MAP, m_textureGL);
        for (int level = 0; level < m_numMipLevels; level++)
        {
            const int levelWid = de::max(1, width >> level);
            const int levelHei = de::max(1, height >> level);
            m_dataSizeApprox += 6 * levelWid * levelHei * format.getPixelSize();
            for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
                glTexImage2D(cubeFaceToGLFace((CubeFace)face), level, internalFormat, levelWid, levelHei, 0,
                             transfer.format, transfer.dataType, src.getDataPtr());
        }
    }
    else
        DE_ASSERT(false);
}

void Texture::setSubData(const ConstPixelBufferAccess &src, const int xOff, const int yOff, const int width,
                         const int height) const
{
    const TextureFormat &format        = src.getFormat();
    const glu::TransferFormat transfer = glu::getTransferFormat(format);

    DE_ASSERT(src.getRowPitch() == format.getPixelSize() * src.getWidth());
    DE_ASSERT(isMatchingGLInternalFormat(m_internalFormat, format));
    DE_ASSERT(width <= src.getWidth() && height <= src.getHeight());

    glPixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(format));

    if (m_type == TEXTURETYPE_2D)
    {
        glBindTexture(GL_TEXTURE_2D, m_textureGL);
        for (int level = 0; level < m_numMipLevels; level++)
            glTexSubImage2D(GL_TEXTURE_2D, level, xOff >> level, yOff >> level, de::max(1, width >> level),
                            de::max(1, height >> level), transfer.format, transfer.dataType, src.getDataPtr());
    }
    else if (m_type == TEXTURETYPE_CUBE)
    {
        glBindTexture(GL_TEXTURE_CUBE_MAP, m_textureGL);
        for (int level = 0; level < m_numMipLevels; level++)
        {
            for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
                glTexSubImage2D(cubeFaceToGLFace((CubeFace)face), level, xOff >> level, yOff >> level,
                                de::max(1, width >> level), de::max(1, height >> level), transfer.format,
                                transfer.dataType, src.getDataPtr());
        }
    }
    else
        DE_ASSERT(false);
}

void Texture::setFilter(const uint32_t min, const uint32_t mag) const
{
    glBindTexture(getGLBindTarget(), m_textureGL);
    glTexParameteri(getGLBindTarget(), GL_TEXTURE_MIN_FILTER, min);
    glTexParameteri(getGLBindTarget(), GL_TEXTURE_MAG_FILTER, mag);
}

void Texture::setWrap(const uint32_t s, const uint32_t t) const
{
    glBindTexture(getGLBindTarget(), m_textureGL);
    glTexParameteri(getGLBindTarget(), GL_TEXTURE_WRAP_S, s);
    glTexParameteri(getGLBindTarget(), GL_TEXTURE_WRAP_T, t);
}

void Texture::toUnit(const int unit) const
{
    glActiveTexture(GL_TEXTURE0 + unit);
    glBindTexture(getGLBindTarget(), m_textureGL);
}

/*--------------------------------------------------------------------*//*!
 * \brief Buffer object helper class
 *
 * Each Buffer owns a GL buffer object that is created when the Buffer
 * is constructed and deleted when it's destructed. The class provides some
 * convenience interface functions to e.g. upload buffer data to the GL.
 *
 * In addition, the class tracks the approximate amount of GL memory,
 * similarly to the Texture class (see above). The getApproxMemUsageDiff()
 * is also analoguous.
 *//*--------------------------------------------------------------------*/
class Buffer
{
public:
    Buffer(void);
    ~Buffer(void);

    // Functions that may change the value returned by getApproxMemUsage().
    template <typename T>
    void setData(const vector<T> &src, const uint32_t target, const uint32_t usage)
    {
        setData(&src[0], (int)(src.size() * sizeof(T)), target, usage);
    }
    void setData(const void *src, int size, uint32_t target, uint32_t usage);

    // Functions that don't change the value returned by getApproxMemUsage().
    template <typename T>
    void setSubData(const vector<T> &src, const int offsetElems, const int numElems, const uint32_t target)
    {
        setSubData(&src[offsetElems], offsetElems * (int)sizeof(T), numElems * (int)sizeof(T), target);
    }
    void setSubData(const void *src, int offsetBytes, int sizeBytes, uint32_t target) const;
    void bind(const uint32_t target) const
    {
        glBindBuffer(target, m_bufferGL);
    }

    int getApproxMemUsage(void) const
    {
        return m_dataSizeApprox;
    }
    template <typename T>
    int getApproxMemUsageDiff(const vector<T> &src) const
    {
        return getApproxMemUsageDiff((int)(src.size() * sizeof(T)));
    }
    int getApproxMemUsageDiff(const int sizeBytes) const
    {
        return sizeBytes - getApproxMemUsage();
    }

private:
    Buffer(const Buffer &);            // Not allowed.
    Buffer &operator=(const Buffer &); // Not allowed.

    static uint32_t genBuffer(void)
    {
        uint32_t buf = 0;
        glGenBuffers(1, &buf);
        return buf;
    }

    const uint32_t m_bufferGL;
    int m_dataSizeApprox;
};

Buffer::Buffer(void) : m_bufferGL(genBuffer()), m_dataSizeApprox(0)
{
}

Buffer::~Buffer(void)
{
    glDeleteBuffers(1, &m_bufferGL);
}

void Buffer::setData(const void *const src, const int size, const uint32_t target, const uint32_t usage)
{
    bind(target);
    glBufferData(target, size, src, usage);
    glBindBuffer(target, 0);

    m_dataSizeApprox = size;
}

void Buffer::setSubData(const void *const src, const int offsetBytes, const int sizeBytes, const uint32_t target) const
{
    bind(target);
    glBufferSubData(target, offsetBytes, sizeBytes, src);
    glBindBuffer(target, 0);
}

class Program
{
public:
    Program(void);
    ~Program(void);

    void setSources(const string &vertSource, const string &fragSource);
    void build(TestLog &log);
    void use(void) const
    {
        DE_ASSERT(m_isBuilt);
        glUseProgram(m_programGL);
    }
    void setRandomUniforms(const vector<VarSpec> &uniforms, const string &shaderNameManglingSuffix, Random &rnd) const;
    void setAttribute(const Buffer &attrBuf, int attrBufOffset, const VarSpec &attrSpec,
                      const string &shaderNameManglingSuffix) const;
    void setAttributeClientMem(const void *attrData, const VarSpec &attrSpec,
                               const string &shaderNameManglingSuffix) const;
    void disableAttributeArray(const VarSpec &attrSpec, const string &shaderNameManglingSuffix) const;

private:
    Program(const Program &);            // Not allowed.
    Program &operator=(const Program &); // Not allowed.

    string m_vertSource;
    string m_fragSource;

    const uint32_t m_vertShaderGL;
    const uint32_t m_fragShaderGL;
    const uint32_t m_programGL;
    bool m_hasSources;
    bool m_isBuilt;
};

Program::Program(void)
    : m_vertShaderGL(glCreateShader(GL_VERTEX_SHADER))
    , m_fragShaderGL(glCreateShader(GL_FRAGMENT_SHADER))
    , m_programGL(glCreateProgram())
    , m_hasSources(false)
    , m_isBuilt(false)
{
    glAttachShader(m_programGL, m_vertShaderGL);
    glAttachShader(m_programGL, m_fragShaderGL);
}

Program::~Program(void)
{
    glDeleteShader(m_vertShaderGL);
    glDeleteShader(m_fragShaderGL);
    glDeleteProgram(m_programGL);
}

void Program::setSources(const string &vertSource, const string &fragSource)
{
    const char *const vertSourceCstr = vertSource.c_str();
    const char *const fragSourceCstr = fragSource.c_str();

    m_vertSource = vertSource;
    m_fragSource = fragSource;

    // \note In GLES2 api the source parameter type lacks one const.
    glShaderSource(m_vertShaderGL, 1, (const char **)&vertSourceCstr, DE_NULL);
    glShaderSource(m_fragShaderGL, 1, (const char **)&fragSourceCstr, DE_NULL);

    m_hasSources = true;
}

void Program::build(TestLog &log)
{
    DE_ASSERT(m_hasSources);

    const bool vertCompileOk = compileShader(m_vertShaderGL);
    const bool fragCompileOk = compileShader(m_fragShaderGL);
    const bool attemptLink   = vertCompileOk && fragCompileOk;
    const bool linkOk        = attemptLink && linkProgram(m_programGL);

    if (!(vertCompileOk && fragCompileOk && linkOk))
    {
        log << TestLog::ShaderProgram(linkOk, attemptLink ? getProgramInfoLog(m_programGL) : string(""))
            << TestLog::Shader(QP_SHADER_TYPE_VERTEX, m_vertSource, vertCompileOk, getShaderInfoLog(m_vertShaderGL))
            << TestLog::Shader(QP_SHADER_TYPE_FRAGMENT, m_fragSource, fragCompileOk, getShaderInfoLog(m_fragShaderGL))
            << TestLog::EndShaderProgram;

        throw tcu::TestError("Program build failed");
    }

    m_isBuilt = true;
}

void Program::setRandomUniforms(const vector<VarSpec> &uniforms, const string &shaderNameManglingSuffix,
                                Random &rnd) const
{
    use();

    for (int unifNdx = 0; unifNdx < (int)uniforms.size(); unifNdx++)
    {
        const VarSpec &spec      = uniforms[unifNdx];
        const int typeScalarSize = glu::getDataTypeScalarSize(spec.type);
        const int location =
            glGetUniformLocation(m_programGL, mangleShaderNames(spec.name, shaderNameManglingSuffix).c_str());
        if (location < 0)
            continue;

        if (glu::isDataTypeFloatOrVec(spec.type))
        {
            float val[4];
            for (int i = 0; i < typeScalarSize; i++)
                val[i] = rnd.getFloat(spec.minValue.f[i], spec.maxValue.f[i]);

            switch (spec.type)
            {
            case glu::TYPE_FLOAT:
                glUniform1f(location, val[0]);
                break;
            case glu::TYPE_FLOAT_VEC2:
                glUniform2f(location, val[0], val[1]);
                break;
            case glu::TYPE_FLOAT_VEC3:
                glUniform3f(location, val[0], val[1], val[2]);
                break;
            case glu::TYPE_FLOAT_VEC4:
                glUniform4f(location, val[0], val[1], val[2], val[3]);
                break;
            default:
                DE_ASSERT(false);
            }
        }
        else if (glu::isDataTypeMatrix(spec.type))
        {
            float val[4 * 4];
            for (int i = 0; i < typeScalarSize; i++)
                val[i] = rnd.getFloat(spec.minValue.f[i], spec.maxValue.f[i]);

            switch (spec.type)
            {
            case glu::TYPE_FLOAT_MAT2:
                glUniformMatrix2fv(location, 1, GL_FALSE, &val[0]);
                break;
            case glu::TYPE_FLOAT_MAT3:
                glUniformMatrix3fv(location, 1, GL_FALSE, &val[0]);
                break;
            case glu::TYPE_FLOAT_MAT4:
                glUniformMatrix4fv(location, 1, GL_FALSE, &val[0]);
                break;
            case glu::TYPE_FLOAT_MAT2X3:
                glUniformMatrix2x3fv(location, 1, GL_FALSE, &val[0]);
                break;
            case glu::TYPE_FLOAT_MAT2X4:
                glUniformMatrix2x4fv(location, 1, GL_FALSE, &val[0]);
                break;
            case glu::TYPE_FLOAT_MAT3X2:
                glUniformMatrix3x2fv(location, 1, GL_FALSE, &val[0]);
                break;
            case glu::TYPE_FLOAT_MAT3X4:
                glUniformMatrix3x4fv(location, 1, GL_FALSE, &val[0]);
                break;
            case glu::TYPE_FLOAT_MAT4X2:
                glUniformMatrix4x2fv(location, 1, GL_FALSE, &val[0]);
                break;
            case glu::TYPE_FLOAT_MAT4X3:
                glUniformMatrix4x3fv(location, 1, GL_FALSE, &val[0]);
                break;
            default:
                DE_ASSERT(false);
            }
        }
        else if (glu::isDataTypeIntOrIVec(spec.type))
        {
            int val[4];
            for (int i = 0; i < typeScalarSize; i++)
                val[i] = rnd.getInt(spec.minValue.i[i], spec.maxValue.i[i]);

            switch (spec.type)
            {
            case glu::TYPE_INT:
                glUniform1i(location, val[0]);
                break;
            case glu::TYPE_INT_VEC2:
                glUniform2i(location, val[0], val[1]);
                break;
            case glu::TYPE_INT_VEC3:
                glUniform3i(location, val[0], val[1], val[2]);
                break;
            case glu::TYPE_INT_VEC4:
                glUniform4i(location, val[0], val[1], val[2], val[3]);
                break;
            default:
                DE_ASSERT(false);
            }
        }
        else if (glu::isDataTypeUintOrUVec(spec.type))
        {
            uint32_t val[4];
            for (int i = 0; i < typeScalarSize; i++)
            {
                DE_ASSERT(spec.minValue.i[i] >= 0 && spec.maxValue.i[i] >= 0);
                val[i] = (uint32_t)rnd.getInt(spec.minValue.i[i], spec.maxValue.i[i]);
            }

            switch (spec.type)
            {
            case glu::TYPE_UINT:
                glUniform1ui(location, val[0]);
                break;
            case glu::TYPE_UINT_VEC2:
                glUniform2ui(location, val[0], val[1]);
                break;
            case glu::TYPE_UINT_VEC3:
                glUniform3ui(location, val[0], val[1], val[2]);
                break;
            case glu::TYPE_UINT_VEC4:
                glUniform4ui(location, val[0], val[1], val[2], val[3]);
                break;
            default:
                DE_ASSERT(false);
            }
        }
        else
            DE_ASSERT(false);
    }
}

void Program::setAttribute(const Buffer &attrBuf, const int attrBufOffset, const VarSpec &attrSpec,
                           const string &shaderNameManglingSuffix) const
{
    const int attrLoc =
        glGetAttribLocation(m_programGL, mangleShaderNames(attrSpec.name, shaderNameManglingSuffix).c_str());

    glEnableVertexAttribArray(attrLoc);
    attrBuf.bind(GL_ARRAY_BUFFER);

    if (glu::isDataTypeFloatOrVec(attrSpec.type))
        glVertexAttribPointer(attrLoc, glu::getDataTypeScalarSize(attrSpec.type), GL_FLOAT, GL_FALSE, 0,
                              (GLvoid *)(intptr_t)attrBufOffset);
    else
        DE_ASSERT(false);
}

void Program::setAttributeClientMem(const void *const attrData, const VarSpec &attrSpec,
                                    const string &shaderNameManglingSuffix) const
{
    const int attrLoc =
        glGetAttribLocation(m_programGL, mangleShaderNames(attrSpec.name, shaderNameManglingSuffix).c_str());

    glEnableVertexAttribArray(attrLoc);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    if (glu::isDataTypeFloatOrVec(attrSpec.type))
        glVertexAttribPointer(attrLoc, glu::getDataTypeScalarSize(attrSpec.type), GL_FLOAT, GL_FALSE, 0, attrData);
    else
        DE_ASSERT(false);
}

void Program::disableAttributeArray(const VarSpec &attrSpec, const string &shaderNameManglingSuffix) const
{
    const int attrLoc =
        glGetAttribLocation(m_programGL, mangleShaderNames(attrSpec.name, shaderNameManglingSuffix).c_str());

    glDisableVertexAttribArray(attrLoc);
}

/*--------------------------------------------------------------------*//*!
 * \brief Container class for managing GL objects
 *
 * GLObjectManager can be used for objects of class Program, Buffer or
 * Texture. In the manager, each such object is associated with a name that
 * is used to access it.
 *
 * In addition to the making, getting and removing functions, the manager
 * supports marking objects as "garbage", meaning they're not yet
 * destroyed, but can be later destroyed with removeRandomGarbage(). The
 * idea is that if we want to stress test with high memory usage, we can
 * continuously move objects to garbage after using them, and when a memory
 * limit is reached, we can call removeGarbageUntilUnder(limit, rnd). This
 * way we can approximately keep our memory usage at just under the wanted
 * limit.
 *
 * The manager also supports querying the approximate amount of GL memory
 * used by its objects.
 *
 * \note The memory usage related functions are not currently supported
 *         for Program objects.
 *//*--------------------------------------------------------------------*/
template <typename T>
class GLObjectManager
{
public:
    void make(const string &name)
    {
        DE_ASSERT(!has(name));
        m_objects[name] = SharedPtr<T>(new T);
    }
    void make(const string &name, gls::TextureType texType)
    {
        DE_ASSERT(!has(name));
        m_objects[name] = SharedPtr<T>(new T(texType));
    }
    bool has(const string &name) const
    {
        return m_objects.find(name) != m_objects.end();
    }
    const T &get(const string &name) const;
    T &get(const string &name)
    {
        return const_cast<T &>(((const GLObjectManager<T> *)this)->get(name));
    }
    void remove(const string &name)
    {
        const int removed = (int)m_objects.erase(name);
        DE_ASSERT(removed);
        DE_UNREF(removed);
    }
    int computeApproxMemUsage(void) const;
    void markAsGarbage(const string &name);
    int removeRandomGarbage(Random &rnd);
    void removeGarbageUntilUnder(int limit, Random &rnd);

private:
    static const char *objTypeName(void);

    map<string, SharedPtr<T>> m_objects;
    vector<SharedPtr<T>> m_garbageObjects;
};

template <>
const char *GLObjectManager<Buffer>::objTypeName(void)
{
    return "buffer";
}
template <>
const char *GLObjectManager<Texture>::objTypeName(void)
{
    return "texture";
}
template <>
const char *GLObjectManager<Program>::objTypeName(void)
{
    return "program";
}

template <typename T>
const T &GLObjectManager<T>::get(const string &name) const
{
    const typename map<string, SharedPtr<T>>::const_iterator it = m_objects.find(name);
    DE_ASSERT(it != m_objects.end());
    return *it->second;
}

template <typename T>
int GLObjectManager<T>::computeApproxMemUsage(void) const
{
    int result = 0;

    for (typename map<string, SharedPtr<T>>::const_iterator it = m_objects.begin(); it != m_objects.end(); ++it)
        result += it->second->getApproxMemUsage();

    for (typename vector<SharedPtr<T>>::const_iterator it = m_garbageObjects.begin(); it != m_garbageObjects.end();
         ++it)
        result += (*it)->getApproxMemUsage();

    return result;
}

template <typename T>
void GLObjectManager<T>::markAsGarbage(const string &name)
{
    const typename map<string, SharedPtr<T>>::iterator it = m_objects.find(name);
    DE_ASSERT(it != m_objects.end());
    m_garbageObjects.push_back(it->second);
    m_objects.erase(it);
}

template <typename T>
int GLObjectManager<T>::removeRandomGarbage(Random &rnd)
{
    if (m_garbageObjects.empty())
        return -1;

    const int removeNdx   = rnd.getInt(0, (int)m_garbageObjects.size() - 1);
    const int memoryFreed = m_garbageObjects[removeNdx]->getApproxMemUsage();
    m_garbageObjects.erase(m_garbageObjects.begin() + removeNdx);
    return memoryFreed;
}

template <typename T>
void GLObjectManager<T>::removeGarbageUntilUnder(const int limit, Random &rnd)
{
    int memUsage = computeApproxMemUsage();

    while (memUsage > limit)
    {
        const int memReleased = removeRandomGarbage(rnd);
        if (memReleased < 0)
            throw tcu::InternalError(string("") + "Given " + objTypeName() +
                                     " memory usage limit exceeded, and no unneeded " + objTypeName() +
                                     " resources available to release");
        memUsage -= memReleased;
        DE_ASSERT(memUsage == computeApproxMemUsage());
    }
}

} // namespace LongStressCaseInternal

using namespace LongStressCaseInternal;

static int generateRandomAttribData(vector<uint8_t> &attrDataBuf, int &dataSizeBytesDst, const VarSpec &attrSpec,
                                    const int numVertices, Random &rnd)
{
    const bool isFloat      = glu::isDataTypeFloatOrVec(attrSpec.type);
    const int numComponents = glu::getDataTypeScalarSize(attrSpec.type);
    const int componentSize = (int)(isFloat ? sizeof(GLfloat) : sizeof(GLint));
    const int offsetInBuf   = nextDivisible((int)attrDataBuf.size(), componentSize); // Round up for alignment.

    DE_STATIC_ASSERT(sizeof(GLint) == sizeof(int));
    DE_STATIC_ASSERT(sizeof(GLfloat) == sizeof(float));

    dataSizeBytesDst = numComponents * componentSize * numVertices;

    attrDataBuf.resize(offsetInBuf + dataSizeBytesDst);

    if (isFloat)
    {
        float *const data = (float *)&attrDataBuf[offsetInBuf];

        for (int vtxNdx = 0; vtxNdx < numVertices; vtxNdx++)
            for (int compNdx = 0; compNdx < numComponents; compNdx++)
                data[vtxNdx * numComponents + compNdx] =
                    rnd.getFloat(attrSpec.minValue.f[compNdx], attrSpec.maxValue.f[compNdx]);
    }
    else
    {
        DE_ASSERT(glu::isDataTypeIntOrIVec(attrSpec.type));

        int *const data = (int *)&attrDataBuf[offsetInBuf];

        for (int vtxNdx = 0; vtxNdx < numVertices; vtxNdx++)
            for (int compNdx = 0; compNdx < numComponents; compNdx++)
                data[vtxNdx * numComponents + compNdx] =
                    rnd.getInt(attrSpec.minValue.i[compNdx], attrSpec.maxValue.i[compNdx]);
    }

    return offsetInBuf;
}

static int generateRandomPositionAttribData(vector<uint8_t> &attrDataBuf, int &dataSizeBytesDst,
                                            const VarSpec &attrSpec, const int numVertices, Random &rnd)
{
    DE_ASSERT(glu::isDataTypeFloatOrVec(attrSpec.type));

    const int numComponents = glu::getDataTypeScalarSize(attrSpec.type);
    DE_ASSERT(numComponents >= 2);
    const int offsetInBuf = generateRandomAttribData(attrDataBuf, dataSizeBytesDst, attrSpec, numVertices, rnd);

    if (numComponents > 2)
    {
        float *const data = (float *)&attrDataBuf[offsetInBuf];

        for (int vtxNdx = 0; vtxNdx < numVertices; vtxNdx++)
            data[vtxNdx * numComponents + 2] = -1.0f;

        for (int triNdx = 0; triNdx < numVertices - 2; triNdx++)
        {
            float *const vtxAComps = &data[(triNdx + 0) * numComponents];
            float *const vtxBComps = &data[(triNdx + 1) * numComponents];
            float *const vtxCComps = &data[(triNdx + 2) * numComponents];

            const float triArea = triangleArea(Vec2(vtxAComps[0], vtxAComps[1]), Vec2(vtxBComps[0], vtxBComps[1]),
                                               Vec2(vtxCComps[0], vtxCComps[1]));
            const float t       = triArea / (triArea + 1.0f);
            const float z       = (1.0f - t) * attrSpec.minValue.f[2] + t * attrSpec.maxValue.f[2];

            vtxAComps[2] = de::max(vtxAComps[2], z);
            vtxBComps[2] = de::max(vtxBComps[2], z);
            vtxCComps[2] = de::max(vtxCComps[2], z);
        }
    }

    return offsetInBuf;
}

static void generateAttribs(vector<uint8_t> &attrDataBuf, vector<int> &attrDataOffsets, vector<int> &attrDataSizes,
                            const vector<VarSpec> &attrSpecs, const string &posAttrName, const int numVertices,
                            Random &rnd)
{
    attrDataBuf.clear();
    attrDataOffsets.clear();
    attrDataSizes.resize(attrSpecs.size());

    for (int i = 0; i < (int)attrSpecs.size(); i++)
    {
        if (attrSpecs[i].name == posAttrName)
            attrDataOffsets.push_back(
                generateRandomPositionAttribData(attrDataBuf, attrDataSizes[i], attrSpecs[i], numVertices, rnd));
        else
            attrDataOffsets.push_back(
                generateRandomAttribData(attrDataBuf, attrDataSizes[i], attrSpecs[i], numVertices, rnd));
    }
}

LongStressCase::LongStressCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *const name,
                               const char *const desc, const int maxTexMemoryUsageBytes,
                               const int maxBufMemoryUsageBytes, const int numDrawCallsPerIteration,
                               const int numTrianglesPerDrawCall, const vector<ProgramContext> &programContexts,
                               const FeatureProbabilities &probabilities, const uint32_t indexBufferUsage,
                               const uint32_t attrBufferUsage, const int redundantBufferFactor,
                               const bool showDebugInfo)
    : tcu::TestCase(testCtx, name, desc)
    , m_renderCtx(renderCtx)
    , m_maxTexMemoryUsageBytes(maxTexMemoryUsageBytes)
    , m_maxBufMemoryUsageBytes(maxBufMemoryUsageBytes)
    , m_numDrawCallsPerIteration(numDrawCallsPerIteration)
    , m_numTrianglesPerDrawCall(numTrianglesPerDrawCall)
    , m_numVerticesPerDrawCall(numTrianglesPerDrawCall + 2) // \note Triangle strips are used.
    , m_programContexts(programContexts)
    , m_probabilities(probabilities)
    , m_indexBufferUsage(indexBufferUsage)
    , m_attrBufferUsage(attrBufferUsage)
    , m_redundantBufferFactor(redundantBufferFactor)
    , m_showDebugInfo(showDebugInfo)
    , m_numIterations(getNumIterations(testCtx, 5))
    , m_isGLES3(contextSupports(renderCtx.getType(), glu::ApiType::es(3, 0)))
    , m_currentIteration(0)
    , m_startTimeSeconds((uint64_t)-1)
    , m_lastLogTime((uint64_t)-1)
    , m_lastLogIteration(0)
    , m_currentLogEntryNdx(0)
    , m_rnd(deStringHash(getName()) ^ testCtx.getCommandLine().getBaseSeed())
    , m_programs(DE_NULL)
    , m_buffers(DE_NULL)
    , m_textures(DE_NULL)
    , m_debugInfoRenderer(DE_NULL)
{
    DE_ASSERT(m_numVerticesPerDrawCall <=
              (int)std::numeric_limits<uint16_t>::max() + 1); // \note Vertices are referred to with 16-bit indices.
    DE_ASSERT(m_redundantBufferFactor > 0);
}

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

void LongStressCase::init(void)
{
    // Generate unused texture data for each texture spec in m_programContexts.

    DE_ASSERT(!m_programContexts.empty());
    DE_ASSERT(m_programResources.empty());
    m_programResources.resize(m_programContexts.size());

    for (int progCtxNdx = 0; progCtxNdx < (int)m_programContexts.size(); progCtxNdx++)
    {
        const ProgramContext &progCtx = m_programContexts[progCtxNdx];
        ProgramResources &progRes     = m_programResources[progCtxNdx];

        for (int texSpecNdx = 0; texSpecNdx < (int)progCtx.textureSpecs.size(); texSpecNdx++)
        {
            const TextureSpec &spec    = progCtx.textureSpecs[texSpecNdx];
            const TextureFormat format = glu::mapGLTransferFormat(spec.format, spec.dataType);

            // If texture data with the same format has already been generated, re-use that (don't care much about contents).

            SharedPtr<TextureLevel> unusedTex;

            for (int prevProgCtxNdx = 0; prevProgCtxNdx < (int)m_programResources.size(); prevProgCtxNdx++)
            {
                const vector<SharedPtr<TextureLevel>> &prevProgCtxTextures =
                    m_programResources[prevProgCtxNdx].unusedTextures;

                for (int texNdx = 0; texNdx < (int)prevProgCtxTextures.size(); texNdx++)
                {
                    if (prevProgCtxTextures[texNdx]->getFormat() == format)
                    {
                        unusedTex = prevProgCtxTextures[texNdx];
                        break;
                    }
                }
            }

            if (!unusedTex)
                unusedTex = SharedPtr<TextureLevel>(new TextureLevel(format));

            if (unusedTex->getWidth() < spec.width || unusedTex->getHeight() < spec.height)
            {
                unusedTex->setSize(spec.width, spec.height);
                tcu::fillWithComponentGradients(unusedTex->getAccess(), spec.minValue, spec.maxValue);
            }

            progRes.unusedTextures.push_back(unusedTex);
        }
    }

    m_vertexIndices.clear();
    for (int i = 0; i < m_numVerticesPerDrawCall; i++)
        m_vertexIndices.push_back((uint16_t)i);
    m_rnd.shuffle(m_vertexIndices.begin(), m_vertexIndices.end());

    DE_ASSERT(!m_programs && !m_buffers && !m_textures);
    m_programs = new GLObjectManager<Program>;
    m_buffers  = new GLObjectManager<Buffer>;
    m_textures = new GLObjectManager<Texture>;

    m_currentIteration = 0;

    {
        TestLog &log = m_testCtx.getLog();

        log << TestLog::Message
            << "Number of iterations: " << (m_numIterations > 0 ? toString(m_numIterations) : "infinite")
            << TestLog::EndMessage << TestLog::Message
            << "Number of draw calls per iteration: " << m_numDrawCallsPerIteration << TestLog::EndMessage
            << TestLog::Message << "Number of triangles per draw call: " << m_numTrianglesPerDrawCall
            << TestLog::EndMessage << TestLog::Message << "Using triangle strips" << TestLog::EndMessage
            << TestLog::Message
            << "Approximate texture memory usage limit: " << de::floatToString((float)m_maxTexMemoryUsageBytes / Mi, 2)
            << " MiB" << TestLog::EndMessage << TestLog::Message
            << "Approximate buffer memory usage limit: " << de::floatToString((float)m_maxBufMemoryUsageBytes / Mi, 2)
            << " MiB" << TestLog::EndMessage << TestLog::Message
            << "Default vertex attribute data buffer usage parameter: " << glu::getUsageName(m_attrBufferUsage)
            << TestLog::EndMessage << TestLog::Message
            << "Default vertex index data buffer usage parameter: " << glu::getUsageName(m_indexBufferUsage)
            << TestLog::EndMessage

            << TestLog::Section("ProbabilityParams", "Per-iteration probability parameters") << TestLog::Message
            << "Program re-build: " << probabilityStr(m_probabilities.rebuildProgram) << TestLog::EndMessage
            << TestLog::Message << "Texture re-upload: " << probabilityStr(m_probabilities.reuploadTexture)
            << TestLog::EndMessage << TestLog::Message
            << "Buffer re-upload: " << probabilityStr(m_probabilities.reuploadBuffer) << TestLog::EndMessage
            << TestLog::Message << "Use glTexImage* instead of glTexSubImage* when uploading texture: "
            << probabilityStr(m_probabilities.reuploadWithTexImage) << TestLog::EndMessage << TestLog::Message
            << "Use glBufferData* instead of glBufferSubData* when uploading buffer: "
            << probabilityStr(m_probabilities.reuploadWithBufferData) << TestLog::EndMessage << TestLog::Message
            << "Delete texture after using it, even if could re-use it: "
            << probabilityStr(m_probabilities.deleteTexture) << TestLog::EndMessage << TestLog::Message
            << "Delete buffer after using it, even if could re-use it: " << probabilityStr(m_probabilities.deleteBuffer)
            << TestLog::EndMessage << TestLog::Message
            << "Don't re-use texture, and only delete if memory limit is hit: "
            << probabilityStr(m_probabilities.wastefulTextureMemoryUsage) << TestLog::EndMessage << TestLog::Message
            << "Don't re-use buffer, and only delete if memory limit is hit: "
            << probabilityStr(m_probabilities.wastefulBufferMemoryUsage) << TestLog::EndMessage << TestLog::Message
            << "Use client memory (instead of GL buffers) for vertex attribute data: "
            << probabilityStr(m_probabilities.clientMemoryAttributeData) << TestLog::EndMessage << TestLog::Message
            << "Use client memory (instead of GL buffers) for vertex index data: "
            << probabilityStr(m_probabilities.clientMemoryIndexData) << TestLog::EndMessage << TestLog::Message
            << "Use random target parameter when uploading buffer data: "
            << probabilityStr(m_probabilities.randomBufferUploadTarget) << TestLog::EndMessage << TestLog::Message
            << "Use random usage parameter when uploading buffer data: "
            << probabilityStr(m_probabilities.randomBufferUsage) << TestLog::EndMessage << TestLog::Message
            << "Use glDrawArrays instead of glDrawElements: " << probabilityStr(m_probabilities.useDrawArrays)
            << TestLog::EndMessage << TestLog::Message
            << "Use separate buffers for each attribute, instead of one array for all: "
            << probabilityStr(m_probabilities.separateAttributeBuffers) << TestLog::EndMessage << TestLog::EndSection
            << TestLog::Message << "Using " << m_programContexts.size() << " program(s)" << TestLog::EndMessage;

        bool anyProgramsFailed = false;
        for (int progCtxNdx = 0; progCtxNdx < (int)m_programContexts.size(); progCtxNdx++)
        {
            const ProgramContext &progCtx = m_programContexts[progCtxNdx];
            glu::ShaderProgram prog(m_renderCtx,
                                    glu::makeVtxFragSources(mangleShaderNames(progCtx.vertexSource, ""),
                                                            mangleShaderNames(progCtx.fragmentSource, "")));
            log << TestLog::Section("ShaderProgram" + toString(progCtxNdx), "Shader program " + toString(progCtxNdx))
                << prog << TestLog::EndSection;
            if (!prog.isOk())
                anyProgramsFailed = true;
        }

        if (anyProgramsFailed)
            throw tcu::TestError("One or more shader programs failed to compile");
    }

    DE_ASSERT(!m_debugInfoRenderer);
    if (m_showDebugInfo)
        m_debugInfoRenderer = new DebugInfoRenderer(m_renderCtx);
}

void LongStressCase::deinit(void)
{
    m_programResources.clear();

    delete m_programs;
    m_programs = DE_NULL;

    delete m_buffers;
    m_buffers = DE_NULL;

    delete m_textures;
    m_textures = DE_NULL;

    delete m_debugInfoRenderer;
    m_debugInfoRenderer = DE_NULL;
}

LongStressCase::IterateResult LongStressCase::iterate(void)
{
    TestLog &log                            = m_testCtx.getLog();
    const int renderWidth                   = m_renderCtx.getRenderTarget().getWidth();
    const int renderHeight                  = m_renderCtx.getRenderTarget().getHeight();
    const bool useClientMemoryIndexData     = m_rnd.getFloat() < m_probabilities.clientMemoryIndexData;
    const bool useDrawArrays                = m_rnd.getFloat() < m_probabilities.useDrawArrays;
    const bool separateAttributeBuffers     = m_rnd.getFloat() < m_probabilities.separateAttributeBuffers;
    const int progContextNdx                = m_rnd.getInt(0, (int)m_programContexts.size() - 1);
    const ProgramContext &programContext    = m_programContexts[progContextNdx];
    ProgramResources &programResources      = m_programResources[progContextNdx];
    const string programName                = "prog" + toString(progContextNdx);
    const string textureNamePrefix          = "tex" + toString(progContextNdx) + "_";
    const string unitedAttrBufferNamePrefix = "attrBuf" + toString(progContextNdx) + "_";
    const string indexBufferName            = "indexBuf" + toString(progContextNdx);
    const string separateAttrBufNamePrefix  = "attrBuf" + toString(progContextNdx) + "_";

    if (m_currentIteration == 0)
        m_lastLogTime = m_startTimeSeconds = deGetTime();

    // Make or re-compile programs.
    {
        const bool hadProgram = m_programs->has(programName);

        if (!hadProgram)
            m_programs->make(programName);

        Program &prog = m_programs->get(programName);

        if (!hadProgram || m_rnd.getFloat() < m_probabilities.rebuildProgram)
        {
            programResources.shaderNameManglingSuffix =
                toString((uint16_t)deUint64Hash((uint64_t)m_currentIteration ^ deGetTime()));

            prog.setSources(
                mangleShaderNames(programContext.vertexSource, programResources.shaderNameManglingSuffix),
                mangleShaderNames(programContext.fragmentSource, programResources.shaderNameManglingSuffix));

            prog.build(log);
        }

        prog.use();
    }

    Program &program = m_programs->get(programName);

    // Make or re-upload textures.

    for (int texNdx = 0; texNdx < (int)programContext.textureSpecs.size(); texNdx++)
    {
        const string texName    = textureNamePrefix + toString(texNdx);
        const bool hadTexture   = m_textures->has(texName);
        const TextureSpec &spec = programContext.textureSpecs[texNdx];

        if (!hadTexture)
            m_textures->make(texName, spec.textureType);

        if (!hadTexture || m_rnd.getFloat() < m_probabilities.reuploadTexture)
        {
            Texture &texture = m_textures->get(texName);

            m_textures->removeGarbageUntilUnder(
                m_maxTexMemoryUsageBytes -
                    texture.getApproxMemUsageDiff(spec.width, spec.height, spec.internalFormat, spec.useMipmap),
                m_rnd);

            if (!hadTexture || m_rnd.getFloat() < m_probabilities.reuploadWithTexImage)
                texture.setData(programResources.unusedTextures[texNdx]->getAccess(), spec.width, spec.height,
                                spec.internalFormat, spec.useMipmap);
            else
                texture.setSubData(programResources.unusedTextures[texNdx]->getAccess(), 0, 0, spec.width, spec.height);

            texture.toUnit(0);
            texture.setWrap(spec.sWrap, spec.tWrap);
            texture.setFilter(spec.minFilter, spec.magFilter);
        }
    }

    // Bind textures to units, in random order (because when multiple texture specs have same unit, we want to pick one randomly).

    {
        vector<int> texSpecIndices(programContext.textureSpecs.size());
        for (int i = 0; i < (int)texSpecIndices.size(); i++)
            texSpecIndices[i] = i;
        m_rnd.shuffle(texSpecIndices.begin(), texSpecIndices.end());
        for (int i = 0; i < (int)texSpecIndices.size(); i++)
            m_textures->get(textureNamePrefix + toString(texSpecIndices[i]))
                .toUnit(programContext.textureSpecs[i].textureUnit);
    }

    // Make or re-upload index buffer.

    if (!useDrawArrays)
    {
        m_rnd.shuffle(m_vertexIndices.begin(), m_vertexIndices.end());

        if (!useClientMemoryIndexData)
        {
            const bool hadIndexBuffer = m_buffers->has(indexBufferName);

            if (!hadIndexBuffer)
                m_buffers->make(indexBufferName);

            Buffer &indexBuf = m_buffers->get(indexBufferName);

            if (!hadIndexBuffer || m_rnd.getFloat() < m_probabilities.reuploadBuffer)
            {
                m_buffers->removeGarbageUntilUnder(
                    m_maxBufMemoryUsageBytes - indexBuf.getApproxMemUsageDiff(m_vertexIndices), m_rnd);
                const uint32_t target = m_rnd.getFloat() < m_probabilities.randomBufferUploadTarget ?
                                            randomBufferTarget(m_rnd, m_isGLES3) :
                                            GL_ELEMENT_ARRAY_BUFFER;

                if (!hadIndexBuffer || m_rnd.getFloat() < m_probabilities.reuploadWithBufferData)
                    indexBuf.setData(m_vertexIndices, target,
                                     m_rnd.getFloat() < m_probabilities.randomBufferUsage ?
                                         randomBufferUsage(m_rnd, m_isGLES3) :
                                         m_indexBufferUsage);
                else
                    indexBuf.setSubData(m_vertexIndices, 0, m_numVerticesPerDrawCall, target);
            }
        }
    }

    // Set vertex attributes. If not using client-memory data, make or re-upload attribute buffers.

    generateAttribs(programResources.attrDataBuf, programResources.attrDataOffsets, programResources.attrDataSizes,
                    programContext.attributes, programContext.positionAttrName, m_numVerticesPerDrawCall, m_rnd);

    if (!(m_rnd.getFloat() < m_probabilities.clientMemoryAttributeData))
    {
        if (separateAttributeBuffers)
        {
            for (int attrNdx = 0; attrNdx < (int)programContext.attributes.size(); attrNdx++)
            {
                const int usedRedundantBufferNdx = m_rnd.getInt(0, m_redundantBufferFactor - 1);

                for (int redundantBufferNdx = 0; redundantBufferNdx < m_redundantBufferFactor; redundantBufferNdx++)
                {
                    const string curAttrBufName =
                        separateAttrBufNamePrefix + toString(attrNdx) + "_" + toString(redundantBufferNdx);
                    const bool hadCurAttrBuffer = m_buffers->has(curAttrBufName);

                    if (!hadCurAttrBuffer)
                        m_buffers->make(curAttrBufName);

                    Buffer &curAttrBuf = m_buffers->get(curAttrBufName);

                    if (!hadCurAttrBuffer || m_rnd.getFloat() < m_probabilities.reuploadBuffer)
                    {
                        m_buffers->removeGarbageUntilUnder(
                            m_maxBufMemoryUsageBytes -
                                curAttrBuf.getApproxMemUsageDiff(programResources.attrDataSizes[attrNdx]),
                            m_rnd);
                        const uint32_t target = m_rnd.getFloat() < m_probabilities.randomBufferUploadTarget ?
                                                    randomBufferTarget(m_rnd, m_isGLES3) :
                                                    GL_ARRAY_BUFFER;

                        if (!hadCurAttrBuffer || m_rnd.getFloat() < m_probabilities.reuploadWithBufferData)
                            curAttrBuf.setData(&programResources.attrDataBuf[programResources.attrDataOffsets[attrNdx]],
                                               programResources.attrDataSizes[attrNdx], target,
                                               m_rnd.getFloat() < m_probabilities.randomBufferUsage ?
                                                   randomBufferUsage(m_rnd, m_isGLES3) :
                                                   m_attrBufferUsage);
                        else
                            curAttrBuf.setSubData(
                                &programResources.attrDataBuf[programResources.attrDataOffsets[attrNdx]], 0,
                                programResources.attrDataSizes[attrNdx], target);
                    }

                    if (redundantBufferNdx == usedRedundantBufferNdx)
                        program.setAttribute(curAttrBuf, 0, programContext.attributes[attrNdx],
                                             programResources.shaderNameManglingSuffix);
                }
            }
        }
        else
        {
            const int usedRedundantBufferNdx = m_rnd.getInt(0, m_redundantBufferFactor - 1);

            for (int redundantBufferNdx = 0; redundantBufferNdx < m_redundantBufferFactor; redundantBufferNdx++)
            {
                const string attrBufName = unitedAttrBufferNamePrefix + toString(redundantBufferNdx);
                const bool hadAttrBuffer = m_buffers->has(attrBufName);

                if (!hadAttrBuffer)
                    m_buffers->make(attrBufName);

                Buffer &attrBuf = m_buffers->get(attrBufName);

                if (!hadAttrBuffer || m_rnd.getFloat() < m_probabilities.reuploadBuffer)
                {
                    m_buffers->removeGarbageUntilUnder(
                        m_maxBufMemoryUsageBytes - attrBuf.getApproxMemUsageDiff(programResources.attrDataBuf), m_rnd);
                    const uint32_t target = m_rnd.getFloat() < m_probabilities.randomBufferUploadTarget ?
                                                randomBufferTarget(m_rnd, m_isGLES3) :
                                                GL_ARRAY_BUFFER;

                    if (!hadAttrBuffer || m_rnd.getFloat() < m_probabilities.reuploadWithBufferData)
                        attrBuf.setData(programResources.attrDataBuf, target,
                                        m_rnd.getFloat() < m_probabilities.randomBufferUsage ?
                                            randomBufferUsage(m_rnd, m_isGLES3) :
                                            m_attrBufferUsage);
                    else
                        attrBuf.setSubData(programResources.attrDataBuf, 0, (int)programResources.attrDataBuf.size(),
                                           target);
                }

                if (redundantBufferNdx == usedRedundantBufferNdx)
                {
                    for (int i = 0; i < (int)programContext.attributes.size(); i++)
                        program.setAttribute(attrBuf, programResources.attrDataOffsets[i], programContext.attributes[i],
                                             programResources.shaderNameManglingSuffix);
                }
            }
        }
    }
    else
    {
        for (int i = 0; i < (int)programContext.attributes.size(); i++)
            program.setAttributeClientMem(&programResources.attrDataBuf[programResources.attrDataOffsets[i]],
                                          programContext.attributes[i], programResources.shaderNameManglingSuffix);
    }

    // Draw.

    glViewport(0, 0, renderWidth, renderHeight);

    glClearDepthf(1.0f);
    glClear(GL_DEPTH_BUFFER_BIT);
    glEnable(GL_DEPTH_TEST);

    for (int i = 0; i < m_numDrawCallsPerIteration; i++)
    {
        program.use();
        program.setRandomUniforms(programContext.uniforms, programResources.shaderNameManglingSuffix, m_rnd);

        if (useDrawArrays)
            glDrawArrays(GL_TRIANGLE_STRIP, 0, m_numVerticesPerDrawCall);
        else
        {
            if (useClientMemoryIndexData)
            {
                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
                glDrawElements(GL_TRIANGLE_STRIP, m_numVerticesPerDrawCall, GL_UNSIGNED_SHORT, &m_vertexIndices[0]);
            }
            else
            {
                m_buffers->get(indexBufferName).bind(GL_ELEMENT_ARRAY_BUFFER);
                glDrawElements(GL_TRIANGLE_STRIP, m_numVerticesPerDrawCall, GL_UNSIGNED_SHORT, DE_NULL);
            }
        }
    }

    for (int i = 0; i < (int)programContext.attributes.size(); i++)
        program.disableAttributeArray(programContext.attributes[i], programResources.shaderNameManglingSuffix);

    if (m_showDebugInfo)
        m_debugInfoRenderer->drawInfo(deGetTime() - m_startTimeSeconds, m_textures->computeApproxMemUsage(),
                                      m_maxTexMemoryUsageBytes, m_buffers->computeApproxMemUsage(),
                                      m_maxBufMemoryUsageBytes, m_currentIteration);

    if (m_currentIteration > 0)
    {
        // Log if a certain amount of time has passed since last log entry (or if this is the last iteration).

        const uint64_t loggingIntervalSeconds = 10;
        const uint64_t time                   = deGetTime();
        const uint64_t timeDiff               = time - m_lastLogTime;
        const int iterDiff                    = m_currentIteration - m_lastLogIteration;

        if (timeDiff >= loggingIntervalSeconds || m_currentIteration == m_numIterations - 1)
        {
            log << TestLog::Section("LogEntry" + toString(m_currentLogEntryNdx),
                                    "Log entry " + toString(m_currentLogEntryNdx))
                << TestLog::Message << "Time elapsed: " << getTimeStr(time - m_startTimeSeconds) << TestLog::EndMessage
                << TestLog::Message << "Frame number: " << m_currentIteration << TestLog::EndMessage << TestLog::Message
                << "Time since last log entry: " << timeDiff << "s" << TestLog::EndMessage << TestLog::Message
                << "Frames since last log entry: " << iterDiff << TestLog::EndMessage << TestLog::Message
                << "Average frame time since last log entry: "
                << de::floatToString((float)timeDiff / (float)iterDiff, 2) << "s" << TestLog::EndMessage
                << TestLog::Message << "Approximate texture memory usage: "
                << de::floatToString((float)m_textures->computeApproxMemUsage() / Mi, 2) << " MiB / "
                << de::floatToString((float)m_maxTexMemoryUsageBytes / Mi, 2) << " MiB" << TestLog::EndMessage
                << TestLog::Message << "Approximate buffer memory usage: "
                << de::floatToString((float)m_buffers->computeApproxMemUsage() / Mi, 2) << " MiB / "
                << de::floatToString((float)m_maxBufMemoryUsageBytes / Mi, 2) << " MiB" << TestLog::EndMessage
                << TestLog::EndSection;

            m_lastLogTime      = time;
            m_lastLogIteration = m_currentIteration;
            m_currentLogEntryNdx++;
        }
    }

    // Possibly remove or set-as-garbage some objects, depending on given probabilities.

    for (int texNdx = 0; texNdx < (int)programContext.textureSpecs.size(); texNdx++)
    {
        const string texName = textureNamePrefix + toString(texNdx);
        if (m_rnd.getFloat() < m_probabilities.deleteTexture)
            m_textures->remove(texName);
        else if (m_rnd.getFloat() < m_probabilities.wastefulTextureMemoryUsage)
            m_textures->markAsGarbage(texName);
    }

    if (m_buffers->has(indexBufferName))
    {
        if (m_rnd.getFloat() < m_probabilities.deleteBuffer)
            m_buffers->remove(indexBufferName);
        else if (m_rnd.getFloat() < m_probabilities.wastefulBufferMemoryUsage)
            m_buffers->markAsGarbage(indexBufferName);
    }

    if (separateAttributeBuffers)
    {
        for (int attrNdx = 0; attrNdx < (int)programContext.attributes.size(); attrNdx++)
        {
            const string curAttrBufNamePrefix = separateAttrBufNamePrefix + toString(attrNdx) + "_";

            if (m_buffers->has(curAttrBufNamePrefix + "0"))
            {
                if (m_rnd.getFloat() < m_probabilities.deleteBuffer)
                {
                    for (int i = 0; i < m_redundantBufferFactor; i++)
                        m_buffers->remove(curAttrBufNamePrefix + toString(i));
                }
                else if (m_rnd.getFloat() < m_probabilities.wastefulBufferMemoryUsage)
                {
                    for (int i = 0; i < m_redundantBufferFactor; i++)
                        m_buffers->markAsGarbage(curAttrBufNamePrefix + toString(i));
                }
            }
        }
    }
    else
    {
        if (m_buffers->has(unitedAttrBufferNamePrefix + "0"))
        {
            if (m_rnd.getFloat() < m_probabilities.deleteBuffer)
            {
                for (int i = 0; i < m_redundantBufferFactor; i++)
                    m_buffers->remove(unitedAttrBufferNamePrefix + toString(i));
            }
            else if (m_rnd.getFloat() < m_probabilities.wastefulBufferMemoryUsage)
            {
                for (int i = 0; i < m_redundantBufferFactor; i++)
                    m_buffers->markAsGarbage(unitedAttrBufferNamePrefix + toString(i));
            }
        }
    }

    GLU_CHECK_MSG("End of LongStressCase::iterate()");

    m_currentIteration++;
    if (m_currentIteration == m_numIterations)
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Passed");
        return STOP;
    }
    else
        return CONTINUE;
}

} // namespace gls
} // namespace deqp