/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) Module
 * -----------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Shader performance measurer; handles calibration and measurement
 *//*--------------------------------------------------------------------*/

#include "glsShaderPerformanceMeasurer.hpp"
#include "gluDefs.hpp"
#include "tcuTestLog.hpp"
#include "tcuRenderTarget.hpp"
#include "deStringUtil.hpp"
#include "deMath.h"
#include "deClock.h"

#include "glwFunctions.hpp"
#include "glwEnums.hpp"

#include <algorithm>

using std::string;
using std::vector;
using tcu::TestLog;
using tcu::Vec4;
using namespace glw; // GL types

namespace deqp
{
namespace gls
{

static inline float triangleInterpolate(float v0, float v1, float v2, float x, float y)
{
    return v0 + (v2 - v0) * x + (v1 - v0) * y;
}

static inline float triQuadInterpolate(float x, float y, const tcu::Vec4 &quad)
{
    // \note Top left fill rule.
    if (x + y < 1.0f)
        return triangleInterpolate(quad.x(), quad.y(), quad.z(), x, y);
    else
        return triangleInterpolate(quad.w(), quad.z(), quad.y(), 1.0f - x, 1.0f - y);
}

static inline int getNumVertices(int gridSizeX, int gridSizeY)
{
    return (gridSizeX + 1) * (gridSizeY + 1);
}

static inline int getNumIndices(int gridSizeX, int gridSizeY)
{
    return gridSizeX * gridSizeY * 6;
}

static inline uint16_t getVtxIndex(int x, int y, int gridSizeX)
{
    return (uint16_t)(y * (gridSizeX + 1) + x);
}

static void generateVertices(std::vector<float> &dst, int gridSizeX, int gridSizeY, const AttribSpec &spec)
{
    const int numComponents = 4;

    DE_ASSERT((gridSizeX + 1) * (gridSizeY + 1) <= (1 << 16)); // Must fit into 16-bit indices.
    DE_ASSERT(gridSizeX >= 1 && gridSizeY >= 1);
    dst.resize((gridSizeX + 1) * (gridSizeY + 1) * 4);

    for (int y = 0; y <= gridSizeY; y++)
    {
        for (int x = 0; x <= gridSizeX; x++)
        {
            float xf = (float)x / (float)gridSizeX;
            float yf = (float)y / (float)gridSizeY;

            for (int compNdx = 0; compNdx < numComponents; compNdx++)
                dst[getVtxIndex(x, y, gridSizeX) * numComponents + compNdx] = triQuadInterpolate(
                    xf, yf, tcu::Vec4(spec.p00[compNdx], spec.p01[compNdx], spec.p10[compNdx], spec.p11[compNdx]));
        }
    }
}

static void generateIndices(std::vector<uint16_t> &dst, int gridSizeX, int gridSizeY)
{
    const int numIndicesPerQuad = 6;
    int numIndices              = gridSizeX * gridSizeY * numIndicesPerQuad;
    dst.resize(numIndices);

    for (int y = 0; y < gridSizeY; y++)
    {
        for (int x = 0; x < gridSizeX; x++)
        {
            int quadNdx = y * gridSizeX + x;

            dst[quadNdx * numIndicesPerQuad + 0] = getVtxIndex(x + 0, y + 0, gridSizeX);
            dst[quadNdx * numIndicesPerQuad + 1] = getVtxIndex(x + 1, y + 0, gridSizeX);
            dst[quadNdx * numIndicesPerQuad + 2] = getVtxIndex(x + 0, y + 1, gridSizeX);

            dst[quadNdx * numIndicesPerQuad + 3] = getVtxIndex(x + 0, y + 1, gridSizeX);
            dst[quadNdx * numIndicesPerQuad + 4] = getVtxIndex(x + 1, y + 0, gridSizeX);
            dst[quadNdx * numIndicesPerQuad + 5] = getVtxIndex(x + 1, y + 1, gridSizeX);
        }
    }
}

ShaderPerformanceMeasurer::ShaderPerformanceMeasurer(const glu::RenderContext &renderCtx, PerfCaseType measureType)
    : m_renderCtx(renderCtx)
    , m_gridSizeX(measureType == CASETYPE_FRAGMENT ? 1 : 255)
    , m_gridSizeY(measureType == CASETYPE_FRAGMENT ? 1 : 255)
    , m_viewportWidth(measureType == CASETYPE_VERTEX ? 32 : renderCtx.getRenderTarget().getWidth())
    , m_viewportHeight(measureType == CASETYPE_VERTEX ? 32 : renderCtx.getRenderTarget().getHeight())
    , m_state(STATE_UNINITIALIZED)
    , m_isFirstIteration(false)
    , m_prevRenderStartTime(0)
    , m_result(-1.0f, -1.0f)
    , m_indexBuffer(0)
    , m_vao(0)
{
}

void ShaderPerformanceMeasurer::logParameters(TestLog &log) const
{
    log << TestLog::Message << "Grid size: " << m_gridSizeX << "x" << m_gridSizeY << TestLog::EndMessage
        << TestLog::Message << "Viewport: " << m_viewportWidth << "x" << m_viewportHeight << TestLog::EndMessage;
}

void ShaderPerformanceMeasurer::init(uint32_t program, const vector<AttribSpec> &attributes,
                                     int calibratorInitialNumCalls)
{
    DE_ASSERT(m_state == STATE_UNINITIALIZED);

    const glw::Functions &gl = m_renderCtx.getFunctions();
    const bool useVAO        = glu::isContextTypeGLCore(m_renderCtx.getType());

    if (useVAO)
    {
        DE_ASSERT(!m_vao);
        gl.genVertexArrays(1, &m_vao);
        gl.bindVertexArray(m_vao);
        GLU_EXPECT_NO_ERROR(gl.getError(), "Create VAO");
    }

    // Validate that we have sane grid and viewport setup.

    DE_ASSERT(de::inBounds(m_gridSizeX, 1, 256) && de::inBounds(m_gridSizeY, 1, 256));

    {
        bool widthTooSmall  = m_renderCtx.getRenderTarget().getWidth() < m_viewportWidth;
        bool heightTooSmall = m_renderCtx.getRenderTarget().getHeight() < m_viewportHeight;

        if (widthTooSmall || heightTooSmall)
            throw tcu::NotSupportedError(
                "Render target too small (" +
                (widthTooSmall ? "width must be at least " + de::toString(m_viewportWidth) : "") +
                (heightTooSmall ?
                     string(widthTooSmall ? ", " : "") + "height must be at least " + de::toString(m_viewportHeight) :
                     "") +
                ")");
    }

    TCU_CHECK_INTERNAL(de::inRange(m_viewportWidth, 1, m_renderCtx.getRenderTarget().getWidth()) &&
                       de::inRange(m_viewportHeight, 1, m_renderCtx.getRenderTarget().getHeight()));

    // Insert a_position to attributes.
    m_attributes = attributes;
    m_attributes.push_back(AttribSpec("a_position", Vec4(-1.0f, -1.0f, 0.0f, 1.0f), Vec4(1.0f, -1.0f, 0.0f, 1.0f),
                                      Vec4(-1.0f, 1.0f, 0.0f, 1.0f), Vec4(1.0f, 1.0f, 0.0f, 1.0f)));

    // Generate indices.
    {
        std::vector<uint16_t> indices;
        generateIndices(indices, m_gridSizeX, m_gridSizeY);

        gl.genBuffers(1, &m_indexBuffer);
        gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer);
        gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)(indices.size() * sizeof(uint16_t)), &indices[0],
                      GL_STATIC_DRAW);

