/*-------------------------------------------------------------------------
* drawElements Quality Program EGL 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 allocation stress tests
*//*--------------------------------------------------------------------*/
#include "teglMemoryStressTests.hpp"
#include "tcuTestLog.hpp"
#include "tcuCommandLine.hpp"
#include "deRandom.hpp"
#include "deClock.h"
#include "deString.h"
#include "gluDefs.hpp"
#include "glwFunctions.hpp"
#include "glwDefs.hpp"
#include "glwEnums.hpp"
#include "egluUtil.hpp"
#include "eglwLibrary.hpp"
#include "eglwEnums.hpp"
#include <vector>
#include <string>
using std::vector;
using std::string;
using tcu::TestLog;
using namespace eglw;
namespace deqp
{
namespace egl
{
namespace
{
enum ObjectType
{
OBJECTTYPE_PBUFFER = (1<<0),
OBJECTTYPE_CONTEXT = (1<<1),
// OBJECTTYPE_WINDOW,
// OBJECTTYPE_PIXMAP,
};
class MemoryAllocator
{
public:
MemoryAllocator (EglTestContext& eglTestCtx, EGLDisplay display, EGLConfig config, int seed, ObjectType types, int minWidth, int minHeight, int maxWidth, int maxHeight, bool use);
~MemoryAllocator (void);
bool allocateUntilFailure (void);
int getAllocationCount (void) const { return (int)(m_pbuffers.size() + m_contexts.size()); }
int getContextCount (void) const { return (int)m_contexts.size(); }
int getPBufferCount (void) const { return (int)m_pbuffers.size(); }
const string& getErrorString (void) const { return m_errorString; }
private:
void allocatePBuffer (void);
void allocateContext (void);
EglTestContext& m_eglTestCtx;
EGLDisplay m_display;
EGLConfig m_config;
glw::Functions m_gl;
de::Random m_rnd;
bool m_failed;
string m_errorString;
ObjectType m_types;
int m_minWidth;
int m_minHeight;
int m_maxWidth;
int m_maxHeight;
bool m_use;
vector<EGLSurface> m_pbuffers;
vector<EGLContext> m_contexts;
};
MemoryAllocator::MemoryAllocator (EglTestContext& eglTestCtx, EGLDisplay display, EGLConfig config, int seed, ObjectType types, int minWidth, int minHeight, int maxWidth, int maxHeight, bool use)
: m_eglTestCtx (eglTestCtx)
, m_display (display)
, m_config (config)
, m_rnd (seed)
, m_failed (false)
, m_types (types)
, m_minWidth (minWidth)
, m_minHeight (minHeight)
, m_maxWidth (maxWidth)
, m_maxHeight (maxHeight)
, m_use (use)
{
m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
}
MemoryAllocator::~MemoryAllocator (void)
{
const Library& egl = m_eglTestCtx.getLibrary();
for (vector<EGLSurface>::const_iterator iter = m_pbuffers.begin(); iter != m_pbuffers.end(); ++iter)
egl.destroySurface(m_display, *iter);
m_pbuffers.clear();
for (vector<EGLContext>::const_iterator iter = m_contexts.begin(); iter != m_contexts.end(); ++iter)
egl.destroyContext(m_display, *iter);
m_contexts.clear();
}
bool MemoryAllocator::allocateUntilFailure (void)
{
const deUint64 timeLimitUs = 10000000; // 10s
deUint64 beginTimeUs = deGetMicroseconds();
vector<ObjectType> types;
if ((m_types & OBJECTTYPE_CONTEXT) != 0)
types.push_back(OBJECTTYPE_CONTEXT);
if ((m_types & OBJECTTYPE_PBUFFER) != 0)
types.push_back(OBJECTTYPE_PBUFFER);
// If objects should be used. Create one of both at beginning to allow using them.
if (m_contexts.size() == 0 && m_pbuffers.size() == 0 && m_use)
{
allocateContext();
allocatePBuffer();
}
while (!m_failed)
{
ObjectType type = m_rnd.choose<ObjectType>(types.begin(), types.end());
switch (type)
{
case OBJECTTYPE_PBUFFER:
allocatePBuffer();
break;
case OBJECTTYPE_CONTEXT:
allocateContext();
break;
default:
DE_ASSERT(false);
}
if (deGetMicroseconds() - beginTimeUs > timeLimitUs)
return true;
}
return false;
}
void MemoryAllocator::allocatePBuffer (void)
{
// Reserve space for new allocations
try
{
m_pbuffers.reserve(m_pbuffers.size() + 1);
}
catch (const std::bad_alloc&)
{
m_errorString = "std::bad_alloc when allocating more space for testcase. Out of host memory.";
m_failed = true;
return;
}
// Allocate pbuffer
try
{
const Library& egl = m_eglTestCtx.getLibrary();
const EGLint width = m_rnd.getInt(m_minWidth, m_maxWidth);
const EGLint height = m_rnd.getInt(m_minHeight, m_maxHeight);
const EGLint attribList[] =
{
EGL_WIDTH, width,
EGL_HEIGHT, height,
EGL_NONE
};
EGLSurface surface = egl.createPbufferSurface(m_display, m_config, attribList);
EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface");
DE_ASSERT(surface != EGL_NO_SURFACE);
m_pbuffers.push_back(surface);
if (m_use && m_contexts.size() > 0)
{
EGLContext context = m_rnd.choose<EGLContext>(m_contexts.begin(), m_contexts.end());
const float red = m_rnd.getFloat();
const float green = m_rnd.getFloat();
const float blue = m_rnd.getFloat();
const float alpha = m_rnd.getFloat();
EGLU_CHECK_CALL(egl, makeCurrent(m_display, surface, surface, context));
m_gl.clearColor(red, green, blue, alpha);
GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClearColor()");
m_gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClear()");
EGLU_CHECK_CALL(egl, makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
}
}
catch (const eglu::Error& error)
{
if (error.getError() == EGL_BAD_ALLOC)
{
m_errorString = "eglCreatePbufferSurface returned EGL_BAD_ALLOC";
m_failed = true;
return;
}
else
throw;
}
}
void MemoryAllocator::allocateContext (void)
{
// Reserve space for new allocations
try
{
m_contexts.reserve(m_contexts.size() + 1);
}
catch (const std::bad_alloc&)
{
m_errorString = "std::bad_alloc when allocating more space for testcase. Out of host memory.";
m_failed = true;
return;
}
// Allocate context
try
{
const Library& egl = m_eglTestCtx.getLibrary();
const EGLint attribList[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
EGLContext context = egl.createContext(m_display, m_config, EGL_NO_CONTEXT, attribList);
EGLU_CHECK_MSG(egl, "eglCreateContext");
DE_ASSERT(context != EGL_NO_CONTEXT);
m_contexts.push_back(context);
if (m_use && m_pbuffers.size() > 0)
{
EGLSurface surface = m_rnd.choose<EGLSurface>(m_pbuffers.begin(), m_pbuffers.end());
const float red = m_rnd.getFloat();
const float green = m_rnd.getFloat();
const float blue = m_rnd.getFloat();
const float alpha = m_rnd.getFloat();
EGLU_CHECK_CALL(egl, makeCurrent(m_display, surface, surface, context));
m_gl.clearColor(red, green, blue, alpha);
GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClearColor()");
m_gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClear()");
EGLU_CHECK_CALL(egl, makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
}
}
catch (const eglu::Error& error)
{
if (error.getError() == EGL_BAD_ALLOC)
{
m_errorString = "eglCreateContext returned EGL_BAD_ALLOC";
m_failed = true;
return;
}
else
throw;
}
}
} // anonymous
class MemoryStressCase : public TestCase
{
public:
struct Spec
{
ObjectType types;
int minWidth;
int minHeight;
int maxWidth;
int maxHeight;
bool use;
};
MemoryStressCase (EglTestContext& eglTestCtx, Spec spec, const char* name, const char* description);
void init (void);
void deinit (void);
IterateResult iterate (void);
private:
Spec m_spec;
vector<int> m_allocationCounts;
MemoryAllocator* m_allocator;
int m_iteration;
int m_iterationCount;
int m_seed;
EGLDisplay m_display;
EGLConfig m_config;
};
MemoryStressCase::MemoryStressCase (EglTestContext& eglTestCtx, Spec spec, const char* name, const char* description)
: TestCase (eglTestCtx, name, description)
, m_spec (spec)
, m_allocator (NULL)
, m_iteration (0)
, m_iterationCount (10)
, m_seed (deStringHash(name))
, m_display (EGL_NO_DISPLAY)
, m_config (DE_NULL)
{
}
void MemoryStressCase::init (void)
{
const Library& egl = m_eglTestCtx.getLibrary();
EGLint configCount = 0;
const EGLint attribList[] =
{
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
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");
}
m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
EGLU_CHECK_CALL(egl, chooseConfig(m_display, attribList, &m_config, 1, &configCount));
TCU_CHECK(configCount != 0);
}
void MemoryStressCase::deinit (void)
{
delete m_allocator;
m_allocator = DE_NULL;
if (m_display != EGL_NO_DISPLAY)
{
m_eglTestCtx.getLibrary().terminate(m_display);
m_display = EGL_NO_DISPLAY;
}
}
TestCase::IterateResult MemoryStressCase::iterate (void)
{
TestLog& log = m_testCtx.getLog();
if (m_iteration < m_iterationCount)
{
try
{
if (!m_allocator)
m_allocator = new MemoryAllocator(m_eglTestCtx, m_display, m_config, m_seed, m_spec.types, m_spec.minWidth, m_spec.minHeight, m_spec.maxWidth, m_spec.maxHeight, m_spec.use);
if (m_allocator->allocateUntilFailure())
{
log << TestLog::Message << "Couldn't exhaust memory before timeout. Allocated " << m_allocator->getAllocationCount() << " objects." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
delete m_allocator;
m_allocator = NULL;
return STOP;
}
log << TestLog::Message << "Iteration " << m_iteration << ": Allocated " << m_allocator->getAllocationCount() << " objects; " << m_allocator->getContextCount() << " contexts, " << m_allocator->getPBufferCount() << " PBuffers." << TestLog::EndMessage;
log << TestLog::Message << "Got expected error: " << m_allocator->getErrorString() << TestLog::EndMessage;
m_allocationCounts.push_back(m_allocator->getAllocationCount());
delete m_allocator;
m_allocator = NULL;
m_iteration++;
return CONTINUE;
} catch (...)
{
log << TestLog::Message << "Iteration " << m_iteration << ": Allocated " << m_allocator->getAllocationCount() << " objects; " << m_allocator->getContextCount() << " contexts, " << m_allocator->getPBufferCount() << " PBuffers." << TestLog::EndMessage;
log << TestLog::Message << "Unexpected error" << TestLog::EndMessage;
throw;
}
}
else
{
// Analyze number of passed allocations.
int min = m_allocationCounts[0];
int max = m_allocationCounts[0];
float threshold = 50.0f;
for (int allocNdx = 0; allocNdx < (int)m_allocationCounts.size(); allocNdx++)
{
min = deMin32(m_allocationCounts[allocNdx], min);
max = deMax32(m_allocationCounts[allocNdx], max);
}
if (min == 0 && max != 0)
{
log << TestLog::Message << "Allocation count zero" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
else
{
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");
}
return STOP;
}
}
MemoryStressTests::MemoryStressTests (EglTestContext& eglTestCtx)
: TestCaseGroup(eglTestCtx, "memory", "Memory allocation stress tests")
{
}
void MemoryStressTests::init (void)
{
// Check small pbuffers 256x256
{
MemoryStressCase::Spec spec;
spec.types = OBJECTTYPE_PBUFFER;
spec.minWidth = 256;
spec.minHeight = 256;
spec.maxWidth = 256;
spec.maxHeight = 256;
spec.use = false;
addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_256x256", "PBuffer allocation stress tests"));
}
// Check small pbuffers 256x256 and use them
{
MemoryStressCase::Spec spec;
spec.types = OBJECTTYPE_PBUFFER;
spec.minWidth = 256;
spec.minHeight = 256;
spec.maxWidth = 256;
spec.maxHeight = 256;
spec.use = true;
addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_256x256_use", "PBuffer allocation stress tests"));
}
// Check big pbuffers 1024x1024
{
MemoryStressCase::Spec spec;
spec.types = OBJECTTYPE_PBUFFER;
spec.minWidth = 1024;
spec.minHeight = 1024;
spec.maxWidth = 1024;
spec.maxHeight = 1024;
spec.use = false;
addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_1024x1024", "PBuffer allocation stress tests"));
}
// Check big pbuffers 1024x1024 and use them
{
MemoryStressCase::Spec spec;
spec.types = OBJECTTYPE_PBUFFER;
spec.minWidth = 1024;
spec.minHeight = 1024;
spec.maxWidth = 1024;
spec.maxHeight = 1024;
spec.use = true;
addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_1024x1024_use", "PBuffer allocation stress tests"));
}
// Check different sized pbuffers
{
MemoryStressCase::Spec spec;
spec.types = OBJECTTYPE_PBUFFER;
spec.minWidth = 64;
spec.minHeight = 64;
spec.maxWidth = 1024;
spec.maxHeight = 1024;
spec.use = false;
addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer", "PBuffer allocation stress tests"));
}
// Check different sized pbuffers and use them
{
MemoryStressCase::Spec spec;
spec.types = OBJECTTYPE_PBUFFER;
spec.minWidth = 64;
spec.minHeight = 64;
spec.maxWidth = 1024;
spec.maxHeight = 1024;
spec.use = true;
addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_use", "PBuffer allocation stress tests"));
}
// Check contexts
{
MemoryStressCase::Spec spec;
spec.types = OBJECTTYPE_CONTEXT;
spec.minWidth = 1024;
spec.minHeight = 1024;
spec.maxWidth = 1024;
spec.maxHeight = 1024;
spec.use = false;
addChild(new MemoryStressCase(m_eglTestCtx, spec, "context", "Context allocation stress tests"));
}
// Check contexts and use them
{
MemoryStressCase::Spec spec;
spec.types = OBJECTTYPE_CONTEXT;
spec.minWidth = 1024;
spec.minHeight = 1024;
spec.maxWidth = 1024;
spec.maxHeight = 1024;
spec.use = true;
addChild(new MemoryStressCase(m_eglTestCtx, spec, "context_use", "Context allocation stress tests"));
}
// Check contexts and pbuffers
{
MemoryStressCase::Spec spec;
spec.types = (ObjectType)(OBJECTTYPE_PBUFFER|OBJECTTYPE_CONTEXT);
spec.minWidth = 64;
spec.minHeight = 64;
spec.maxWidth = 1024;
spec.maxHeight = 1024;
spec.use = false;
addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_context", "PBuffer and context allocation stress tests"));
}
// Check contexts and pbuffers and use
{
MemoryStressCase::Spec spec;
spec.types = (ObjectType)(OBJECTTYPE_PBUFFER|OBJECTTYPE_CONTEXT);
spec.minWidth = 64;
spec.minHeight = 64;
spec.maxWidth = 1024;
spec.maxHeight = 1024;
spec.use = true;
addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_context_use", "PBuffer and context allocation stress tests"));
}
}
} // egl
} // deqp