You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
293 lines
8.1 KiB
293 lines
8.1 KiB
/*-------------------------------------------------------------------------
|
|
* drawElements Quality Program OpenGL ES 3.0 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 Sync stress tests.
|
|
*//*--------------------------------------------------------------------*/
|
|
|
|
#include "es3sSyncTests.hpp"
|
|
|
|
#include "tcuTestLog.hpp"
|
|
#include "deRandom.hpp"
|
|
#include "tcuVector.hpp"
|
|
#include "gluShaderProgram.hpp"
|
|
#include "gluCallLogWrapper.hpp"
|
|
#include "gluRenderContext.hpp"
|
|
#include "deStringUtil.hpp"
|
|
#include "deString.h"
|
|
|
|
#include <vector>
|
|
|
|
#include "glw.h"
|
|
|
|
using tcu::TestLog;
|
|
using std::vector;
|
|
|
|
namespace deqp
|
|
{
|
|
namespace gles3
|
|
{
|
|
namespace Stress
|
|
{
|
|
|
|
static const int NUM_CASE_ITERATIONS = 1;
|
|
|
|
enum WaitCommand
|
|
{
|
|
COMMAND_WAIT_SYNC = 1 << 0,
|
|
COMMAND_CLIENT_WAIT_SYNC = 1 << 1
|
|
};
|
|
|
|
class FenceSyncCase : public TestCase, public glu::CallLogWrapper
|
|
{
|
|
public:
|
|
FenceSyncCase (Context& context, const char* name, const char* description, int numPrimitives, deUint32 waitCommand);
|
|
~FenceSyncCase (void);
|
|
|
|
void init (void);
|
|
void deinit (void);
|
|
IterateResult iterate (void);
|
|
|
|
private:
|
|
FenceSyncCase (const FenceSyncCase& other);
|
|
FenceSyncCase& operator= (const FenceSyncCase& other);
|
|
|
|
int m_numSyncs;
|
|
deUint32 m_waitCommand;
|
|
|
|
glu::ShaderProgram* m_program;
|
|
vector<GLsync> m_syncObjects;
|
|
int m_iterNdx;
|
|
de::Random m_rnd;
|
|
};
|
|
|
|
FenceSyncCase::FenceSyncCase (Context& context, const char* name, const char* description, int numSyncs, deUint32 waitCommand)
|
|
: TestCase (context, name, description)
|
|
, CallLogWrapper (context.getRenderContext().getFunctions(), context.getTestContext().getLog())
|
|
, m_numSyncs (numSyncs)
|
|
, m_waitCommand (waitCommand)
|
|
, m_program (DE_NULL)
|
|
, m_syncObjects (DE_NULL)
|
|
, m_iterNdx (0)
|
|
, m_rnd (deStringHash(name))
|
|
{
|
|
}
|
|
|
|
FenceSyncCase::~FenceSyncCase (void)
|
|
{
|
|
FenceSyncCase::deinit();
|
|
}
|
|
|
|
static void generateVertices (std::vector<float>& dst, int numPrimitives, de::Random& rnd)
|
|
{
|
|
int numVertices = 3*numPrimitives;
|
|
dst.resize(numVertices * 4);
|
|
|
|
for (int i = 0; i < numVertices; i++)
|
|
{
|
|
dst[i*4 ] = rnd.getFloat(-1.0f, 1.0f); // x
|
|
dst[i*4 + 1] = rnd.getFloat(-1.0f, 1.0f); // y
|
|
dst[i*4 + 2] = rnd.getFloat( 0.0f, 1.0f); // z
|
|
dst[i*4 + 3] = 1.0f; // w
|
|
}
|
|
}
|
|
|
|
void FenceSyncCase::init (void)
|
|
{
|
|
const char* vertShaderSource =
|
|
"#version 300 es\n"
|
|
"layout(location = 0) in mediump vec4 a_position;\n"
|
|
"\n"
|
|
"void main (void)\n"
|
|
"{\n"
|
|
" gl_Position = a_position;\n"
|
|
"}\n";
|
|
|
|
const char* fragShaderSource =
|
|
"#version 300 es\n"
|
|
"layout(location = 0) out mediump vec4 o_color;\n"
|
|
"\n"
|
|
"void main (void)\n"
|
|
"{\n"
|
|
" o_color = vec4(0.25, 0.5, 0.75, 1.0);\n"
|
|
"}\n";
|
|
|
|
DE_ASSERT(!m_program);
|
|
m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(vertShaderSource, fragShaderSource));
|
|
|
|
if (!m_program->isOk())
|
|
{
|
|
m_testCtx.getLog() << *m_program;
|
|
TCU_FAIL("Failed to compile shader program");
|
|
}
|
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); // Initialize test result to pass.
|
|
GLU_CHECK_MSG ("Case initialization finished");
|
|
}
|
|
|
|
void FenceSyncCase::deinit (void)
|
|
{
|
|
if (m_program)
|
|
{
|
|
delete m_program;
|
|
m_program = DE_NULL;
|
|
}
|
|
|
|
for (int i = 0; i < (int)m_syncObjects.size(); i++)
|
|
if (m_syncObjects[i])
|
|
glDeleteSync(m_syncObjects[i]);
|
|
|
|
m_syncObjects.erase(m_syncObjects.begin(), m_syncObjects.end());
|
|
}
|
|
|
|
FenceSyncCase::IterateResult FenceSyncCase::iterate (void)
|
|
{
|
|
TestLog& log = m_testCtx.getLog();
|
|
std::vector<float> vertices;
|
|
bool testOk = true;
|
|
|
|
std::string header = "Case iteration " + de::toString(m_iterNdx+1) + " / " + de::toString(NUM_CASE_ITERATIONS);
|
|
tcu::ScopedLogSection section (log, header, header);
|
|
|
|
enableLogging(true);
|
|
|
|
TCU_CHECK (m_program);
|
|
glUseProgram (m_program->getProgram());
|
|
glEnable (GL_DEPTH_TEST);
|
|
glClearColor (0.3f, 0.3f, 0.3f, 1.0f);
|
|
glClearDepthf (1.0f);
|
|
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
// Generate vertices
|
|
|
|
glEnableVertexAttribArray (0);
|
|
generateVertices (vertices, m_numSyncs, m_rnd);
|
|
glVertexAttribPointer (0, 4, GL_FLOAT, GL_FALSE, 0, &vertices[0]);
|
|
m_syncObjects.resize (m_numSyncs);
|
|
|
|
// Perform draws and create sync objects
|
|
|
|
enableLogging(false);
|
|
log << TestLog::Message << "// NOT LOGGED: " << m_numSyncs << " glDrawArrays and glFenceSync calls done here." << TestLog::EndMessage;
|
|
|
|
for (int i = 0; i < m_numSyncs; i++)
|
|
{
|
|
glDrawArrays(GL_TRIANGLES, i*3, 3);
|
|
m_syncObjects[i] = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
|
|
GLU_CHECK_MSG("Sync object created");
|
|
}
|
|
enableLogging(true);
|
|
log << TestLog::Message << "// Draws performed, sync objects created." << TestLog::EndMessage;
|
|
|
|
// Wait for sync objects
|
|
|
|
m_rnd.shuffle(m_syncObjects.begin(), m_syncObjects.end());
|
|
|
|
enableLogging(false);
|
|
if (m_waitCommand & COMMAND_WAIT_SYNC)
|
|
log << TestLog::Message << "// NOT LOGGED: " << m_numSyncs << " glWaitSync calls done here." << TestLog::EndMessage;
|
|
else if (m_waitCommand & COMMAND_CLIENT_WAIT_SYNC)
|
|
log << TestLog::Message << "// NOT LOGGED: " << m_numSyncs << " glClientWaitSync calls done here." << TestLog::EndMessage;
|
|
|
|
for (int i = 0; i < m_numSyncs; i++)
|
|
{
|
|
GLenum waitValue = 0;
|
|
|
|
if (m_waitCommand & COMMAND_WAIT_SYNC)
|
|
{
|
|
glWaitSync(m_syncObjects[i], 0, GL_TIMEOUT_IGNORED);
|
|
GLU_CHECK_MSG("glWaitSync called");
|
|
}
|
|
else if (m_waitCommand & COMMAND_CLIENT_WAIT_SYNC)
|
|
{
|
|
waitValue = glClientWaitSync(m_syncObjects[i], 0, 100);
|
|
GLU_CHECK_MSG("glClientWaitSync called");
|
|
switch (waitValue)
|
|
{
|
|
case GL_ALREADY_SIGNALED: break;
|
|
case GL_TIMEOUT_EXPIRED: break;
|
|
case GL_CONDITION_SATISFIED: break;
|
|
case GL_WAIT_FAILED: log << TestLog::Message << "// glClientWaitSync returned GL_WAIT_FAILED" << TestLog::EndMessage; testOk = false; break;
|
|
default: TCU_FAIL("glClientWaitSync returned an unknown return value.");
|
|
}
|
|
}
|
|
}
|
|
enableLogging(true);
|
|
|
|
glFinish();
|
|
|
|
// Delete sync objects
|
|
|
|
enableLogging(false);
|
|
log << TestLog::Message << "// NOT LOGGED: " << m_numSyncs << " glDeleteSync calls done here." << TestLog::EndMessage;
|
|
|
|
for (int i = 0; i < (int)m_syncObjects.size(); i++)
|
|
{
|
|
if (m_syncObjects[i])
|
|
{
|
|
glDeleteSync(m_syncObjects[i]);
|
|
GLU_CHECK_MSG("Sync object deleted");
|
|
}
|
|
}
|
|
|
|
enableLogging(true);
|
|
|
|
m_syncObjects.erase(m_syncObjects.begin(), m_syncObjects.end());
|
|
|
|
// Evaluate test result
|
|
|
|
log << TestLog::Message << "// Test result: " << (testOk ? "Passed!" : "Failed!") << TestLog::EndMessage;
|
|
|
|
if (!testOk)
|
|
{
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
|
|
return STOP;
|
|
}
|
|
|
|
log << TestLog::Message << "// Sync objects created and deleted successfully." << TestLog::EndMessage;
|
|
|
|
return (++m_iterNdx < NUM_CASE_ITERATIONS) ? CONTINUE : STOP;
|
|
}
|
|
|
|
SyncTests::SyncTests (Context& context)
|
|
: TestCaseGroup(context, "fence_sync", "Fence Sync Tests")
|
|
{
|
|
}
|
|
|
|
SyncTests::~SyncTests (void)
|
|
{
|
|
}
|
|
|
|
void SyncTests::init (void)
|
|
{
|
|
// Fence sync stress tests.
|
|
|
|
addChild(new FenceSyncCase(m_context, "wait_sync_10_syncs", "", 10, COMMAND_WAIT_SYNC));
|
|
addChild(new FenceSyncCase(m_context, "wait_sync_1000_syncs", "", 1000, COMMAND_WAIT_SYNC));
|
|
addChild(new FenceSyncCase(m_context, "wait_sync_10000_syncs", "", 10000, COMMAND_WAIT_SYNC));
|
|
|
|
addChild(new FenceSyncCase(m_context, "client_wait_sync_10_syncs", "", 10, COMMAND_CLIENT_WAIT_SYNC));
|
|
addChild(new FenceSyncCase(m_context, "client_wait_sync_1000_syncs", "", 1000, COMMAND_CLIENT_WAIT_SYNC));
|
|
addChild(new FenceSyncCase(m_context, "client_wait_sync_10000_syncs", "", 10000, COMMAND_CLIENT_WAIT_SYNC));
|
|
}
|
|
|
|
} // Stress
|
|
} // gles3
|
|
} // deqp
|