xref: /aosp_15_r20/external/deqp/external/openglcts/modules/gl/gl4cShaderAtomicCounterOpsTests.hpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

#ifndef _GL4CSHADERATOMICCOUNTEROPSTESTS_HPP
#define _GL4CSHADERATOMICCOUNTEROPSTESTS_HPP
/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2017 The Khronos Group Inc.
 *
 * 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  gl4cShaderAtomicCounterOpsTests.hpp
 * \brief Conformance tests for the ARB_shader_atomic_counter_ops functionality.
 */ /*-------------------------------------------------------------------*/

#include "deUniquePtr.hpp"
#include "glcTestCase.hpp"
#include "gluShaderProgram.hpp"

#include <algorithm>
#include <map>
#include <string>

namespace gl4cts
{

class ShaderAtomicCounterOpsTestBase : public deqp::TestCase
{
public:
    class AtomicOperation
    {
    private:
        std::string m_function;
        glw::GLuint m_inputValue;
        glw::GLuint m_paramValue;
        glw::GLuint m_compareValue;
        bool m_testReturnValue;

    protected:
        virtual glw::GLuint iterate(glw::GLuint input, glw::GLuint param, glw::GLuint compare) const = 0;

    public:
        AtomicOperation(std::string function, glw::GLuint inputValue, glw::GLuint paramValue,
                        glw::GLuint compareValue = 0, bool testReturnValue = false)
            : m_function(function)
            , m_inputValue(inputValue)
            , m_paramValue(paramValue)
            , m_compareValue(compareValue)
            , m_testReturnValue(testReturnValue)
        {
        }

        virtual ~AtomicOperation()
        {
        }

        glw::GLuint getResult(unsigned int iterations) const
        {
            glw::GLuint result = m_inputValue;
            for (unsigned int i = 0; i < iterations; ++i)
            {
                result = iterate(result, m_paramValue, m_compareValue);
            }
            return result;
        }

        inline std::string getFunction() const
        {
            return m_function;
        }
        inline glw::GLuint getInputValue() const
        {
            return m_inputValue;
        }
        inline glw::GLuint getParamValue() const
        {
            return m_paramValue;
        }
        inline glw::GLuint getCompareValue() const
        {
            return m_compareValue;
        }
        inline bool shouldTestReturnValue() const
        {
            return m_testReturnValue;
        }
    };

    class AtomicOperationAdd : public AtomicOperation
    {
    private:
        glw::GLuint iterate(glw::GLuint input, glw::GLuint param, glw::GLuint compare) const
        {
            DE_UNREF(compare);
            return input + param;
        }

    public:
        AtomicOperationAdd(glw::GLuint inputValue, glw::GLuint paramValue)
            : AtomicOperation("atomicCounterAdd", inputValue, paramValue, 0U, true)
        {
        }
    };

    class AtomicOperationSubtract : public AtomicOperation
    {
    private:
        glw::GLuint iterate(glw::GLuint input, glw::GLuint param, glw::GLuint compare) const
        {
            DE_UNREF(compare);
            return input - param;
        }

    public:
        AtomicOperationSubtract(glw::GLuint inputValue, glw::GLuint paramValue)
            : AtomicOperation("atomicCounterSubtract", inputValue, paramValue, 0U, true)
        {
        }
    };

    class AtomicOperationMin : public AtomicOperation
    {
    private:
        glw::GLuint iterate(glw::GLuint input, glw::GLuint param, glw::GLuint compare) const
        {
            DE_UNREF(compare);
            return std::min(input, param);
        }

    public:
        AtomicOperationMin(glw::GLuint inputValue, glw::GLuint paramValue)
            : AtomicOperation("atomicCounterMin", inputValue, paramValue)
        {
        }
    };

    class AtomicOperationMax : public AtomicOperation
    {
    private:
        glw::GLuint iterate(glw::GLuint input, glw::GLuint param, glw::GLuint compare) const
        {
            DE_UNREF(compare);
            return std::max(input, param);
        }

    public:
        AtomicOperationMax(glw::GLuint inputValue, glw::GLuint paramValue)
            : AtomicOperation("atomicCounterMax", inputValue, paramValue)
        {
        }
    };

    class AtomicOperationAnd : public AtomicOperation
    {
    private:
        glw::GLuint iterate(glw::GLuint input, glw::GLuint param, glw::GLuint compare) const
        {
            DE_UNREF(compare);
            return input & param;
        }

    public:
        AtomicOperationAnd(glw::GLuint inputValue, glw::GLuint paramValue)
            : AtomicOperation("atomicCounterAnd", inputValue, paramValue)
        {
        }
    };

    class AtomicOperationOr : public AtomicOperation
    {
    private:
        glw::GLuint iterate(glw::GLuint input, glw::GLuint param, glw::GLuint compare) const
        {
            DE_UNREF(compare);
            return input | param;
        }

    public:
        AtomicOperationOr(glw::GLuint inputValue, glw::GLuint paramValue)
            : AtomicOperation("atomicCounterOr", inputValue, paramValue)
        {
        }
    };

    class AtomicOperationXor : public AtomicOperation
    {
    private:
        glw::GLuint iterate(glw::GLuint input, glw::GLuint param, glw::GLuint compare) const
        {
            DE_UNREF(compare);
            return input ^ param;
        }

    public:
        AtomicOperationXor(glw::GLuint inputValue, glw::GLuint paramValue)
            : AtomicOperation("atomicCounterXor", inputValue, paramValue)
        {
        }
    };

