/*-------------------------------------------------------------------------
* 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 Memory object stress test
*//*--------------------------------------------------------------------*/
#include "glsMemoryStressCase.hpp"
#include "gluShaderProgram.hpp"
#include "tcuTestLog.hpp"
#include "tcuCommandLine.hpp"
#include "deRandom.hpp"
#include "deClock.h"
#include "deString.h"
#include "glw.h"
#include <vector>
#include <iostream>
using std::vector;
using tcu::TestLog;
namespace deqp
{
namespace gls
{
static const char* glErrorToString (deUint32 error)
{
switch (error)
{
case GL_OUT_OF_MEMORY:
return "GL_OUT_OF_MEMORY";
break;
case GL_INVALID_ENUM:
return "GL_INVALID_ENUM";
break;
case GL_INVALID_FRAMEBUFFER_OPERATION:
return "GL_INVALID_FRAMEBUFFER_OPERATION";
break;
case GL_INVALID_OPERATION:
return "GL_INVALID_OPERATION";
break;
case GL_INVALID_VALUE:
return "GL_INVALID_VALUE";
break;
case 0:
return "<none>";
break;
default:
// \todo [mika] Handle uknown errors?
DE_ASSERT(false);
return NULL;
break;
}
}
static const float s_quadCoords[] =
{
-1.0f, -1.0f,
1.0f, -1.0f,
1.0f, 1.0f,
-1.0f, 1.0f
};
static const GLubyte s_quadIndices[] =
{
0, 1, 2,
2, 3, 0
};
class TextureRenderer
{
public:
TextureRenderer (tcu::TestLog& log, glu::RenderContext& renderContext);
~TextureRenderer (void);
void render (deUint32 texture);
private:
glu::ShaderProgram* m_program;
glu::RenderContext& m_renderCtx;
deUint32 m_coordBuffer;
deUint32 m_indexBuffer;
deUint32 m_vao;
static const char* s_vertexShaderGLES2;
static const char* s_fragmentShaderGLES2;
static const char* s_vertexShaderGLES3;
static const char* s_fragmentShaderGLES3;
static const char* s_vertexShaderGL3;
static const char* s_fragmentShaderGL3;
};
const char* TextureRenderer::s_vertexShaderGLES2 =
"attribute mediump vec2 a_coord;\n"
"varying mediump vec2 v_texCoord;\n"
"void main (void)\n"
"{\n"
"\tv_texCoord = 0.5 * (a_coord + vec2(1.0));\n"
"\tgl_Position = vec4(a_coord, 0.0, 1.0);\n"
"}\n";
const char* TextureRenderer::s_fragmentShaderGLES2 =
"varying mediump vec2 v_texCoord;\n"
"uniform sampler2D u_texture;\n"
"void main (void)\n"
"{\n"
"\tgl_FragColor = texture2D(u_texture, v_texCoord);\n"
"}\n";
const char* TextureRenderer::s_vertexShaderGLES3 =
"#version 300 es\n"
"in mediump vec2 a_coord;\n"
"out mediump vec2 v_texCoord;\n"
"void main (void)\n"
"{\n"
"\tv_texCoord = 0.5 * (a_coord + vec2(1.0));\n"
"\tgl_Position = vec4(a_coord, 0.0, 1.0);\n"
"}\n";
const char* TextureRenderer::s_fragmentShaderGLES3 =
"#version 300 es\n"
"in mediump vec2 v_texCoord;\n"
"uniform sampler2D u_texture;\n"
"layout(location = 0) out mediump vec4 dEQP_FragColor;\n"
"void main (void)\n"
"{\n"
"\tdEQP_FragColor = texture(u_texture, v_texCoord);\n"
"}\n";
const char* TextureRenderer::s_vertexShaderGL3 =
"#version 330\n"
"in mediump vec2 a_coord;\n"
"out mediump vec2 v_texCoord;\n"
"void main (void)\n"
"{\n"
"\tv_texCoord = 0.5 * (a_coord + vec2(1.0));\n"
"\tgl_Position = vec4(a_coord, 0.0, 1.0);\n"
"}\n";
const char* TextureRenderer::s_fragmentShaderGL3 =
"#version 330\n"
"in mediump vec2 v_texCoord;\n"
"uniform sampler2D u_texture;\n"
"layout(location = 0) out mediump vec4 dEQP_FragColor;\n"
"void main (void)\n"
"{\n"
"\tdEQP_FragColor = texture(u_texture, v_texCoord);\n"
"}\n";
TextureRenderer::TextureRenderer (tcu::TestLog& log, glu::RenderContext& renderContext)
: m_program (NULL)
, m_renderCtx (renderContext)
, m_coordBuffer (0)
, m_indexBuffer (0)
, m_vao (0)
{
const glu::ContextType ctxType = renderContext.getType();
if (glu::isGLSLVersionSupported(ctxType, glu::GLSL_VERSION_300_ES))
m_program = new glu::ShaderProgram(m_renderCtx, glu::makeVtxFragSources(s_vertexShaderGLES3, s_fragmentShaderGLES3));
else if (glu::isGLSLVersionSupported(ctxType, glu::GLSL_VERSION_100_ES))
m_program = new glu::ShaderProgram(m_renderCtx, glu::makeVtxFragSources(s_vertexShaderGLES2, s_fragmentShaderGLES2));
else if (glu::isGLSLVersionSupported(ctxType, glu::GLSL_VERSION_330))
m_program = new glu::ShaderProgram(m_renderCtx, glu::makeVtxFragSources(s_vertexShaderGL3, s_fragmentShaderGL3));
else
DE_ASSERT(false);
if (ctxType.getProfile() == glu::PROFILE_CORE)
GLU_CHECK_CALL(glGenVertexArrays(1, &m_vao));
GLU_CHECK_CALL(glGenBuffers(1, &m_coordBuffer));
GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, m_coordBuffer));
GLU_CHECK_CALL(glBufferData(GL_ARRAY_BUFFER, sizeof(s_quadCoords), s_quadCoords, GL_STATIC_DRAW));
GLU_CHECK_CALL(glGenBuffers(1, &m_indexBuffer));
GLU_CHECK_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer));
GLU_CHECK_CALL(glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(s_quadIndices), s_quadIndices, GL_STATIC_DRAW));
if (!m_program->isOk())
{
log << *m_program;
TCU_CHECK_MSG(m_program->isOk(), "Shader compilation failed");
}
}
TextureRenderer::~TextureRenderer (void)
{
delete m_program;
glDeleteBuffers(1, &m_coordBuffer);
glDeleteBuffers(1, &m_indexBuffer);
}
void TextureRenderer::render (deUint32 texture)
{
deUint32 coordLoc = -1;
deUint32 texLoc = -1;
GLU_CHECK_CALL(glUseProgram(m_program->getProgram()));
coordLoc = glGetAttribLocation(m_program->getProgram(), "a_coord");
GLU_CHECK();
TCU_CHECK(coordLoc != (deUint32)-1);
if (m_vao != 0)
GLU_CHECK_CALL(glBindVertexArray(m_vao));
GLU_CHECK_CALL(glEnableVertexAttribArray(coordLoc));
GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, m_coordBuffer));
GLU_CHECK_CALL(glVertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL));
GLU_CHECK_CALL(glActiveTexture(GL_TEXTURE0));
GLU_CHECK_CALL(glBindTexture(GL_TEXTURE_2D, texture));
texLoc = glGetUniformLocation(m_program->getProgram(), "u_texture");
GLU_CHECK();
TCU_CHECK(texLoc != (deUint32)-1);
GLU_CHECK_CALL(glUniform1i(texLoc, 0));
GLU_CHECK_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer));
GLU_CHECK_CALL(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, NULL));
GLU_CHECK_CALL(glDisableVertexAttribArray(coordLoc));
if (m_vao != 0)
GLU_CHECK_CALL(glBindVertexArray(0));
}
class BufferRenderer
{
public:
BufferRenderer (tcu::TestLog& log, glu::RenderContext& renderContext);
~BufferRenderer (void);
void render (deUint32 buffer, int size);
private:
glu::ShaderProgram* m_program;
glu::RenderContext& m_renderCtx;
deUint32 m_coordBuffer;
deUint32 m_indexBuffer;
deUint32 m_vao;
static const char* s_vertexShaderGLES2;
static const char* s_fragmentShaderGLES2;
static const char* s_vertexShaderGLES3;
static const char* s_fragmentShaderGLES3;
static const char* s_vertexShaderGL3;
static const char* s_fragmentShaderGL3;
};
const char* BufferRenderer::s_vertexShaderGLES2 =
"attribute mediump vec2 a_coord;\n"
"attribute mediump vec4 a_buffer;\n"
"varying mediump vec4 v_buffer;\n"
"void main (void)\n"
"{\n"
"\tv_buffer = a_buffer;\n"
"\tgl_Position = vec4(a_coord, 0.0, 1.0);\n"
"}\n";
const char* BufferRenderer::s_fragmentShaderGLES2 =
"varying mediump vec4 v_buffer;\n"
"void main (void)\n"
"{\n"
"\tgl_FragColor = v_buffer;\n"
"}\n";
const char* BufferRenderer::s_vertexShaderGLES3 =
"#version 300 es\n"
"in mediump vec2 a_coord;\n"
"in mediump vec4 a_buffer;\n"
"out mediump vec4 v_buffer;\n"
"void main (void)\n"
"{\n"
"\tv_buffer = a_buffer;\n"
"\tgl_Position = vec4(a_coord, 0.0, 1.0);\n"
"}\n";
const char* BufferRenderer::s_fragmentShaderGLES3 =
"#version 300 es\n"
"in mediump vec4 v_buffer;\n"
"layout(location = 0) out mediump vec4 dEQP_FragColor;\n"
"void main (void)\n"
"{\n"
"\tdEQP_FragColor = v_buffer;\n"
"}\n";
const char* BufferRenderer::s_vertexShaderGL3 =
"#version 330\n"
"in mediump vec2 a_coord;\n"
"in mediump vec4 a_buffer;\n"
"out mediump vec4 v_buffer;\n"
"void main (void)\n"
"{\n"
"\tv_buffer = a_buffer;\n"
"\tgl_Position = vec4(a_coord, 0.0, 1.0);\n"
"}\n";
const char* BufferRenderer::s_fragmentShaderGL3 =
"#version 330\n"
"in mediump vec4 v_buffer;\n"
"layout(location = 0) out mediump vec4 dEQP_FragColor;\n"
"void main (void)\n"
"{\n"
"\tdEQP_FragColor = v_buffer;\n"
"}\n";
BufferRenderer::BufferRenderer (tcu::TestLog& log, glu::RenderContext& renderContext)
: m_program (NULL)
, m_renderCtx (renderContext)
, m_coordBuffer (0)
, m_indexBuffer (0)
, m_vao (0)
{
const glu::ContextType ctxType = renderContext.getType();
if (glu::isGLSLVersionSupported(ctxType, glu::GLSL_VERSION_300_ES))
m_program = new glu::ShaderProgram(m_renderCtx, glu::makeVtxFragSources(s_vertexShaderGLES3, s_fragmentShaderGLES3));
else if (glu::isGLSLVersionSupported(ctxType, glu::GLSL_VERSION_100_ES))
m_program = new glu::ShaderProgram(m_renderCtx, glu::makeVtxFragSources(s_vertexShaderGLES2, s_fragmentShaderGLES2));
else if (glu::isGLSLVersionSupported(ctxType, glu::GLSL_VERSION_330))
m_program = new glu::ShaderProgram(m_renderCtx, glu::makeVtxFragSources(s_vertexShaderGL3, s_fragmentShaderGL3));
else
DE_ASSERT(false);
if (ctxType.getProfile() == glu::PROFILE_CORE)
GLU_CHECK_CALL(glGenVertexArrays(1, &m_vao));
GLU_CHECK_CALL(glGenBuffers(1, &m_coordBuffer));
GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, m_coordBuffer));
GLU_CHECK_CALL(glBufferData(GL_ARRAY_BUFFER, sizeof(s_quadCoords), s_quadCoords, GL_STATIC_DRAW));
GLU_CHECK_CALL(glGenBuffers(1, &m_indexBuffer));
GLU_CHECK_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer));
GLU_CHECK_CALL(glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(s_quadIndices), s_quadIndices, GL_STATIC_DRAW));
if (!m_program->isOk())
{
log << *m_program;
TCU_CHECK_MSG(m_program->isOk(), "Shader compilation failed");
}
}
BufferRenderer::~BufferRenderer (void)
{
delete m_program;
glDeleteBuffers(1, &m_coordBuffer);
glDeleteBuffers(1, &m_indexBuffer);
}
void BufferRenderer::render (deUint32 buffer, int size)
{
DE_UNREF(size);
DE_ASSERT((size_t)size >= sizeof(GLubyte) * 4 * 6);
GLU_CHECK_CALL(glUseProgram(m_program->getProgram()));
deUint32 bufferLoc = glGetAttribLocation(m_program->getProgram(), "a_buffer");
TCU_CHECK(bufferLoc != (deUint32)-1);
deUint32 coordLoc = glGetAttribLocation(m_program->getProgram(), "a_coord");
TCU_CHECK(coordLoc != (deUint32)-1);
if (m_vao != 0)
GLU_CHECK_CALL(glBindVertexArray(m_vao));
GLU_CHECK_CALL(glEnableVertexAttribArray(bufferLoc));
GLU_CHECK_CALL(glEnableVertexAttribArray(coordLoc));
GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, m_coordBuffer));
GLU_CHECK_CALL(glVertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL));
GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, buffer));
GLU_CHECK_CALL(glVertexAttribPointer(bufferLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0));
GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, 0));
GLU_CHECK_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer));
GLU_CHECK_CALL(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, NULL));
GLU_CHECK_CALL(glDisableVertexAttribArray(bufferLoc));
GLU_CHECK_CALL(glDisableVertexAttribArray(coordLoc));
if (m_vao != 0)
GLU_CHECK_CALL(glBindVertexArray(0));
}
class MemObjectAllocator
{
public:
enum Result
{
RESULT_GOT_BAD_ALLOC = 0,
RESULT_GEN_TEXTURES_FAILED,
RESULT_GEN_BUFFERS_FAILED,
RESULT_BUFFER_DATA_FAILED,
RESULT_BUFFER_SUB_DATA_FAILED,
RESULT_TEXTURE_IMAGE_FAILED,
RESULT_TEXTURE_SUB_IMAGE_FAILED,
RESULT_BIND_TEXTURE_FAILED,
RESULT_BIND_BUFFER_FAILED,
RESULT_DELETE_TEXTURES_FAILED,
RESULT_DELETE_BUFFERS_FAILED,
RESULT_RENDER_FAILED,
RESULT_LAST
};
MemObjectAllocator (tcu::TestLog& log, glu::RenderContext& renderContext, MemObjectType objectTypes, const MemObjectConfig& config, int seed);
~MemObjectAllocator (void);
bool allocUntilFailure (void);
void clearObjects (void);
Result getResult (void) const { return m_result; }
deUint32 getGLError (void) const { return m_glError; }
int getObjectCount (void) const { return m_objectCount; }
deUint32 getBytes (void) const { return m_bytesRequired; }
static const char* resultToString (Result result);
private:
void allocateTexture (de::Random& rnd);
void allocateBuffer (de::Random& rnd);
vector<deUint32> m_buffers;
vector<deUint32> m_textures;
int m_seed;
int m_objectCount;
deUint32 m_bytesRequired;
MemObjectType m_objectTypes;
Result m_result;
MemObjectConfig m_config;
deUint32 m_glError;
vector<deUint8> m_dummyData;
BufferRenderer m_bufferRenderer;
TextureRenderer m_textureRenderer;
};
MemObjectAllocator::MemObjectAllocator (tcu::TestLog& log, glu::RenderContext& renderContext, MemObjectType objectTypes, const MemObjectConfig& config, int seed)
: m_seed (seed)
, m_objectCount (0)
, m_bytesRequired (0)
, m_objectTypes (objectTypes)
, m_result (RESULT_LAST)
, m_config (config)
, m_glError (0)
, m_bufferRenderer (log, renderContext)
, m_textureRenderer (log, renderContext)
{
DE_UNREF(renderContext);
if (m_config.useDummyData)
{
int dummySize = deMax32(m_config.maxBufferSize, m_config.maxTextureSize*m_config.maxTextureSize*4);
m_dummyData = vector<deUint8>(dummySize);
}
else if (m_config.write)
m_dummyData = vector<deUint8>(128);
}
MemObjectAllocator::~MemObjectAllocator (void)
{
}
bool MemObjectAllocator::allocUntilFailure (void)
{
de::Random rnd(m_seed);
GLU_CHECK_MSG("Error in init");
try
{
const deUint64 timeoutUs = 10000000; // 10s
deUint64 beginTimeUs = deGetMicroseconds();
deUint64 currentTimeUs;
do
{
GLU_CHECK_MSG("Unkown Error");
switch (m_objectTypes)
{
case MEMOBJECTTYPE_TEXTURE:
allocateTexture(rnd);
break;
case MEMOBJECTTYPE_BUFFER:
allocateBuffer(rnd);
break;
default:
{
if (rnd.getBool())
allocateBuffer(rnd);
else
allocateTexture(rnd);
break;
}
}
if (m_result != RESULT_LAST)
{
glFinish();
return true;
}
currentTimeUs = deGetMicroseconds();
} while (currentTimeUs - beginTimeUs < timeoutUs);
// Timeout
if (currentTimeUs - beginTimeUs >= timeoutUs)
return false;
else
return true;
}
catch (const std::bad_alloc&)
{
m_result = RESULT_GOT_BAD_ALLOC;
return true;
}
}
void MemObjectAllocator::clearObjects (void)
{
deUint32 error = 0;
if (!m_textures.empty())
{
glDeleteTextures((GLsizei)m_textures.size(), &(m_textures[0]));
error = glGetError();
if (error != 0)
{
m_result = RESULT_DELETE_TEXTURES_FAILED;
m_glError = error;
}
m_textures.clear();
}
if (!m_buffers.empty())
{
glDeleteBuffers((GLsizei)m_buffers.size(), &(m_buffers[0]));
error = glGetError();
if (error != 0)
{
m_result = RESULT_DELETE_BUFFERS_FAILED;
m_glError = error;
}
m_buffers.clear();
}
}
void MemObjectAllocator::allocateTexture (de::Random& rnd)
{
const int vectorBlockSize = 128;
deUint32 tex = 0;
deUint32 error = 0;
int width = rnd.getInt(m_config.minTextureSize, m_config.maxTextureSize);
int height = rnd.getInt(m_config.minTextureSize, m_config.maxTextureSize);
glGenTextures(1, &tex);
error = glGetError();
if (error != 0)
{
m_result = RESULT_GEN_TEXTURES_FAILED;
m_glError = error;
return;
}
if (m_textures.size() % vectorBlockSize == 0)
m_textures.reserve(m_textures.size() + vectorBlockSize);
m_textures.push_back(tex);
glBindTexture(GL_TEXTURE_2D, tex);
error = glGetError();
if (error != 0)
{
m_result = RESULT_BIND_TEXTURE_FAILED;
m_glError = error;
return;
}
if (m_config.useDummyData)
{
DE_ASSERT((int)m_dummyData.size() >= width*height*4);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &(m_dummyData[0]));
}
else
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
error = glGetError();
if (error != 0)
{
m_result = RESULT_TEXTURE_IMAGE_FAILED;
m_glError = error;
return;
}
if (m_config.write)
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &(m_dummyData[0]));
error = glGetError();
if (error != 0)
{
m_result = RESULT_TEXTURE_SUB_IMAGE_FAILED;
m_glError = error;
return;
}
if (m_config.use)
{
try
{
m_textureRenderer.render(tex);
}
catch (const glu::Error& err)
{
m_result = RESULT_RENDER_FAILED;
m_glError = err.getError();
return;
}
catch (const glu::OutOfMemoryError&)
{
m_result = RESULT_RENDER_FAILED;
m_glError = GL_OUT_OF_MEMORY;
return;
}
}
glBindTexture(GL_TEXTURE_2D, 0);
error = glGetError();
if (error != 0)
{
m_result = RESULT_BIND_TEXTURE_FAILED;
m_glError = error;
return;
}
m_objectCount++;
m_bytesRequired += width*height*4;
}
void MemObjectAllocator::allocateBuffer (de::Random& rnd)
{
const int vectorBlockSize = 128;
deUint32 buffer = 0;
deUint32 error = 0;
int size = rnd.getInt(m_config.minBufferSize, m_config.maxBufferSize);
glGenBuffers(1, &buffer);
error = glGetError();
if (error != 0)
{
m_result = RESULT_GEN_BUFFERS_FAILED;
m_glError = error;
return;
}
glBindBuffer(GL_ARRAY_BUFFER, buffer);
error = glGetError();
if (error != 0)
{
m_result = RESULT_BIND_BUFFER_FAILED;
m_glError = error;
return;
}
if (m_buffers.size() % vectorBlockSize == 0)
m_buffers.reserve(m_buffers.size() + vectorBlockSize);
m_buffers.push_back(buffer);
if (m_config.useDummyData)
{
DE_ASSERT((int)m_dummyData.size() >= size);
glBufferData(GL_ARRAY_BUFFER, size, &(m_dummyData[0]), GL_DYNAMIC_DRAW);
}
else
glBufferData(GL_ARRAY_BUFFER, size, NULL, GL_DYNAMIC_DRAW);
error = glGetError();
if (error != 0)
{
m_result = RESULT_BUFFER_DATA_FAILED;
m_glError = error;
return;
}
if (m_config.write)
glBufferSubData(GL_ARRAY_BUFFER, 0, 1, &(m_dummyData[0]));
error = glGetError();
if (error != 0)
{
m_result = RESULT_BUFFER_SUB_DATA_FAILED;
m_glError = error;
return;
}
if (m_config.use)
{
try
{
m_bufferRenderer.render(buffer, size);
}
catch (const glu::Error& err)
{
m_result = RESULT_RENDER_FAILED;
m_glError = err.getError();
return;
}
catch (const glu::OutOfMemoryError&)
{
m_result = RESULT_RENDER_FAILED;
m_glError = GL_OUT_OF_MEMORY;
return;
}
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
error = glGetError();
if (error != 0)
{
m_result = RESULT_BIND_BUFFER_FAILED;
m_glError = error;
return;
}
m_objectCount++;
m_bytesRequired += size;
}
const char* MemObjectAllocator::resultToString (Result result)
{
switch (result)
{
case RESULT_GOT_BAD_ALLOC:
return "Caught std::bad_alloc";
break;
case RESULT_GEN_TEXTURES_FAILED:
return "glGenTextures failed";
break;
case RESULT_GEN_BUFFERS_FAILED:
return "glGenBuffers failed";
break;
case RESULT_BUFFER_DATA_FAILED:
return "glBufferData failed";
break;
case RESULT_BUFFER_SUB_DATA_FAILED:
return "glBufferSubData failed";
break;
case RESULT_TEXTURE_IMAGE_FAILED:
return "glTexImage2D failed";
break;
case RESULT_TEXTURE_SUB_IMAGE_FAILED:
return "glTexSubImage2D failed";
break;
case RESULT_BIND_TEXTURE_FAILED:
return "glBindTexture failed";
break;
case RESULT_BIND_BUFFER_FAILED:
return "glBindBuffer failed";
break;
case RESULT_DELETE_TEXTURES_FAILED:
return "glDeleteTextures failed";
break;
case RESULT_DELETE_BUFFERS_FAILED:
return "glDeleteBuffers failed";
break;
case RESULT_RENDER_FAILED:
return "Rendering result failed";
break;
default:
DE_ASSERT(false);
return NULL;
}
}
MemoryStressCase::MemoryStressCase (tcu::TestContext& ctx, glu::RenderContext& renderContext, deUint32 objectTypes, int minTextureSize, int maxTextureSize, int minBufferSize, int maxBufferSize, bool write, bool use, bool useDummyData, bool clearAfterOOM, const char* name, const char* desc)
: tcu::TestCase (ctx, name, desc)
, m_iteration (0)
, m_iterationCount (5)
, m_objectTypes ((MemObjectType)objectTypes)
, m_zeroAlloc (false)
, m_clearAfterOOM (clearAfterOOM)
, m_renderCtx (renderContext)
{
m_allocated.reserve(m_iterationCount);
m_config.maxTextureSize = maxTextureSize;
m_config.minTextureSize = minTextureSize;
m_config.maxBufferSize = maxBufferSize;
m_config.minBufferSize = minBufferSize;
m_config.useDummyData = useDummyData;
m_config.write = write;
m_config.use = use;
}
MemoryStressCase::~MemoryStressCase (void)
{
}
void MemoryStressCase::init (void)
{
if (!m_testCtx.getCommandLine().isOutOfMemoryTestEnabled())
{
m_testCtx.getLog() << TestLog::Message << "Tests that exhaust memory are disabled, use --deqp-test-oom=enable command line option to enable." << TestLog::EndMessage;
throw tcu::NotSupportedError("OOM tests disabled");
}
}
void MemoryStressCase::deinit (void)
{
TCU_CHECK(!m_zeroAlloc);
}
tcu::TestCase::IterateResult MemoryStressCase::iterate (void)
{
bool end = false;
tcu::TestLog& log = m_testCtx.getLog();
MemObjectAllocator allocator(log, m_renderCtx, m_objectTypes, m_config, deStringHash(getName()));
if (!allocator.allocUntilFailure())
{
// Allocation timed out
allocator.clearObjects();
log << TestLog::Message << "Timeout. Couldn't exhaust memory in timelimit. Allocated " << allocator.getObjectCount() << " objects." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
// Try to cancel rendering operations
if (m_clearAfterOOM)
GLU_CHECK_CALL(glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT));
allocator.clearObjects();
m_allocated.push_back(allocator.getObjectCount());
if (m_iteration != 0 && allocator.getObjectCount() == 0)
m_zeroAlloc = true;
log << TestLog::Message << "Got error when allocation object count: " << allocator.getObjectCount() << " bytes: " << allocator.getBytes() << TestLog::EndMessage;
if ((allocator.getGLError() == 0) && (allocator.getResult() == MemObjectAllocator::RESULT_GOT_BAD_ALLOC))
{
log << TestLog::Message << "std::bad_alloc" << TestLog::EndMessage;
end = true;
m_testCtx.setTestResult(QP_TEST_RESULT_RESOURCE_ERROR, "Memory allocation failed");
}
else if (allocator.getGLError() != GL_OUT_OF_MEMORY)
{
log << TestLog::Message << "Invalid Error " << MemObjectAllocator::resultToString(allocator.getResult())
<< " GLError: " << glErrorToString(allocator.getGLError()) <<
TestLog::EndMessage;
end = true;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
if ((m_iteration+1) == m_iterationCount)
{
int min = m_allocated[0];
int max = m_allocated[0];
float threshold = 50.0f;
for (int allocNdx = 0; allocNdx < (int)m_allocated.size(); allocNdx++)
{
min = deMin32(m_allocated[allocNdx], min);
max = deMax32(m_allocated[allocNdx], max);
}
if (min == 0 && max != 0)
{
log << TestLog::Message << "Allocation count zero" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
else
{
const float change = (float)(min - max) / (float)(max);
if (change > threshold)
{
log << TestLog::Message << "Allocated objects max: " << max << ", min: " << min << ", difference: " << change << "% threshold: " << threshold << "%" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Allocation count variation");
}
else
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
end = true;
}
GLU_CHECK_CALL(glFinish());
m_iteration++;
if (end)
return STOP;
else
return CONTINUE;
}
} // gls
} // deqp