1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL (ES) Module 3 * ----------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Single-program test case wrapper for ShaderPerformanceMeasurer. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "glsShaderPerformanceCase.hpp" 25 #include "tcuRenderTarget.hpp" 26 #include "deStringUtil.hpp" 27 #include "deMath.h" 28 29 #include "glwFunctions.hpp" 30 #include "glwEnums.hpp" 31 32 using tcu::Vec4; 33 using tcu::TestLog; 34 using namespace glw; // GL types 35 36 namespace deqp 37 { 38 namespace gls 39 { 40 41 ShaderPerformanceCase::ShaderPerformanceCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, PerfCaseType caseType) 42 : tcu::TestCase (testCtx, tcu::NODETYPE_PERFORMANCE, name, description) 43 , m_renderCtx (renderCtx) 44 , m_caseType (caseType) 45 , m_program (DE_NULL) 46 , m_measurer (renderCtx, caseType) 47 { 48 } 49 50 ShaderPerformanceCase::~ShaderPerformanceCase (void) 51 { 52 ShaderPerformanceCase::deinit(); 53 } 54 55 void ShaderPerformanceCase::setGridSize (int gridW, int gridH) 56 { 57 m_measurer.setGridSize(gridW, gridH); 58 } 59 60 void ShaderPerformanceCase::setViewportSize (int width, int height) 61 { 62 m_measurer.setViewportSize(width, height); 63 } 64 65 void ShaderPerformanceCase::setVertexFragmentRatio (float fragmentsPerVertices) 66 { 67 const float eps = 0.01f; 68 int gridW = 255; 69 int gridH = 255; 70 int viewportW = m_renderCtx.getRenderTarget().getWidth(); 71 int viewportH = m_renderCtx.getRenderTarget().getHeight(); 72 73 for (int i = 0; i < 10; i++) 74 { 75 int numVert = (gridW+1)*(gridH+1); 76 int numFrag = viewportW*viewportH; 77 float ratio = (float)numFrag / (float)numVert; 78 79 if (de::abs(ratio - fragmentsPerVertices) < eps) 80 break; 81 else if (ratio < fragmentsPerVertices) 82 { 83 // Not enough fragments. 84 numVert = deRoundFloatToInt32((float)numFrag / fragmentsPerVertices); 85 86 while ((gridW+1)*(gridH+1) > numVert) 87 { 88 if (gridW > gridH) 89 gridW -= 1; 90 else 91 gridH -= 1; 92 } 93 } 94 else 95 { 96 // Not enough vertices. 97 numFrag = deRoundFloatToInt32((float)numVert * fragmentsPerVertices); 98 99 while (viewportW*viewportH > numFrag) 100 { 101 if (viewportW > viewportH) 102 viewportW -= 1; 103 else 104 viewportH -= 1; 105 } 106 } 107 } 108 109 float finalRatio = (float)(viewportW*viewportH) / (float)((gridW+1)*(gridH+1)); 110 m_testCtx.getLog() << TestLog::Message << "Requested fragment/vertex-ratio: " << de::floatToString(fragmentsPerVertices, 2) << "\n" 111 << "Computed fragment/vertex-ratio: " << de::floatToString(finalRatio, 2) 112 << TestLog::EndMessage; 113 114 setGridSize(gridW, gridH); 115 setViewportSize(viewportW, viewportH); 116 } 117 118 static void logRenderTargetInfo (TestLog& log, const tcu::RenderTarget& renderTarget) 119 { 120 log << TestLog::Section("RenderTarget", "Render target") 121 << TestLog::Message << "size: " << renderTarget.getWidth() << "x" << renderTarget.getHeight() << TestLog::EndMessage 122 << TestLog::Message << "bits:" 123 << " R" << renderTarget.getPixelFormat().redBits 124 << " G" << renderTarget.getPixelFormat().greenBits 125 << " B" << renderTarget.getPixelFormat().blueBits 126 << " A" << renderTarget.getPixelFormat().alphaBits 127 << " D" << renderTarget.getDepthBits() 128 << " S" << renderTarget.getStencilBits() 129 << TestLog::EndMessage; 130 131 if (renderTarget.getNumSamples() != 0) 132 log << TestLog::Message << renderTarget.getNumSamples() << "x MSAA" << TestLog::EndMessage; 133 else 134 log << TestLog::Message << "No MSAA" << TestLog::EndMessage; 135 136 log << TestLog::EndSection; 137 } 138 139 void ShaderPerformanceCase::init (void) 140 { 141 tcu::TestLog& log = m_testCtx.getLog(); 142 143 m_program = new glu::ShaderProgram(m_renderCtx, glu::makeVtxFragSources(m_vertShaderSource, m_fragShaderSource)); 144 145 if (m_program->isOk()) 146 { 147 const int initialCallCount = m_initialCalibration ? m_initialCalibration->initialNumCalls : 1; 148 logRenderTargetInfo(log, m_renderCtx.getRenderTarget()); 149 m_measurer.init(m_program->getProgram(), m_attributes, initialCallCount); 150 m_measurer.logParameters(log); 151 log << *m_program; 152 } 153 else 154 { 155 log << *m_program; 156 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Compile failed"); 157 return; // Skip rest of init. 158 } 159 160 setupProgram(m_program->getProgram()); 161 setupRenderState(); 162 } 163 164 void ShaderPerformanceCase::deinit (void) 165 { 166 delete m_program; 167 m_program = DE_NULL; 168 169 m_measurer.deinit(); 170 } 171 172 void ShaderPerformanceCase::setupProgram (deUint32 program) 173 { 174 DE_UNREF(program); 175 } 176 177 void ShaderPerformanceCase::setupRenderState (void) 178 { 179 } 180 181 ShaderPerformanceCase::IterateResult ShaderPerformanceCase::iterate (void) 182 { 183 DE_ASSERT(m_program); 184 185 if (!m_program->isOk()) // This happens when compilation failed in init(). 186 return STOP; 187 188 m_measurer.iterate(); 189 190 if (m_measurer.isFinished()) 191 { 192 m_measurer.logMeasurementInfo(m_testCtx.getLog()); 193 194 if (m_initialCalibration) 195 m_initialCalibration->initialNumCalls = de::max(1, m_measurer.getFinalCallCount()); 196 197 const ShaderPerformanceMeasurer::Result result = m_measurer.getResult(); 198 reportResult(result.megaVertPerSec, result.megaFragPerSec); 199 return STOP; 200 } 201 else 202 return CONTINUE; 203 } 204 205 void ShaderPerformanceCase::reportResult (float mvertPerSecond, float mfragPerSecond) 206 { 207 float result = 0.0f; 208 switch (m_caseType) 209 { 210 case CASETYPE_VERTEX: result = mvertPerSecond; break; 211 case CASETYPE_FRAGMENT: result = mfragPerSecond; break; 212 case CASETYPE_BALANCED: result = mfragPerSecond; break; 213 default: 214 DE_ASSERT(false); 215 } 216 217 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::floatToString(result, 2).c_str()); 218 } 219 220 ShaderPerformanceCaseGroup::ShaderPerformanceCaseGroup (tcu::TestContext& testCtx, const char* name, const char* description) 221 : TestCaseGroup (testCtx, name, description) 222 , m_initialCalibrationStorage (new ShaderPerformanceCase::InitialCalibration) 223 { 224 } 225 226 void ShaderPerformanceCaseGroup::addChild (ShaderPerformanceCase* perfCase) 227 { 228 perfCase->setCalibrationInitialParamStorage(m_initialCalibrationStorage); 229 TestCaseGroup::addChild(perfCase); 230 } 231 232 } // gls 233 } // deqp 234
