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.
966 lines
30 KiB
966 lines
30 KiB
/*-------------------------------------------------------------------------
|
|
* drawElements Quality Program OpenGL ES 2.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 Shader control statement performance tests.
|
|
*//*--------------------------------------------------------------------*/
|
|
|
|
#include "es2pShaderControlStatementTests.hpp"
|
|
#include "glsShaderPerformanceCase.hpp"
|
|
#include "tcuTestLog.hpp"
|
|
|
|
#include "glwEnums.hpp"
|
|
#include "glwFunctions.hpp"
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace deqp
|
|
{
|
|
namespace gles2
|
|
{
|
|
namespace Performance
|
|
{
|
|
|
|
using namespace gls;
|
|
using namespace glw; // GL types
|
|
using tcu::Vec4;
|
|
using tcu::TestLog;
|
|
using std::string;
|
|
using std::vector;
|
|
|
|
// Writes the workload expression used in conditional tests.
|
|
static void writeConditionalWorkload (std::ostringstream& stream, const char* resultName, const char* operandName)
|
|
{
|
|
const int numMultiplications = 64;
|
|
|
|
stream << resultName << " = ";
|
|
|
|
for (int i = 0; i < numMultiplications; i++)
|
|
{
|
|
if (i > 0)
|
|
stream << "*";
|
|
|
|
stream << operandName;
|
|
}
|
|
|
|
stream << ";";
|
|
}
|
|
|
|
// Writes the workload expression used in loop tests (one iteration).
|
|
static void writeLoopWorkload (std::ostringstream& stream, const char* resultName, const char* operandName)
|
|
{
|
|
const int numMultiplications = 8;
|
|
|
|
stream << resultName << " = ";
|
|
|
|
for (int i = 0; i < numMultiplications; i++)
|
|
{
|
|
if (i > 0)
|
|
stream << " * ";
|
|
|
|
stream << "(" << resultName << " + " << operandName << ")";
|
|
}
|
|
|
|
stream << ";";
|
|
}
|
|
|
|
// The type of decision to be made in a conditional expression.
|
|
// \note In fragment cases with DECISION_ATTRIBUTE, the value in the expression will actually be a varying.
|
|
enum DecisionType
|
|
{
|
|
DECISION_STATIC = 0,
|
|
DECISION_UNIFORM,
|
|
DECISION_ATTRIBUTE,
|
|
|
|
DECISION_LAST
|
|
};
|
|
|
|
class ControlStatementCase : public ShaderPerformanceCase
|
|
{
|
|
public:
|
|
ControlStatementCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, gls::PerfCaseType caseType)
|
|
: ShaderPerformanceCase(testCtx, renderCtx, name, description, caseType)
|
|
{
|
|
}
|
|
|
|
void init (void)
|
|
{
|
|
m_testCtx.getLog() << TestLog::Message << "Using additive blending." << TestLog::EndMessage;
|
|
ShaderPerformanceCase::init();
|
|
}
|
|
|
|
void setupRenderState (void)
|
|
{
|
|
const glw::Functions& gl = m_renderCtx.getFunctions();
|
|
|
|
gl.enable(GL_BLEND);
|
|
gl.blendEquation(GL_FUNC_ADD);
|
|
gl.blendFunc(GL_ONE, GL_ONE);
|
|
}
|
|
};
|
|
|
|
class ConditionalCase : public ControlStatementCase
|
|
{
|
|
public:
|
|
enum BranchResult
|
|
{
|
|
BRANCH_TRUE = 0,
|
|
BRANCH_FALSE,
|
|
BRANCH_MIXED,
|
|
|
|
BRANCH_LAST
|
|
};
|
|
|
|
enum WorkloadDivision
|
|
{
|
|
WORKLOAD_DIVISION_EVEN = 0, //! Both true and false branches contain same amount of computation.
|
|
WORKLOAD_DIVISION_TRUE_HEAVY, //! True branch contains more computation.
|
|
WORKLOAD_DIVISION_FALSE_HEAVY, //! False branch contains more computation.
|
|
|
|
WORKLOAD_DIVISION_LAST
|
|
};
|
|
|
|
ConditionalCase (Context& context, const char* name, const char* description, DecisionType decisionType, BranchResult branchType, WorkloadDivision workloadDivision, bool isVertex);
|
|
~ConditionalCase (void);
|
|
|
|
void init (void);
|
|
void deinit (void);
|
|
void setupProgram (deUint32 program);
|
|
|
|
private:
|
|
DecisionType m_decisionType;
|
|
BranchResult m_branchType;
|
|
WorkloadDivision m_workloadDivision;
|
|
|
|
vector<float> m_comparisonValueArray; // Will contain per-vertex comparison values if using mixed branch type in vertex case.
|
|
deUint32 m_arrayBuffer;
|
|
};
|
|
|
|
ConditionalCase::ConditionalCase (Context& context, const char* name, const char* description, DecisionType decisionType, BranchResult branchType, WorkloadDivision workloadDivision, bool isVertex)
|
|
: ControlStatementCase (context.getTestContext(), context.getRenderContext(), name, description, isVertex ? CASETYPE_VERTEX : CASETYPE_FRAGMENT)
|
|
, m_decisionType (decisionType)
|
|
, m_branchType (branchType)
|
|
, m_workloadDivision (workloadDivision)
|
|
, m_arrayBuffer (0)
|
|
{
|
|
}
|
|
|
|
void ConditionalCase::init (void)
|
|
{
|
|
bool isVertexCase = m_caseType == CASETYPE_VERTEX;
|
|
|
|
bool isStaticCase = m_decisionType == DECISION_STATIC;
|
|
bool isUniformCase = m_decisionType == DECISION_UNIFORM;
|
|
bool isAttributeCase = m_decisionType == DECISION_ATTRIBUTE;
|
|
|
|
DE_ASSERT(isStaticCase || isUniformCase || isAttributeCase);
|
|
|
|
bool isConditionTrue = m_branchType == BRANCH_TRUE;
|
|
bool isConditionFalse = m_branchType == BRANCH_FALSE;
|
|
bool isConditionMixed = m_branchType == BRANCH_MIXED;
|
|
|
|
DE_ASSERT(isConditionTrue || isConditionFalse || isConditionMixed);
|
|
DE_UNREF(isConditionFalse);
|
|
|
|
DE_ASSERT(isAttributeCase || !isConditionMixed); // The branch taken can vary between executions only if using attribute input.
|
|
|
|
const char* staticCompareValueStr = isConditionTrue ? "1.0" : "-1.0";
|
|
const char* compareValueStr = isStaticCase ? staticCompareValueStr :
|
|
isUniformCase ? "u_compareValue" :
|
|
isVertexCase ? "a_compareValue" :
|
|
"v_compareValue";
|
|
|
|
std::ostringstream vtx;
|
|
std::ostringstream frag;
|
|
std::ostringstream& op = isVertexCase ? vtx : frag;
|
|
|
|
vtx << "attribute highp vec4 a_position;\n"; // Position attribute.
|
|
vtx << "attribute mediump vec4 a_value0;\n"; // Input for workload calculations of "true" branch.
|
|
vtx << "attribute mediump vec4 a_value1;\n"; // Input for workload calculations of "false" branch.
|
|
|
|
// Value to be used in the conditional expression.
|
|
if (isAttributeCase)
|
|
vtx << "attribute mediump float a_compareValue;\n";
|
|
else if (isUniformCase)
|
|
op << "uniform mediump float u_compareValue;\n";
|
|
|
|
// Varyings.
|
|
if (isVertexCase)
|
|
{
|
|
vtx << "varying mediump vec4 v_color;\n";
|
|
frag << "varying mediump vec4 v_color;\n";
|
|
}
|
|
else
|
|
{
|
|
vtx << "varying mediump vec4 v_value0;\n";
|
|
vtx << "varying mediump vec4 v_value1;\n";
|
|
frag << "varying mediump vec4 v_value0;\n";
|
|
frag << "varying mediump vec4 v_value1;\n";
|
|
|
|
if (isAttributeCase)
|
|
{
|
|
vtx << "varying mediump float v_compareValue;\n";
|
|
frag << "varying mediump float v_compareValue;\n";
|
|
}
|
|
}
|
|
|
|
vtx << "\n";
|
|
vtx << "void main()\n";
|
|
vtx << "{\n";
|
|
vtx << " gl_Position = a_position;\n";
|
|
|
|
frag << "\n";
|
|
frag << "void main()\n";
|
|
frag << "{\n";
|
|
|
|
op << " mediump vec4 res;\n";
|
|
|
|
string condition;
|
|
|
|
if (isConditionMixed && !isVertexCase)
|
|
condition = string("") + "fract(" + compareValueStr + ") < 0.5"; // Comparison result varies with high frequency.
|
|
else
|
|
condition = string("") + compareValueStr + " > 0.0";
|
|
|
|
op << " if (" << condition << ")\n";
|
|
op << " {\n";
|
|
|
|
op << "\t\t";
|
|
if (m_workloadDivision == WORKLOAD_DIVISION_EVEN || m_workloadDivision == WORKLOAD_DIVISION_TRUE_HEAVY)
|
|
writeConditionalWorkload(op, "res", isVertexCase ? "a_value0" : "v_value0"); // Workload calculation for the "true" branch.
|
|
else
|
|
op << "res = " << (isVertexCase ? "a_value0" : "v_value0") << ";";
|
|
op << "\n";
|
|
|
|
op << " }\n";
|
|
op << " else\n";
|
|
op << " {\n";
|
|
|
|
op << "\t\t";
|
|
if (m_workloadDivision == WORKLOAD_DIVISION_EVEN || m_workloadDivision == WORKLOAD_DIVISION_FALSE_HEAVY)
|
|
writeConditionalWorkload(op, "res", isVertexCase ? "a_value1" : "v_value1"); // Workload calculations for the "false" branch.
|
|
else
|
|
op << "res = " << (isVertexCase ? "a_value1" : "v_value1") << ";";
|
|
op << "\n";
|
|
|
|
op << " }\n";
|
|
|
|
if (isVertexCase)
|
|
{
|
|
// Put result to color variable.
|
|
vtx << " v_color = res;\n";
|
|
frag << " gl_FragColor = v_color;\n";
|
|
}
|
|
else
|
|
{
|
|
// Transfer inputs to fragment shader through varyings.
|
|
if (isAttributeCase)
|
|
vtx << " v_compareValue = a_compareValue;\n";
|
|
vtx << " v_value0 = a_value0;\n";
|
|
vtx << " v_value1 = a_value1;\n";
|
|
|
|
frag << " gl_FragColor = res;\n"; // Put result to color variable.
|
|
}
|
|
|
|
vtx << "}\n";
|
|
frag << "}\n";
|
|
|
|
m_vertShaderSource = vtx.str();
|
|
m_fragShaderSource = frag.str();
|
|
|
|
if (isAttributeCase)
|
|
{
|
|
if (!isConditionMixed)
|
|
{
|
|
// Every execution takes the same branch.
|
|
|
|
float value = isConditionTrue ? +1.0f : -1.0f;
|
|
m_attributes.push_back(AttribSpec("a_compareValue", Vec4(value, 0.0f, 0.0f, 0.0f),
|
|
Vec4(value, 0.0f, 0.0f, 0.0f),
|
|
Vec4(value, 0.0f, 0.0f, 0.0f),
|
|
Vec4(value, 0.0f, 0.0f, 0.0f)));
|
|
}
|
|
else if (isVertexCase)
|
|
{
|
|
// Vertex case, not every execution takes the same branch.
|
|
|
|
const int numComponents = 4;
|
|
int numVertices = (getGridWidth() + 1) * (getGridHeight() + 1);
|
|
|
|
// setupProgram() will later bind this array as an attribute.
|
|
m_comparisonValueArray.resize(numVertices * numComponents);
|
|
|
|
// Make every second vertex take the true branch, and every second the false branch.
|
|
for (int i = 0; i < (int)m_comparisonValueArray.size(); i++)
|
|
{
|
|
if (i % numComponents == 0)
|
|
m_comparisonValueArray[i] = (i / numComponents) % 2 == 0 ? +1.0f : -1.0f;
|
|
else
|
|
m_comparisonValueArray[i] = 0.0f;
|
|
}
|
|
}
|
|
else // isConditionMixed && !isVertexCase
|
|
{
|
|
// Fragment case, not every execution takes the same branch.
|
|
// \note fract(a_compareValue) < 0.5 will be true for every second column of fragments.
|
|
|
|
float minValue = 0.0f;
|
|
float maxValue = (float)getViewportWidth()*0.5f;
|
|
m_attributes.push_back(AttribSpec("a_compareValue", Vec4(minValue, 0.0f, 0.0f, 0.0f),
|
|
Vec4(maxValue, 0.0f, 0.0f, 0.0f),
|
|
Vec4(minValue, 0.0f, 0.0f, 0.0f),
|
|
Vec4(maxValue, 0.0f, 0.0f, 0.0f)));
|
|
}
|
|
}
|
|
|
|
m_attributes.push_back(AttribSpec("a_value0", Vec4(0.0f, 0.1f, 0.2f, 0.3f),
|
|
Vec4(0.4f, 0.5f, 0.6f, 0.7f),
|
|
Vec4(0.8f, 0.9f, 1.0f, 1.1f),
|
|
Vec4(1.2f, 1.3f, 1.4f, 1.5f)));
|
|
|
|
m_attributes.push_back(AttribSpec("a_value1", Vec4(0.0f, 0.1f, 0.2f, 0.3f),
|
|
Vec4(0.4f, 0.5f, 0.6f, 0.7f),
|
|
Vec4(0.8f, 0.9f, 1.0f, 1.1f),
|
|
Vec4(1.2f, 1.3f, 1.4f, 1.5f)));
|
|
|
|
ControlStatementCase::init();
|
|
}
|
|
|
|
void ConditionalCase::setupProgram (deUint32 program)
|
|
{
|
|
const glw::Functions& gl = m_renderCtx.getFunctions();
|
|
|
|
if (m_decisionType == DECISION_UNIFORM)
|
|
{
|
|
int location = gl.getUniformLocation(program, "u_compareValue");
|
|
gl.uniform1f(location, m_branchType == BRANCH_TRUE ? +1.0f : -1.0f);
|
|
}
|
|
else if (m_decisionType == DECISION_ATTRIBUTE && m_branchType == BRANCH_MIXED && m_caseType == CASETYPE_VERTEX)
|
|
{
|
|
// Setup per-vertex comparison values calculated in init().
|
|
|
|
const int numComponents = 4;
|
|
int compareAttribLocation = gl.getAttribLocation(program, "a_compareValue");
|
|
|
|
DE_ASSERT((int)m_comparisonValueArray.size() == numComponents * (getGridWidth() + 1) * (getGridHeight() + 1));
|
|
|
|
gl.genBuffers(1, &m_arrayBuffer);
|
|
gl.bindBuffer(GL_ARRAY_BUFFER, m_arrayBuffer);
|
|
gl.bufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(m_comparisonValueArray.size()*sizeof(float)), &m_comparisonValueArray[0], GL_STATIC_DRAW);
|
|
gl.enableVertexAttribArray(compareAttribLocation);
|
|
gl.vertexAttribPointer(compareAttribLocation, (GLint)numComponents, GL_FLOAT, GL_FALSE, 0, DE_NULL);
|
|
}
|
|
|
|
GLU_EXPECT_NO_ERROR(gl.getError(), "Setup program state");
|
|
}
|
|
|
|
ConditionalCase::~ConditionalCase (void)
|
|
{
|
|
const glw::Functions& gl = m_renderCtx.getFunctions();
|
|
|
|
if (m_arrayBuffer != 0)
|
|
{
|
|
gl.deleteBuffers(1, &m_arrayBuffer);
|
|
m_arrayBuffer = 0;
|
|
}
|
|
}
|
|
|
|
void ConditionalCase::deinit (void)
|
|
{
|
|
const glw::Functions& gl = m_renderCtx.getFunctions();
|
|
|
|
m_comparisonValueArray.clear();
|
|
|
|
if (m_arrayBuffer != 0)
|
|
{
|
|
gl.deleteBuffers(1, &m_arrayBuffer);
|
|
m_arrayBuffer = 0;
|
|
}
|
|
|
|
ShaderPerformanceCase::deinit();
|
|
}
|
|
|
|
class LoopCase : public ControlStatementCase
|
|
{
|
|
public:
|
|
enum LoopType
|
|
{
|
|
LOOP_FOR = 0,
|
|
LOOP_WHILE,
|
|
LOOP_DO_WHILE,
|
|
|
|
LOOP_LAST
|
|
};
|
|
LoopCase (Context& context, const char* name, const char* description, LoopType type, DecisionType decisionType, bool isLoopBoundStable, bool isVertex);
|
|
~LoopCase (void);
|
|
|
|
void init (void);
|
|
void deinit (void);
|
|
void setupProgram (deUint32 program);
|
|
|
|
private:
|
|
DecisionType m_decisionType;
|
|
LoopType m_type;
|
|
|
|
bool m_isLoopBoundStable; // Whether loop bound is same in all executions.
|
|
vector<float> m_boundArray; // Will contain per-vertex loop bounds if using non-stable attribute in vertex case.
|
|
deUint32 m_arrayBuffer;
|
|
};
|
|
|
|
LoopCase::LoopCase (Context& context, const char* name, const char* description, LoopType type, DecisionType decisionType, bool isLoopBoundStable, bool isVertex)
|
|
: ControlStatementCase (context.getTestContext(), context.getRenderContext(), name, description, isVertex ? CASETYPE_VERTEX : CASETYPE_FRAGMENT)
|
|
, m_decisionType (decisionType)
|
|
, m_type (type)
|
|
, m_isLoopBoundStable (isLoopBoundStable)
|
|
, m_arrayBuffer (0)
|
|
{
|
|
}
|
|
|
|
void LoopCase::init (void)
|
|
{
|
|
bool isVertexCase = m_caseType == CASETYPE_VERTEX;
|
|
|
|
bool isStaticCase = m_decisionType == DECISION_STATIC;
|
|
bool isUniformCase = m_decisionType == DECISION_UNIFORM;
|
|
bool isAttributeCase = m_decisionType == DECISION_ATTRIBUTE;
|
|
|
|
DE_ASSERT(isStaticCase || isUniformCase || isAttributeCase);
|
|
|
|
DE_ASSERT(m_type == LOOP_FOR ||
|
|
m_type == LOOP_WHILE ||
|
|
m_type == LOOP_DO_WHILE);
|
|
|
|
DE_ASSERT(isAttributeCase || m_isLoopBoundStable); // The loop bound count can vary between executions only if using attribute input.
|
|
|
|
// \note The fractional part is .5 (instead of .0) so that these can be safely used as loop bounds.
|
|
const float loopBound = 10.5f;
|
|
const float unstableBoundLow = 5.5f;
|
|
const float unstableBoundHigh = 15.5f;
|
|
static const char* loopBoundStr = "10.5";
|
|
static const char* unstableBoundLowStr = "5.5";
|
|
static const char* unstableBoundHighStr = "15.5";
|
|
|
|
const char* boundValueStr = isStaticCase ? loopBoundStr :
|
|
isUniformCase ? "u_bound" :
|
|
isVertexCase ? "a_bound" :
|
|
m_isLoopBoundStable ? "v_bound" :
|
|
"loopBound";
|
|
|
|
std::ostringstream vtx;
|
|
std::ostringstream frag;
|
|
std::ostringstream& op = isVertexCase ? vtx : frag;
|
|
|
|
vtx << "attribute highp vec4 a_position;\n"; // Position attribute.
|
|
vtx << "attribute mediump vec4 a_value;\n"; // Input for workload calculations.
|
|
|
|
// Value to be used as the loop iteration count.
|
|
if (isAttributeCase)
|
|
vtx << "attribute mediump float a_bound;\n";
|
|
else if (isUniformCase)
|
|
op << "uniform mediump float u_bound;\n";
|
|
|
|
// Varyings.
|
|
if (isVertexCase)
|
|
{
|
|
vtx << "varying mediump vec4 v_color;\n";
|
|
frag << "varying mediump vec4 v_color;\n";
|
|
}
|
|
else
|
|
{
|
|
vtx << "varying mediump vec4 v_value;\n";
|
|
frag << "varying mediump vec4 v_value;\n";
|
|
|
|
if (isAttributeCase)
|
|
{
|
|
vtx << "varying mediump float v_bound;\n";
|
|
frag << "varying mediump float v_bound;\n";
|
|
}
|
|
}
|
|
|
|
vtx << "\n";
|
|
vtx << "void main()\n";
|
|
vtx << "{\n";
|
|
vtx << " gl_Position = a_position;\n";
|
|
|
|
frag << "\n";
|
|
frag << "void main()\n";
|
|
frag << "{\n";
|
|
|
|
op << " mediump vec4 res = vec4(0.0);\n";
|
|
|
|
if (!m_isLoopBoundStable && !isVertexCase)
|
|
{
|
|
// Choose the actual loop bound based on v_bound.
|
|
// \note Loop bound will vary with high frequency between fragment columns, given appropriate range for v_bound.
|
|
op << " mediump float loopBound = fract(v_bound) < 0.5 ? " << unstableBoundLowStr << " : " << unstableBoundHighStr << ";\n";
|
|
}
|
|
|
|
// Start a for, while or do-while loop.
|
|
if (m_type == LOOP_FOR)
|
|
op << " for (mediump float i = 0.0; i < " << boundValueStr << "; i++)\n";
|
|
else
|
|
{
|
|
op << " mediump float i = 0.0;\n";
|
|
if (m_type == LOOP_WHILE)
|
|
op << " while (i < " << boundValueStr << ")\n";
|
|
else // LOOP_DO_WHILE
|
|
op << " do\n";
|
|
}
|
|
op << " {\n";
|
|
|
|
// Workload calculations inside the loop.
|
|
op << "\t\t";
|
|
writeLoopWorkload(op, "res", isVertexCase ? "a_value" : "v_value");
|
|
op << "\n";
|
|
|
|
// Only "for" has counter increment in the loop head.
|
|
if (m_type != LOOP_FOR)
|
|
op << " i++;\n";
|
|
|
|
// End the loop.
|
|
if (m_type == LOOP_DO_WHILE)
|
|
op << " } while (i < " << boundValueStr << ");\n";
|
|
else
|
|
op << " }\n";
|
|
|
|
if (isVertexCase)
|
|
{
|
|
// Put result to color variable.
|
|
vtx << " v_color = res;\n";
|
|
frag << " gl_FragColor = v_color;\n";
|
|
}
|
|
else
|
|
{
|
|
// Transfer inputs to fragment shader through varyings.
|
|
if (isAttributeCase)
|
|
vtx << " v_bound = a_bound;\n";
|
|
vtx << " v_value = a_value;\n";
|
|
|
|
frag << " gl_FragColor = res;\n"; // Put result to color variable.
|
|
}
|
|
|
|
vtx << "}\n";
|
|
frag << "}\n";
|
|
|
|
m_vertShaderSource = vtx.str();
|
|
m_fragShaderSource = frag.str();
|
|
|
|
if (isAttributeCase)
|
|
{
|
|
if (m_isLoopBoundStable)
|
|
{
|
|
// Every execution has same number of iterations.
|
|
|
|
m_attributes.push_back(AttribSpec("a_bound", Vec4(loopBound, 0.0f, 0.0f, 0.0f),
|
|
Vec4(loopBound, 0.0f, 0.0f, 0.0f),
|
|
Vec4(loopBound, 0.0f, 0.0f, 0.0f),
|
|
Vec4(loopBound, 0.0f, 0.0f, 0.0f)));
|
|
}
|
|
else if (isVertexCase)
|
|
{
|
|
// Vertex case, with non-constant number of iterations.
|
|
|
|
const int numComponents = 4;
|
|
int numVertices = (getGridWidth() + 1) * (getGridHeight() + 1);
|
|
|
|
// setupProgram() will later bind this array as an attribute.
|
|
m_boundArray.resize(numVertices * numComponents);
|
|
|
|
// Vary between low and high loop bounds; they should average to loopBound however.
|
|
for (int i = 0; i < (int)m_boundArray.size(); i++)
|
|
{
|
|
if (i % numComponents == 0)
|
|
m_boundArray[i] = (i / numComponents) % 2 == 0 ? unstableBoundLow : unstableBoundHigh;
|
|
else
|
|
m_boundArray[i] = 0.0f;
|
|
}
|
|
}
|
|
else // !m_isLoopBoundStable && !isVertexCase
|
|
{
|
|
// Fragment case, with non-constant number of iterations.
|
|
// \note fract(a_bound) < 0.5 will be true for every second fragment.
|
|
|
|
float minValue = 0.0f;
|
|
float maxValue = (float)getViewportWidth()*0.5f;
|
|
m_attributes.push_back(AttribSpec("a_bound", Vec4(minValue, 0.0f, 0.0f, 0.0f),
|
|
Vec4(maxValue, 0.0f, 0.0f, 0.0f),
|
|
Vec4(minValue, 0.0f, 0.0f, 0.0f),
|
|
Vec4(maxValue, 0.0f, 0.0f, 0.0f)));
|
|
}
|
|
}
|
|
|
|
m_attributes.push_back(AttribSpec("a_value", Vec4(0.0f, 0.1f, 0.2f, 0.3f),
|
|
Vec4(0.4f, 0.5f, 0.6f, 0.7f),
|
|
Vec4(0.8f, 0.9f, 1.0f, 1.1f),
|
|
Vec4(1.2f, 1.3f, 1.4f, 1.5f)));
|
|
|
|
ControlStatementCase::init();
|
|
}
|
|
|
|
void LoopCase::setupProgram (deUint32 program)
|
|
{
|
|
const glw::Functions& gl = m_renderCtx.getFunctions();
|
|
|
|
if (m_decisionType == DECISION_UNIFORM)
|
|
{
|
|
const float loopBound = 10.5f;
|
|
|
|
int location = gl.getUniformLocation(program, "u_bound");
|
|
gl.uniform1f(location, loopBound);
|
|
}
|
|
else if (m_decisionType == DECISION_ATTRIBUTE && !m_isLoopBoundStable && m_caseType == CASETYPE_VERTEX)
|
|
{
|
|
// Setup per-vertex loop bounds calculated in init().
|
|
|
|
const int numComponents = 4;
|
|
int boundAttribLocation = gl.getAttribLocation(program, "a_bound");
|
|
|
|
DE_ASSERT((int)m_boundArray.size() == numComponents * (getGridWidth() + 1) * (getGridHeight() + 1));
|
|
|
|
gl.genBuffers(1, &m_arrayBuffer);
|
|
gl.bindBuffer(GL_ARRAY_BUFFER, m_arrayBuffer);
|
|
gl.bufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(m_boundArray.size()*sizeof(float)), &m_boundArray[0], GL_STATIC_DRAW);
|
|
gl.enableVertexAttribArray(boundAttribLocation);
|
|
gl.vertexAttribPointer(boundAttribLocation, (GLint)numComponents, GL_FLOAT, GL_FALSE, 0, DE_NULL);
|
|
}
|
|
|
|
GLU_EXPECT_NO_ERROR(gl.getError(), "Setup program state");
|
|
}
|
|
|
|
LoopCase::~LoopCase (void)
|
|
{
|
|
const glw::Functions& gl = m_renderCtx.getFunctions();
|
|
|
|
if (m_arrayBuffer)
|
|
{
|
|
gl.deleteBuffers(1, &m_arrayBuffer);
|
|
m_arrayBuffer = 0;
|
|
}
|
|
}
|
|
|
|
void LoopCase::deinit (void)
|
|
{
|
|
const glw::Functions& gl = m_renderCtx.getFunctions();
|
|
|
|
m_boundArray.clear();
|
|
|
|
if (m_arrayBuffer)
|
|
{
|
|
gl.deleteBuffers(1, &m_arrayBuffer);
|
|
m_arrayBuffer = 0;
|
|
}
|
|
|
|
ShaderPerformanceCase::deinit();
|
|
}
|
|
|
|
// A reference case, same calculations as the actual tests but without control statements.
|
|
class WorkloadReferenceCase : public ControlStatementCase
|
|
{
|
|
public:
|
|
WorkloadReferenceCase (Context& context, const char* name, const char* description, bool isVertex);
|
|
|
|
void init (void);
|
|
|
|
protected:
|
|
virtual void writeWorkload (std::ostringstream& dst, const char* resultVariableName, const char* inputVariableName) const = 0;
|
|
};
|
|
|
|
WorkloadReferenceCase::WorkloadReferenceCase (Context& context, const char* name, const char* description, bool isVertex)
|
|
: ControlStatementCase(context.getTestContext(), context.getRenderContext(), name, description, isVertex ? CASETYPE_VERTEX : CASETYPE_FRAGMENT)
|
|
{
|
|
}
|
|
|
|
void WorkloadReferenceCase::init (void)
|
|
{
|
|
bool isVertexCase = m_caseType == CASETYPE_VERTEX;
|
|
|
|
std::ostringstream vtx;
|
|
std::ostringstream frag;
|
|
std::ostringstream& op = isVertexCase ? vtx : frag;
|
|
|
|
vtx << "attribute highp vec4 a_position;\n"; // Position attribute.
|
|
vtx << "attribute mediump vec4 a_value;\n"; // Value for workload calculations.
|
|
|
|
// Varyings.
|
|
if (isVertexCase)
|
|
{
|
|
vtx << "varying mediump vec4 v_color;\n";
|
|
frag << "varying mediump vec4 v_color;\n";
|
|
}
|
|
else
|
|
{
|
|
vtx << "varying mediump vec4 v_value;\n";
|
|
frag << "varying mediump vec4 v_value;\n";
|
|
}
|
|
|
|
vtx << "\n";
|
|
vtx << "void main()\n";
|
|
vtx << "{\n";
|
|
vtx << " gl_Position = a_position;\n";
|
|
|
|
frag << "\n";
|
|
frag << "void main()\n";
|
|
frag << "{\n";
|
|
|
|
op << "\tmediump vec4 res;\n";
|
|
writeWorkload(op, "res", isVertexCase ? "a_value" : "v_value");
|
|
|
|
if (isVertexCase)
|
|
{
|
|
// Put result to color variable.
|
|
vtx << " v_color = res;\n";
|
|
frag << " gl_FragColor = v_color;\n";
|
|
}
|
|
else
|
|
{
|
|
vtx << " v_value = a_value;\n"; // Transfer input to fragment shader through varying.
|
|
frag << " gl_FragColor = res;\n"; // Put result to color variable.
|
|
}
|
|
|
|
vtx << "}\n";
|
|
frag << "}\n";
|
|
|
|
m_vertShaderSource = vtx.str();
|
|
m_fragShaderSource = frag.str();
|
|
|
|
m_attributes.push_back(AttribSpec("a_value", Vec4(0.0f, 0.1f, 0.2f, 0.3f),
|
|
Vec4(0.4f, 0.5f, 0.6f, 0.7f),
|
|
Vec4(0.8f, 0.9f, 1.0f, 1.1f),
|
|
Vec4(1.2f, 1.3f, 1.4f, 1.5f)));
|
|
|
|
ControlStatementCase::init();
|
|
}
|
|
|
|
class LoopWorkloadReferenceCase : public WorkloadReferenceCase
|
|
{
|
|
public:
|
|
LoopWorkloadReferenceCase (Context& context, const char* name, const char* description, bool isAttributeStable, bool isVertex)
|
|
: WorkloadReferenceCase (context, name, description, isVertex)
|
|
, m_isAttributeStable (isAttributeStable)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void writeWorkload (std::ostringstream& dst, const char* resultVariableName, const char* inputVariableName) const;
|
|
|
|
private:
|
|
bool m_isAttributeStable;
|
|
};
|
|
|
|
void LoopWorkloadReferenceCase::writeWorkload (std::ostringstream& dst, const char* resultVariableName, const char* inputVariableName) const
|
|
{
|
|
const int loopIterations = 11;
|
|
bool isVertexCase = m_caseType == CASETYPE_VERTEX;
|
|
|
|
dst << "\t" << resultVariableName << " = vec4(0.0);\n";
|
|
|
|
for (int i = 0; i < loopIterations; i++)
|
|
{
|
|
dst << "\t";
|
|
writeLoopWorkload(dst, resultVariableName, inputVariableName);
|
|
dst << "\n";
|
|
}
|
|
|
|
if (!isVertexCase && !m_isAttributeStable)
|
|
{
|
|
// Corresponds to the fract() done in a real test's fragment case with non-stable attribute.
|
|
dst << " res.x = fract(res.x);\n";
|
|
}
|
|
}
|
|
|
|
class ConditionalWorkloadReferenceCase : public WorkloadReferenceCase
|
|
{
|
|
public:
|
|
ConditionalWorkloadReferenceCase (Context& context, const char* name, const char* description, bool isAttributeStable, bool isVertex)
|
|
: WorkloadReferenceCase (context, name, description, isVertex)
|
|
, m_isAttributeStable (isAttributeStable)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void writeWorkload (std::ostringstream& dst, const char* resultVariableName, const char* inputVariableName) const;
|
|
|
|
private:
|
|
bool m_isAttributeStable;
|
|
};
|
|
|
|
void ConditionalWorkloadReferenceCase::writeWorkload (std::ostringstream& dst, const char* resultVariableName, const char* inputVariableName) const
|
|
{
|
|
bool isVertexCase = m_caseType == CASETYPE_VERTEX;
|
|
|
|
dst << "\t";
|
|
writeConditionalWorkload(dst, resultVariableName, inputVariableName);
|
|
dst << "\n";
|
|
|
|
if (!isVertexCase && !m_isAttributeStable)
|
|
{
|
|
// Corresponds to the fract() done in a real test's fragment case with non-stable attribute.
|
|
dst << " res.x = fract(res.x);\n";
|
|
}
|
|
}
|
|
|
|
// A workload reference case for e.g. a conditional case with a branch with no computation.
|
|
class EmptyWorkloadReferenceCase : public WorkloadReferenceCase
|
|
{
|
|
public:
|
|
EmptyWorkloadReferenceCase (Context& context, const char* name, const char* description, bool isVertex)
|
|
: WorkloadReferenceCase (context, name, description, isVertex)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void writeWorkload (std::ostringstream& dst, const char* resultVariableName, const char* inputVariableName) const
|
|
{
|
|
dst << "\t" << resultVariableName << " = " << inputVariableName << ";\n";
|
|
}
|
|
};
|
|
|
|
ShaderControlStatementTests::ShaderControlStatementTests (Context& context)
|
|
: TestCaseGroup(context, "control_statement", "Control Statement Performance Tests")
|
|
{
|
|
}
|
|
|
|
ShaderControlStatementTests::~ShaderControlStatementTests (void)
|
|
{
|
|
}
|
|
|
|
void ShaderControlStatementTests::init (void)
|
|
{
|
|
// Conditional cases (if-else).
|
|
|
|
tcu::TestCaseGroup* ifElseGroup = new tcu::TestCaseGroup(m_testCtx, "if_else", "if-else Conditional Performance Tests");
|
|
addChild(ifElseGroup);
|
|
|
|
for (int isFrag = 0; isFrag <= 1; isFrag++)
|
|
{
|
|
bool isVertex = isFrag == 0;
|
|
ShaderPerformanceCaseGroup* vertexOrFragmentGroup = new ShaderPerformanceCaseGroup(m_testCtx, isVertex ? "vertex" : "fragment", "");
|
|
ifElseGroup->addChild(vertexOrFragmentGroup);
|
|
|
|
DE_STATIC_ASSERT(DECISION_STATIC == 0);
|
|
for (int decisionType = (int)DECISION_STATIC; decisionType < (int)DECISION_LAST; decisionType++)
|
|
{
|
|
const char* decisionName = decisionType == (int)DECISION_STATIC ? "static" :
|
|
decisionType == (int)DECISION_UNIFORM ? "uniform" :
|
|
decisionType == (int)DECISION_ATTRIBUTE ? (isVertex ? "attribute" : "varying") :
|
|
DE_NULL;
|
|
DE_ASSERT(decisionName != DE_NULL);
|
|
|
|
for (int workloadDivision = 0; workloadDivision < ConditionalCase::WORKLOAD_DIVISION_LAST; workloadDivision++)
|
|
{
|
|
const char* workloadDivisionSuffix = workloadDivision == (int)ConditionalCase::WORKLOAD_DIVISION_EVEN ? "" :
|
|
workloadDivision == (int)ConditionalCase::WORKLOAD_DIVISION_TRUE_HEAVY ? "_with_heavier_true" :
|
|
workloadDivision == (int)ConditionalCase::WORKLOAD_DIVISION_FALSE_HEAVY ? "_with_heavier_false" :
|
|
DE_NULL;
|
|
DE_ASSERT(workloadDivisionSuffix != DE_NULL);
|
|
|
|
DE_STATIC_ASSERT(ConditionalCase::BRANCH_TRUE == 0);
|
|
for (int branchResult = (int)ConditionalCase::BRANCH_TRUE; branchResult < (int)ConditionalCase::BRANCH_LAST; branchResult++)
|
|
{
|
|
if (decisionType != (int)DECISION_ATTRIBUTE && branchResult == (int)ConditionalCase::BRANCH_MIXED)
|
|
continue;
|
|
|
|
const char* branchResultName = branchResult == (int)ConditionalCase::BRANCH_TRUE ? "true" :
|
|
branchResult == (int)ConditionalCase::BRANCH_FALSE ? "false" :
|
|
branchResult == (int)ConditionalCase::BRANCH_MIXED ? "mixed" :
|
|
DE_NULL;
|
|
DE_ASSERT(branchResultName != DE_NULL);
|
|
|
|
string caseName = string("") + decisionName + "_" + branchResultName + workloadDivisionSuffix;
|
|
|
|
vertexOrFragmentGroup->addChild(new ConditionalCase(m_context, caseName.c_str(), "",
|
|
(DecisionType)decisionType, (ConditionalCase::BranchResult)branchResult,
|
|
(ConditionalCase::WorkloadDivision)workloadDivision, isVertex));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isVertex)
|
|
vertexOrFragmentGroup->addChild(new ConditionalWorkloadReferenceCase(m_context, "reference", "", true, isVertex));
|
|
else
|
|
{
|
|
// Only fragment case with BRANCH_MIXED has an additional fract() call.
|
|
vertexOrFragmentGroup->addChild(new ConditionalWorkloadReferenceCase(m_context, "reference_unmixed", "", true, isVertex));
|
|
vertexOrFragmentGroup->addChild(new ConditionalWorkloadReferenceCase(m_context, "reference_mixed", "", false, isVertex));
|
|
}
|
|
|
|
vertexOrFragmentGroup->addChild(new EmptyWorkloadReferenceCase(m_context, "reference_empty", "", isVertex));
|
|
}
|
|
|
|
// Loop cases.
|
|
|
|
static const struct
|
|
{
|
|
LoopCase::LoopType type;
|
|
const char* name;
|
|
const char* description;
|
|
} loopGroups[] =
|
|
{
|
|
{LoopCase::LOOP_FOR, "for", "for Loop Performance Tests"},
|
|
{LoopCase::LOOP_WHILE, "while", "while Loop Performance Tests"},
|
|
{LoopCase::LOOP_DO_WHILE, "do_while", "do-while Loop Performance Tests"}
|
|
};
|
|
|
|
for (int groupNdx = 0; groupNdx < DE_LENGTH_OF_ARRAY(loopGroups); groupNdx++)
|
|
{
|
|
tcu::TestCaseGroup* currentLoopGroup = new tcu::TestCaseGroup(m_testCtx, loopGroups[groupNdx].name, loopGroups[groupNdx].description);
|
|
addChild(currentLoopGroup);
|
|
|
|
for (int isFrag = 0; isFrag <= 1; isFrag++)
|
|
{
|
|
bool isVertex = isFrag == 0;
|
|
ShaderPerformanceCaseGroup* vertexOrFragmentGroup = new ShaderPerformanceCaseGroup(m_testCtx, isVertex ? "vertex" : "fragment", "");
|
|
currentLoopGroup->addChild(vertexOrFragmentGroup);
|
|
|
|
DE_STATIC_ASSERT(DECISION_STATIC == 0);
|
|
for (int decisionType = (int)DECISION_STATIC; decisionType < (int)DECISION_LAST; decisionType++)
|
|
{
|
|
const char* decisionName = decisionType == (int)DECISION_STATIC ? "static" :
|
|
decisionType == (int)DECISION_UNIFORM ? "uniform" :
|
|
decisionType == (int)DECISION_ATTRIBUTE ? (isVertex ? "attribute" : "varying") :
|
|
DE_NULL;
|
|
DE_ASSERT(decisionName != DE_NULL);
|
|
|
|
if (decisionType == (int)DECISION_ATTRIBUTE)
|
|
{
|
|
vertexOrFragmentGroup->addChild(new LoopCase(m_context, (string(decisionName) + "_stable").c_str(), "", loopGroups[groupNdx].type, (DecisionType)decisionType, true, isVertex));
|
|
vertexOrFragmentGroup->addChild(new LoopCase(m_context, (string(decisionName) + "_unstable").c_str(), "", loopGroups[groupNdx].type, (DecisionType)decisionType, false, isVertex));
|
|
}
|
|
else
|
|
vertexOrFragmentGroup->addChild(new LoopCase(m_context, decisionName, "", loopGroups[groupNdx].type, (DecisionType)decisionType, true, isVertex));
|
|
|
|
}
|
|
|
|
if (isVertex)
|
|
vertexOrFragmentGroup->addChild(new LoopWorkloadReferenceCase(m_context, "reference", "", true, isVertex));
|
|
else
|
|
{
|
|
// Only fragment case with unstable attribute has an additional fract() call.
|
|
vertexOrFragmentGroup->addChild(new LoopWorkloadReferenceCase(m_context, "reference_stable", "", true, isVertex));
|
|
vertexOrFragmentGroup->addChild(new LoopWorkloadReferenceCase(m_context, "reference_unstable", "", false, isVertex));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} // Performance
|
|
} // gles2
|
|
} // deqp
|