1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief GLSL Shared variable tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fShaderSharedVarTests.hpp" 25 #include "es31fShaderAtomicOpTests.hpp" 26 #include "gluShaderProgram.hpp" 27 #include "gluShaderUtil.hpp" 28 #include "gluRenderContext.hpp" 29 #include "gluObjectWrapper.hpp" 30 #include "gluProgramInterfaceQuery.hpp" 31 #include "tcuVector.hpp" 32 #include "tcuTestLog.hpp" 33 #include "tcuVectorUtil.hpp" 34 #include "tcuFormatUtil.hpp" 35 #include "deRandom.hpp" 36 #include "deArrayUtil.hpp" 37 #include "glwFunctions.hpp" 38 #include "glwEnums.hpp" 39 40 #include <algorithm> 41 #include <set> 42 43 namespace deqp 44 { 45 namespace gles31 46 { 47 namespace Functional 48 { 49 50 using std::string; 51 using std::vector; 52 using tcu::TestLog; 53 using tcu::UVec3; 54 using std::set; 55 using namespace glu; 56 57 enum 58 { 59 MAX_VALUE_ARRAY_LENGTH = 15 // * 2 * sizeof(mat4) + sizeof(int) = 481 uniform components (limit 512) 60 }; 61 62 template<typename T, int Size> 63 static inline T product (const tcu::Vector<T, Size>& v) 64 { 65 T res = v[0]; 66 for (int ndx = 1; ndx < Size; ndx++) 67 res *= v[ndx]; 68 return res; 69 } 70 71 class SharedBasicVarCase : public TestCase 72 { 73 public: 74 SharedBasicVarCase (Context& context, const char* name, DataType basicType, Precision precision, const tcu::UVec3& workGroupSize); 75 ~SharedBasicVarCase (void); 76 77 void init (void); 78 void deinit (void); 79 IterateResult iterate (void); 80 81 private: 82 SharedBasicVarCase (const SharedBasicVarCase& other); 83 SharedBasicVarCase& operator= (const SharedBasicVarCase& other); 84 85 const DataType m_basicType; 86 const Precision m_precision; 87 const tcu::UVec3 m_workGroupSize; 88 89 ShaderProgram* m_program; 90 }; 91 92 static std::string getBasicCaseDescription (DataType basicType, Precision precision, const tcu::UVec3& workGroupSize) 93 { 94 std::ostringstream str; 95 if (precision != PRECISION_LAST) 96 str << getPrecisionName(precision) << " "; 97 str << getDataTypeName(basicType) << ", work group size = " << workGroupSize; 98 return str.str(); 99 } 100 101 SharedBasicVarCase::SharedBasicVarCase (Context& context, const char* name, DataType basicType, Precision precision, const tcu::UVec3& workGroupSize) 102 : TestCase (context, name, getBasicCaseDescription(basicType, precision, workGroupSize).c_str()) 103 , m_basicType (basicType) 104 , m_precision (precision) 105 , m_workGroupSize (workGroupSize) 106 , m_program (DE_NULL) 107 { 108 } 109 110 SharedBasicVarCase::~SharedBasicVarCase (void) 111 { 112 SharedBasicVarCase::deinit(); 113 } 114 115 void SharedBasicVarCase::init (void) 116 { 117 const int valArrayLength = de::min<int>(MAX_VALUE_ARRAY_LENGTH, product(m_workGroupSize)); 118 const char* precName = m_precision != glu::PRECISION_LAST ? getPrecisionName(m_precision) : ""; 119 const char* typeName = getDataTypeName(m_basicType); 120 std::ostringstream src; 121 122 src << "#version 310 es\n" 123 << "layout (local_size_x = " << m_workGroupSize[0] 124 << ", local_size_y = " << m_workGroupSize[1] 125 << ", local_size_z = " << m_workGroupSize[2] 126 << ") in;\n" 127 << "const uint LOCAL_SIZE = gl_WorkGroupSize.x*gl_WorkGroupSize.y*gl_WorkGroupSize.z;\n" 128 << "shared " << precName << " " << typeName << " s_var;\n" 129 << "uniform " << precName << " " << typeName << " u_val[" << valArrayLength << "];\n" 130 << "uniform " << precName << " " << typeName << " u_ref[" << valArrayLength << "];\n" 131 << "uniform uint u_numIters;\n" 132 << "layout(binding = 0) buffer Result\n" 133 << "{\n" 134 << " bool isOk[LOCAL_SIZE];\n" 135 << "};\n" 136 << "\n" 137 << "void main (void)\n" 138 << "{\n" 139 << " bool allOk = true;\n" 140 << " for (uint ndx = 0u; ndx < u_numIters; ndx++)\n" 141 << " {\n" 142 << " if (ndx == gl_LocalInvocationIndex)\n" 143 << " s_var = u_val[ndx%uint(u_val.length())];\n" 144 << "\n" 145 << " barrier();\n" 146 << "\n" 147 << " if (s_var != u_ref[ndx%uint(u_ref.length())])\n" 148 << " allOk = false;\n" 149 << "\n" 150 << " barrier();\n" 151 << " }\n" 152 << "\n" 153 << " isOk[gl_LocalInvocationIndex] = allOk;\n" 154 << "}\n"; 155 156 DE_ASSERT(!m_program); 157 m_program = new ShaderProgram(m_context.getRenderContext(), ProgramSources() << ComputeSource(src.str())); 158 159 m_testCtx.getLog() << *m_program; 160 161 if (!m_program->isOk()) 162 { 163 delete m_program; 164 m_program = DE_NULL; 165 throw tcu::TestError("Compile failed"); 166 } 167 } 168 169 void SharedBasicVarCase::deinit (void) 170 { 171 delete m_program; 172 m_program = DE_NULL; 173 } 174 175 SharedBasicVarCase::IterateResult SharedBasicVarCase::iterate (void) 176 { 177 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 178 const deUint32 program = m_program->getProgram(); 179 Buffer outputBuffer (m_context.getRenderContext()); 180 const deUint32 outBlockNdx = gl.getProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, "Result"); 181 const InterfaceBlockInfo outBlockInfo = getProgramInterfaceBlockInfo(gl, program, GL_SHADER_STORAGE_BLOCK, outBlockNdx); 182 183 gl.useProgram(program); 184 185 // Setup input values. 186 { 187 const int numValues = (int)product(m_workGroupSize); 188 const int valLoc = gl.getUniformLocation(program, "u_val[0]"); 189 const int refLoc = gl.getUniformLocation(program, "u_ref[0]"); 190 const int iterCountLoc = gl.getUniformLocation(program, "u_numIters"); 191 const int scalarSize = getDataTypeScalarSize(m_basicType); 192 193 if (isDataTypeFloatOrVec(m_basicType)) 194 { 195 const int maxInt = m_precision == glu::PRECISION_LOWP ? 2 : 1024; 196 const int minInt = -de::min(numValues/2, maxInt); 197 vector<float> values (numValues*scalarSize); 198 199 for (int ndx = 0; ndx < (int)values.size(); ndx++) 200 values[ndx] = float(minInt + (ndx % (maxInt-minInt+1))); 201 202 for (int uNdx = 0; uNdx < 2; uNdx++) 203 { 204 const int location = uNdx == 1 ? refLoc : valLoc; 205 206 if (scalarSize == 1) gl.uniform1fv(location, numValues, &values[0]); 207 else if (scalarSize == 2) gl.uniform2fv(location, numValues, &values[0]); 208 else if (scalarSize == 3) gl.uniform3fv(location, numValues, &values[0]); 209 else if (scalarSize == 4) gl.uniform4fv(location, numValues, &values[0]); 210 } 211 } 212 else if (isDataTypeIntOrIVec(m_basicType)) 213 { 214 const int maxInt = m_precision == glu::PRECISION_LOWP ? 64 : 1024; 215 const int minInt = -de::min(numValues/2, maxInt); 216 vector<int> values (numValues*scalarSize); 217 218 for (int ndx = 0; ndx < (int)values.size(); ndx++) 219 values[ndx] = minInt + (ndx % (maxInt-minInt+1)); 220 221 for (int uNdx = 0; uNdx < 2; uNdx++) 222 { 223 const int location = uNdx == 1 ? refLoc : valLoc; 224 225 if (scalarSize == 1) gl.uniform1iv(location, numValues, &values[0]); 226 else if (scalarSize == 2) gl.uniform2iv(location, numValues, &values[0]); 227 else if (scalarSize == 3) gl.uniform3iv(location, numValues, &values[0]); 228 else if (scalarSize == 4) gl.uniform4iv(location, numValues, &values[0]); 229 } 230 } 231 else if (isDataTypeUintOrUVec(m_basicType)) 232 { 233 const deUint32 maxInt = m_precision == glu::PRECISION_LOWP ? 128 : 1024; 234 vector<deUint32> values (numValues*scalarSize); 235 236 for (int ndx = 0; ndx < (int)values.size(); ndx++) 237 values[ndx] = ndx % (maxInt+1); 238 239 for (int uNdx = 0; uNdx < 2; uNdx++) 240 { 241 const int location = uNdx == 1 ? refLoc : valLoc; 242 243 if (scalarSize == 1) gl.uniform1uiv(location, numValues, &values[0]); 244 else if (scalarSize == 2) gl.uniform2uiv(location, numValues, &values[0]); 245 else if (scalarSize == 3) gl.uniform3uiv(location, numValues, &values[0]); 246 else if (scalarSize == 4) gl.uniform4uiv(location, numValues, &values[0]); 247 } 248 } 249 else if (isDataTypeBoolOrBVec(m_basicType)) 250 { 251 de::Random rnd (0x324f); 252 vector<int> values (numValues*scalarSize); 253 254 for (int ndx = 0; ndx < (int)values.size(); ndx++) 255 values[ndx] = rnd.getBool() ? 1 : 0; 256 257 for (int uNdx = 0; uNdx < 2; uNdx++) 258 { 259 const int location = uNdx == 1 ? refLoc : valLoc; 260 261 if (scalarSize == 1) gl.uniform1iv(location, numValues, &values[0]); 262 else if (scalarSize == 2) gl.uniform2iv(location, numValues, &values[0]); 263 else if (scalarSize == 3) gl.uniform3iv(location, numValues, &values[0]); 264 else if (scalarSize == 4) gl.uniform4iv(location, numValues, &values[0]); 265 } 266 } 267 else if (isDataTypeMatrix(m_basicType)) 268 { 269 const int maxInt = m_precision == glu::PRECISION_LOWP ? 2 : 1024; 270 const int minInt = -de::min(numValues/2, maxInt); 271 vector<float> values (numValues*scalarSize); 272 273 for (int ndx = 0; ndx < (int)values.size(); ndx++) 274 values[ndx] = float(minInt + (ndx % (maxInt-minInt+1))); 275 276 for (int uNdx = 0; uNdx < 2; uNdx++) 277 { 278 const int location = uNdx == 1 ? refLoc : valLoc; 279 280 switch (m_basicType) 281 { 282 case TYPE_FLOAT_MAT2: gl.uniformMatrix2fv (location, numValues, DE_FALSE, &values[0]); break; 283 case TYPE_FLOAT_MAT2X3: gl.uniformMatrix2x3fv(location, numValues, DE_FALSE, &values[0]); break; 284 case TYPE_FLOAT_MAT2X4: gl.uniformMatrix2x4fv(location, numValues, DE_FALSE, &values[0]); break; 285 case TYPE_FLOAT_MAT3X2: gl.uniformMatrix3x2fv(location, numValues, DE_FALSE, &values[0]); break; 286 case TYPE_FLOAT_MAT3: gl.uniformMatrix3fv (location, numValues, DE_FALSE, &values[0]); break; 287 case TYPE_FLOAT_MAT3X4: gl.uniformMatrix3x4fv(location, numValues, DE_FALSE, &values[0]); break; 288 case TYPE_FLOAT_MAT4X2: gl.uniformMatrix4x2fv(location, numValues, DE_FALSE, &values[0]); break; 289 case TYPE_FLOAT_MAT4X3: gl.uniformMatrix4x3fv(location, numValues, DE_FALSE, &values[0]); break; 290 case TYPE_FLOAT_MAT4: gl.uniformMatrix4fv (location, numValues, DE_FALSE, &values[0]); break; 291 default: 292 DE_ASSERT(false); 293 } 294 } 295 } 296 297 gl.uniform1ui(iterCountLoc, product(m_workGroupSize)); 298 GLU_EXPECT_NO_ERROR(gl.getError(), "Input value setup failed"); 299 } 300 301 // Setup output buffer. 302 { 303 vector<deUint8> emptyData(outBlockInfo.dataSize); 304 std::fill(emptyData.begin(), emptyData.end(), 0); 305 306 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer); 307 gl.bufferData(GL_SHADER_STORAGE_BUFFER, outBlockInfo.dataSize, &emptyData[0], GL_STATIC_READ); 308 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer); 309 GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed"); 310 } 311 312 gl.dispatchCompute(1, 1, 1); 313 314 // Read back and compare 315 { 316 const deUint32 numValues = product(m_workGroupSize); 317 const InterfaceVariableInfo outVarInfo = getProgramInterfaceVariableInfo(gl, program, GL_BUFFER_VARIABLE, outBlockInfo.activeVariables[0]); 318 const void* resPtr = gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, outBlockInfo.dataSize, GL_MAP_READ_BIT); 319 const int maxErrMsg = 10; 320 int numFailed = 0; 321 322 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()"); 323 TCU_CHECK(resPtr); 324 325 for (deUint32 ndx = 0; ndx < numValues; ndx++) 326 { 327 const int resVal = *((const int*)((const deUint8*)resPtr + outVarInfo.offset + outVarInfo.arrayStride*ndx)); 328 329 if (resVal == 0) 330 { 331 if (numFailed < maxErrMsg) 332 m_testCtx.getLog() << TestLog::Message << "ERROR: isOk[" << ndx << "] = " << resVal << " != true" << TestLog::EndMessage; 333 else if (numFailed == maxErrMsg) 334 m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage; 335 336 numFailed += 1; 337 } 338 } 339 340 gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER); 341 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer()"); 342 343 m_testCtx.getLog() << TestLog::Message << (numValues-numFailed) << " / " << numValues << " values passed" << TestLog::EndMessage; 344 345 m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 346 numFailed == 0 ? "Pass" : "Comparison failed"); 347 } 348 349 return STOP; 350 } 351 352 ShaderSharedVarTests::ShaderSharedVarTests (Context& context) 353 : TestCaseGroup(context, "shared_var", "Shared Variable Tests") 354 { 355 } 356 357 ShaderSharedVarTests::~ShaderSharedVarTests (void) 358 { 359 } 360 361 void ShaderSharedVarTests::init (void) 362 { 363 // .basic_type 364 { 365 tcu::TestCaseGroup *const basicTypeGroup = new tcu::TestCaseGroup(m_testCtx, "basic_type", "Basic Types"); 366 addChild(basicTypeGroup); 367 368 for (int basicType = TYPE_FLOAT; basicType <= TYPE_BOOL_VEC4; basicType++) 369 { 370 if (glu::getDataTypeScalarType(DataType(basicType)) == glu::TYPE_DOUBLE) 371 continue; 372 373 if (glu::isDataTypeBoolOrBVec(DataType(basicType))) 374 { 375 const tcu::UVec3 workGroupSize (2,1,3); 376 basicTypeGroup->addChild(new SharedBasicVarCase(m_context, getDataTypeName(DataType(basicType)), DataType(basicType), PRECISION_LAST, workGroupSize)); 377 } 378 else 379 { 380 for (int precision = 0; precision < PRECISION_LAST; precision++) 381 { 382 const tcu::UVec3 workGroupSize (2,1,3); 383 const string name = string(getDataTypeName(DataType(basicType))) + "_" + getPrecisionName(Precision(precision)); 384 385 basicTypeGroup->addChild(new SharedBasicVarCase(m_context, name.c_str(), DataType(basicType), Precision(precision), workGroupSize)); 386 } 387 } 388 } 389 } 390 391 // .work_group_size 392 { 393 tcu::TestCaseGroup *const workGroupSizeGroup = new tcu::TestCaseGroup(m_testCtx, "work_group_size", "Shared Variables with Various Work Group Sizes"); 394 addChild(workGroupSizeGroup); 395 396 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_1_1_1", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(1,1,1))); 397 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_64_1_1", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(64,1,1))); 398 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_1_64_1", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(1,64,1))); 399 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_1_1_64", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(1,1,64))); 400 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_128_1_1", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(128,1,1))); 401 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_1_128_1", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(1,128,1))); 402 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_13_2_4", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(13,2,4))); 403 404 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_1_1_1", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(1,1,1))); 405 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_64_1_1", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(64,1,1))); 406 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_1_64_1", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(1,64,1))); 407 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_1_1_64", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(1,1,64))); 408 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_128_1_1", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(128,1,1))); 409 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_1_128_1", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(1,128,1))); 410 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_13_2_4", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(13,2,4))); 411 412 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_1_1_1", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(1,1,1))); 413 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_64_1_1", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(64,1,1))); 414 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_1_64_1", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(1,64,1))); 415 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_1_1_64", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(1,1,64))); 416 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_128_1_1", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(128,1,1))); 417 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_1_128_1", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(1,128,1))); 418 workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_13_2_4", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(13,2,4))); 419 } 420 421 // .atomic 422 addChild(new ShaderAtomicOpTests(m_context, "atomic", ATOMIC_OPERAND_SHARED_VARIABLE)); 423 } 424 425 } // Functional 426 } // gles31 427 } // deqp 428