        GLU_EXPECT_NO_ERROR(gl.getError(), "Upload index data");
    }

    // Generate vertices.
    m_attribBuffers.resize(m_attributes.size(), 0);
    gl.genBuffers((GLsizei)m_attribBuffers.size(), &m_attribBuffers[0]);

    for (int attribNdx = 0; attribNdx < (int)m_attributes.size(); attribNdx++)
    {
        std::vector<float> vertices;
        generateVertices(vertices, m_gridSizeX, m_gridSizeY, m_attributes[attribNdx]);

        gl.bindBuffer(GL_ARRAY_BUFFER, m_attribBuffers[attribNdx]);
        gl.bufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(vertices.size() * sizeof(float)), &vertices[0], GL_STATIC_DRAW);
    }

    GLU_EXPECT_NO_ERROR(gl.getError(), "Upload vertex data");

    // Setup attribute bindings.
    for (int attribNdx = 0; attribNdx < (int)m_attributes.size(); attribNdx++)
    {
        int location = gl.getAttribLocation(program, m_attributes[attribNdx].name.c_str());

        if (location >= 0)
        {
            gl.enableVertexAttribArray(location);
            gl.bindBuffer(GL_ARRAY_BUFFER, m_attribBuffers[attribNdx]);
            gl.vertexAttribPointer(location, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
        }

        GLU_EXPECT_NO_ERROR(gl.getError(), "Setup vertex attribute state");
    }

    gl.useProgram(program);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");

    m_state            = STATE_MEASURING;
    m_isFirstIteration = true;

    m_calibrator.clear(CalibratorParameters(calibratorInitialNumCalls, 10 /* calibrate iteration frames */,
                                            2000.0f /* calibrate iteration shortcut threshold (ms) */,
                                            16 /* max calibrate iterations */, 1000.0f / 30.0f /* frame time (ms) */,
                                            1000.0f / 60.0f /* frame time cap (ms) */,
                                            1000.0f /* target measure duration (ms) */));
}

void ShaderPerformanceMeasurer::deinit(void)
{
    const glw::Functions &gl = m_renderCtx.getFunctions();

    if (m_indexBuffer)
    {
        gl.deleteBuffers(1, &m_indexBuffer);
        m_indexBuffer = 0;
    }

    if (m_vao)
    {
        gl.deleteVertexArrays(1, &m_vao);
        m_vao = 0;
    }

    if (!m_attribBuffers.empty())
    {
        gl.deleteBuffers((GLsizei)m_attribBuffers.size(), &m_attribBuffers[0]);
        m_attribBuffers.clear();
    }

    m_state = STATE_UNINITIALIZED;
}

