/*-------------------------------------------------------------------------
|
* 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 tcu::TestLog;
|
using tcu::Vec2;
|
using tcu::Vec3;
|
using tcu::Vec4;
|
using tcu::IVec2;
|
using tcu::IVec3;
|
using tcu::IVec4;
|
using tcu::TextureLevel;
|
using tcu::TextureFormat;
|
using tcu::ConstPixelBufferAccess;
|
using tcu::CubeFace;
|
using de::SharedPtr;
|
using de::Random;
|
using de::toString;
|
|
using std::vector;
|
using std::string;
|
using std::map;
|
|
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 deUint32 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 deUint32 bufferUsagesGLES2[] =
|
{
|
GL_STATIC_DRAW,
|
GL_DYNAMIC_DRAW,
|
GL_STREAM_DRAW
|
};
|
|
static const deUint32 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 deUint32 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 deUint64 seconds)
|
{
|
const deUint64 m = seconds / 60;
|
const deUint64 h = m / 60;
|
const deUint64 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 deUint32 randomBufferTarget (Random& rnd, const bool isGLES3)
|
{
|
return isGLES3 ? randomChoose(rnd, bufferTargets) : randomChoose(rnd, bufferTargetsGLES2);
|
}
|
|
static inline deUint32 randomBufferUsage (Random& rnd, const bool isGLES3)
|
{
|
return isGLES3 ? randomChoose(rnd, bufferUsages) : randomChoose(rnd, bufferUsagesGLES2);
|
}
|
|
static inline deUint32 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 deUint32 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 deUint32 shaderGL)
|
{
|
glCompileShader(shaderGL);
|
|
int success = GL_FALSE;
|
glGetShaderiv(shaderGL, GL_COMPILE_STATUS, &success);
|
|
return success == GL_TRUE;
|
}
|
|
static inline bool linkProgram (const deUint32 programGL)
|
{
|
glLinkProgram(programGL);
|
|
int success = GL_FALSE;
|
glGetProgramiv(programGL, GL_LINK_STATUS, &success);
|
|
return success == GL_TRUE;
|
}
|
|
static inline string getShaderInfoLog (const deUint32 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 deUint32 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 (deUint64 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<deUint16> m_ndxBuf;
|
};
|
|
void DebugInfoRenderer::drawInfo (const deUint64 secondsElapsed, const int texMem, const int maxTexMem, const int bufMem, const int maxBufMem, const int iterNdx)
|
{
|
const deUint64 m = secondsElapsed / 60;
|
const deUint64 h = m / 60;
|
const deUint64 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(deUint16(vtxNdx+0));
|
m_ndxBuf.push_back(deUint16(vtxNdx+1));
|
m_ndxBuf.push_back(deUint16(vtxNdx+2));
|
|
m_ndxBuf.push_back(deUint16(vtxNdx+2));
|
m_ndxBuf.push_back(deUint16(vtxNdx+1));
|
m_ndxBuf.push_back(deUint16(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, deUint32 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 (deUint32 min, deUint32 mag) const;
|
void setWrap (deUint32 s, deUint32 t) const;
|
|
int getApproxMemUsage (void) const { return m_dataSizeApprox; }
|
int getApproxMemUsageDiff (int width, int height, deUint32 internalFormat, bool useMipmap) const;
|
|
private:
|
Texture (const Texture&); // Not allowed.
|
Texture& operator= (const Texture&); // Not allowed.
|
|
static deUint32 genTexture (void) { deUint32 tex = 0; glGenTextures(1, &tex); return tex; }
|
|
deUint32 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 deUint32 m_textureGL;
|
|
int m_numMipLevels;
|
deUint32 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 deUint32 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 deUint32 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 deUint32 min, const deUint32 mag) const
|
{
|
glBindTexture(getGLBindTarget(), m_textureGL);
|
glTexParameteri(getGLBindTarget(), GL_TEXTURE_MIN_FILTER, min);
|
glTexParameteri(getGLBindTarget(), GL_TEXTURE_MAG_FILTER, mag);
|
}
|
|
void Texture::setWrap (const deUint32 s, const deUint32 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 deUint32 target, const deUint32 usage) { setData(&src[0], (int)(src.size()*sizeof(T)), target, usage); }
|
void setData (const void* src, int size, deUint32 target, deUint32 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 deUint32 target) { setSubData(&src[offsetElems], offsetElems*(int)sizeof(T), numElems*(int)sizeof(T), target); }
|
void setSubData (const void* src, int offsetBytes, int sizeBytes, deUint32 target) const;
|
void bind (const deUint32 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 deUint32 genBuffer (void) { deUint32 buf = 0; glGenBuffers(1, &buf); return buf; }
|
|
const deUint32 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 deUint32 target, const deUint32 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 deUint32 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 deUint32 m_vertShaderGL;
|
const deUint32 m_fragShaderGL;
|
const deUint32 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))
|
{
|
deUint32 val[4];
|
for (int i = 0; i < typeScalarSize; i++)
|
{
|
DE_ASSERT(spec.minValue.i[i] >= 0 && spec.maxValue.i[i] >= 0);
|
val[i] = (deUint32)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*)(deIntptr)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());
|
}
|
}
|
|
} // LongStressCaseInternal
|
|
using namespace LongStressCaseInternal;
|
|
static int generateRandomAttribData (vector<deUint8>& 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<deUint8>& 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<deUint8>& 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 deUint32 indexBufferUsage,
|
const deUint32 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 ((deUint64)-1)
|
, m_lastLogTime ((deUint64)-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<deUint16>::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 dummy 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> dummyTex;
|
|
for (int prevProgCtxNdx = 0; prevProgCtxNdx < (int)m_programResources.size(); prevProgCtxNdx++)
|
{
|
const vector<SharedPtr<TextureLevel> >& prevProgCtxTextures = m_programResources[prevProgCtxNdx].dummyTextures;
|
|
for (int texNdx = 0; texNdx < (int)prevProgCtxTextures.size(); texNdx++)
|
{
|
if (prevProgCtxTextures[texNdx]->getFormat() == format)
|
{
|
dummyTex = prevProgCtxTextures[texNdx];
|
break;
|
}
|
}
|
}
|
|
if (!dummyTex)
|
dummyTex = SharedPtr<TextureLevel>(new TextureLevel(format));
|
|
if (dummyTex->getWidth() < spec.width || dummyTex->getHeight() < spec.height)
|
{
|
dummyTex->setSize(spec.width, spec.height);
|
tcu::fillWithComponentGradients(dummyTex->getAccess(), spec.minValue, spec.maxValue);
|
}
|
|
progRes.dummyTextures.push_back(dummyTex);
|
}
|
}
|
|
m_vertexIndices.clear();
|
for (int i = 0; i < m_numVerticesPerDrawCall; i++)
|
m_vertexIndices.push_back((deUint16)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((deUint16)deUint64Hash((deUint64)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.dummyTextures[texNdx]->getAccess(), spec.width, spec.height, spec.internalFormat, spec.useMipmap);
|
else
|
texture.setSubData(programResources.dummyTextures[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 deUint32 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 deUint32 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 deUint32 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 deUint64 loggingIntervalSeconds = 10;
|
const deUint64 time = deGetTime();
|
const deUint64 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;
|
}
|
|
} // gls
|
} // deqp
|
