xref: /aosp_15_r20/external/deqp/external/openglcts/modules/gl/gl4cMapBufferAlignmentTests.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2015-2016 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
 * \brief
 */ /*-------------------------------------------------------------------*/

/**
 * \file  gl4cMapBufferAlignmentTests.cpp
 * \brief Implements conformance tests for "Map Buffer Alignment" functionality.
 */ /*-------------------------------------------------------------------*/

#include "gl4cMapBufferAlignmentTests.hpp"

#include "gluContextInfo.hpp"
#include "gluDefs.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"

#include <algorithm>
#include <vector>

using namespace glw;

namespace gl4cts
{
namespace MapBufferAlignment
{
/** Implementation of Query test, description follows:
 *
 * Verify that GetInteger returns at least 64 when MIN_MAP_BUFFER_ALIGNEMENT is
 * requested.
 **/
class Query : public deqp::TestCase
{
public:
    /* Public methods */
    Query(deqp::Context &context) : TestCase(context, "query", "Verifies value of MIN_MAP_BUFFER_ALIGNEMENT")
    {
        /* Nothing to be done */
    }
    virtual ~Query()
    {
        /* Nothing to be done */
    }

    /** Execute test
     *
     * @return tcu::TestNode::STOP
     **/
    virtual tcu::TestNode::IterateResult iterate(void);

    static const GLint m_min_map_buffer_alignment = 64;
};

/** Implementation of Functional test, description follows:
 *
 * Verifies that results of MapBuffer operations are as required.
 *
 * Steps:
 * - prepare buffer filled with specific content;
 * - map buffer with MapBuffer;
 * - verify that returned data match contents of the buffer;
 * - unmap buffer;
 * - map buffer with MapBufferRange;
 * - verify that returned data match contents of the buffer;
 * - unmap buffer;
 * - verify that pointers returned by map operations fulfil alignment
 * requirements.
 *
 * Repeat steps for all valid:
 * - <buffer> values;
 * - <access> combinations.
 *
 * <offset> should be set to MIN_MAP_BUFFER_ALIGNEMENT - 1.
 **/
class Functional : public deqp::TestCase
{
public:
    /* Public methods */
    Functional(deqp::Context &context)
        : TestCase(context, "functional", "Verifies alignment of memory returned by MapBuffer operations")
    {
        /* Nothing to be done */
    }

    virtual ~Functional()
    {
        /* Nothing to be done */
    }

