/*-------------------------------------------------------------------------
* 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 Texture upload performance tests.
*
* \todo [2012-10-01 pyry]
* - Test different pixel unpack alignments
* - Use multiple textures
* - Trash cache prior to uploading from data ptr
*//*--------------------------------------------------------------------*/
#include "es2pTextureUploadTests.hpp"
#include "tcuTexture.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuSurface.hpp"
#include "gluTextureUtil.hpp"
#include "gluShaderProgram.hpp"
#include "gluPixelTransfer.hpp"
#include "deStringUtil.hpp"
#include "deRandom.hpp"
#include "deClock.h"
#include "deString.h"
#include "glsCalibration.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include <algorithm>
#include <vector>
namespace deqp
{
namespace gles2
{
namespace Performance
{
using tcu::Vec2;
using tcu::Vec3;
using tcu::Vec4;
using tcu::IVec4;
using std::string;
using std::vector;
using tcu::TestLog;
using tcu::TextureFormat;
using namespace glw; // GL types
static const int VIEWPORT_SIZE = 64;
static const float quadCoords[] =
{
-1.0f, -1.0f,
1.0f, -1.0f,
-1.0f, 1.0f,
1.0f, 1.0f
};
class TextureUploadCase : public TestCase
{
public:
TextureUploadCase (Context& context, const char* name, const char* description, UploadFunction uploadFunction, deUint32 format, deUint32 type, int texSize);
~TextureUploadCase (void);
virtual void init (void);
void deinit (void);
virtual IterateResult iterate (void) = 0;
void logResults (void);
protected:
UploadFunction m_uploadFunction;
deUint32 m_format;
deUint32 m_type;
int m_texSize;
int m_alignment;
gls::TheilSenCalibrator m_calibrator;
glu::ShaderProgram* m_program;
deUint32 m_texture;
de::Random m_rnd;
TestLog& m_log;
vector<deUint8> m_texData;
};
TextureUploadCase::TextureUploadCase (Context& context, const char* name, const char* description, UploadFunction uploadFunction, deUint32 format, deUint32 type, int texSize)
: TestCase (context, tcu::NODETYPE_PERFORMANCE, name, description)
, m_uploadFunction (uploadFunction)
, m_format (format)
, m_type (type)
, m_texSize (texSize)
, m_alignment (4)
, m_calibrator ()
, m_program (DE_NULL)
, m_texture (0)
, m_rnd (deStringHash(name))
, m_log (context.getTestContext().getLog())
{
}
TextureUploadCase::~TextureUploadCase (void)
{
TextureUploadCase::deinit();
}
void TextureUploadCase::deinit (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
if (m_program)
{
delete m_program;
m_program = DE_NULL;
}
gl.deleteTextures(1, &m_texture);
m_texture = 0;
m_texData.clear();
}
void TextureUploadCase::init (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
int maxTextureSize;
gl.getIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
if (m_texSize > maxTextureSize)
{
m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Unsupported texture size");
return;
}
// Create program
string vertexShaderSource = "";
string fragmentShaderSource = "";
vertexShaderSource.append( "precision mediump float;\n"
"attribute vec2 a_pos;\n"
"varying vec2 v_texCoord;\n"
"\n"
"void main (void)\n"
"{\n"
" v_texCoord = a_pos;\n"
" gl_Position = vec4(a_pos, 0.5, 1.0);\n"
"}\n");
fragmentShaderSource.append("precision mediump float;\n"
"uniform lowp sampler2D u_sampler;\n"
"varying vec2 v_texCoord;\n"
"\n"
"void main (void)\n"
"{\n"
" gl_FragColor = texture2D(u_sampler, v_texCoord.xy);\n"
"}\n");
DE_ASSERT(!m_program);
m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
if (!m_program->isOk())
{
m_log << *m_program;
TCU_FAIL("Failed to create shader program (m_programRender)");
}
gl.useProgram (m_program->getProgram());
// Init GL state
gl.viewport (0, 0, VIEWPORT_SIZE, VIEWPORT_SIZE);
gl.disable (GL_DEPTH_TEST);
gl.disable (GL_CULL_FACE);
gl.enable (GL_BLEND);
gl.blendFunc (GL_ONE, GL_ONE);
gl.clearColor (0.0f, 0.0f, 0.0f, 1.0f);
gl.clear (GL_COLOR_BUFFER_BIT);
deUint32 uSampler = gl.getUniformLocation(m_program->getProgram(), "u_sampler");
deUint32 aPos = gl.getAttribLocation (m_program->getProgram(), "a_pos");
gl.enableVertexAttribArray (aPos);
gl.vertexAttribPointer (aPos, 2, GL_FLOAT, GL_FALSE, 0, &quadCoords[0]);
gl.uniform1i (uSampler, 0);
// Create texture
gl.activeTexture (GL_TEXTURE0);
gl.genTextures (1, &m_texture);
gl.bindTexture (GL_TEXTURE_2D, m_texture);
gl.pixelStorei (GL_UNPACK_ALIGNMENT, m_alignment);
gl.texParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl.texParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
gl.texParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gl.texParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Prepare texture data
{
const tcu::TextureFormat& texFmt = glu::mapGLTransferFormat(m_format, m_type);
int pixelSize = texFmt.getPixelSize();
int stride = deAlign32(pixelSize*m_texSize, m_alignment);
m_texData.resize(stride*m_texSize);
tcu::PixelBufferAccess access (texFmt, m_texSize, m_texSize, 1, stride, 0, &m_texData[0]);
tcu::fillWithComponentGradients(access, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
}
// Do a dry-run to ensure the pipes are hot
gl.texImage2D (GL_TEXTURE_2D, 0, m_format, m_texSize, m_texSize, 0, m_format, m_type, &m_texData[0]);
gl.drawArrays (GL_TRIANGLE_STRIP, 0, 4);
gl.finish ();
}
void TextureUploadCase::logResults (void)
{
const gls::MeasureState& measureState = m_calibrator.getMeasureState();
// Log measurement details
m_log << TestLog::Section("Measurement details", "Measurement details");
m_log << TestLog::Message << "Uploading texture with " << (m_uploadFunction == UPLOAD_TEXIMAGE2D ? "glTexImage2D" : "glTexSubImage2D") << "." << TestLog::EndMessage; // \todo [arttu] Change enum to struct with name included
m_log << TestLog::Message << "Texture size = " << m_texSize << "x" << m_texSize << "." << TestLog::EndMessage;
m_log << TestLog::Message << "Viewport size = " << VIEWPORT_SIZE << "x" << VIEWPORT_SIZE << "." << TestLog::EndMessage;
m_log << TestLog::Message << measureState.numDrawCalls << " upload calls / iteration" << TestLog::EndMessage;
m_log << TestLog::EndSection;
// Log results
TestLog& log = m_testCtx.getLog();
log << TestLog::Section("Results", "Results");
// Log individual frame durations
//for (int i = 0; i < m_calibrator.measureState.numFrames; i++)
// m_log << TestLog::Message << "Frame " << i+1 << " duration: \t" << m_calibrator.measureState.frameTimes[i] << " us."<< TestLog::EndMessage;
std::vector<deUint64> sortedFrameTimes(measureState.frameTimes.begin(), measureState.frameTimes.end());
std::sort(sortedFrameTimes.begin(), sortedFrameTimes.end());
vector<deUint64>::const_iterator first = sortedFrameTimes.begin();
vector<deUint64>::const_iterator last = sortedFrameTimes.end();
vector<deUint64>::const_iterator middle = first + (last - first) / 2;
deUint64 medianFrameTime = *middle;
double medianMTexelsPerSeconds = (double)(m_texSize*m_texSize*measureState.numDrawCalls) / medianFrameTime;
double medianTexelDrawDurationNs = (double)medianFrameTime * 1000.0 / (double)(m_texSize*m_texSize*measureState.numDrawCalls);
deUint64 totalTime = measureState.getTotalTime();
int numFrames = (int)measureState.frameTimes.size();
deInt64 numTexturesDrawn = measureState.numDrawCalls * numFrames;
deInt64 numPixels = (deInt64)m_texSize * (deInt64)m_texSize * numTexturesDrawn;
double framesPerSecond = (double)numFrames / ((double)totalTime / 1000000.0);
double avgFrameTime = (double)totalTime / (double)numFrames;
double avgMTexelsPerSeconds = (double)numPixels / (double)totalTime;
double avgTexelDrawDurationNs = (double)totalTime * 1000.0 / (double)numPixels;
log << TestLog::Float("FramesPerSecond", "Frames per second in measurement\t\t", "Frames/s", QP_KEY_TAG_PERFORMANCE, (float)framesPerSecond);
log << TestLog::Float("AverageFrameTime", "Average frame duration in measurement\t", "us", QP_KEY_TAG_PERFORMANCE, (float)avgFrameTime);
log << TestLog::Float("AverageTexelPerf", "Average texel upload performance\t\t", "MTex/s", QP_KEY_TAG_PERFORMANCE, (float)avgMTexelsPerSeconds);
log << TestLog::Float("AverageTexelTime", "Average texel upload duration\t\t", "ns", QP_KEY_TAG_PERFORMANCE, (float)avgTexelDrawDurationNs);
log << TestLog::Float("MedianTexelPerf", "Median texel upload performance\t\t", "MTex/s", QP_KEY_TAG_PERFORMANCE, (float)medianMTexelsPerSeconds);
log << TestLog::Float("MedianTexelTime", "Median texel upload duration\t\t", "ns", QP_KEY_TAG_PERFORMANCE, (float)medianTexelDrawDurationNs);
log << TestLog::EndSection;
gls::logCalibrationInfo(log, m_calibrator); // Log calibration details
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::floatToString((float)avgMTexelsPerSeconds, 2).c_str());
}
// Texture upload call case
class TextureUploadCallCase : public TextureUploadCase
{
public:
TextureUploadCallCase (Context& context, const char* name, const char* description, UploadFunction uploadFunction, deUint32 format, deUint32 type, int texSize);
~TextureUploadCallCase (void);
IterateResult iterate (void);
void render (void);
};
TextureUploadCallCase::TextureUploadCallCase (Context& context, const char* name, const char* description, UploadFunction uploadFunction, deUint32 format, deUint32 type, int texSize)
: TextureUploadCase (context, name, description, uploadFunction, format, type, texSize)
{
}
TextureUploadCallCase::~TextureUploadCallCase (void)
{
TextureUploadCase::deinit();
}
void TextureUploadCallCase::render (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
// Draw multiple quads to ensure enough workload
switch (m_uploadFunction)
{
case UPLOAD_TEXIMAGE2D:
gl.texImage2D(GL_TEXTURE_2D, 0, m_format, m_texSize, m_texSize, 0, m_format, m_type, &m_texData[0]);
break;
case UPLOAD_TEXSUBIMAGE2D:
gl.texSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_texSize, m_texSize, m_format, m_type, &m_texData[0]);
break;
default:
DE_ASSERT(false);
}
}
tcu::TestNode::IterateResult TextureUploadCallCase::iterate (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
if (m_testCtx.getTestResult() == QP_TEST_RESULT_NOT_SUPPORTED)
return STOP;
for (;;)
{
gls::TheilSenCalibrator::State state = m_calibrator.getState();
if (state == gls::TheilSenCalibrator::STATE_MEASURE)
{
int numCalls = m_calibrator.getCallCount();
deUint64 startTime = deGetMicroseconds();
for (int i = 0; i < numCalls; i++)
render();
gl.finish();
deUint64 endTime = deGetMicroseconds();
deUint64 duration = endTime-startTime;
m_calibrator.recordIteration(duration);
}
else if (state == gls::TheilSenCalibrator::STATE_RECOMPUTE_PARAMS)
{
m_calibrator.recomputeParameters();
}
else
{
DE_ASSERT(state == gls::TheilSenCalibrator::STATE_FINISHED);
break;
}
// Touch watchdog between iterations to avoid timeout.
{
qpWatchDog* dog = m_testCtx.getWatchDog();
if (dog)
qpWatchDog_touch(dog);
}
}
GLU_EXPECT_NO_ERROR(gl.getError(), "iterate");
logResults();
return STOP;
}
// Texture upload and draw case
class TextureUploadAndDrawCase : public TextureUploadCase
{
public:
TextureUploadAndDrawCase (Context& context, const char* name, const char* description, UploadFunction uploadFunction, deUint32 format, deUint32 type, int texSize);
~TextureUploadAndDrawCase (void);
IterateResult iterate (void);
void render (void);
private:
bool m_lastIterationRender;
deUint64 m_renderStart;
};
TextureUploadAndDrawCase::TextureUploadAndDrawCase (Context& context, const char* name, const char* description, UploadFunction uploadFunction, deUint32 format, deUint32 type, int texSize)
: TextureUploadCase (context, name, description, uploadFunction, format, type, texSize)
, m_lastIterationRender (false)
, m_renderStart (0)
{
}
TextureUploadAndDrawCase::~TextureUploadAndDrawCase (void)
{
TextureUploadCase::deinit();
}
void TextureUploadAndDrawCase::render (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
// Draw multiple quads to ensure enough workload
switch (m_uploadFunction)
{
case UPLOAD_TEXIMAGE2D:
gl.texImage2D(GL_TEXTURE_2D, 0, m_format, m_texSize, m_texSize, 0, m_format, m_type, &m_texData[0]);
break;
case UPLOAD_TEXSUBIMAGE2D:
gl.texSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_texSize, m_texSize, m_format, m_type, &m_texData[0]);
break;
default:
DE_ASSERT(false);
}
gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
tcu::TestNode::IterateResult TextureUploadAndDrawCase::iterate (void)
{
if (m_testCtx.getTestResult() == QP_TEST_RESULT_NOT_SUPPORTED)
return STOP;
if (m_lastIterationRender && (m_calibrator.getState() == gls::TheilSenCalibrator::STATE_MEASURE))
{
deUint64 curTime = deGetMicroseconds();
m_calibrator.recordIteration(curTime - m_renderStart);
}
gls::TheilSenCalibrator::State state = m_calibrator.getState();
if (state == gls::TheilSenCalibrator::STATE_MEASURE)
{
// Render
int numCalls = m_calibrator.getCallCount();
m_renderStart = deGetMicroseconds();
m_lastIterationRender = true;
for (int i = 0; i < numCalls; i++)
render();
return CONTINUE;
}
else if (state == gls::TheilSenCalibrator::STATE_RECOMPUTE_PARAMS)
{
m_calibrator.recomputeParameters();
m_lastIterationRender = false;
return CONTINUE;
}
else
{
DE_ASSERT(state == gls::TheilSenCalibrator::STATE_FINISHED);
GLU_EXPECT_NO_ERROR(m_context.getRenderContext().getFunctions().getError(), "finish");
logResults();
return STOP;
}
}
// Texture upload tests
TextureUploadTests::TextureUploadTests (Context& context)
: TestCaseGroup(context, "upload", "Texture upload tests")
{
}
TextureUploadTests::~TextureUploadTests (void)
{
TextureUploadTests::deinit();
}
void TextureUploadTests::deinit (void)
{
}
void TextureUploadTests::init (void)
{
TestCaseGroup* uploadCall = new TestCaseGroup(m_context, "upload", "Texture upload");
TestCaseGroup* uploadAndDraw = new TestCaseGroup(m_context, "upload_draw_swap", "Texture upload, draw & buffer swap");
addChild(uploadCall);
addChild(uploadAndDraw);
static const struct
{
const char* name;
const char* nameLower;
UploadFunction func;
} uploadFunctions[] =
{
{ "texImage2D", "teximage2d", UPLOAD_TEXIMAGE2D },
{ "texSubImage2D", "texsubimage2d", UPLOAD_TEXSUBIMAGE2D }
};
static const struct
{
const char* name;
deUint32 format;
deUint32 type;
} textureCombinations[] =
{
{ "rgb_ubyte", GL_RGB, GL_UNSIGNED_BYTE },
{ "rgba_ubyte", GL_RGBA, GL_UNSIGNED_BYTE },
{ "alpha_ubyte", GL_ALPHA, GL_UNSIGNED_BYTE },
{ "luminance_ubyte", GL_LUMINANCE, GL_UNSIGNED_BYTE },
{ "luminance-alpha_ubyte", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE },
{ "rgb_ushort565", GL_RGB, GL_UNSIGNED_SHORT_5_6_5 },
{ "rgba_ushort4444", GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 },
{ "rgba_ushort5551", GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 },
};
static const struct
{
int size;
TestCaseGroup* uploadCallGroup;
TestCaseGroup* uploadAndDrawGroup;
} textureSizes[] =
{
{ 16, new TestCaseGroup(m_context, "16x16", "Texture size 16x16"), new TestCaseGroup(m_context, "16x16", "Texture size 16x16") },
{ 256, new TestCaseGroup(m_context, "256x256", "Texture size 256x256"), new TestCaseGroup(m_context, "256x256", "Texture size 256x256") },
{ 257, new TestCaseGroup(m_context, "257x257", "Texture size 257x257"), new TestCaseGroup(m_context, "257x257", "Texture size 257x257") },
{ 1024, new TestCaseGroup(m_context, "1024x1024", "Texture size 1024x1024"), new TestCaseGroup(m_context, "1024x1024", "Texture size 1024x1024") },
{ 2048, new TestCaseGroup(m_context, "2048x2048", "Texture size 2048x2048"), new TestCaseGroup(m_context, "2048x2048", "Texture size 2048x2048") },
};
#define FOR_EACH(ITERATOR, ARRAY, BODY) \
for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \
BODY
FOR_EACH(uploadFunc, uploadFunctions,
FOR_EACH(texSize, textureSizes,
FOR_EACH(texCombination, textureCombinations,
{
string caseName = string("") + uploadFunctions[uploadFunc].nameLower + "_" + textureCombinations[texCombination].name;
UploadFunction function = uploadFunctions[uploadFunc].func;
deUint32 format = textureCombinations[texCombination].format;
deUint32 type = textureCombinations[texCombination].type;
int size = textureSizes[texSize].size;
textureSizes[texSize].uploadCallGroup->addChild (new TextureUploadCallCase (m_context, caseName.c_str(), "", function, format, type, size));
textureSizes[texSize].uploadAndDrawGroup->addChild (new TextureUploadAndDrawCase (m_context, caseName.c_str(), "", function, format, type, size));
})));
for (int i = 0; i < DE_LENGTH_OF_ARRAY(textureSizes); i++)
{
uploadCall->addChild (textureSizes[i].uploadCallGroup);
uploadAndDraw->addChild (textureSizes[i].uploadAndDrawGroup);
}
}
} // Performance
} // gles2
} // deqp