void ShaderPerformanceMeasurer::render(int numDrawCalls)
{
    const glw::Functions &gl = m_renderCtx.getFunctions();
    GLsizei numIndices       = (GLsizei)getNumIndices(m_gridSizeX, m_gridSizeY);

    gl.viewport(0, 0, m_viewportWidth, m_viewportHeight);

    for (int callNdx = 0; callNdx < numDrawCalls; callNdx++)
        gl.drawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, DE_NULL);
}

void ShaderPerformanceMeasurer::iterate(void)
{
    DE_ASSERT(m_state == STATE_MEASURING);

    uint64_t renderStartTime = deGetMicroseconds();
    render(m_calibrator.getCallCount()); // Always render. This gives more stable performance behavior.

    TheilSenCalibrator::State calibratorState = m_calibrator.getState();

    if (calibratorState == TheilSenCalibrator::STATE_RECOMPUTE_PARAMS)
    {
        m_calibrator.recomputeParameters();

        m_isFirstIteration    = true;
        m_prevRenderStartTime = renderStartTime;
    }
    else if (calibratorState == TheilSenCalibrator::STATE_MEASURE)
    {
        if (!m_isFirstIteration)
            m_calibrator.recordIteration(renderStartTime - m_prevRenderStartTime);

        m_isFirstIteration    = false;
        m_prevRenderStartTime = renderStartTime;
    }
    else
    {
        DE_ASSERT(calibratorState == TheilSenCalibrator::STATE_FINISHED);

        GLU_EXPECT_NO_ERROR(m_renderCtx.getFunctions().getError(), "End of rendering");

        const MeasureState &measureState = m_calibrator.getMeasureState();

        // Compute result.
        uint64_t totalTime    = measureState.getTotalTime();
        int numFrames         = (int)measureState.frameTimes.size();
        int64_t numQuadGrids  = measureState.numDrawCalls * numFrames;
        int64_t numPixels     = (int64_t)m_viewportWidth * (int64_t)m_viewportHeight * numQuadGrids;
        int64_t numVertices   = (int64_t)getNumVertices(m_gridSizeX, m_gridSizeY) * numQuadGrids;
        double mfragPerSecond = (double)numPixels / (double)totalTime;
        double mvertPerSecond = (double)numVertices / (double)totalTime;

        m_result = Result((float)mvertPerSecond, (float)mfragPerSecond);
        m_state  = STATE_FINISHED;
    }
}

void ShaderPerformanceMeasurer::logMeasurementInfo(TestLog &log) const
{
    DE_ASSERT(m_state == STATE_FINISHED);

    const MeasureState &measureState(m_calibrator.getMeasureState());

    // Compute totals.
    uint64_t totalTime     = measureState.getTotalTime();
    int numFrames          = (int)measureState.frameTimes.size();
    int64_t numQuadGrids   = measureState.numDrawCalls * numFrames;
    int64_t numPixels      = (int64_t)m_viewportWidth * (int64_t)m_viewportHeight * numQuadGrids;
    int64_t numVertices    = (int64_t)getNumVertices(m_gridSizeX, m_gridSizeY) * numQuadGrids;
    double mfragPerSecond  = (double)numPixels / (double)totalTime;
    double mvertPerSecond  = (double)numVertices / (double)totalTime;
    double framesPerSecond = (double)numFrames / ((double)totalTime / 1000000.0);

    logCalibrationInfo(log, m_calibrator);

    log << TestLog::Float("FramesPerSecond", "Frames per second in measurement", "Frames/s", QP_KEY_TAG_PERFORMANCE,
                          (float)framesPerSecond)
        << TestLog::Float("FragmentsPerVertices", "Vertex-fragment ratio", "Fragments/Vertices", QP_KEY_TAG_NONE,
                          (float)numPixels / (float)numVertices)
        << TestLog::Float("FragmentPerf", "Fragment performance", "MPix/s", QP_KEY_TAG_PERFORMANCE,
                          (float)mfragPerSecond)
        << TestLog::Float("VertexPerf", "Vertex performance", "MVert/s", QP_KEY_TAG_PERFORMANCE, (float)mvertPerSecond);
}

void ShaderPerformanceMeasurer::setGridSize(int gridW, int gridH)
{
    DE_ASSERT(m_state == STATE_UNINITIALIZED);
    DE_ASSERT(de::inBounds(gridW, 1, 256) && de::inBounds(gridH, 1, 256));
    m_gridSizeX = gridW;
    m_gridSizeY = gridH;
}

void ShaderPerformanceMeasurer::setViewportSize(int width, int height)
{
    DE_ASSERT(m_state == STATE_UNINITIALIZED);
    DE_ASSERT(de::inRange(width, 1, m_renderCtx.getRenderTarget().getWidth()) &&
              de::inRange(height, 1, m_renderCtx.getRenderTarget().getHeight()));
    m_viewportWidth  = width;
    m_viewportHeight = height;
}

} // namespace gls
} // namespace deqp