1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.0 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 Floating-point packing and unpacking function tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es3fShaderPackingFunctionTests.hpp" 25 #include "glsShaderExecUtil.hpp" 26 #include "tcuTestLog.hpp" 27 #include "tcuFormatUtil.hpp" 28 #include "tcuFloat.hpp" 29 #include "deRandom.hpp" 30 #include "deMath.h" 31 #include "deString.h" 32 33 namespace deqp 34 { 35 namespace gles3 36 { 37 namespace Functional 38 { 39 40 using std::string; 41 using tcu::TestLog; 42 using namespace gls::ShaderExecUtil; 43 44 namespace 45 { 46 47 inline deUint32 getUlpDiff (float a, float b) 48 { 49 const deUint32 aBits = tcu::Float32(a).bits(); 50 const deUint32 bBits = tcu::Float32(b).bits(); 51 return aBits > bBits ? aBits - bBits : bBits - aBits; 52 } 53 54 struct HexFloat 55 { 56 const float value; 57 HexFloat (const float value_) : value(value_) {} 58 }; 59 60 std::ostream& operator<< (std::ostream& str, const HexFloat& v) 61 { 62 return str << v.value << " / " << tcu::toHex(tcu::Float32(v.value).bits()); 63 } 64 65 } // anonymous 66 67 // ShaderPackingFunctionCase 68 69 class ShaderPackingFunctionCase : public TestCase 70 { 71 public: 72 ShaderPackingFunctionCase (Context& context, const char* name, const char* description, glu::ShaderType shaderType); 73 ~ShaderPackingFunctionCase (void); 74 75 void init (void); 76 void deinit (void); 77 78 protected: 79 glu::ShaderType m_shaderType; 80 ShaderSpec m_spec; 81 ShaderExecutor* m_executor; 82 83 private: 84 ShaderPackingFunctionCase (const ShaderPackingFunctionCase& other); 85 ShaderPackingFunctionCase& operator= (const ShaderPackingFunctionCase& other); 86 }; 87 88 ShaderPackingFunctionCase::ShaderPackingFunctionCase (Context& context, const char* name, const char* description, glu::ShaderType shaderType) 89 : TestCase (context, name, description) 90 , m_shaderType (shaderType) 91 , m_executor (DE_NULL) 92 { 93 m_spec.version = glu::GLSL_VERSION_300_ES; 94 } 95 96 ShaderPackingFunctionCase::~ShaderPackingFunctionCase (void) 97 { 98 ShaderPackingFunctionCase::deinit(); 99 } 100 101 void ShaderPackingFunctionCase::init (void) 102 { 103 DE_ASSERT(!m_executor); 104 105 m_executor = createExecutor(m_context.getRenderContext(), m_shaderType, m_spec); 106 m_testCtx.getLog() << m_executor; 107 108 if (!m_executor->isOk()) 109 throw tcu::TestError("Compile failed"); 110 } 111 112 void ShaderPackingFunctionCase::deinit (void) 113 { 114 delete m_executor; 115 m_executor = DE_NULL; 116 } 117 118 // Test cases 119 120 static const char* getPrecisionPostfix (glu::Precision precision) 121 { 122 static const char* s_postfix[] = 123 { 124 "_lowp", 125 "_mediump", 126 "_highp" 127 }; 128 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_postfix) == glu::PRECISION_LAST); 129 DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(s_postfix))); 130 return s_postfix[precision]; 131 } 132 133 static const char* getShaderTypePostfix (glu::ShaderType shaderType) 134 { 135 static const char* s_postfix[] = 136 { 137 "_vertex", 138 "_fragment" 139 }; 140 DE_ASSERT(de::inBounds<int>(shaderType, 0, DE_LENGTH_OF_ARRAY(s_postfix))); 141 return s_postfix[shaderType]; 142 } 143 144 class PackSnorm2x16Case : public ShaderPackingFunctionCase 145 { 146 public: 147 PackSnorm2x16Case (Context& context, glu::ShaderType shaderType, glu::Precision precision) 148 : ShaderPackingFunctionCase (context, (string("packsnorm2x16") + getPrecisionPostfix(precision) + getShaderTypePostfix(shaderType)).c_str(), "packSnorm2x16", shaderType) 149 , m_precision (precision) 150 { 151 m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_FLOAT_VEC2, precision))); 152 m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP))); 153 154 m_spec.source = "out0 = packSnorm2x16(in0);"; 155 } 156 157 IterateResult iterate (void) 158 { 159 de::Random rnd (deStringHash(getName()) ^ 0x776002); 160 std::vector<tcu::Vec2> inputs; 161 std::vector<deUint32> outputs; 162 const int maxDiff = m_precision == glu::PRECISION_HIGHP ? 1 : // Rounding only. 163 m_precision == glu::PRECISION_MEDIUMP ? 33 : // (2^-10) * (2^15) + 1 164 m_precision == glu::PRECISION_LOWP ? 129 : 0; // (2^-8) * (2^15) + 1 165 166 // Special values to check. 167 inputs.push_back(tcu::Vec2(0.0f, 0.0f)); 168 inputs.push_back(tcu::Vec2(-1.0f, 1.0f)); 169 inputs.push_back(tcu::Vec2(0.5f, -0.5f)); 170 inputs.push_back(tcu::Vec2(-1.5f, 1.5f)); 171 inputs.push_back(tcu::Vec2(0.25f, -0.75f)); 172 173 // Random values, mostly in range. 174 for (int ndx = 0; ndx < 15; ndx++) 175 { 176 const float x = rnd.getFloat()*2.5f - 1.25f; 177 const float y = rnd.getFloat()*2.5f - 1.25f; 178 inputs.push_back(tcu::Vec2(x, y)); 179 } 180 181 // Large random values. 182 for (int ndx = 0; ndx < 80; ndx++) 183 { 184 const float x = rnd.getFloat()*1e6f - 0.5e6f; 185 const float y = rnd.getFloat()*1e6f - 0.5e6f; 186 inputs.push_back(tcu::Vec2(x, y)); 187 } 188 189 outputs.resize(inputs.size()); 190 191 m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values" << tcu::TestLog::EndMessage; 192 193 { 194 const void* in = &inputs[0]; 195 void* out = &outputs[0]; 196 197 m_executor->useProgram(); 198 m_executor->execute((int)inputs.size(), &in, &out); 199 } 200 201 // Verify 202 { 203 const int numValues = (int)inputs.size(); 204 const int maxPrints = 10; 205 int numFailed = 0; 206 207 for (int valNdx = 0; valNdx < numValues; valNdx++) 208 { 209 const deUint16 ref0 = (deUint16)de::clamp(deRoundFloatToInt32(de::clamp(inputs[valNdx].x(), -1.0f, 1.0f) * 32767.0f), -(1<<15), (1<<15)-1); 210 const deUint16 ref1 = (deUint16)de::clamp(deRoundFloatToInt32(de::clamp(inputs[valNdx].y(), -1.0f, 1.0f) * 32767.0f), -(1<<15), (1<<15)-1); 211 const deUint32 ref = (ref1 << 16) | ref0; 212 const deUint32 res = outputs[valNdx]; 213 const deUint16 res0 = (deUint16)(res & 0xffff); 214 const deUint16 res1 = (deUint16)(res >> 16); 215 const int diff0 = de::abs((int)ref0 - (int)res0); 216 const int diff1 = de::abs((int)ref1 - (int)res1); 217 218 if (diff0 > maxDiff || diff1 > maxDiff) 219 { 220 if (numFailed < maxPrints) 221 { 222 m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx 223 << ", expected packSnorm2x16(" << inputs[valNdx] << ") = " << tcu::toHex(ref) 224 << ", got " << tcu::toHex(res) 225 << "\n diffs = (" << diff0 << ", " << diff1 << "), max diff = " << maxDiff 226 << TestLog::EndMessage; 227 } 228 else if (numFailed == maxPrints) 229 m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage; 230 231 numFailed += 1; 232 } 233 } 234 235 m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed" << TestLog::EndMessage; 236 237 m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 238 numFailed == 0 ? "Pass" : "Result comparison failed"); 239 } 240 241 return STOP; 242 } 243 244 private: 245 glu::Precision m_precision; 246 }; 247 248 class UnpackSnorm2x16Case : public ShaderPackingFunctionCase 249 { 250 public: 251 UnpackSnorm2x16Case (Context& context, glu::ShaderType shaderType) 252 : ShaderPackingFunctionCase(context, (string("unpacksnorm2x16") + getShaderTypePostfix(shaderType)).c_str(), "unpackSnorm2x16", shaderType) 253 { 254 m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP))); 255 m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_HIGHP))); 256 257 m_spec.source = "out0 = unpackSnorm2x16(in0);"; 258 } 259 260 IterateResult iterate (void) 261 { 262 const deUint32 maxDiff = 1; // Rounding error. 263 de::Random rnd (deStringHash(getName()) ^ 0x776002); 264 std::vector<deUint32> inputs; 265 std::vector<tcu::Vec2> outputs; 266 267 inputs.push_back(0x00000000u); 268 inputs.push_back(0x7fff8000u); 269 inputs.push_back(0x80007fffu); 270 inputs.push_back(0xffffffffu); 271 inputs.push_back(0x0001fffeu); 272 273 // Random values. 274 for (int ndx = 0; ndx < 95; ndx++) 275 inputs.push_back(rnd.getUint32()); 276 277 outputs.resize(inputs.size()); 278 279 m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values" << tcu::TestLog::EndMessage; 280 281 { 282 const void* in = &inputs[0]; 283 void* out = &outputs[0]; 284 285 m_executor->useProgram(); 286 m_executor->execute((int)inputs.size(), &in, &out); 287 } 288 289 // Verify 290 { 291 const int numValues = (int)inputs.size(); 292 const int maxPrints = 10; 293 int numFailed = 0; 294 295 for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++) 296 { 297 const deInt16 in0 = (deInt16)(deUint16)(inputs[valNdx] & 0xffff); 298 const deInt16 in1 = (deInt16)(deUint16)(inputs[valNdx] >> 16); 299 const float ref0 = de::clamp(float(in0) / 32767.f, -1.0f, 1.0f); 300 const float ref1 = de::clamp(float(in1) / 32767.f, -1.0f, 1.0f); 301 const float res0 = outputs[valNdx].x(); 302 const float res1 = outputs[valNdx].y(); 303 304 const deUint32 diff0 = getUlpDiff(ref0, res0); 305 const deUint32 diff1 = getUlpDiff(ref1, res1); 306 307 if (diff0 > maxDiff || diff1 > maxDiff) 308 { 309 if (numFailed < maxPrints) 310 { 311 m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx << ",\n" 312 << " expected unpackSnorm2x16(" << tcu::toHex(inputs[valNdx]) << ") = " 313 << "vec2(" << HexFloat(ref0) << ", " << HexFloat(ref1) << ")" 314 << ", got vec2(" << HexFloat(res0) << ", " << HexFloat(res1) << ")" 315 << "\n ULP diffs = (" << diff0 << ", " << diff1 << "), max diff = " << maxDiff 316 << TestLog::EndMessage; 317 } 318 else if (numFailed == maxPrints) 319 m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage; 320 321 numFailed += 1; 322 } 323 } 324 325 m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed" << TestLog::EndMessage; 326 327 m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 328 numFailed == 0 ? "Pass" : "Result comparison failed"); 329 } 330 331 return STOP; 332 } 333 }; 334 335 class PackUnorm2x16Case : public ShaderPackingFunctionCase 336 { 337 public: 338 PackUnorm2x16Case (Context& context, glu::ShaderType shaderType, glu::Precision precision) 339 : ShaderPackingFunctionCase (context, (string("packunorm2x16") + getPrecisionPostfix(precision) + getShaderTypePostfix(shaderType)).c_str(), "packUnorm2x16", shaderType) 340 , m_precision (precision) 341 { 342 m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_FLOAT_VEC2, precision))); 343 m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP))); 344 345 m_spec.source = "out0 = packUnorm2x16(in0);"; 346 } 347 348 IterateResult iterate (void) 349 { 350 de::Random rnd (deStringHash(getName()) ^ 0x776002); 351 std::vector<tcu::Vec2> inputs; 352 std::vector<deUint32> outputs; 353 const int maxDiff = m_precision == glu::PRECISION_HIGHP ? 1 : // Rounding only. 354 m_precision == glu::PRECISION_MEDIUMP ? 65 : // (2^-10) * (2^16) + 1 355 m_precision == glu::PRECISION_LOWP ? 257 : 0; // (2^-8) * (2^16) + 1 356 357 // Special values to check. 358 inputs.push_back(tcu::Vec2(0.0f, 0.0f)); 359 inputs.push_back(tcu::Vec2(0.5f, 1.0f)); 360 inputs.push_back(tcu::Vec2(1.0f, 0.5f)); 361 inputs.push_back(tcu::Vec2(-0.5f, 1.5f)); 362 inputs.push_back(tcu::Vec2(0.25f, 0.75f)); 363 364 // Random values, mostly in range. 365 for (int ndx = 0; ndx < 15; ndx++) 366 { 367 const float x = rnd.getFloat()*1.25f; 368 const float y = rnd.getFloat()*1.25f; 369 inputs.push_back(tcu::Vec2(x, y)); 370 } 371 372 // Large random values. 373 for (int ndx = 0; ndx < 80; ndx++) 374 { 375 const float x = rnd.getFloat()*1e6f - 1e5f; 376 const float y = rnd.getFloat()*1e6f - 1e5f; 377 inputs.push_back(tcu::Vec2(x, y)); 378 } 379 380 outputs.resize(inputs.size()); 381 382 m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values" << tcu::TestLog::EndMessage; 383 384 { 385 const void* in = &inputs[0]; 386 void* out = &outputs[0]; 387 388 m_executor->useProgram(); 389 m_executor->execute((int)inputs.size(), &in, &out); 390 } 391 392 // Verify 393 { 394 const int numValues = (int)inputs.size(); 395 const int maxPrints = 10; 396 int numFailed = 0; 397 398 for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++) 399 { 400 const deUint16 ref0 = (deUint16)de::clamp(deRoundFloatToInt32(de::clamp(inputs[valNdx].x(), 0.0f, 1.0f) * 65535.0f), 0, (1<<16)-1); 401 const deUint16 ref1 = (deUint16)de::clamp(deRoundFloatToInt32(de::clamp(inputs[valNdx].y(), 0.0f, 1.0f) * 65535.0f), 0, (1<<16)-1); 402 const deUint32 ref = (ref1 << 16) | ref0; 403 const deUint32 res = outputs[valNdx]; 404 const deUint16 res0 = (deUint16)(res & 0xffff); 405 const deUint16 res1 = (deUint16)(res >> 16); 406 const int diff0 = de::abs((int)ref0 - (int)res0); 407 const int diff1 = de::abs((int)ref1 - (int)res1); 408 409 if (diff0 > maxDiff || diff1 > maxDiff) 410 { 411 if (numFailed < maxPrints) 412 { 413 m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx 414 << ", expected packUnorm2x16(" << inputs[valNdx] << ") = " << tcu::toHex(ref) 415 << ", got " << tcu::toHex(res) 416 << "\n diffs = (" << diff0 << ", " << diff1 << "), max diff = " << maxDiff 417 << TestLog::EndMessage; 418 } 419 else if (numFailed == maxPrints) 420 m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage; 421 422 numFailed += 1; 423 } 424 } 425 426 m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed" << TestLog::EndMessage; 427 428 m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 429 numFailed == 0 ? "Pass" : "Result comparison failed"); 430 } 431 432 return STOP; 433 } 434 435 private: 436 glu::Precision m_precision; 437 }; 438 439 class UnpackUnorm2x16Case : public ShaderPackingFunctionCase 440 { 441 public: 442 UnpackUnorm2x16Case (Context& context, glu::ShaderType shaderType) 443 : ShaderPackingFunctionCase(context, (string("unpackunorm2x16") + getShaderTypePostfix(shaderType)).c_str(), "unpackUnorm2x16", shaderType) 444 { 445 m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP))); 446 m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_HIGHP))); 447 448 m_spec.source = "out0 = unpackUnorm2x16(in0);"; 449 } 450 451 IterateResult iterate (void) 452 { 453 const deUint32 maxDiff = 1; // Rounding error. 454 de::Random rnd (deStringHash(getName()) ^ 0x776002); 455 std::vector<deUint32> inputs; 456 std::vector<tcu::Vec2> outputs; 457 458 inputs.push_back(0x00000000u); 459 inputs.push_back(0x7fff8000u); 460 inputs.push_back(0x80007fffu); 461 inputs.push_back(0xffffffffu); 462 inputs.push_back(0x0001fffeu); 463 464 // Random values. 465 for (int ndx = 0; ndx < 95; ndx++) 466 inputs.push_back(rnd.getUint32()); 467 468 outputs.resize(inputs.size()); 469 470 m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values" << tcu::TestLog::EndMessage; 471 472 { 473 const void* in = &inputs[0]; 474 void* out = &outputs[0]; 475 476 m_executor->useProgram(); 477 m_executor->execute((int)inputs.size(), &in, &out); 478 } 479 480 // Verify 481 { 482 const int numValues = (int)inputs.size(); 483 const int maxPrints = 10; 484 int numFailed = 0; 485 486 for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++) 487 { 488 const deUint16 in0 = (deUint16)(inputs[valNdx] & 0xffff); 489 const deUint16 in1 = (deUint16)(inputs[valNdx] >> 16); 490 const float ref0 = float(in0) / 65535.0f; 491 const float ref1 = float(in1) / 65535.0f; 492 const float res0 = outputs[valNdx].x(); 493 const float res1 = outputs[valNdx].y(); 494 495 const deUint32 diff0 = getUlpDiff(ref0, res0); 496 const deUint32 diff1 = getUlpDiff(ref1, res1); 497 498 if (diff0 > maxDiff || diff1 > maxDiff) 499 { 500 if (numFailed < maxPrints) 501 { 502 m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx << ",\n" 503 << " expected unpackUnorm2x16(" << tcu::toHex(inputs[valNdx]) << ") = " 504 << "vec2(" << HexFloat(ref0) << ", " << HexFloat(ref1) << ")" 505 << ", got vec2(" << HexFloat(res0) << ", " << HexFloat(res1) << ")" 506 << "\n ULP diffs = (" << diff0 << ", " << diff1 << "), max diff = " << maxDiff 507 << TestLog::EndMessage; 508 } 509 else if (numFailed == maxPrints) 510 m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage; 511 512 numFailed += 1; 513 } 514 } 515 516 m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed" << TestLog::EndMessage; 517 518 m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 519 numFailed == 0 ? "Pass" : "Result comparison failed"); 520 } 521 522 return STOP; 523 } 524 }; 525 526 class PackHalf2x16Case : public ShaderPackingFunctionCase 527 { 528 public: 529 PackHalf2x16Case (Context& context, glu::ShaderType shaderType) 530 : ShaderPackingFunctionCase(context, (string("packhalf2x16") + getShaderTypePostfix(shaderType)).c_str(), "packHalf2x16", shaderType) 531 { 532 m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_HIGHP))); 533 m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP))); 534 535 m_spec.source = "out0 = packHalf2x16(in0);"; 536 } 537 538 IterateResult iterate (void) 539 { 540 const int maxDiff = 0; // Values can be represented exactly in mediump. 541 de::Random rnd (deStringHash(getName()) ^ 0x776002); 542 std::vector<tcu::Vec2> inputs; 543 std::vector<deUint32> outputs; 544 545 // Special values to check. 546 inputs.push_back(tcu::Vec2(0.0f, 0.0f)); 547 inputs.push_back(tcu::Vec2(0.5f, 1.0f)); 548 inputs.push_back(tcu::Vec2(1.0f, 0.5f)); 549 inputs.push_back(tcu::Vec2(-0.5f, 1.5f)); 550 inputs.push_back(tcu::Vec2(0.25f, 0.75f)); 551 552 // Random values. 553 { 554 const int minExp = -14; 555 const int maxExp = 15; 556 557 for (int ndx = 0; ndx < 95; ndx++) 558 { 559 tcu::Vec2 v; 560 for (int c = 0; c < 2; c++) 561 { 562 const int s = rnd.getBool() ? 1 : -1; 563 const int exp = rnd.getInt(minExp, maxExp); 564 const deUint32 mantissa = rnd.getUint32() & ((1<<23)-1); 565 566 v[c] = tcu::Float32::construct(s, exp ? exp : 1 /* avoid denormals */, (1u<<23) | mantissa).asFloat(); 567 } 568 inputs.push_back(v); 569 } 570 } 571 572 // Convert input values to fp16 and back to make sure they can be represented exactly in mediump. 573 for (std::vector<tcu::Vec2>::iterator inVal = inputs.begin(); inVal != inputs.end(); ++inVal) 574 *inVal = tcu::Vec2(tcu::Float16(inVal->x()).asFloat(), tcu::Float16(inVal->y()).asFloat()); 575 576 outputs.resize(inputs.size()); 577 578 m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values" << tcu::TestLog::EndMessage; 579 580 { 581 const void* in = &inputs[0]; 582 void* out = &outputs[0]; 583 584 m_executor->useProgram(); 585 m_executor->execute((int)inputs.size(), &in, &out); 586 } 587 588 // Verify 589 { 590 const int numValues = (int)inputs.size(); 591 const int maxPrints = 10; 592 int numFailed = 0; 593 594 for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++) 595 { 596 const deUint16 ref0 = (deUint16)tcu::Float16(inputs[valNdx].x()).bits(); 597 const deUint16 ref1 = (deUint16)tcu::Float16(inputs[valNdx].y()).bits(); 598 const deUint32 ref = (ref1 << 16) | ref0; 599 const deUint32 res = outputs[valNdx]; 600 const deUint16 res0 = (deUint16)(res & 0xffff); 601 const deUint16 res1 = (deUint16)(res >> 16); 602 const int diff0 = de::abs((int)ref0 - (int)res0); 603 const int diff1 = de::abs((int)ref1 - (int)res1); 604 605 if (diff0 > maxDiff || diff1 > maxDiff) 606 { 607 if (numFailed < maxPrints) 608 { 609 m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx 610 << ", expected packHalf2x16(" << inputs[valNdx] << ") = " << tcu::toHex(ref) 611 << ", got " << tcu::toHex(res) 612 << "\n diffs = (" << diff0 << ", " << diff1 << "), max diff = " << maxDiff 613 << TestLog::EndMessage; 614 } 615 else if (numFailed == maxPrints) 616 m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage; 617 618 numFailed += 1; 619 } 620 } 621 622 m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed" << TestLog::EndMessage; 623 624 m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 625 numFailed == 0 ? "Pass" : "Result comparison failed"); 626 } 627 628 return STOP; 629 } 630 }; 631 632 class UnpackHalf2x16Case : public ShaderPackingFunctionCase 633 { 634 public: 635 UnpackHalf2x16Case (Context& context, glu::ShaderType shaderType) 636 : ShaderPackingFunctionCase(context, (string("unpackhalf2x16") + getShaderTypePostfix(shaderType)).c_str(), "unpackHalf2x16", shaderType) 637 { 638 m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP))); 639 m_spec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_FLOAT_VEC2, glu::PRECISION_MEDIUMP))); 640 641 m_spec.source = "out0 = unpackHalf2x16(in0);"; 642 } 643 644 IterateResult iterate (void) 645 { 646 const int maxDiff = 0; // All bits must be accurate. 647 de::Random rnd (deStringHash(getName()) ^ 0x776002); 648 std::vector<deUint32> inputs; 649 std::vector<tcu::Vec2> outputs; 650 651 // Special values. 652 inputs.push_back((tcu::Float16( 0.0f).bits() << 16) | tcu::Float16( 1.0f).bits()); 653 inputs.push_back((tcu::Float16( 1.0f).bits() << 16) | tcu::Float16( 0.0f).bits()); 654 inputs.push_back((tcu::Float16(-1.0f).bits() << 16) | tcu::Float16( 0.5f).bits()); 655 inputs.push_back((tcu::Float16( 0.5f).bits() << 16) | tcu::Float16(-0.5f).bits()); 656 657 // Construct random values. 658 { 659 const int minExp = -14; 660 const int maxExp = 15; 661 const int mantBits = 10; 662 663 for (int ndx = 0; ndx < 96; ndx++) 664 { 665 deUint32 inVal = 0; 666 for (int c = 0; c < 2; c++) 667 { 668 const int s = rnd.getBool() ? 1 : -1; 669 const int exp = rnd.getInt(minExp, maxExp); 670 const deUint32 mantissa = rnd.getUint32() & ((1<<mantBits)-1); 671 const deUint16 value = tcu::Float16::construct(s, exp ? exp : 1 /* avoid denorm */, (1u<<10) | mantissa).bits(); 672 673 inVal |= value << (16*c); 674 } 675 inputs.push_back(inVal); 676 } 677 } 678 679 outputs.resize(inputs.size()); 680 681 m_testCtx.getLog() << TestLog::Message << "Executing shader for " << inputs.size() << " input values" << tcu::TestLog::EndMessage; 682 683 { 684 const void* in = &inputs[0]; 685 void* out = &outputs[0]; 686 687 m_executor->useProgram(); 688 m_executor->execute((int)inputs.size(), &in, &out); 689 } 690 691 // Verify 692 { 693 const int numValues = (int)inputs.size(); 694 const int maxPrints = 10; 695 int numFailed = 0; 696 697 for (int valNdx = 0; valNdx < (int)inputs.size(); valNdx++) 698 { 699 const deUint16 in0 = (deUint16)(inputs[valNdx] & 0xffff); 700 const deUint16 in1 = (deUint16)(inputs[valNdx] >> 16); 701 const float ref0 = tcu::Float16(in0).asFloat(); 702 const float ref1 = tcu::Float16(in1).asFloat(); 703 const float res0 = outputs[valNdx].x(); 704 const float res1 = outputs[valNdx].y(); 705 706 const deUint32 refBits0 = tcu::Float32(ref0).bits(); 707 const deUint32 refBits1 = tcu::Float32(ref1).bits(); 708 const deUint32 resBits0 = tcu::Float32(res0).bits(); 709 const deUint32 resBits1 = tcu::Float32(res1).bits(); 710 711 const int diff0 = de::abs((int)refBits0 - (int)resBits0); 712 const int diff1 = de::abs((int)refBits1 - (int)resBits1); 713 714 if (diff0 > maxDiff || diff1 > maxDiff) 715 { 716 if (numFailed < maxPrints) 717 { 718 m_testCtx.getLog() << TestLog::Message << "ERROR: Mismatch in value " << valNdx << ",\n" 719 << " expected unpackHalf2x16(" << tcu::toHex(inputs[valNdx]) << ") = " 720 << "vec2(" << ref0 << " / " << tcu::toHex(refBits0) << ", " << ref1 << " / " << tcu::toHex(refBits1) << ")" 721 << ", got vec2(" << res0 << " / " << tcu::toHex(resBits0) << ", " << res1 << " / " << tcu::toHex(resBits1) << ")" 722 << "\n ULP diffs = (" << diff0 << ", " << diff1 << "), max diff = " << maxDiff 723 << TestLog::EndMessage; 724 } 725 else if (numFailed == maxPrints) 726 m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage; 727 728 numFailed += 1; 729 } 730 } 731 732 m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed" << TestLog::EndMessage; 733 734 m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 735 numFailed == 0 ? "Pass" : "Result comparison failed"); 736 } 737 738 return STOP; 739 } 740 }; 741 742 ShaderPackingFunctionTests::ShaderPackingFunctionTests (Context& context) 743 : TestCaseGroup(context, "pack_unpack", "Floating-point pack and unpack function tests") 744 { 745 } 746 747 ShaderPackingFunctionTests::~ShaderPackingFunctionTests (void) 748 { 749 } 750 751 void ShaderPackingFunctionTests::init (void) 752 { 753 addChild(new PackSnorm2x16Case (m_context, glu::SHADERTYPE_VERTEX, glu::PRECISION_LOWP)); 754 addChild(new PackSnorm2x16Case (m_context, glu::SHADERTYPE_FRAGMENT, glu::PRECISION_LOWP)); 755 addChild(new PackSnorm2x16Case (m_context, glu::SHADERTYPE_VERTEX, glu::PRECISION_MEDIUMP)); 756 addChild(new PackSnorm2x16Case (m_context, glu::SHADERTYPE_FRAGMENT, glu::PRECISION_MEDIUMP)); 757 addChild(new PackSnorm2x16Case (m_context, glu::SHADERTYPE_VERTEX, glu::PRECISION_HIGHP)); 758 addChild(new PackSnorm2x16Case (m_context, glu::SHADERTYPE_FRAGMENT, glu::PRECISION_HIGHP)); 759 760 addChild(new UnpackSnorm2x16Case(m_context, glu::SHADERTYPE_VERTEX)); 761 addChild(new UnpackSnorm2x16Case(m_context, glu::SHADERTYPE_FRAGMENT)); 762 763 addChild(new PackUnorm2x16Case (m_context, glu::SHADERTYPE_VERTEX, glu::PRECISION_LOWP)); 764 addChild(new PackUnorm2x16Case (m_context, glu::SHADERTYPE_FRAGMENT, glu::PRECISION_LOWP)); 765 addChild(new PackUnorm2x16Case (m_context, glu::SHADERTYPE_VERTEX, glu::PRECISION_MEDIUMP)); 766 addChild(new PackUnorm2x16Case (m_context, glu::SHADERTYPE_FRAGMENT, glu::PRECISION_MEDIUMP)); 767 addChild(new PackUnorm2x16Case (m_context, glu::SHADERTYPE_VERTEX, glu::PRECISION_HIGHP)); 768 addChild(new PackUnorm2x16Case (m_context, glu::SHADERTYPE_FRAGMENT, glu::PRECISION_HIGHP)); 769 770 addChild(new UnpackUnorm2x16Case(m_context, glu::SHADERTYPE_VERTEX)); 771 addChild(new UnpackUnorm2x16Case(m_context, glu::SHADERTYPE_FRAGMENT)); 772 773 addChild(new PackHalf2x16Case (m_context, glu::SHADERTYPE_VERTEX)); 774 addChild(new PackHalf2x16Case (m_context, glu::SHADERTYPE_FRAGMENT)); 775 776 addChild(new UnpackHalf2x16Case (m_context, glu::SHADERTYPE_VERTEX)); 777 addChild(new UnpackHalf2x16Case (m_context, glu::SHADERTYPE_FRAGMENT)); 778 } 779 780 } // Functional 781 } // gles3 782 } // deqp 783
