From: Andres Gomez <agomez@igalia.com>
Date: Thu, 22 Jun 2017 21:31:44 +0000 (+0300)
Subject: GL_ARB_enhanced_layouts: use proper max size value
X-Git-Tag: upstream/0.1.0~221
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=9940cc8228f6a4fcda97238da9548d08fa559480;p=platform%2Fupstream%2FVK-GL-CTS.git

GL_ARB_enhanced_layouts: use proper max size value

When checking for invalid offset alignment in uniform blocks we have
to take into account the MAX_UNIFORM_BLOCK_SIZE limit but, when trying
to do the same for Shader Storage Blocks, the limit to have into
account is MAX_SHADER_STORAGE_BLOCK_SIZE.

From page 52 (page 65 of the PDF) of the OpenGL 3.1 spec:

  "2.11.4 Uniform Variables

   ...

   The total amount of buffer object storage available for any given
   uniform block is subject to an implementation-dependent limit. The
   maximum amount of available space, in basic machine units, can be
   queried by calling GetIntegerv with the constant
   MAX_UNIFORM_BLOCK_SIZE . If the amount of storage required for a
   uniform block exceeds this limit, a program may fail to link."

From page 128 (page 129 of the PDF) of the OpenGL 4.3 spec:

  "7.8 Shader Buffer Variables and Shader Storage Blocks

   ...

   The total amount of buffer object storage that can be accessed in
   any shader storage block is subject to an implementation-dependent
   limit. The maximum amount of available space, in basic machine
   units, can be queried by calling GetIntegerv with the constant
   MAX_SHADER_STORAGE_BLOCK_SIZE . If the amount of storage required
   for any shader storage block exceeds this limit, a program will
   fail to link."

Affects:

GL44-CTS.enhanced_layouts.uniform_block_member_invalid_offset_alignment
GL44-CTS.enhanced_layouts.ssb_member_invalid_offset_alignment

Components: OpenGL

VK-GL-CTS issue: 527

Change-Id: I9185f32a6a90643aa1d3fca0e27a70dbd80d6e16
---

diff --git a/external/openglcts/modules/gl/gl4cEnhancedLayoutsTests.cpp b/external/openglcts/modules/gl/gl4cEnhancedLayoutsTests.cpp
index be9d946..7f5679b 100644
--- a/external/openglcts/modules/gl/gl4cEnhancedLayoutsTests.cpp
+++ b/external/openglcts/modules/gl/gl4cEnhancedLayoutsTests.cpp
@@ -9299,6 +9299,21 @@ GLuint UniformBlockMemberInvalidOffsetAlignmentTest::getTestCaseNumber()
 	return static_cast<GLuint>(m_test_cases.size());
 }
 
+/** Get the maximum size for an uniform block
+ *
+ * @return The maximum size in basic machine units of a uniform block.
+ **/
+GLint UniformBlockMemberInvalidOffsetAlignmentTest::getMaxBlockSize()
+{
+	const Functions& gl		  = m_context.getRenderContext().getFunctions();
+	GLint			 max_size = 0;
+
+	gl.getIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &max_size);
+	GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv");
+
+	return max_size;
+}
+
 /** Selects if "compute" stage is relevant for test
  *
  * @param test_case_index Index of test case
@@ -9337,25 +9352,20 @@ bool UniformBlockMemberInvalidOffsetAlignmentTest::isStageSupported(Utils::Shade
  **/
 void UniformBlockMemberInvalidOffsetAlignmentTest::testInit()
 {
-	const Functions& gl		  = m_context.getRenderContext().getFunctions();
-	GLint			 max_size = 0;
-	const GLuint	 n_types  = getTypesNumber();
-	bool			 stage_support[Utils::Shader::STAGE_MAX];
+	const GLuint n_types = getTypesNumber();
+	bool		 stage_support[Utils::Shader::STAGE_MAX];
 
 	for (GLuint stage = 0; stage < Utils::Shader::STAGE_MAX; ++stage)
 	{
 		stage_support[stage] = isStageSupported((Utils::Shader::STAGES)stage);
 	}
 
-	gl.getIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &max_size);
-	GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv");
-
 	for (GLuint i = 0; i < n_types; ++i)
 	{
 		const Utils::Type& type		  = getType(i);
 		const GLuint	   alignment  = type.GetBaseAlignment(false);
 		const GLuint	   type_size  = type.GetSize(true);
-		const GLuint	   sec_to_end = max_size - 2 * type_size;
+		const GLuint	   sec_to_end = getMaxBlockSize() - 2 * type_size;
 
 		for (GLuint stage = 0; stage < Utils::Shader::STAGE_MAX; ++stage)
 		{
@@ -10999,6 +11009,21 @@ SSBMemberInvalidOffsetAlignmentTest::SSBMemberInvalidOffsetAlignmentTest(deqp::C
 	/* Nothing to be done here */
 }
 
+/** Get the maximum size for a shader storage block
+ *
+ * @return The maximum size in basic machine units of a shader storage block.
+ **/
+GLint SSBMemberInvalidOffsetAlignmentTest::getMaxBlockSize()
+{
+	const Functions& gl		  = m_context.getRenderContext().getFunctions();
+	GLint			 max_size = 0;
+
+	gl.getIntegerv(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &max_size);
+	GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv");
+
+	return max_size;
+}
+
 /** Source for given test case and stage
  *
  * @param test_case_index Index of test case
diff --git a/external/openglcts/modules/gl/gl4cEnhancedLayoutsTests.hpp b/external/openglcts/modules/gl/gl4cEnhancedLayoutsTests.hpp
index 5e87d73..ff9d606 100644
--- a/external/openglcts/modules/gl/gl4cEnhancedLayoutsTests.hpp
+++ b/external/openglcts/modules/gl/gl4cEnhancedLayoutsTests.hpp
@@ -1610,6 +1610,7 @@ protected:
 
 	virtual std::string getTestCaseName(glw::GLuint test_case_index);
 	virtual glw::GLuint getTestCaseNumber();
+	virtual glw::GLint  getMaxBlockSize();
 	virtual bool isComputeRelevant(glw::GLuint test_case_index);
 	virtual bool isFailureExpected(glw::GLuint test_case_index);
 	virtual bool isStageSupported(Utils::Shader::STAGES stage);
@@ -1902,8 +1903,9 @@ private:
  *
  * Test verifies that offset alignment rules are enforced.
  *
- * Modify UniformBlockMemberInvalidOffsetAlignment to test shader storage block
- * instead of uniform block
+ * Modify UniformBlockMemberInvalidOffsetAlignment to test shader
+ * storage block against MAX_SHADER_STORAGE_BLOCK_SIZE instead of
+ * uniform block
  **/
 class SSBMemberInvalidOffsetAlignmentTest : public UniformBlockMemberInvalidOffsetAlignmentTest
 {
@@ -1917,6 +1919,7 @@ public:
 
 protected:
 	/* Methods to be implemented by child class */
+	virtual glw::GLint  getMaxBlockSize();
 	virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
 
 	virtual bool isStageSupported(Utils::Shader::STAGES stage);