    class AtomicOperationExchange : public AtomicOperation
    {
    private:
        glw::GLuint iterate(glw::GLuint input, glw::GLuint param, glw::GLuint compare) const
        {
            DE_UNREF(input);
            DE_UNREF(compare);
            return param;
        }

    public:
        AtomicOperationExchange(glw::GLuint inputValue, glw::GLuint paramValue)
            : AtomicOperation("atomicCounterExchange", inputValue, paramValue)
        {
        }
    };

    class AtomicOperationCompSwap : public AtomicOperation
    {
    private:
        glw::GLuint iterate(glw::GLuint input, glw::GLuint param, glw::GLuint compare) const
        {
            return input == compare ? param : input;
        }

    public:
        AtomicOperationCompSwap(glw::GLuint inputValue, glw::GLuint paramValue, glw::GLuint compareValue)
            : AtomicOperation("atomicCounterCompSwap", inputValue, paramValue, compareValue)
        {
        }
    };

    class ShaderPipeline
    {
    private:
        glu::ShaderProgram *m_program;
        glu::ShaderProgram *m_programCompute;
        glu::ShaderType m_testedShader;
        AtomicOperation *m_atomicOp;

        std::string m_shaders[glu::SHADERTYPE_LAST];

        void renderQuad(deqp::Context &context);
        void executeComputeShader(deqp::Context &context);

    public:
        ShaderPipeline(glu::ShaderType testedShader, AtomicOperation *newOp, bool contextGL46);
        ~ShaderPipeline();

        void prepareShader(std::string &shader, const std::string &tag, const std::string &replace);

        void create(deqp::Context &context);
        void use(deqp::Context &context);

        inline glu::ShaderProgram *getShaderProgram() const
        {
            return m_program;
        }

        inline AtomicOperation *getAtomicOperation() const
        {
            return m_atomicOp;
        }

        void test(deqp::Context &context);
    };

private:
    /* Private methods*/
    void fillAtomicCounterBuffer(AtomicOperation *atomicOp);
    bool checkAtomicCounterBuffer(AtomicOperation *atomicOp);

    void bindBuffers();
    bool validateColor(tcu::Vec4 testedColor, tcu::Vec4 desiredColor);
    bool validateScreenPixels(tcu::Vec4 desiredColor, tcu::Vec4 ignoredColor);

protected:
    /* Protected members */
    glw::GLuint m_atomicCounterBuffer;
    glw::GLuint m_atomicCounterCallsBuffer;
    bool m_contextSupportsGL46;
    std::vector<AtomicOperation *> m_operations;
    std::vector<ShaderPipeline> m_shaderPipelines;

    /* Protected methods */
    inline void addOperation(AtomicOperation *newOp)
    {
        for (unsigned int i = 0; i < glu::SHADERTYPE_LAST; ++i)
        {
            m_shaderPipelines.push_back(ShaderPipeline((glu::ShaderType)i, newOp, m_contextSupportsGL46));
        }
    }

    virtual void setOperations() = 0;

public:
    /* Public methods */
    ShaderAtomicCounterOpsTestBase(deqp::Context &context, const char *name, const char *description);

    void init();
    void deinit();

    tcu::TestNode::IterateResult iterate();

    typedef std::vector<ShaderPipeline>::iterator ShaderPipelineIter;
    typedef std::vector<AtomicOperation *>::iterator AtomicOperationIter;
};

/** Test verifies new built-in addition and substraction atomic counter operations
 **/
class ShaderAtomicCounterOpsAdditionSubstractionTestCase : public ShaderAtomicCounterOpsTestBase
{
private:
    /* Private methods */
    void setOperations();

public:
    /* Public methods */
    ShaderAtomicCounterOpsAdditionSubstractionTestCase(deqp::Context &context);
};

/** Test verifies new built-in minimum and maximum atomic counter operations
 **/
class ShaderAtomicCounterOpsMinMaxTestCase : public ShaderAtomicCounterOpsTestBase
{
private:
    /* Private methods */
    void setOperations();

public:
    /* Public methods */
    ShaderAtomicCounterOpsMinMaxTestCase(deqp::Context &context);
};

/** Test verifies new built-in bitwise atomic counter operations
 **/
class ShaderAtomicCounterOpsBitwiseTestCase : public ShaderAtomicCounterOpsTestBase
{
private:
    /* Private methods */
    void setOperations();

public:
    /* Public methods */
    ShaderAtomicCounterOpsBitwiseTestCase(deqp::Context &context);
};

/** Test verifies new built-in exchange and swap atomic counter operations
 **/
class ShaderAtomicCounterOpsExchangeTestCase : public ShaderAtomicCounterOpsTestBase
{
private:
    /* Private methods */
    void setOperations();

public:
    /* Public methods */
    ShaderAtomicCounterOpsExchangeTestCase(deqp::Context &context);
};

/** Test group which encapsulates all ARB_shader_atomic_counter_ops conformance tests */
class ShaderAtomicCounterOps : public deqp::TestCaseGroup
{
public:
    /* Public methods */
    ShaderAtomicCounterOps(deqp::Context &context);

    void init();

private:
    ShaderAtomicCounterOps(const ShaderAtomicCounterOps &other);
    ShaderAtomicCounterOps &operator=(const ShaderAtomicCounterOps &other);
};

} // namespace gl4cts

#endif // _GL4CSHADERATOMICCOUNTEROPSTESTS_HPP