xref: /external/deqp/external/openglcts/modules/glesext/gpu_shader5/esextcGPUShader5AtomicCountersArrayIndexing.cpp

/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2014-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 esextcGPUShader5AtomicCountersArrayIndexing.cpp
 * \brief GPUShader5 Atomic Counters Array Indexing (Test 3)
 */ /*-------------------------------------------------------------------*/

#include "esextcGPUShader5AtomicCountersArrayIndexing.hpp"
#include "gluContextInfo.hpp"
#include "gluDefs.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"
#include <cstring>

namespace glcts
{
const glw::GLuint GPUShader5AtomicCountersArrayIndexing::m_atomic_counters_array_size = 4;

/* Compute Shader code */
const char* GPUShader5AtomicCountersArrayIndexing::m_compute_shader_code =
	"${VERSION}\n"
	"\n"
	"${GPU_SHADER5_REQUIRE}\n"
	"\n"
	"layout (local_size_x = 2, local_size_y = 2) in;\n"
	"layout (binding      = 0, offset       = 0) uniform atomic_uint counters[4];\n"
	"\n"
	"void main(void)\n"
	"{\n"
	"    for (uint index = 0u; index <= 3u; ++index)\n"
	"    {\n"
	"        for (uint iteration = 0u; iteration <= gl_LocalInvocationID.x * 2u + gl_LocalInvocationID.y; "
	"++iteration)\n"
	"        {\n"
	"            atomicCounterIncrement( counters[index] );\n"
	"        }\n"
	"    }\n"
	"}\n";

/** Constructor
 *
 *  @param context     Test context
 *  @param name        Test case's name
 *  @param description Test case's description
 **/
GPUShader5AtomicCountersArrayIndexing::GPUShader5AtomicCountersArrayIndexing(Context&			  context,
																			 const ExtParameters& extParams,
																			 const char* name, const char* description)
	: TestCaseBase(context, extParams, name, description), m_buffer_id(0), m_compute_shader_id(0), m_program_id(0)
{
	/* Nothing to be done here */
}

/** Initializes GLES objects used during the test.
 *
 */
void GPUShader5AtomicCountersArrayIndexing::initTest(void)
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Check if gpu_shader5 extension is supported */
	if (!m_is_gpu_shader5_supported)
	{
		throw tcu::NotSupportedError(GPU_SHADER5_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
	}

	/* Create program object from the supplied compute shader code */
	m_program_id = gl.createProgram();
	GLU_EXPECT_NO_ERROR(gl.getError(), "Creating program object failed");

	m_compute_shader_id = gl.createShader(GL_COMPUTE_SHADER);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Creating compute shader object failed");

	if (!buildProgram(m_program_id, m_compute_shader_id, 1, &m_compute_shader_code))
	{
		TCU_FAIL("Could not create program object!");
	}

	glw::GLuint bufferData[m_atomic_counters_array_size];
	for (glw::GLuint index = 0; index < m_atomic_counters_array_size; ++index)
	{
		bufferData[index] = index;
	}

	gl.genBuffers(1, &m_buffer_id);
	gl.bindBuffer(GL_ATOMIC_COUNTER_BUFFER, m_buffer_id);
	gl.bufferData(GL_ATOMIC_COUNTER_BUFFER, m_atomic_counters_array_size * sizeof(glw::GLuint), bufferData,
				  GL_DYNAMIC_COPY);
	gl.bindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, m_buffer_id);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not setup buffer object!");
}

/** Executes the test.
 *
 *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
 *
 *  Note the function throws exception should an error occur!
 *
 *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
 **/
tcu::TestNode::IterateResult GPUShader5AtomicCountersArrayIndexing::iterate(void)
{
	initTest();

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

	/* Do the computations */
	gl.useProgram(m_program_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not use program object!");

	gl.dispatchCompute(10, /* num_groups_x */
					   10, /* num_groups_y */
					   1); /* num_groups_z */
	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to dispatch compute operation!");

	/* Map the buffer object storage into user space */
	glw::GLuint* bufferData =
		(glw::GLuint*)gl.mapBufferRange(GL_ATOMIC_COUNTER_BUFFER, 0, /* offset */
										m_atomic_counters_array_size * sizeof(glw::GLuint), GL_MAP_READ_BIT);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to map buffer range to client space!");

	/* Compare the result values with reference value */
	const glw::GLuint expectedResult = 1000;

	if (expectedResult != bufferData[0] || expectedResult + 1 != bufferData[1] || expectedResult + 2 != bufferData[2] ||
		expectedResult + 3 != bufferData[3])
	{
		m_testCtx.getLog() << tcu::TestLog::Message << "Invalid data rendered. Expected Data"
						   << " (" << expectedResult << ", " << expectedResult << ", " << expectedResult << ", "
						   << expectedResult << ") Result Data"
						   << " (" << bufferData[0] << " ," << bufferData[1] << " ," << bufferData[2] << " ,"
						   << bufferData[3] << ")" << tcu::TestLog::EndMessage;

		gl.unmapBuffer(GL_ATOMIC_COUNTER_BUFFER);
		GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to unmap buffer!");

		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		return STOP;
	}

	gl.unmapBuffer(GL_ATOMIC_COUNTER_BUFFER);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to unmap buffer!");

	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	return STOP;
}

/** Deinitializes GLES objects created during the test.
 *
 */
void GPUShader5AtomicCountersArrayIndexing::deinit(void)
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Reset OpenGL ES state */
	gl.useProgram(0);
	gl.bindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0);

	if (m_program_id != 0)
	{
		gl.deleteProgram(m_program_id);
		m_program_id = 0;
	}

	if (m_compute_shader_id != 0)
	{
		gl.deleteShader(m_compute_shader_id);
		m_compute_shader_id = 0;
	}

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

	/* Release base class */
	TestCaseBase::deinit();
}

} // namespace glcts