    void init();
    /** Execute test
     *
     * @return tcu::TestNode::STOP
     **/
    virtual tcu::TestNode::IterateResult iterate(void);
};

/** Execute test
 *
 * @return tcu::TestNode::STOP
 **/
tcu::TestNode::IterateResult Query::iterate()
{
    GLint min_map_buffer_alignment = 0;
    bool test_result               = true;

    const Functions &gl = m_context.getRenderContext().getFunctions();

    gl.getIntegerv(GL_MIN_MAP_BUFFER_ALIGNMENT, &min_map_buffer_alignment);
    GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv");

    if (m_min_map_buffer_alignment > min_map_buffer_alignment)
    {
        test_result = false;
    }

    /* Set result */
    if (true == test_result)
    {
        m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
    }
    else
    {
        m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
    }

    /* Done */
    return tcu::TestNode::STOP;
}

struct BufferEnums
{
    GLenum m_target;
    GLenum m_max_size;
};

void Functional::init(void)
{
    if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_buffer_storage"))
    {
        TCU_THROW(NotSupportedError, "GL_ARB_buffer_storage not supported");
    }
}

/** Execute test
 *
 * @return tcu::TestNode::STOP
 **/
tcu::TestNode::IterateResult Functional::iterate()
{
    static const GLenum storage_flags[] = {
        GL_MAP_READ_BIT,
        GL_MAP_WRITE_BIT,
        GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
        GL_DYNAMIC_STORAGE_BIT | GL_MAP_READ_BIT,
        GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT,
        GL_DYNAMIC_STORAGE_BIT | GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
        GL_MAP_PERSISTENT_BIT | GL_MAP_READ_BIT,
        GL_MAP_PERSISTENT_BIT | GL_MAP_WRITE_BIT,
        GL_MAP_PERSISTENT_BIT | GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
        GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT | GL_MAP_READ_BIT,
        GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT,
        GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT | GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
        GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_READ_BIT,
        GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_WRITE_BIT,
        GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
        GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT | GL_MAP_READ_BIT,
        GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT,
        GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT | GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
        GL_CLIENT_STORAGE_BIT | GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_READ_BIT,
        GL_CLIENT_STORAGE_BIT | GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_WRITE_BIT,
        GL_CLIENT_STORAGE_BIT | GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
        GL_CLIENT_STORAGE_BIT | GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT | GL_MAP_READ_BIT,
        GL_CLIENT_STORAGE_BIT | GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT,
        GL_CLIENT_STORAGE_BIT | GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT | GL_MAP_READ_BIT |
            GL_MAP_WRITE_BIT,
    };

    static const size_t n_storage_flags = sizeof(storage_flags) / sizeof(storage_flags[0]);

    static const BufferEnums buffers[] = {
        {GL_ARRAY_BUFFER, GL_MAX_VARYING_COMPONENTS},
        {GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE},
        {GL_COPY_READ_BUFFER, 0},
        {GL_COPY_WRITE_BUFFER, 0},
        {GL_DISPATCH_INDIRECT_BUFFER, 0},
        {GL_DRAW_INDIRECT_BUFFER, 0},
        {GL_ELEMENT_ARRAY_BUFFER, GL_MAX_ELEMENTS_INDICES},
        {GL_PIXEL_PACK_BUFFER, 0},
        {GL_PIXEL_UNPACK_BUFFER, 0},
        {GL_QUERY_BUFFER, 0},
        {GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BLOCK_SIZE},
        {GL_TEXTURE_BUFFER, GL_MAX_TEXTURE_BUFFER_SIZE},
        {GL_TRANSFORM_FEEDBACK_BUFFER, GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS},
        {GL_UNIFORM_BUFFER, GL_MAX_UNIFORM_BLOCK_SIZE}};
    static const size_t n_buffers = sizeof(buffers) / sizeof(buffers[0]);

    const Functions &gl = m_context.getRenderContext().getFunctions();

    std::vector<GLubyte> buffer_data;
    size_t buffer_data_size        = 0;
    GLuint buffer_id               = 0;
    GLint buffer_size              = 0;
    GLint min_map_buffer_alignment = 0;
    GLuint offset                  = 0;
    bool test_result               = true;

    /* Get min alignment */
    gl.getIntegerv(GL_MIN_MAP_BUFFER_ALIGNMENT, &min_map_buffer_alignment);
    GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv");

    /* Prepare storage */
    buffer_data_size = 2 * min_map_buffer_alignment;
    buffer_data.resize(buffer_data_size);

    /* Prepare data */
    for (size_t i = 0; i < buffer_data_size; ++i)
    {
        buffer_data[i] = (GLubyte)i;
    }

    /* Run test */
    try
    {
        for (size_t buffer_idx = 0; buffer_idx < n_buffers; ++buffer_idx)
        {
            const BufferEnums &buffer = buffers[buffer_idx];

            buffer_size = static_cast<GLint>(buffer_data_size);

            /* Get max size */
            if (0 != buffer.m_max_size)
            {
                gl.getIntegerv(buffer.m_max_size, &buffer_size);
                GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv");
            }

            switch (buffer.m_max_size)
            {
            case GL_MAX_VARYING_COMPONENTS:
            case GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
                buffer_size = static_cast<glw::GLint>(buffer_size * sizeof(GLfloat));
                break;

            case GL_MAX_ELEMENTS_INDICES:
                buffer_size = static_cast<glw::GLint>(buffer_size * sizeof(GLuint));
                break;

            default:
                break;
            }

            buffer_size = std::min(buffer_size, (GLint)buffer_data_size);
            offset      = std::min(buffer_size - 1, min_map_buffer_alignment - 1);

            for (size_t set_idx = 0; set_idx < n_storage_flags; ++set_idx)
            {
                const GLenum &storage_set = storage_flags[set_idx];

                /* Prepare buffer */
                gl.genBuffers(1, &buffer_id);
                GLU_EXPECT_NO_ERROR(gl.getError(), "GenBuffers");

                gl.bindBuffer(buffer.m_target, buffer_id);
                GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer");

                gl.bufferStorage(buffer.m_target, buffer_size, &buffer_data[0], storage_set);
                GLU_EXPECT_NO_ERROR(gl.getError(), "BufferStorage");

                /* Test MapBuffer */
                GLenum map_buffer_access = GL_READ_WRITE;
                if (0 == (storage_set & GL_MAP_READ_BIT))
                {
                    map_buffer_access = GL_WRITE_ONLY;
                }
                else if (0 == (storage_set & GL_MAP_WRITE_BIT))
                {
                    map_buffer_access = GL_READ_ONLY;
                }

                GLubyte *map_buffer_ptr = (GLubyte *)gl.mapBuffer(buffer.m_target, map_buffer_access);
                GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer");

                if (GL_WRITE_ONLY != map_buffer_access)
                {
                    for (size_t i = 0; i < (size_t)buffer_size; ++i)
                    {
                        if (buffer_data[i] != map_buffer_ptr[i])
                        {
                            test_result = false;
                            break;
                        }
                    }
                }

                gl.unmapBuffer(buffer.m_target);
                GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");

                /* Test MapBufferRange */
                static const GLenum map_buffer_range_access_mask = GL_DYNAMIC_STORAGE_BIT | GL_CLIENT_STORAGE_BIT;
                GLenum map_buffer_range_access                   = (storage_set & (~map_buffer_range_access_mask));

                GLubyte *map_buffer_range_ptr = (GLubyte *)gl.mapBufferRange(
                    buffer.m_target, offset, buffer_size - offset, map_buffer_range_access);
                GLU_EXPECT_NO_ERROR(gl.getError(), "MapBufferRange");

                if (0 != (GL_MAP_READ_BIT & map_buffer_range_access))
                {
                    for (size_t i = 0; i < (size_t)buffer_size - (size_t)offset; ++i)
                    {
                        if (buffer_data[i + offset] != map_buffer_range_ptr[i])
                        {
                            test_result = false;
                            break;
                        }
                    }
                }

                gl.unmapBuffer(buffer.m_target);
                GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");

                gl.bindBuffer(buffer.m_target, 0 /* id */);
                GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer");

                /* Remove buffer */
                gl.deleteBuffers(1, &buffer_id);
                GLU_EXPECT_NO_ERROR(gl.getError(), "DeleteBuffers");

                buffer_id = 0;

                /* Verify that pointers are properly aligned */
                if (0 != ((GLintptr)map_buffer_ptr % min_map_buffer_alignment))
                {
                    test_result = false;
                    break;
                }

                if (0 != (((GLintptr)map_buffer_range_ptr - offset) % min_map_buffer_alignment))
                {
                    test_result = false;
                    break;
                }
            }
        }
    }
    catch (const std::exception &exc)
    {
        if (0 != buffer_id)
        {
            gl.deleteBuffers(1, &buffer_id);
            GLU_EXPECT_NO_ERROR(gl.getError(), "DeleteBuffers");
        }

        TCU_FAIL(exc.what());
    }

    /* Set result */
    if (true == test_result)
    {
        m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
    }
    else
    {
        m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
    }

    /* Done */
    return tcu::TestNode::STOP;
}
} // namespace MapBufferAlignment

/** Constructor.
 *
 *  @param context Rendering context.
 **/
MapBufferAlignmentTests::MapBufferAlignmentTests(deqp::Context &context)
    : TestCaseGroup(context, "map_buffer_alignment", "Verifies \"map buffer alignment\" functionality")
{
    /* Left blank on purpose */
}

/** Initializes a texture_storage_multisample test group.
 *
 **/
void MapBufferAlignmentTests::init(void)
{
    addChild(new MapBufferAlignment::Query(m_context));
    addChild(new MapBufferAlignment::Functional(m_context));
}

} // namespace gl4cts