modules/glshared/glsShaderPerformanceMeasurer.cpp

   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 Shader performance measurer; handles calibration and measurement
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "glsShaderPerformanceMeasurer.hpp"
  25 #include "gluDefs.hpp"
  26 #include "tcuTestLog.hpp"
  27 #include "tcuRenderTarget.hpp"
  28 #include "deStringUtil.hpp"
  29 #include "deMath.h"
  30 #include "deClock.h"
  31
  32 #include "glwFunctions.hpp"
  33 #include "glwEnums.hpp"
  34
  35 #include <algorithm>
  36
  37 using tcu::Vec4;
  38 using std::string;
  39 using std::vector;
  40 using tcu::TestLog;
  41 using namespace glw; // GL types
  42
  43 namespace deqp
  44 {
  45 namespace gls
  46 {
  47
  48 static inline float triangleInterpolate (float v0, float v1, float v2, float x, float y)
  49 {
  50         return v0 + (v2-v0)*x + (v1-v0)*y;
  51 }
  52
  53 static inline float triQuadInterpolate (float x, float y, const tcu::Vec4& quad)
  54 {
  55         // \note Top left fill rule.
  56         if (x + y < 1.0f)
  57                 return triangleInterpolate(quad.x(), quad.y(), quad.z(), x, y);
  58         else
  59                 return triangleInterpolate(quad.w(), quad.z(), quad.y(), 1.0f-x, 1.0f-y);
  60 }
  61
  62 static inline int getNumVertices (int gridSizeX, int gridSizeY)
  63 {
  64         return (gridSizeX + 1) * (gridSizeY + 1);
  65 }
  66
  67 static inline int getNumIndices (int gridSizeX, int gridSizeY)
  68 {
  69         return gridSizeX*gridSizeY*6;
  70 }
  71
  72 static inline deUint16 getVtxIndex (int x, int y, int gridSizeX)
  73 {
  74         return (deUint16)(y*(gridSizeX+1) + x);
  75 }
  76
  77 static void generateVertices (std::vector<float>& dst, int gridSizeX, int gridSizeY, const AttribSpec& spec)
  78 {
  79         const int numComponents = 4;
  80
  81         DE_ASSERT((gridSizeX + 1)*(gridSizeY + 1) <= (1<<16)); // Must fit into 16-bit indices.
  82         DE_ASSERT(gridSizeX >= 1 && gridSizeY >= 1);
  83         dst.resize((gridSizeX + 1) * (gridSizeY + 1) * 4);
  84
  85         for (int y = 0; y <= gridSizeY; y++)
  86         {
  87                 for (int x = 0; x <= gridSizeX; x++)
  88                 {
  89                         float   xf      = (float)x / (float)gridSizeX;
  90                         float   yf      = (float)y / (float)gridSizeY;
  91
  92                         for (int compNdx = 0; compNdx < numComponents; compNdx++)
  93                                 dst[getVtxIndex(x, y, gridSizeX)*numComponents + compNdx] = triQuadInterpolate(xf, yf, tcu::Vec4(spec.p00[compNdx], spec.p01[compNdx], spec.p10[compNdx], spec.p11[compNdx]));
  94                 }
  95         }
  96 }
  97
  98 static void generateIndices (std::vector<deUint16>& dst, int gridSizeX, int gridSizeY)
  99 {
 100         const int       numIndicesPerQuad       = 6;
 101         int                     numIndices                      = gridSizeX * gridSizeY * numIndicesPerQuad;
 102         dst.resize(numIndices);
 103
 104         for (int y = 0; y < gridSizeY; y++)
 105         {
 106                 for (int x = 0; x < gridSizeX; x++)
 107                 {
 108                         int quadNdx = y*gridSizeX + x;
 109
 110                         dst[quadNdx*numIndicesPerQuad + 0] = getVtxIndex(x+0, y+0, gridSizeX);
 111                         dst[quadNdx*numIndicesPerQuad + 1] = getVtxIndex(x+1, y+0, gridSizeX);
 112                         dst[quadNdx*numIndicesPerQuad + 2] = getVtxIndex(x+0, y+1, gridSizeX);
 113
 114                         dst[quadNdx*numIndicesPerQuad + 3] = getVtxIndex(x+0, y+1, gridSizeX);
 115                         dst[quadNdx*numIndicesPerQuad + 4] = getVtxIndex(x+1, y+0, gridSizeX);
 116                         dst[quadNdx*numIndicesPerQuad + 5] = getVtxIndex(x+1, y+1, gridSizeX);
 117                 }
 118         }
 119 }
 120
 121 ShaderPerformanceMeasurer::ShaderPerformanceMeasurer (const glu::RenderContext& renderCtx, PerfCaseType measureType)
 122         : m_renderCtx           (renderCtx)
 123         , m_gridSizeX           (measureType == CASETYPE_FRAGMENT       ? 1             : 255)
 124         , m_gridSizeY           (measureType == CASETYPE_FRAGMENT       ? 1             : 255)
 125         , m_viewportWidth       (measureType == CASETYPE_VERTEX         ? 32    : renderCtx.getRenderTarget().getWidth())
 126         , m_viewportHeight      (measureType == CASETYPE_VERTEX         ? 32    : renderCtx.getRenderTarget().getHeight())
 127         , m_state                       (STATE_UNINITIALIZED)
 128         , m_result                      (-1.0f, -1.0f)
 129         , m_indexBuffer         (0)
 130         , m_vao                         (0)
 131 {
 132 }
 133
 134 void ShaderPerformanceMeasurer::logParameters (TestLog& log) const
 135 {
 136         log << TestLog::Message << "Grid size: " << m_gridSizeX << "x" << m_gridSizeY << TestLog::EndMessage
 137                 << TestLog::Message << "Viewport: " << m_viewportWidth << "x" << m_viewportHeight << TestLog::EndMessage;
 138 }
 139
 140 void ShaderPerformanceMeasurer::init (deUint32 program, const vector<AttribSpec>& attributes, int calibratorInitialNumCalls)
 141 {
 142         DE_ASSERT(m_state == STATE_UNINITIALIZED);
 143
 144         const glw::Functions&   gl              = m_renderCtx.getFunctions();
 145         const bool                              useVAO  = glu::isContextTypeGLCore(m_renderCtx.getType());
 146
 147         if (useVAO)
 148         {
 149                 DE_ASSERT(!m_vao);
 150                 gl.genVertexArrays(1, &m_vao);
 151                 gl.bindVertexArray(m_vao);
 152                 GLU_EXPECT_NO_ERROR(gl.getError(), "Create VAO");
 153         }
 154
 155         // Validate that we have sane grid and viewport setup.
 156
 157         DE_ASSERT(de::inBounds(m_gridSizeX, 1, 256) && de::inBounds(m_gridSizeY, 1, 256));
 158
 159         {
 160                 bool widthTooSmall              = m_renderCtx.getRenderTarget().getWidth() < m_viewportWidth;
 161                 bool heightTooSmall             = m_renderCtx.getRenderTarget().getHeight() < m_viewportHeight;
 162
 163                 if (widthTooSmall || heightTooSmall)
 164                         throw tcu::NotSupportedError("Render target too small (" +
 165                                                                                          (widthTooSmall  ?                                                                         "width must be at least "  + de::toString(m_viewportWidth)  : "") +
 166                                                                                          (heightTooSmall ? string(widthTooSmall ? ", " : "") + "height must be at least " + de::toString(m_viewportHeight) : "") +
 167                                                                                          ")");
 168         }
 169
 170         TCU_CHECK_INTERNAL(de::inRange(m_viewportWidth,         1, m_renderCtx.getRenderTarget().getWidth()) &&
 171                                            de::inRange(m_viewportHeight,        1, m_renderCtx.getRenderTarget().getHeight()));
 172
 173         // Insert a_position to attributes.
 174         m_attributes = attributes;
 175         m_attributes.push_back(AttribSpec("a_position",
 176                                                                           Vec4(-1.0f, -1.0f, 0.0f, 1.0f),
 177                                                                           Vec4( 1.0f, -1.0f, 0.0f, 1.0f),
 178                                                                           Vec4(-1.0f,  1.0f, 0.0f, 1.0f),
 179                                                                           Vec4( 1.0f,  1.0f, 0.0f, 1.0f)));
 180
 181         // Generate indices.
 182         {
 183                 std::vector<deUint16> indices;
 184                 generateIndices(indices, m_gridSizeX, m_gridSizeY);
 185
 186                 gl.genBuffers(1, &m_indexBuffer);
 187                 gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer);
 188                 gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(indices.size()*sizeof(deUint16)), &indices[0], GL_STATIC_DRAW);
 189
 190                 GLU_EXPECT_NO_ERROR(gl.getError(), "Upload index data");
 191         }
 192
 193         // Generate vertices.
 194         m_attribBuffers.resize(m_attributes.size(), 0);
 195         gl.genBuffers((GLsizei)m_attribBuffers.size(), &m_attribBuffers[0]);
 196
 197         for (int attribNdx = 0; attribNdx < (int)m_attributes.size(); attribNdx++)
 198         {
 199                 std::vector<float> vertices;
 200                 generateVertices(vertices, m_gridSizeX, m_gridSizeY, m_attributes[attribNdx]);
 201
 202                 gl.bindBuffer(GL_ARRAY_BUFFER, m_attribBuffers[attribNdx]);
 203                 gl.bufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(vertices.size()*sizeof(float)), &vertices[0], GL_STATIC_DRAW);
 204         }
 205
 206         GLU_EXPECT_NO_ERROR(gl.getError(), "Upload vertex data");
 207
 208         // Setup attribute bindings.
 209         for (int attribNdx = 0; attribNdx < (int)m_attributes.size(); attribNdx++)
 210         {
 211                 int location = gl.getAttribLocation(program, m_attributes[attribNdx].name.c_str());
 212
 213                 if (location >= 0)
 214                 {
 215                         gl.enableVertexAttribArray(location);
 216                         gl.bindBuffer(GL_ARRAY_BUFFER, m_attribBuffers[attribNdx]);
 217                         gl.vertexAttribPointer(location, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
 218                 }
 219
 220                 GLU_EXPECT_NO_ERROR(gl.getError(), "Setup vertex attribute state");
 221         }
 222
 223         gl.useProgram(program);
 224         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 225
 226         m_state = STATE_MEASURING;
 227         m_isFirstIteration = true;
 228
 229         m_calibrator.clear(CalibratorParameters(calibratorInitialNumCalls, 10 /* calibrate iteration frames */, 2000.0f /* calibrate iteration shortcut threshold (ms) */, 16 /* max calibrate iterations */,
 230                                                                                         1000.0f/30.0f /* frame time (ms) */, 1000.0f/60.0f /* frame time cap (ms) */, 1000.0f /* target measure duration (ms) */));
 231 }
 232
 233 void ShaderPerformanceMeasurer::deinit (void)
 234 {
 235         const glw::Functions& gl = m_renderCtx.getFunctions();
 236
 237         if (m_indexBuffer)
 238         {
 239                 gl.deleteBuffers(1, &m_indexBuffer);
 240                 m_indexBuffer = 0;
 241         }
 242
 243         if (m_vao)
 244         {
 245                 gl.deleteVertexArrays(1, &m_vao);
 246                 m_vao = 0;
 247         }
 248
 249         if (!m_attribBuffers.empty())
 250         {
 251                 gl.deleteBuffers((GLsizei)m_attribBuffers.size(), &m_attribBuffers[0]);
 252                 m_attribBuffers.clear();
 253         }
 254
 255         m_state = STATE_UNINITIALIZED;
 256 }
 257
 258 void ShaderPerformanceMeasurer::render (int numDrawCalls)
 259 {
 260         const glw::Functions&   gl                      = m_renderCtx.getFunctions();
 261         GLsizei                                 numIndices      = (GLsizei)getNumIndices(m_gridSizeX, m_gridSizeY);
 262
 263         gl.viewport(0, 0, m_viewportWidth, m_viewportHeight);
 264
 265         for (int callNdx = 0; callNdx < numDrawCalls; callNdx++)
 266                 gl.drawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, DE_NULL);
 267 }
 268
 269 void ShaderPerformanceMeasurer::iterate (void)
 270 {
 271         DE_ASSERT(m_state == STATE_MEASURING);
 272
 273         deUint64 renderStartTime = deGetMicroseconds();
 274         render(m_calibrator.getCallCount()); // Always render. This gives more stable performance behavior.
 275
 276         TheilSenCalibrator::State calibratorState = m_calibrator.getState();
 277
 278         if (calibratorState == TheilSenCalibrator::STATE_RECOMPUTE_PARAMS)
 279         {
 280                 m_calibrator.recomputeParameters();
 281
 282                 m_isFirstIteration = true;
 283                 m_prevRenderStartTime = renderStartTime;
 284         }
 285         else if (calibratorState == TheilSenCalibrator::STATE_MEASURE)
 286         {
 287                 if (!m_isFirstIteration)
 288                         m_calibrator.recordIteration(renderStartTime - m_prevRenderStartTime);
 289
 290                 m_isFirstIteration = false;
 291                 m_prevRenderStartTime = renderStartTime;
 292         }
 293         else
 294         {
 295                 DE_ASSERT(calibratorState == TheilSenCalibrator::STATE_FINISHED);
 296
 297                 GLU_EXPECT_NO_ERROR(m_renderCtx.getFunctions().getError(), "End of rendering");
 298
 299                 const MeasureState& measureState = m_calibrator.getMeasureState();
 300
 301                 // Compute result.
 302                 deUint64        totalTime                       = measureState.getTotalTime();
 303                 int                     numFrames                       = (int)measureState.frameTimes.size();
 304                 deInt64         numQuadGrids            = measureState.numDrawCalls * numFrames;
 305                 deInt64         numPixels                       = (deInt64)m_viewportWidth * (deInt64)m_viewportHeight * numQuadGrids;
 306                 deInt64         numVertices                     = (deInt64)getNumVertices(m_gridSizeX, m_gridSizeY) * numQuadGrids;
 307                 double          mfragPerSecond          = (double)numPixels / (double)totalTime;
 308                 double          mvertPerSecond          = (double)numVertices / (double)totalTime;
 309
 310                 m_result = Result((float)mvertPerSecond, (float)mfragPerSecond);
 311                 m_state = STATE_FINISHED;
 312         }
 313 }
 314
 315 void ShaderPerformanceMeasurer::logMeasurementInfo (TestLog& log) const
 316 {
 317         DE_ASSERT(m_state == STATE_FINISHED);
 318
 319         const MeasureState& measureState(m_calibrator.getMeasureState());
 320
 321         // Compute totals.
 322         deUint64        totalTime                       = measureState.getTotalTime();
 323         int                     numFrames                       = (int)measureState.frameTimes.size();
 324         deInt64         numQuadGrids            = measureState.numDrawCalls * numFrames;
 325         deInt64         numPixels                       = (deInt64)m_viewportWidth * (deInt64)m_viewportHeight * numQuadGrids;
 326         deInt64         numVertices                     = (deInt64)getNumVertices(m_gridSizeX, m_gridSizeY) * numQuadGrids;
 327         double          mfragPerSecond          = (double)numPixels / (double)totalTime;
 328         double          mvertPerSecond          = (double)numVertices / (double)totalTime;
 329         double          framesPerSecond         = (double)numFrames / ((double)totalTime / 1000000.0);
 330
 331         logCalibrationInfo(log, m_calibrator);
 332
 333         log << TestLog::Float("FramesPerSecond",                "Frames per second in measurement",     "Frames/s",                             QP_KEY_TAG_PERFORMANCE, (float)framesPerSecond)
 334                 << TestLog::Float("FragmentsPerVertices",       "Vertex-fragment ratio",                        "Fragments/Vertices",   QP_KEY_TAG_NONE,                (float)numPixels / (float)numVertices)
 335                 << TestLog::Float("FragmentPerf",                       "Fragment performance",                         "MPix/s",                               QP_KEY_TAG_PERFORMANCE, (float)mfragPerSecond)
 336                 << TestLog::Float("VertexPerf",                         "Vertex performance",                           "MVert/s",                              QP_KEY_TAG_PERFORMANCE, (float)mvertPerSecond);
 337 }
 338
 339 void ShaderPerformanceMeasurer::setGridSize (int gridW, int gridH)
 340 {
 341         DE_ASSERT(m_state == STATE_UNINITIALIZED);
 342         DE_ASSERT(de::inBounds(gridW, 1, 256) && de::inBounds(gridH, 1, 256));
 343         m_gridSizeX             = gridW;
 344         m_gridSizeY             = gridH;
 345 }
 346
 347 void ShaderPerformanceMeasurer::setViewportSize (int width, int height)
 348 {
 349         DE_ASSERT(m_state == STATE_UNINITIALIZED);
 350         DE_ASSERT(de::inRange(width,    1, m_renderCtx.getRenderTarget().getWidth()) &&
 351                           de::inRange(height,   1, m_renderCtx.getRenderTarget().getHeight()));
 352         m_viewportWidth         = width;
 353         m_viewportHeight        = height;
 354 }
 355
 356 } // gls
 357 } // deqp