| /*------------------------------------------------------------------------- |
| * 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 Depth buffer performance tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es3pDepthTests.hpp" |
| |
| #include "glsCalibration.hpp" |
| |
| #include "gluShaderProgram.hpp" |
| #include "gluObjectWrapper.hpp" |
| #include "gluPixelTransfer.hpp" |
| |
| #include "glwFunctions.hpp" |
| #include "glwEnums.hpp" |
| |
| #include "tcuTestLog.hpp" |
| #include "tcuStringTemplate.hpp" |
| #include "tcuCPUWarmup.hpp" |
| #include "tcuCommandLine.hpp" |
| #include "tcuResultCollector.hpp" |
| |
| #include "deClock.h" |
| #include "deString.h" |
| #include "deMath.h" |
| #include "deStringUtil.hpp" |
| #include "deRandom.hpp" |
| #include "deUniquePtr.hpp" |
| |
| #include <vector> |
| #include <algorithm> |
| |
| namespace deqp |
| { |
| namespace gles3 |
| { |
| namespace Performance |
| { |
| namespace |
| { |
| using namespace glw; |
| using de::MovePtr; |
| using glu::ProgramSources; |
| using glu::RenderContext; |
| using glu::ShaderSource; |
| using std::map; |
| using std::string; |
| using std::vector; |
| using tcu::TestContext; |
| using tcu::TestLog; |
| using tcu::Vec2; |
| using tcu::Vec3; |
| using tcu::Vec4; |
| |
| struct Sample |
| { |
| int64_t nullTime; |
| int64_t baseTime; |
| int64_t testTime; |
| int order; |
| int workload; |
| }; |
| |
| struct SampleParams |
| { |
| int step; |
| int measurement; |
| |
| SampleParams(int step_, int measurement_) : step(step_), measurement(measurement_) |
| { |
| } |
| }; |
| |
| typedef vector<float> Geometry; |
| |
| struct ObjectData |
| { |
| ProgramSources shader; |
| Geometry geometry; |
| |
| ObjectData(const ProgramSources &shader_, const Geometry &geometry_) : shader(shader_), geometry(geometry_) |
| { |
| } |
| }; |
| |
| class RenderData |
| { |
| public: |
| RenderData(const ObjectData &object, const glu::RenderContext &renderCtx, TestLog &log); |
| ~RenderData(void) |
| { |
| } |
| |
| const glu::ShaderProgram m_program; |
| const glu::VertexArray m_vao; |
| const glu::Buffer m_vbo; |
| |
| const int m_numVertices; |
| }; |
| |
| RenderData::RenderData(const ObjectData &object, const glu::RenderContext &renderCtx, TestLog &log) |
| : m_program(renderCtx, object.shader) |
| , m_vao(renderCtx.getFunctions()) |
| , m_vbo(renderCtx.getFunctions()) |
| , m_numVertices(int(object.geometry.size()) / 4) |
| { |
| const glw::Functions &gl = renderCtx.getFunctions(); |
| |
| if (!m_program.isOk()) |
| log << m_program; |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, *m_vbo); |
| gl.bufferData(GL_ARRAY_BUFFER, object.geometry.size() * sizeof(float), &object.geometry[0], GL_STATIC_DRAW); |
| gl.bindAttribLocation(m_program.getProgram(), 0, "a_position"); |
| |
| gl.bindVertexArray(*m_vao); |
| gl.vertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL); |
| gl.enableVertexAttribArray(0); |
| gl.bindVertexArray(0); |
| } |
| |
| namespace Utils |
| { |
| vector<float> getFullscreenQuad(float depth) |
| { |
| const float data[] = { |
| +1.0f, +1.0f, depth, 0.0f, // .w is gl_VertexId%3 since Nexus 4&5 can't handle that on their own |
| +1.0f, -1.0f, depth, 1.0f, -1.0f, -1.0f, depth, 2.0f, -1.0f, -1.0f, |
| depth, 0.0f, -1.0f, +1.0f, depth, 1.0f, +1.0f, +1.0f, depth, 2.0f, |
| }; |
| |
| return vector<float>(DE_ARRAY_BEGIN(data), DE_ARRAY_END(data)); |
| } |
| |
| vector<float> getFullscreenQuadWithGradient(float depth0, float depth1) |
| { |
| const float data[] = { |
| +1.0f, +1.0f, depth0, 0.0f, +1.0f, -1.0f, depth0, 1.0f, -1.0f, -1.0f, depth1, 2.0f, |
| -1.0f, -1.0f, depth1, 0.0f, -1.0f, +1.0f, depth1, 1.0f, +1.0f, +1.0f, depth0, 2.0f, |
| }; |
| |
| return vector<float>(DE_ARRAY_BEGIN(data), DE_ARRAY_END(data)); |
| } |
| |
| vector<float> getPartScreenQuad(float coverage, float depth) |
| { |
| const float xMax = -1.0f + 2.0f * coverage; |
| const float data[] = { |
| xMax, +1.0f, depth, 0.0f, xMax, -1.0f, depth, 1.0f, -1.0f, -1.0f, depth, 2.0f, |
| -1.0f, -1.0f, depth, 0.0f, -1.0f, +1.0f, depth, 1.0f, xMax, +1.0f, depth, 2.0f, |
| }; |
| |
| return vector<float>(DE_ARRAY_BEGIN(data), DE_ARRAY_END(data)); |
| } |
| |
| // Axis aligned grid. Depth of vertices is baseDepth +/- depthNoise |
| vector<float> getFullScreenGrid(int resolution, uint32_t seed, float baseDepth, float depthNoise, float xyNoise) |
| { |
| const int gridsize = resolution + 1; |
| vector<Vec3> vertices(gridsize * gridsize); |
| vector<float> retval; |
| de::Random rng(seed); |
| |
| for (int y = 0; y < gridsize; y++) |
| for (int x = 0; x < gridsize; x++) |
| { |
| const bool isEdge = x == 0 || y == 0 || x == resolution || y == resolution; |
| const float x_ = |
| float(x) / float(resolution) * 2.0f - 1.0f + (isEdge ? 0.0f : rng.getFloat(-xyNoise, +xyNoise)); |
| const float y_ = |
| float(y) / float(resolution) * 2.0f - 1.0f + (isEdge ? 0.0f : rng.getFloat(-xyNoise, +xyNoise)); |
| const float z_ = baseDepth + rng.getFloat(-depthNoise, +depthNoise); |
| |
| vertices[y * gridsize + x] = Vec3(x_, y_, z_); |
| } |
| |
| retval.reserve(resolution * resolution * 6); |
| |
| for (int y = 0; y < resolution; y++) |
| for (int x = 0; x < resolution; x++) |
| { |
| const Vec3 &p0 = vertices[(y + 0) * gridsize + (x + 0)]; |
| const Vec3 &p1 = vertices[(y + 0) * gridsize + (x + 1)]; |
| const Vec3 &p2 = vertices[(y + 1) * gridsize + (x + 0)]; |
| const Vec3 &p3 = vertices[(y + 1) * gridsize + (x + 1)]; |
| |
| const float temp[6 * 4] = { |
| p0.x(), p0.y(), p0.z(), 0.0f, p2.x(), p2.y(), p2.z(), 1.0f, p1.x(), p1.y(), p1.z(), 2.0f, |
| |
| p3.x(), p3.y(), p3.z(), 0.0f, p1.x(), p1.y(), p1.z(), 1.0f, p2.x(), p2.y(), p2.z(), 2.0f, |
| }; |
| |
| retval.insert(retval.end(), DE_ARRAY_BEGIN(temp), DE_ARRAY_END(temp)); |
| } |
| |
| return retval; |
| } |
| |
| // Outputs barycentric coordinates as v_bcoords. Otherwise a passthrough shader |
| string getBaseVertexShader(void) |
| { |
| return "#version 300 es\n" |
| "in highp vec4 a_position;\n" |
| "out mediump vec3 v_bcoords;\n" |
| "void main()\n" |
| "{\n" |
| " v_bcoords = vec3(0, 0, 0);\n" |
| " v_bcoords[int(a_position.w)] = 1.0;\n" |
| " gl_Position = vec4(a_position.xyz, 1.0);\n" |
| "}\n"; |
| } |
| |
| // Adds noise to coordinates based on InstanceID Outputs barycentric coordinates as v_bcoords |
| string getInstanceNoiseVertexShader(void) |
| { |
| return "#version 300 es\n" |
| "in highp vec4 a_position;\n" |
| "out mediump vec3 v_bcoords;\n" |
| "void main()\n" |
| "{\n" |
| " v_bcoords = vec3(0, 0, 0);\n" |
| " v_bcoords[int(a_position.w)] = 1.0;\n" |
| " vec3 noise = vec3(sin(float(gl_InstanceID)*1.05), sin(float(gl_InstanceID)*1.23), " |
| "sin(float(gl_InstanceID)*1.71));\n" |
| " gl_Position = vec4(a_position.xyz + noise * 0.005, 1.0);\n" |
| "}\n"; |
| } |
| |
| // Renders green triangles with edges highlighted. Exact shade depends on depth. |
| string getDepthAsGreenFragmentShader(void) |
| { |
| return "#version 300 es\n" |
| "in mediump vec3 v_bcoords;\n" |
| "out mediump vec4 fragColor;\n" |
| "void main()\n" |
| "{\n" |
| " mediump float d = gl_FragCoord.z;\n" |
| " if (v_bcoords.x < 0.02 || v_bcoords.y < 0.02 || v_bcoords.z < 0.02)\n" |
| " fragColor = vec4(d,1,d,1);\n" |
| " else\n" |
| " fragColor = vec4(0,d,0,1);\n" |
| "}\n"; |
| } |
| |
| // Renders green triangles with edges highlighted. Exact shade depends on depth. |
| string getDepthAsRedFragmentShader(void) |
| { |
| return "#version 300 es\n" |
| "in mediump vec3 v_bcoords;\n" |
| "out mediump vec4 fragColor;\n" |
| "void main()\n" |
| "{\n" |
| " mediump float d = gl_FragCoord.z;\n" |
| " if (v_bcoords.x < 0.02 || v_bcoords.y < 0.02 || v_bcoords.z < 0.02)\n" |
| " fragColor = vec4(1,d,d,1);\n" |
| " else\n" |
| " fragColor = vec4(d,0,0,1);\n" |
| "}\n"; |
| } |
| |
| // Basic time waster. Renders red triangles with edges highlighted. Exact shade depends on depth. |
| string getArithmeticWorkloadFragmentShader(void) |
| { |
| |
| return "#version 300 es\n" |
| "in mediump vec3 v_bcoords;\n" |
| "out mediump vec4 fragColor;\n" |
| "uniform mediump int u_iterations;\n" |
| "void main()\n" |
| "{\n" |
| " mediump float d = gl_FragCoord.z;\n" |
| " for (int i = 0; i<u_iterations; i++)\n" |
| // cos(a)^2 + sin(a)^2 == 1. since d is in range [0,1] this will lose a few ULP's of precision per iteration but should not significantly change the value of d without extreme iteration counts |
| " d = d*sin(d)*sin(d) + d*cos(d)*cos(d);\n" |
| " if (v_bcoords.x < 0.02 || v_bcoords.y < 0.02 || v_bcoords.z < 0.02)\n" |
| " fragColor = vec4(1,d,d,1);\n" |
| " else\n" |
| " fragColor = vec4(d,0,0,1);\n" |
| "}\n"; |
| } |
| |
| // Arithmetic workload shader but contains discard |
| string getArithmeticWorkloadDiscardFragmentShader(void) |
| { |
| return "#version 300 es\n" |
| "in mediump vec3 v_bcoords;\n" |
| "out mediump vec4 fragColor;\n" |
| "uniform mediump int u_iterations;\n" |
| "void main()\n" |
| "{\n" |
| " mediump float d = gl_FragCoord.z;\n" |
| " for (int i = 0; i<u_iterations; i++)\n" |
| " d = d*sin(d)*sin(d) + d*cos(d)*cos(d);\n" |
| " if (d < 0.5) discard;\n" |
| " if (v_bcoords.x < 0.02 || v_bcoords.y < 0.02 || v_bcoords.z < 0.02)\n" |
| " fragColor = vec4(1,d,d,1);\n" |
| " else\n" |
| " fragColor = vec4(d,0,0,1);\n" |
| "}\n"; |
| } |
| |
| // Texture fetch based time waster. Renders red triangles with edges highlighted. Exact shade depends on depth. |
| string getTextureWorkloadFragmentShader(void) |
| { |
| return "#version 300 es\n" |
| "in mediump vec3 v_bcoords;\n" |
| "out mediump vec4 fragColor;\n" |
| "uniform mediump int u_iterations;\n" |
| "uniform sampler2D u_texture;\n" |
| "void main()\n" |
| "{\n" |
| " mediump float d = gl_FragCoord.z;\n" |
| " for (int i = 0; i<u_iterations; i++)\n" |
| " d *= texture(u_texture, (gl_FragCoord.xy+vec2(i))/512.0).r;\n" // Texture is expected to be fully white |
| " if (v_bcoords.x < 0.02 || v_bcoords.y < 0.02 || v_bcoords.z < 0.02)\n" |
| " fragColor = vec4(1,1,1,1);\n" |
| " else\n" |
| " fragColor = vec4(d,0,0,1);\n" |
| "}\n"; |
| } |
| |
| // Discard fragments in a grid pattern |
| string getGridDiscardFragmentShader(int gridsize) |
| { |
| const string fragSrc = |
| "#version 300 es\n" |
| "in mediump vec3 v_bcoords;\n" |
| "out mediump vec4 fragColor;\n" |
| "void main()\n" |
| "{\n" |
| " mediump float d = gl_FragCoord.z;\n" |
| " if ((int(gl_FragCoord.x)/${GRIDRENDER_SIZE} + int(gl_FragCoord.y)/${GRIDRENDER_SIZE})%2 == 0)\n" |
| " discard;\n" |
| " if (v_bcoords.x < 0.02 || v_bcoords.y < 0.02 || v_bcoords.z < 0.02)\n" |
| " fragColor = vec4(d,1,d,1);\n" |
| " else\n" |
| " fragColor = vec4(0,d,0,1);\n" |
| "}\n"; |
| map<string, string> params; |
| |
| params["GRIDRENDER_SIZE"] = de::toString(gridsize); |
| |
| return tcu::StringTemplate(fragSrc).specialize(params); |
| } |
| |
| // A static increment to frag depth |
| string getStaticFragDepthFragmentShader(void) |
| { |
| return "#version 300 es\n" |
| "in mediump vec3 v_bcoords;\n" |
| "out mediump vec4 fragColor;\n" |
| "void main()\n" |
| "{\n" |
| " mediump float d = gl_FragCoord.z;\n" |
| " gl_FragDepth = gl_FragCoord.z + 0.1;\n" |
| " if (v_bcoords.x < 0.02 || v_bcoords.y < 0.02 || v_bcoords.z < 0.02)\n" |
| " fragColor = vec4(d,1,d,1);\n" |
| " else\n" |
| " fragColor = vec4(0,d,0,1);\n" |
| "}\n"; |
| } |
| |
| // A trivial dynamic change to frag depth |
| string getDynamicFragDepthFragmentShader(void) |
| { |
| return "#version 300 es\n" |
| "in mediump vec3 v_bcoords;\n" |
| "out mediump vec4 fragColor;\n" |
| "void main()\n" |
| "{\n" |
| " mediump float d = gl_FragCoord.z;\n" |
| " gl_FragDepth = gl_FragCoord.z + (v_bcoords.x + v_bcoords.y + v_bcoords.z)*0.05;\n" // Sum of v_bcoords components is allways 1 |
| " if (v_bcoords.x < 0.02 || v_bcoords.y < 0.02 || v_bcoords.z < 0.02)\n" |
| " fragColor = vec4(d,1,d,1);\n" |
| " else\n" |
| " fragColor = vec4(0,d,0,1);\n" |
| "}\n"; |
| } |
| |
| // A static increment to frag depth |
| string getStaticFragDepthArithmeticWorkloadFragmentShader(void) |
| { |
| return "#version 300 es\n" |
| "in mediump vec3 v_bcoords;\n" |
| "out mediump vec4 fragColor;\n" |
| "uniform mediump int u_iterations;\n" |
| "void main()\n" |
| "{\n" |
| " mediump float d = gl_FragCoord.z;\n" |
| " gl_FragDepth = gl_FragCoord.z + 0.1;\n" |
| " for (int i = 0; i<u_iterations; i++)\n" |
| " d = d*sin(d)*sin(d) + d*cos(d)*cos(d);\n" |
| " if (v_bcoords.x < 0.02 || v_bcoords.y < 0.02 || v_bcoords.z < 0.02)\n" |
| " fragColor = vec4(1,d,d,1);\n" |
| " else\n" |
| " fragColor = vec4(d,0,0,1);\n" |
| "}\n"; |
| } |
| |
| // A trivial dynamic change to frag depth |
| string getDynamicFragDepthArithmeticWorkloadFragmentShader(void) |
| { |
| return "#version 300 es\n" |
| "in mediump vec3 v_bcoords;\n" |
| "out mediump vec4 fragColor;\n" |
| "uniform mediump int u_iterations;\n" |
| "void main()\n" |
| "{\n" |
| " mediump float d = gl_FragCoord.z;\n" |
| " gl_FragDepth = gl_FragCoord.z + (v_bcoords.x + v_bcoords.y + v_bcoords.z)*0.05;\n" // Sum of v_bcoords components is allways 1 |
| " for (int i = 0; i<u_iterations; i++)\n" |
| " d = d*sin(d)*sin(d) + d*cos(d)*cos(d);\n" |
| " if (v_bcoords.x < 0.02 || v_bcoords.y < 0.02 || v_bcoords.z < 0.02)\n" |
| " fragColor = vec4(1,d,d,1);\n" |
| " else\n" |
| " fragColor = vec4(d,0,0,1);\n" |
| "}\n"; |
| } |
| |
| glu::ProgramSources getBaseShader(void) |
| { |
| return glu::makeVtxFragSources(getBaseVertexShader(), getDepthAsGreenFragmentShader()); |
| } |
| |
| glu::ProgramSources getArithmeticWorkloadShader(void) |
| { |
| return glu::makeVtxFragSources(getBaseVertexShader(), getArithmeticWorkloadFragmentShader()); |
| } |
| |
| glu::ProgramSources getArithmeticWorkloadDiscardShader(void) |
| { |
| return glu::makeVtxFragSources(getBaseVertexShader(), getArithmeticWorkloadDiscardFragmentShader()); |
| } |
| |
| glu::ProgramSources getTextureWorkloadShader(void) |
| { |
| return glu::makeVtxFragSources(getBaseVertexShader(), getTextureWorkloadFragmentShader()); |
| } |
| |
| glu::ProgramSources getGridDiscardShader(int gridsize) |
| { |
| return glu::makeVtxFragSources(getBaseVertexShader(), getGridDiscardFragmentShader(gridsize)); |
| } |
| |
| inline ObjectData quadWith(const glu::ProgramSources &shader, float depth) |
| { |
| return ObjectData(shader, getFullscreenQuad(depth)); |
| } |
| |
| inline ObjectData quadWith(const string &fragShader, float depth) |
| { |
| return ObjectData(glu::makeVtxFragSources(getBaseVertexShader(), fragShader), getFullscreenQuad(depth)); |
| } |
| |
| inline ObjectData variableQuad(float depth) |
| { |
| return ObjectData(glu::makeVtxFragSources(getInstanceNoiseVertexShader(), getDepthAsRedFragmentShader()), |
| getFullscreenQuad(depth)); |
| } |
| |
| inline ObjectData fastQuad(float depth) |
| { |
| return ObjectData(getBaseShader(), getFullscreenQuad(depth)); |
| } |
| |
| inline ObjectData slowQuad(float depth) |
| { |
| return ObjectData(getArithmeticWorkloadShader(), getFullscreenQuad(depth)); |
| } |
| |
| inline ObjectData fastQuadWithGradient(float depth0, float depth1) |
| { |
| return ObjectData(getBaseShader(), getFullscreenQuadWithGradient(depth0, depth1)); |
| } |
| } // namespace Utils |
| |
| // Shared base |
| class BaseCase : public tcu::TestCase |
| { |
| public: |
| enum |
| { |
| RENDER_SIZE = 512 |
| }; |
| |
| BaseCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, const char *desc); |
| virtual ~BaseCase(void) |
| { |
| } |
| |
| virtual IterateResult iterate(void); |
| |
| protected: |
| void logSamples(const vector<Sample> &samples, const string &name, const string &desc); |
| void logGeometry(const tcu::ConstPixelBufferAccess &sample, const glu::ShaderProgram &occluderProg, |
| const glu::ShaderProgram &occludedProg); |
| virtual void logAnalysis(const vector<Sample> &samples) = 0; |
| virtual void logDescription(void) = 0; |
| |
| virtual ObjectData genOccluderGeometry(void) const = 0; |
| virtual ObjectData genOccludedGeometry(void) const = 0; |
| |
| virtual int calibrate(void) const = 0; |
| virtual Sample renderSample(const RenderData &occluder, const RenderData &occluded, int workload) const = 0; |
| |
| void render(const RenderData &data) const; |
| void render(const RenderData &data, int instances) const; |
| |
| const RenderContext &m_renderCtx; |
| tcu::ResultCollector m_results; |
| |
| enum |
| { |
| ITERATION_STEPS = 10, |
| ITERATION_SAMPLES = 16 |
| }; |
| }; |
| |
| BaseCase::BaseCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, const char *desc) |
| : TestCase(testCtx, tcu::NODETYPE_PERFORMANCE, name, desc) |
| , m_renderCtx(renderCtx) |
| { |
| } |
| |
| BaseCase::IterateResult BaseCase::iterate(void) |
| { |
| typedef de::MovePtr<RenderData> RenderDataP; |
| |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| TestLog &log = m_testCtx.getLog(); |
| |
| const glu::Framebuffer framebuffer(gl); |
| const glu::Renderbuffer renderbuffer(gl); |
| const glu::Renderbuffer depthbuffer(gl); |
| |
| vector<Sample> results; |
| vector<int> params; |
| RenderDataP occluderData; |
| RenderDataP occludedData; |
| tcu::TextureLevel resultTex(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), |
| RENDER_SIZE, RENDER_SIZE); |
| int maxWorkload = 0; |
| de::Random rng(deInt32Hash(deStringHash(getName())) ^ m_testCtx.getCommandLine().getBaseSeed()); |
| |
| logDescription(); |
| |
| gl.bindRenderbuffer(GL_RENDERBUFFER, *renderbuffer); |
| gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, RENDER_SIZE, RENDER_SIZE); |
| gl.bindRenderbuffer(GL_RENDERBUFFER, *depthbuffer); |
| gl.renderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, RENDER_SIZE, RENDER_SIZE); |
| |
| gl.bindFramebuffer(GL_FRAMEBUFFER, *framebuffer); |
| gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *renderbuffer); |
| gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, *depthbuffer); |
| gl.viewport(0, 0, RENDER_SIZE, RENDER_SIZE); |
| gl.clearColor(0.125f, 0.25f, 0.5f, 1.0f); |
| |
| maxWorkload = calibrate(); |
| |
| // Setup data |
| occluderData = RenderDataP(new RenderData(genOccluderGeometry(), m_renderCtx, log)); |
| occludedData = RenderDataP(new RenderData(genOccludedGeometry(), m_renderCtx, log)); |
| |
| TCU_CHECK(occluderData->m_program.isOk()); |
| TCU_CHECK(occludedData->m_program.isOk()); |
| |
| // Force initialization of GPU resources |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.enable(GL_DEPTH_TEST); |
| |
| render(*occluderData); |
| render(*occludedData); |
| glu::readPixels(m_renderCtx, 0, 0, resultTex.getAccess()); |
| |
| logGeometry(resultTex.getAccess(), occluderData->m_program, occludedData->m_program); |
| |
| params.reserve(ITERATION_STEPS * ITERATION_SAMPLES); |
| |
| // Setup parameters |
| for (int step = 0; step < ITERATION_STEPS; step++) |
| { |
| const int workload = maxWorkload * step / ITERATION_STEPS; |
| |
| for (int count = 0; count < ITERATION_SAMPLES; count++) |
| params.push_back(workload); |
| } |
| |
| rng.shuffle(params.begin(), params.end()); |
| |
| // Render samples |
| for (size_t ndx = 0; ndx < params.size(); ndx++) |
| { |
| const int workload = params[ndx]; |
| Sample sample = renderSample(*occluderData, *occludedData, workload); |
| |
| sample.workload = workload; |
| sample.order = int(ndx); |
| |
| results.push_back(sample); |
| } |
| |
| logSamples(results, "Samples", "Samples"); |
| logAnalysis(results); |
| |
| m_results.setTestContextResult(m_testCtx); |
| |
| return STOP; |
| } |
| |
| void BaseCase::logSamples(const vector<Sample> &samples, const string &name, const string &desc) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| bool testOnly = true; |
| |
| for (size_t ndx = 0; ndx < samples.size(); ndx++) |
| { |
| if (samples[ndx].baseTime != 0 || samples[ndx].nullTime != 0) |
| { |
| testOnly = false; |
| break; |
| } |
| } |
| |
| log << TestLog::SampleList(name, desc); |
| |
| if (testOnly) |
| { |
| log << TestLog::SampleInfo << TestLog::ValueInfo("Workload", "Workload", "", QP_SAMPLE_VALUE_TAG_PREDICTOR) |
| << TestLog::ValueInfo("Order", "Order of sample", "", QP_SAMPLE_VALUE_TAG_PREDICTOR) |
| << TestLog::ValueInfo("TestTime", "Test render time", "us", QP_SAMPLE_VALUE_TAG_RESPONSE) |
| << TestLog::EndSampleInfo; |
| |
| for (size_t sampleNdx = 0; sampleNdx < samples.size(); sampleNdx++) |
| { |
| const Sample &sample = samples[sampleNdx]; |
| |
| log << TestLog::Sample << sample.workload << sample.order << sample.testTime << TestLog::EndSample; |
| } |
| } |
| else |
| { |
| log << TestLog::SampleInfo << TestLog::ValueInfo("Workload", "Workload", "", QP_SAMPLE_VALUE_TAG_PREDICTOR) |
| << TestLog::ValueInfo("Order", "Order of sample", "", QP_SAMPLE_VALUE_TAG_PREDICTOR) |
| << TestLog::ValueInfo("TestTime", "Test render time", "us", QP_SAMPLE_VALUE_TAG_RESPONSE) |
| << TestLog::ValueInfo("NullTime", "Read pixels time", "us", QP_SAMPLE_VALUE_TAG_RESPONSE) |
| << TestLog::ValueInfo("BaseTime", "Base render time", "us", QP_SAMPLE_VALUE_TAG_RESPONSE) |
| << TestLog::EndSampleInfo; |
| |
| for (size_t sampleNdx = 0; sampleNdx < samples.size(); sampleNdx++) |
| { |
| const Sample &sample = samples[sampleNdx]; |
| |
| log << TestLog::Sample << sample.workload << sample.order << sample.testTime << sample.nullTime |
| << sample.baseTime << TestLog::EndSample; |
| } |
| } |
| |
| log << TestLog::EndSampleList; |
| } |
| |
| void BaseCase::logGeometry(const tcu::ConstPixelBufferAccess &sample, const glu::ShaderProgram &occluderProg, |
| const glu::ShaderProgram &occludedProg) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Geometry", "Geometry"); |
| log << TestLog::Message << "Occluding geometry is green with shade dependent on depth (rgb == 0, depth, 0)" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "Occluded geometry is red with shade dependent on depth (rgb == depth, 0, 0)" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "Primitive edges are a lighter shade of red/green" << TestLog::EndMessage; |
| |
| log << TestLog::Image("Test Geometry", "Test Geometry", sample); |
| log << TestLog::EndSection; |
| |
| log << TestLog::Section("Occluder", "Occluder"); |
| log << occluderProg; |
| log << TestLog::EndSection; |
| |
| log << TestLog::Section("Occluded", "Occluded"); |
| log << occludedProg; |
| log << TestLog::EndSection; |
| } |
| |
| void BaseCase::render(const RenderData &data) const |
| { |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| |
| gl.useProgram(data.m_program.getProgram()); |
| |
| gl.bindVertexArray(*data.m_vao); |
| gl.drawArrays(GL_TRIANGLES, 0, data.m_numVertices); |
| gl.bindVertexArray(0); |
| } |
| |
| void BaseCase::render(const RenderData &data, int instances) const |
| { |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| |
| gl.useProgram(data.m_program.getProgram()); |
| |
| gl.bindVertexArray(*data.m_vao); |
| gl.drawArraysInstanced(GL_TRIANGLES, 0, data.m_numVertices, instances); |
| gl.bindVertexArray(0); |
| } |
| |
| // Render occluder once, then repeatedly render occluded geometry. Sample with multiple repetition counts & establish time per call with linear regression |
| class RenderCountCase : public BaseCase |
| { |
| public: |
| RenderCountCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, const char *desc); |
| ~RenderCountCase(void) |
| { |
| } |
| |
| protected: |
| virtual void logAnalysis(const vector<Sample> &samples); |
| |
| private: |
| virtual int calibrate(void) const; |
| virtual Sample renderSample(const RenderData &occluder, const RenderData &occluded, int callcount) const; |
| }; |
| |
| RenderCountCase::RenderCountCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc) |
| : BaseCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| void RenderCountCase::logAnalysis(const vector<Sample> &samples) |
| { |
| using namespace gls; |
| |
| TestLog &log = m_testCtx.getLog(); |
| int maxWorkload = 0; |
| vector<Vec2> testSamples(samples.size()); |
| |
| for (size_t ndx = 0; ndx < samples.size(); ndx++) |
| { |
| const Sample &sample = samples[ndx]; |
| |
| testSamples[ndx] = Vec2((float)sample.workload, (float)sample.testTime); |
| |
| maxWorkload = de::max(maxWorkload, sample.workload); |
| } |
| |
| { |
| const float confidence = 0.60f; |
| const LineParametersWithConfidence testParam = theilSenSiegelLinearRegression(testSamples, confidence); |
| const float usPerCall = testParam.coefficient; |
| const float pxPerCall = RENDER_SIZE * RENDER_SIZE; |
| const float pxPerUs = pxPerCall / usPerCall; |
| const float mpxPerS = pxPerUs; |
| |
| log << TestLog::Section("Linear Regression", "Linear Regression"); |
| log << TestLog::Message |
| << "Offset & coefficient presented as [confidence interval min, estimate, confidence interval max]. " |
| "Reported confidence interval for this test is " |
| << confidence << TestLog::EndMessage; |
| log << TestLog::Message << "Render time for scene with depth test was\n\t" |
| << "[" << testParam.offsetConfidenceLower << ", " << testParam.offset << ", " |
| << testParam.offsetConfidenceUpper << "]us +" |
| << "[" << testParam.coefficientConfidenceLower << ", " << testParam.coefficient << ", " |
| << testParam.coefficientConfidenceUpper << "]" |
| << "us/workload" << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| |
| log << TestLog::Section("Result", "Result"); |
| |
| if (testParam.coefficientConfidenceLower < 0.0f) |
| { |
| log << TestLog::Message |
| << "Coefficient confidence bounds include values below 0.0, the operation likely has neglible " |
| "per-pixel cost" |
| << TestLog::EndMessage; |
| m_results.addResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else if (testParam.coefficientConfidenceLower < testParam.coefficientConfidenceUpper * 0.25) |
| { |
| log << TestLog::Message << "Coefficient confidence range is extremely large, cannot give reliable result" |
| << TestLog::EndMessage; |
| m_results.addResult(QP_TEST_RESULT_PASS, "Result confidence extremely low"); |
| } |
| else |
| { |
| log << TestLog::Message << "Culled hidden pixels @ " << mpxPerS << "Mpx/s" << TestLog::EndMessage; |
| m_results.addResult(QP_TEST_RESULT_PASS, de::floatToString(mpxPerS, 2)); |
| } |
| |
| log << TestLog::EndSection; |
| } |
| } |
| |
| Sample RenderCountCase::renderSample(const RenderData &occluder, const RenderData &occluded, int callcount) const |
| { |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| Sample sample; |
| uint64_t now = 0; |
| uint64_t prev = 0; |
| uint8_t buffer[4]; |
| |
| // Stabilize |
| { |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.enable(GL_DEPTH_TEST); |
| gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| } |
| |
| prev = deGetMicroseconds(); |
| |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.enable(GL_DEPTH_TEST); |
| |
| render(occluder); |
| render(occluded, callcount); |
| |
| gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| |
| now = deGetMicroseconds(); |
| |
| sample.testTime = now - prev; |
| sample.baseTime = 0; |
| sample.nullTime = 0; |
| sample.workload = callcount; |
| |
| return sample; |
| } |
| |
| int RenderCountCase::calibrate(void) const |
| { |
| using namespace gls; |
| |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| TestLog &log = m_testCtx.getLog(); |
| |
| const RenderData occluderGeometry(genOccluderGeometry(), m_renderCtx, log); |
| const RenderData occludedGeometry(genOccludedGeometry(), m_renderCtx, log); |
| |
| TheilSenCalibrator calibrator(CalibratorParameters(20, // Initial workload |
| 10, // Max iteration frames |
| 20.0f, // Iteration shortcut threshold ms |
| 20, // Max iterations |
| 33.0f, // Target frame time |
| 40.0f, // Frame time cap |
| 1000.0f // Target measurement duration |
| )); |
| |
| while (true) |
| { |
| switch (calibrator.getState()) |
| { |
| case TheilSenCalibrator::STATE_FINISHED: |
| logCalibrationInfo(m_testCtx.getLog(), calibrator); |
| return calibrator.getCallCount(); |
| |
| case TheilSenCalibrator::STATE_MEASURE: |
| { |
| uint8_t buffer[4]; |
| int64_t now; |
| int64_t prev; |
| |
| prev = deGetMicroseconds(); |
| |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.disable(GL_DEPTH_TEST); |
| |
| render(occluderGeometry); |
| render(occludedGeometry, calibrator.getCallCount()); |
| |
| gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| |
| now = deGetMicroseconds(); |
| |
| calibrator.recordIteration(now - prev); |
| break; |
| } |
| |
| case TheilSenCalibrator::STATE_RECOMPUTE_PARAMS: |
| calibrator.recomputeParameters(); |
| break; |
| default: |
| DE_ASSERT(false); |
| return 1; |
| } |
| } |
| } |
| |
| // Compares time/workload gradients of same geometry with and without depth testing |
| class RelativeChangeCase : public BaseCase |
| { |
| public: |
| RelativeChangeCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, const char *desc); |
| virtual ~RelativeChangeCase(void) |
| { |
| } |
| |
| protected: |
| Sample renderSample(const RenderData &occluder, const RenderData &occluded, int workload) const; |
| |
| virtual void logAnalysis(const vector<Sample> &samples); |
| |
| private: |
| int calibrate(void) const; |
| }; |
| |
| RelativeChangeCase::RelativeChangeCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc) |
| : BaseCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| int RelativeChangeCase::calibrate(void) const |
| { |
| using namespace gls; |
| |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| TestLog &log = m_testCtx.getLog(); |
| |
| const RenderData geom(genOccludedGeometry(), m_renderCtx, log); |
| |
| TheilSenCalibrator calibrator(CalibratorParameters(20, // Initial workload |
| 10, // Max iteration frames |
| 20.0f, // Iteration shortcut threshold ms |
| 20, // Max iterations |
| 33.0f, // Target frame time |
| 40.0f, // Frame time cap |
| 1000.0f // Target measurement duration |
| )); |
| |
| while (true) |
| { |
| switch (calibrator.getState()) |
| { |
| case TheilSenCalibrator::STATE_FINISHED: |
| logCalibrationInfo(m_testCtx.getLog(), calibrator); |
| return calibrator.getCallCount(); |
| |
| case TheilSenCalibrator::STATE_MEASURE: |
| { |
| uint8_t buffer[4]; |
| const GLuint program = geom.m_program.getProgram(); |
| |
| gl.useProgram(program); |
| gl.uniform1i(gl.getUniformLocation(program, "u_iterations"), calibrator.getCallCount()); |
| |
| const int64_t prev = deGetMicroseconds(); |
| |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.disable(GL_DEPTH_TEST); |
| |
| render(geom); |
| |
| gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| |
| const int64_t now = deGetMicroseconds(); |
| |
| calibrator.recordIteration(now - prev); |
| break; |
| } |
| |
| case TheilSenCalibrator::STATE_RECOMPUTE_PARAMS: |
| calibrator.recomputeParameters(); |
| break; |
| default: |
| DE_ASSERT(false); |
| return 1; |
| } |
| } |
| } |
| |
| Sample RelativeChangeCase::renderSample(const RenderData &occluder, const RenderData &occluded, int workload) const |
| { |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| const GLuint program = occluded.m_program.getProgram(); |
| Sample sample; |
| uint64_t now = 0; |
| uint64_t prev = 0; |
| uint8_t buffer[4]; |
| |
| gl.useProgram(program); |
| gl.uniform1i(gl.getUniformLocation(program, "u_iterations"), workload); |
| |
| // Warmup (this workload seems to reduce variation in following workloads) |
| { |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.disable(GL_DEPTH_TEST); |
| |
| gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| } |
| |
| // Null time |
| { |
| prev = deGetMicroseconds(); |
| |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.disable(GL_DEPTH_TEST); |
| |
| gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| |
| now = deGetMicroseconds(); |
| |
| sample.nullTime = now - prev; |
| } |
| |
| // Test time |
| { |
| prev = deGetMicroseconds(); |
| |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.enable(GL_DEPTH_TEST); |
| |
| render(occluder); |
| render(occluded); |
| |
| gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| |
| now = deGetMicroseconds(); |
| |
| sample.testTime = now - prev; |
| } |
| |
| // Base time |
| { |
| prev = deGetMicroseconds(); |
| |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.disable(GL_DEPTH_TEST); |
| |
| render(occluder); |
| render(occluded); |
| |
| gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| |
| now = deGetMicroseconds(); |
| |
| sample.baseTime = now - prev; |
| } |
| |
| sample.workload = 0; |
| |
| return sample; |
| } |
| |
| void RelativeChangeCase::logAnalysis(const vector<Sample> &samples) |
| { |
| using namespace gls; |
| |
| TestLog &log = m_testCtx.getLog(); |
| |
| int maxWorkload = 0; |
| |
| vector<Vec2> nullSamples(samples.size()); |
| vector<Vec2> baseSamples(samples.size()); |
| vector<Vec2> testSamples(samples.size()); |
| |
| for (size_t ndx = 0; ndx < samples.size(); ndx++) |
| { |
| const Sample &sample = samples[ndx]; |
| |
| nullSamples[ndx] = Vec2((float)sample.workload, (float)sample.nullTime); |
| baseSamples[ndx] = Vec2((float)sample.workload, (float)sample.baseTime); |
| testSamples[ndx] = Vec2((float)sample.workload, (float)sample.testTime); |
| |
| maxWorkload = de::max(maxWorkload, sample.workload); |
| } |
| |
| { |
| const float confidence = 0.60f; |
| |
| const LineParametersWithConfidence nullParam = theilSenSiegelLinearRegression(nullSamples, confidence); |
| const LineParametersWithConfidence baseParam = theilSenSiegelLinearRegression(baseSamples, confidence); |
| const LineParametersWithConfidence testParam = theilSenSiegelLinearRegression(testSamples, confidence); |
| |
| if (!de::inRange(0.0f, nullParam.coefficientConfidenceLower, nullParam.coefficientConfidenceUpper)) |
| { |
| m_results.addResult(QP_TEST_RESULT_FAIL, "Constant operation sequence duration not constant"); |
| log << TestLog::Message |
| << "Constant operation sequence timing may vary as a function of workload. Result quality extremely low" |
| << TestLog::EndMessage; |
| } |
| |
| if (de::inRange(0.0f, baseParam.coefficientConfidenceLower, baseParam.coefficientConfidenceUpper)) |
| { |
| m_results.addResult(QP_TEST_RESULT_FAIL, "Workload has no effect on duration"); |
| log << TestLog::Message << "Workload factor has no effect on duration of sample (smart optimizer?)" |
| << TestLog::EndMessage; |
| } |
| |
| log << TestLog::Section("Linear Regression", "Linear Regression"); |
| log << TestLog::Message |
| << "Offset & coefficient presented as [confidence interval min, estimate, confidence interval max]. " |
| "Reported confidence interval for this test is " |
| << confidence << TestLog::EndMessage; |
| |
| log << TestLog::Message << "Render time for empty scene was\n\t" |
| << "[" << nullParam.offsetConfidenceLower << ", " << nullParam.offset << ", " |
| << nullParam.offsetConfidenceUpper << "]us +" |
| << "[" << nullParam.coefficientConfidenceLower << ", " << nullParam.coefficient << ", " |
| << nullParam.coefficientConfidenceUpper << "]" |
| << "us/workload" << TestLog::EndMessage; |
| |
| log << TestLog::Message << "Render time for scene without depth test was\n\t" |
| << "[" << baseParam.offsetConfidenceLower << ", " << baseParam.offset << ", " |
| << baseParam.offsetConfidenceUpper << "]us +" |
| << "[" << baseParam.coefficientConfidenceLower << ", " << baseParam.coefficient << ", " |
| << baseParam.coefficientConfidenceUpper << "]" |
| << "us/workload" << TestLog::EndMessage; |
| |
| log << TestLog::Message << "Render time for scene with depth test was\n\t" |
| << "[" << testParam.offsetConfidenceLower << ", " << testParam.offset << ", " |
| << testParam.offsetConfidenceUpper << "]us +" |
| << "[" << testParam.coefficientConfidenceLower << ", " << testParam.coefficient << ", " |
| << testParam.coefficientConfidenceUpper << "]" |
| << "us/workload" << TestLog::EndMessage; |
| |
| log << TestLog::EndSection; |
| |
| if (de::inRange(0.0f, testParam.coefficientConfidenceLower, testParam.coefficientConfidenceUpper)) |
| { |
| log << TestLog::Message << "Test duration not dependent on culled workload" << TestLog::EndMessage; |
| m_results.addResult(QP_TEST_RESULT_PASS, "0.0"); |
| } |
| else if (testParam.coefficientConfidenceLower < testParam.coefficientConfidenceUpper * 0.25) |
| { |
| log << TestLog::Message << "Coefficient confidence range is extremely large, cannot give reliable result" |
| << TestLog::EndMessage; |
| m_results.addResult(QP_TEST_RESULT_PASS, "Result confidence extremely low"); |
| } |
| else if (baseParam.coefficientConfidenceLower < baseParam.coefficientConfidenceUpper * 0.25) |
| { |
| log << TestLog::Message |
| << "Coefficient confidence range for base render time is extremely large, cannot give reliable result" |
| << TestLog::EndMessage; |
| m_results.addResult(QP_TEST_RESULT_PASS, "Result confidence extremely low"); |
| } |
| else |
| { |
| log << TestLog::Message << "Test duration is dependent on culled workload" << TestLog::EndMessage; |
| m_results.addResult(QP_TEST_RESULT_PASS, |
| de::floatToString(de::abs(testParam.coefficient) / de::abs(baseParam.coefficient), 2)); |
| } |
| } |
| } |
| |
| // Speed of trivial culling |
| class BaseCostCase : public RenderCountCase |
| { |
| public: |
| BaseCostCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, const char *desc) |
| : RenderCountCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| ~BaseCostCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::fastQuad(0.2f); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::variableQuad(0.8f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing hidden fragment culling speed" << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullsceen quads. The first (occluding) is rendered once, the second " |
| "(occluded) is rendered repeatedly" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "Workload indicates the number of times the occluded quad is rendered" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "The time per culled pixel is estimated from the rate of change of rendering time as a function of " |
| "workload" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| }; |
| |
| // Gradient |
| class GradientCostCase : public RenderCountCase |
| { |
| public: |
| GradientCostCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, const char *desc, |
| float gradientDistance) |
| : RenderCountCase(testCtx, renderCtx, name, desc) |
| , m_gradientDistance(gradientDistance) |
| { |
| } |
| |
| ~GradientCostCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::fastQuadWithGradient(0.0f, 1.0f - m_gradientDistance); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return ObjectData( |
| glu::makeVtxFragSources(Utils::getInstanceNoiseVertexShader(), Utils::getDepthAsRedFragmentShader()), |
| Utils::getFullscreenQuadWithGradient(m_gradientDistance, 1.0f)); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing hidden fragment culling speed" << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullsceen quads. The first (occluding) is rendered once, the second " |
| "(occluded) is rendered repeatedly" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "Workload indicates the number of times the occluded quad is rendered" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "The quads are tilted so that the left edge of the occluded quad has a depth of 1.0 and the right edge " |
| "of the occluding quad has a depth of 0.0." |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The quads are spaced to have a depth difference of " << m_gradientDistance |
| << " at all points." << TestLog::EndMessage; |
| log << TestLog::Message |
| << "The time per culled pixel is estimated from the rate of change of rendering time as a function of " |
| "workload" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| |
| const float m_gradientDistance; |
| }; |
| |
| // Constant offset to frag depth in occluder |
| class OccluderStaticFragDepthCostCase : public RenderCountCase |
| { |
| public: |
| OccluderStaticFragDepthCostCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc) |
| : RenderCountCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| ~OccluderStaticFragDepthCostCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::quadWith(Utils::getStaticFragDepthFragmentShader(), 0.2f); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::fastQuad(0.8f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing hidden fragment culling speed" << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullsceen quads. The first (occluding) is rendered once, the second " |
| "(occluded) is rendered repeatedly" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "Workload indicates the number of times the occluded quad is rendered" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The occluder quad has a static offset applied to gl_FragDepth" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "The time per culled pixel is estimated from the rate of change of rendering time as a function of " |
| "workload" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| }; |
| |
| // Dynamic offset to frag depth in occluder |
| class OccluderDynamicFragDepthCostCase : public RenderCountCase |
| { |
| public: |
| OccluderDynamicFragDepthCostCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc) |
| : RenderCountCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| ~OccluderDynamicFragDepthCostCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::quadWith(Utils::getDynamicFragDepthFragmentShader(), 0.2f); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::fastQuad(0.8f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing hidden fragment culling speed" << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullsceen quads. The first (occluding) is rendered once, the second " |
| "(occluded) is rendered repeatedly" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "Workload indicates the number of times the occluded quad is rendered" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The occluder quad has a dynamic offset applied to gl_FragDepth" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "The time per culled pixel is estimated from the rate of change of rendering time as a function of " |
| "workload" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| }; |
| |
| // Constant offset to frag depth in occluder |
| class OccludedStaticFragDepthCostCase : public RenderCountCase |
| { |
| public: |
| OccludedStaticFragDepthCostCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc) |
| : RenderCountCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| ~OccludedStaticFragDepthCostCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::fastQuad(0.2f); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::quadWith(Utils::getStaticFragDepthFragmentShader(), 0.2f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing hidden fragment culling speed" << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullsceen quads. The first (occluding) is rendered once, the second " |
| "(occluded) is rendered repeatedly" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "Workload indicates the number of times the occluded quad is rendered" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The occluded quad has a static offset applied to gl_FragDepth" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "The time per culled pixel is estimated from the rate of change of rendering time as a function of " |
| "workload" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| }; |
| |
| // Dynamic offset to frag depth in occluder |
| class OccludedDynamicFragDepthCostCase : public RenderCountCase |
| { |
| public: |
| OccludedDynamicFragDepthCostCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc) |
| : RenderCountCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| ~OccludedDynamicFragDepthCostCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::fastQuad(0.2f); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::quadWith(Utils::getDynamicFragDepthFragmentShader(), 0.2f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing hidden fragment culling speed" << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullsceen quads. The first (occluding) is rendered once, the second " |
| "(occluded) is rendered repeatedly" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "Workload indicates the number of times the occluded quad is rendered" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The occluded quad has a dynamic offset applied to gl_FragDepth" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "The time per culled pixel is estimated from the rate of change of rendering time as a function of " |
| "workload" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| }; |
| |
| // Culling speed with slightly less trivial geometry |
| class OccludingGeometryComplexityCostCase : public RenderCountCase |
| { |
| public: |
| OccludingGeometryComplexityCostCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc, int resolution, float xyNoise, float zNoise) |
| : RenderCountCase(testCtx, renderCtx, name, desc) |
| , m_resolution(resolution) |
| , m_xyNoise(xyNoise) |
| , m_zNoise(zNoise) |
| { |
| } |
| |
| ~OccludingGeometryComplexityCostCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return ObjectData(Utils::getBaseShader(), Utils::getFullScreenGrid(m_resolution, |
| deInt32Hash(deStringHash(getName())) ^ |
| m_testCtx.getCommandLine().getBaseSeed(), |
| 0.2f, m_zNoise, m_xyNoise)); |
| } |
| |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::variableQuad(0.8f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing hidden fragment culling speed" << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of an occluding grid and an occluded fullsceen quad. The occluding geometry is " |
| "rendered once, the occluded one is rendered repeatedly" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "Workload indicates the number of times the occluded quad is rendered" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "The time per culled pixel is estimated from the rate of change of rendering time as a function of " |
| "workload" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| |
| const int m_resolution; |
| const float m_xyNoise; |
| const float m_zNoise; |
| }; |
| |
| // Cases with varying workloads in the fragment shader |
| class FragmentWorkloadCullCase : public RelativeChangeCase |
| { |
| public: |
| FragmentWorkloadCullCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, const char *desc); |
| virtual ~FragmentWorkloadCullCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::fastQuad(0.2f); |
| } |
| |
| virtual void logDescription(void); |
| }; |
| |
| FragmentWorkloadCullCase::FragmentWorkloadCullCase(TestContext &testCtx, const RenderContext &renderCtx, |
| const char *name, const char *desc) |
| : RelativeChangeCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| void FragmentWorkloadCullCase::logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing effects of culled fragment workload on render time" << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullsceen quads. The first (occluding) quad uses a trivial shader," |
| "the second (occluded) contains significant fragment shader work" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Workload indicates the number of iterations of unused work done in the occluded quad's fragment shader" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The ratio of rendering times of this scene with/without depth testing are compared" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Successfull early Z-testing should result in no correlation between workload and render time" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| |
| // Additional workload consists of texture lookups |
| class FragmentTextureWorkloadCullCase : public FragmentWorkloadCullCase |
| { |
| public: |
| FragmentTextureWorkloadCullCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc); |
| virtual ~FragmentTextureWorkloadCullCase(void) |
| { |
| } |
| |
| virtual void init(void); |
| virtual void deinit(void); |
| |
| private: |
| typedef MovePtr<glu::Texture> TexPtr; |
| |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return ObjectData(Utils::getTextureWorkloadShader(), Utils::getFullscreenQuad(0.8f)); |
| } |
| |
| TexPtr m_texture; |
| }; |
| |
| FragmentTextureWorkloadCullCase::FragmentTextureWorkloadCullCase(TestContext &testCtx, const RenderContext &renderCtx, |
| const char *name, const char *desc) |
| : FragmentWorkloadCullCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| void FragmentTextureWorkloadCullCase::init(void) |
| { |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| const int size = 128; |
| const vector<uint8_t> data(size * size * 4, 255); |
| |
| m_texture = MovePtr<glu::Texture>(new glu::Texture(gl)); |
| |
| gl.bindTexture(GL_TEXTURE_2D, m_texture); |
| gl.texImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]); |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| } |
| |
| void FragmentTextureWorkloadCullCase::deinit(void) |
| { |
| m_texture.clear(); |
| } |
| |
| // Additional workload consists of arithmetic |
| class FragmentArithmeticWorkloadCullCase : public FragmentWorkloadCullCase |
| { |
| public: |
| FragmentArithmeticWorkloadCullCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc) |
| : FragmentWorkloadCullCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| virtual ~FragmentArithmeticWorkloadCullCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return ObjectData(Utils::getArithmeticWorkloadShader(), Utils::getFullscreenQuad(0.8f)); |
| } |
| }; |
| |
| // Contains dynamicly unused discard after a series of calculations |
| class FragmentDiscardArithmeticWorkloadCullCase : public FragmentWorkloadCullCase |
| { |
| public: |
| FragmentDiscardArithmeticWorkloadCullCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc) |
| : FragmentWorkloadCullCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| virtual ~FragmentDiscardArithmeticWorkloadCullCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return ObjectData(Utils::getArithmeticWorkloadDiscardShader(), Utils::getFullscreenQuad(0.8f)); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing effects of culled fragment workload on render time" << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullsceen quads. The first (occluding) quad uses a trivial shader," |
| "the second (occluded) contains significant fragment shader work and a discard that is never triggers " |
| "but has a dynamic condition" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Workload indicates the number of iterations of unused work done in the occluded quad's fragment shader" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The ratio of rendering times of this scene with/without depth testing are compared" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Successfull early Z-testing should result in no correlation between workload and render time" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| }; |
| |
| // Discards fragments from the occluder in a grid pattern |
| class PartialOccluderDiscardCullCase : public RelativeChangeCase |
| { |
| public: |
| PartialOccluderDiscardCullCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc, int gridsize) |
| : RelativeChangeCase(testCtx, renderCtx, name, desc) |
| , m_gridsize(gridsize) |
| { |
| } |
| virtual ~PartialOccluderDiscardCullCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::quadWith(Utils::getGridDiscardShader(m_gridsize), 0.2f); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::slowQuad(0.8f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing effects of partially discarded occluder on rendering time" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullsceen quads. The first (occluding) quad discards half the " |
| "fragments in a grid pattern, the second (partially occluded) contains significant fragment shader work" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Workload indicates the number of iterations of unused work done in the occluded quad's fragment shader" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The ratio of rendering times of this scene with/without depth testing are compared" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "Successfull early Z-testing should result in depth testing halving the render time" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| |
| const int m_gridsize; |
| }; |
| |
| // Trivial occluder covering part of screen |
| class PartialOccluderCullCase : public RelativeChangeCase |
| { |
| public: |
| PartialOccluderCullCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, const char *desc, |
| float coverage) |
| : RelativeChangeCase(testCtx, renderCtx, name, desc) |
| , m_coverage(coverage) |
| { |
| } |
| ~PartialOccluderCullCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return ObjectData(Utils::getBaseShader(), Utils::getPartScreenQuad(m_coverage, 0.2f)); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::slowQuad(0.8f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing effects of partial occluder on rendering time" << TestLog::EndMessage; |
| log << TestLog::Message << "Geometry consists of two quads. The first (occluding) quad covers " |
| << m_coverage * 100.0f |
| << "% of the screen, while the second (partially occluded, fullscreen) contains significant fragment " |
| "shader work" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Workload indicates the number of iterations of unused work done in the occluded quad's fragment shader" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The ratio of rendering times of this scene with/without depth testing are compared" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Successfull early Z-testing should result in render time increasing proportionally with unoccluded area" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| |
| const float m_coverage; |
| }; |
| |
| // Constant offset to frag depth in occluder |
| class StaticOccluderFragDepthCullCase : public RelativeChangeCase |
| { |
| public: |
| StaticOccluderFragDepthCullCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc) |
| : RelativeChangeCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| ~StaticOccluderFragDepthCullCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::quadWith(Utils::getStaticFragDepthFragmentShader(), 0.2f); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::slowQuad(0.8f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing effects of non-default frag depth on culling efficiency" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullscreen quads. The first (occluding) quad is trivial, while the second " |
| "(occluded) contains significant fragment shader work" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Workload indicates the number of iterations of unused work done in the occluded quad's fragment shader" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The occluder quad has a static offset applied to gl_FragDepth" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The ratio of rendering times of this scene with/without depth testing are compared" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Successfull early Z-testing should result in no correlation between workload and render time" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| }; |
| |
| // Dynamic offset to frag depth in occluder |
| class DynamicOccluderFragDepthCullCase : public RelativeChangeCase |
| { |
| public: |
| DynamicOccluderFragDepthCullCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc) |
| : RelativeChangeCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| ~DynamicOccluderFragDepthCullCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::quadWith(Utils::getDynamicFragDepthFragmentShader(), 0.2f); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::slowQuad(0.8f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing effects of non-default frag depth on culling efficiency" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullscreen quads. The first (occluding) quad is trivial, while the second " |
| "(occluded) contains significant fragment shader work" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Workload indicates the number of iterations of unused work done in the occluded quad's fragment shader" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The occluder quad has a dynamic offset applied to gl_FragDepth" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The ratio of rendering times of this scene with/without depth testing are compared" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Successfull early Z-testing should result in no correlation between workload and render time" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| }; |
| |
| // Constant offset to frag depth in occluded |
| class StaticOccludedFragDepthCullCase : public RelativeChangeCase |
| { |
| public: |
| StaticOccludedFragDepthCullCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc) |
| : RelativeChangeCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| ~StaticOccludedFragDepthCullCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::fastQuad(0.2f); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::quadWith(Utils::getStaticFragDepthArithmeticWorkloadFragmentShader(), 0.2f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing effects of non-default frag depth on rendering time" << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullscreen quads. The first (occluding) quad is trivial, while the second " |
| "(occluded) contains significant fragment shader work" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Workload indicates the number of iterations of unused work done in the occluded quad's fragment shader" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The occluded quad has a static offset applied to gl_FragDepth" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The ratio of rendering times of this scene with/without depth testing are compared" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Successfull early Z-testing should result in no correlation between workload and render time" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| }; |
| |
| // Dynamic offset to frag depth in occluded |
| class DynamicOccludedFragDepthCullCase : public RelativeChangeCase |
| { |
| public: |
| DynamicOccludedFragDepthCullCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, |
| const char *desc) |
| : RelativeChangeCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| ~DynamicOccludedFragDepthCullCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::fastQuad(0.2f); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::quadWith(Utils::getDynamicFragDepthArithmeticWorkloadFragmentShader(), 0.2f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing effects of non-default frag depth on rendering time" << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullscreen quads. The first (occluding) quad is trivial, while the second " |
| "(occluded) contains significant fragment shader work" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Workload indicates the number of iterations of unused work done in the occluded quad's fragment shader" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The occluded quad has a dynamic offset applied to gl_FragDepth" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The ratio of rendering times of this scene with/without depth testing are compared" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Successfull early Z-testing should result in no correlation between workload and render time" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| }; |
| |
| // Dynamic offset to frag depth in occluded |
| class ReversedDepthOrderCullCase : public RelativeChangeCase |
| { |
| public: |
| ReversedDepthOrderCullCase(TestContext &testCtx, const RenderContext &renderCtx, const char *name, const char *desc) |
| : RelativeChangeCase(testCtx, renderCtx, name, desc) |
| { |
| } |
| |
| ~ReversedDepthOrderCullCase(void) |
| { |
| } |
| |
| private: |
| virtual ObjectData genOccluderGeometry(void) const |
| { |
| return Utils::fastQuad(0.2f); |
| } |
| virtual ObjectData genOccludedGeometry(void) const |
| { |
| return Utils::slowQuad(0.8f); |
| } |
| |
| virtual void logDescription(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| |
| log << TestLog::Section("Description", "Test description"); |
| log << TestLog::Message << "Testing effects of of back first rendering order on culling efficiency" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Geometry consists of two fullscreen quads. The second (occluding) quad is trivial, while the first " |
| "(occluded) contains significant fragment shader work" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Workload indicates the number of iterations of unused work done in the occluded quad's fragment shader" |
| << TestLog::EndMessage; |
| log << TestLog::Message << "The ratio of rendering times of this scene with/without depth testing are compared" |
| << TestLog::EndMessage; |
| log << TestLog::Message |
| << "Successfull early Z-testing should result in no correlation between workload and render time" |
| << TestLog::EndMessage; |
| log << TestLog::EndSection; |
| } |
| |
| // Rendering order of occluder & occluded is reversed, otherwise identical to parent version |
| Sample renderSample(const RenderData &occluder, const RenderData &occluded, int workload) const |
| { |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| const GLuint program = occluded.m_program.getProgram(); |
| Sample sample; |
| uint64_t now = 0; |
| uint64_t prev = 0; |
| uint8_t buffer[4]; |
| |
| gl.useProgram(program); |
| gl.uniform1i(gl.getUniformLocation(program, "u_iterations"), workload); |
| |
| // Warmup (this workload seems to reduce variation in following workloads) |
| { |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.disable(GL_DEPTH_TEST); |
| |
| gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| } |
| |
| // Null time |
| { |
| prev = deGetMicroseconds(); |
| |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.disable(GL_DEPTH_TEST); |
| |
| gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| |
| now = deGetMicroseconds(); |
| |
| sample.nullTime = now - prev; |
| } |
| |
| // Test time |
| { |
| prev = deGetMicroseconds(); |
| |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.enable(GL_DEPTH_TEST); |
| |
| render(occluded); |
| render(occluder); |
| |
| gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| |
| now = deGetMicroseconds(); |
| |
| sample.testTime = now - prev; |
| } |
| |
| // Base time |
| { |
| prev = deGetMicroseconds(); |
| |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| gl.disable(GL_DEPTH_TEST); |
| |
| render(occluded); |
| render(occluder); |
| |
| gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| |
| now = deGetMicroseconds(); |
| |
| sample.baseTime = now - prev; |
| } |
| |
| sample.workload = 0; |
| |
| return sample; |
| } |
| }; |
| |
| } // namespace |
| |
| DepthTests::DepthTests(Context &context) : TestCaseGroup(context, "depth", "Depth culling performance") |
| { |
| } |
| |
| void DepthTests::init(void) |
| { |
| TestContext &testCtx = m_context.getTestContext(); |
| const RenderContext &renderCtx = m_context.getRenderContext(); |
| |
| { |
| tcu::TestCaseGroup *const cullEfficiencyGroup = |
| new tcu::TestCaseGroup(m_testCtx, "cull_efficiency", "Fragment cull efficiency"); |
| |
| addChild(cullEfficiencyGroup); |
| |
| { |
| tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "workload", "Workload"); |
| |
| cullEfficiencyGroup->addChild(group); |
| |
| group->addChild(new FragmentTextureWorkloadCullCase(testCtx, renderCtx, "workload_texture", |
| "Fragment shader with texture lookup workload")); |
| group->addChild(new FragmentArithmeticWorkloadCullCase(testCtx, renderCtx, "workload_arithmetic", |
| "Fragment shader with arithmetic workload")); |
| group->addChild(new FragmentDiscardArithmeticWorkloadCullCase( |
| testCtx, renderCtx, "workload_arithmetic_discard", |
| "Fragment shader that may discard with arithmetic workload")); |
| } |
| |
| { |
| tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "occluder_discard", "Discard"); |
| |
| cullEfficiencyGroup->addChild(group); |
| |
| group->addChild(new PartialOccluderDiscardCullCase(testCtx, renderCtx, "grid_256", |
| "Parts of occluder geometry discarded", 256)); |
| group->addChild(new PartialOccluderDiscardCullCase(testCtx, renderCtx, "grid_128", |
| "Parts of occluder geometry discarded", 128)); |
| group->addChild(new PartialOccluderDiscardCullCase(testCtx, renderCtx, "grid_64", |
| "Parts of occluder geometry discarded", 64)); |
| group->addChild(new PartialOccluderDiscardCullCase(testCtx, renderCtx, "grid_32", |
| "Parts of occluder geometry discarded", 32)); |
| group->addChild(new PartialOccluderDiscardCullCase(testCtx, renderCtx, "grid_16", |
| "Parts of occluder geometry discarded", 16)); |
| group->addChild(new PartialOccluderDiscardCullCase(testCtx, renderCtx, "grid_8", |
| "Parts of occluder geometry discarded", 8)); |
| group->addChild(new PartialOccluderDiscardCullCase(testCtx, renderCtx, "grid_4", |
| "Parts of occluder geometry discarded", 4)); |
| group->addChild(new PartialOccluderDiscardCullCase(testCtx, renderCtx, "grid_2", |
| "Parts of occluder geometry discarded", 2)); |
| group->addChild(new PartialOccluderDiscardCullCase(testCtx, renderCtx, "grid_1", |
| "Parts of occluder geometry discarded", 1)); |
| } |
| |
| { |
| tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "partial_coverage", "Partial Coverage"); |
| |
| cullEfficiencyGroup->addChild(group); |
| |
| group->addChild(new PartialOccluderCullCase(testCtx, renderCtx, "100", |
| "Occluder covering only part of occluded geometry", 1.00f)); |
| group->addChild(new PartialOccluderCullCase(testCtx, renderCtx, "099", |
| "Occluder covering only part of occluded geometry", 0.99f)); |
| group->addChild(new PartialOccluderCullCase(testCtx, renderCtx, "095", |
| "Occluder covering only part of occluded geometry", 0.95f)); |
| group->addChild(new PartialOccluderCullCase(testCtx, renderCtx, "090", |
| "Occluder covering only part of occluded geometry", 0.90f)); |
| group->addChild(new PartialOccluderCullCase(testCtx, renderCtx, "080", |
| "Occluder covering only part of occluded geometry", 0.80f)); |
| group->addChild(new PartialOccluderCullCase(testCtx, renderCtx, "070", |
| "Occluder covering only part of occluded geometry", 0.70f)); |
| group->addChild(new PartialOccluderCullCase(testCtx, renderCtx, "050", |
| "Occluder covering only part of occluded geometry", 0.50f)); |
| group->addChild(new PartialOccluderCullCase(testCtx, renderCtx, "025", |
| "Occluder covering only part of occluded geometry", 0.25f)); |
| group->addChild(new PartialOccluderCullCase(testCtx, renderCtx, "010", |
| "Occluder covering only part of occluded geometry", 0.10f)); |
| } |
| |
| { |
| tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "frag_depth", "Partial Coverage"); |
| |
| cullEfficiencyGroup->addChild(group); |
| |
| group->addChild(new StaticOccluderFragDepthCullCase(testCtx, renderCtx, "occluder_static", "")); |
| group->addChild(new DynamicOccluderFragDepthCullCase(testCtx, renderCtx, "occluder_dynamic", "")); |
| group->addChild(new StaticOccludedFragDepthCullCase(testCtx, renderCtx, "occluded_static", "")); |
| group->addChild(new DynamicOccludedFragDepthCullCase(testCtx, renderCtx, "occluded_dynamic", "")); |
| } |
| |
| { |
| tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "order", "Rendering order"); |
| |
| cullEfficiencyGroup->addChild(group); |
| |
| group->addChild( |
| new ReversedDepthOrderCullCase(testCtx, renderCtx, "reversed", "Back to front rendering order")); |
| } |
| } |
| |
| { |
| tcu::TestCaseGroup *const testCostGroup = |
| new tcu::TestCaseGroup(m_testCtx, "culled_pixel_cost", "Fragment cull efficiency"); |
| |
| addChild(testCostGroup); |
| |
| { |
| tcu::TestCaseGroup *const group = |
| new tcu::TestCaseGroup(m_testCtx, "gradient", "Gradients with small depth differences"); |
| |
| testCostGroup->addChild(group); |
| |
| group->addChild(new BaseCostCase(testCtx, renderCtx, "flat", "")); |
| group->addChild(new GradientCostCase(testCtx, renderCtx, "gradient_050", "", 0.50f)); |
| group->addChild(new GradientCostCase(testCtx, renderCtx, "gradient_010", "", 0.10f)); |
| group->addChild(new GradientCostCase(testCtx, renderCtx, "gradient_005", "", 0.05f)); |
| group->addChild(new GradientCostCase(testCtx, renderCtx, "gradient_002", "", 0.02f)); |
| group->addChild(new GradientCostCase(testCtx, renderCtx, "gradient_001", "", 0.01f)); |
| } |
| |
| { |
| tcu::TestCaseGroup *const group = |
| new tcu::TestCaseGroup(m_testCtx, "occluder_geometry", "Occluders with varying geometry complexity"); |
| |
| testCostGroup->addChild(group); |
| |
| group->addChild( |
| new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "flat_uniform_grid_5", "", 5, 0.0f, 0.0f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "flat_uniform_grid_15", "", 15, |
| 0.0f, 0.0f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "flat_uniform_grid_25", "", 25, |
| 0.0f, 0.0f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "flat_uniform_grid_50", "", 50, |
| 0.0f, 0.0f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "flat_uniform_grid_100", "", |
| 100, 0.0f, 0.0f)); |
| |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "flat_noisy_grid_5", "", 5, |
| 1.0f / 5.0f, 0.0f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "flat_noisy_grid_15", "", 15, |
| 1.0f / 15.0f, 0.0f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "flat_noisy_grid_25", "", 25, |
| 1.0f / 25.0f, 0.0f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "flat_noisy_grid_50", "", 50, |
| 1.0f / 50.0f, 0.0f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "flat_noisy_grid_100", "", 100, |
| 1.0f / 100.0f, 0.0f)); |
| |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "uneven_uniform_grid_5", "", 5, |
| 0.0f, 0.2f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "uneven_uniform_grid_15", "", |
| 15, 0.0f, 0.2f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "uneven_uniform_grid_25", "", |
| 25, 0.0f, 0.2f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "uneven_uniform_grid_50", "", |
| 50, 0.0f, 0.2f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "uneven_uniform_grid_100", "", |
| 100, 0.0f, 0.2f)); |
| |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "uneven_noisy_grid_5", "", 5, |
| 1.0f / 5.0f, 0.2f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "uneven_noisy_grid_15", "", 15, |
| 1.0f / 15.0f, 0.2f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "uneven_noisy_grid_25", "", 25, |
| 1.0f / 25.0f, 0.2f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "uneven_noisy_grid_50", "", 50, |
| 1.0f / 50.0f, 0.2f)); |
| group->addChild(new OccludingGeometryComplexityCostCase(testCtx, renderCtx, "uneven_noisy_grid_100", "", |
| 100, 1.0f / 100.0f, 0.2f)); |
| } |
| |
| { |
| tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "frag_depth", "Modifying gl_FragDepth"); |
| |
| testCostGroup->addChild(group); |
| |
| group->addChild(new OccluderStaticFragDepthCostCase(testCtx, renderCtx, "occluder_static", "")); |
| group->addChild(new OccluderDynamicFragDepthCostCase(testCtx, renderCtx, "occluder_dynamic", "")); |
| group->addChild(new OccludedStaticFragDepthCostCase(testCtx, renderCtx, "occluded_static", "")); |
| group->addChild(new OccludedDynamicFragDepthCostCase(testCtx, renderCtx, "occluded_dynamic", "")); |
| } |
| } |
| } |
| |
| } // namespace Performance |
| } // namespace gles3 |
| } // namespace deqp |
