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 Basic Compute Shader Tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fAtomicCounterTests.hpp" 25 26 #include "gluShaderProgram.hpp" 27 #include "gluObjectWrapper.hpp" 28 #include "gluRenderContext.hpp" 29 30 #include "glwFunctions.hpp" 31 #include "glwEnums.hpp" 32 33 #include "tcuTestLog.hpp" 34 35 #include "deStringUtil.hpp" 36 #include "deRandom.hpp" 37 #include "deMemory.h" 38 39 #include <vector> 40 #include <string> 41 42 using namespace glw; 43 using tcu::TestLog; 44 45 using std::vector; 46 using std::string; 47 48 namespace deqp 49 { 50 namespace gles31 51 { 52 namespace Functional 53 { 54 namespace 55 { 56 57 class AtomicCounterTest : public TestCase 58 { 59 public: 60 enum Operation 61 { 62 OPERATION_INC = (1<<0), 63 OPERATION_DEC = (1<<1), 64 OPERATION_GET = (1<<2) 65 }; 66 67 enum OffsetType 68 { 69 OFFSETTYPE_NONE = 0, 70 OFFSETTYPE_BASIC, 71 OFFSETTYPE_REVERSE, 72 OFFSETTYPE_FIRST_AUTO, 73 OFFSETTYPE_DEFAULT_AUTO, 74 OFFSETTYPE_RESET_DEFAULT, 75 OFFSETTYPE_INVALID, 76 OFFSETTYPE_INVALID_OVERLAPPING, 77 OFFSETTYPE_INVALID_DEFAULT 78 }; 79 80 enum BindingType 81 { 82 BINDINGTYPE_BASIC = 0, 83 BINDINGTYPE_INVALID, 84 BINDINGTYPE_INVALID_DEFAULT 85 }; 86 87 struct TestSpec 88 { 89 TestSpec (void) 90 : atomicCounterCount (0) 91 , operations ((Operation)0) 92 , callCount (0) 93 , useBranches (false) 94 , threadCount (0) 95 , offsetType (OFFSETTYPE_NONE) 96 , bindingType (BINDINGTYPE_BASIC) 97 { 98 } 99 100 int atomicCounterCount; 101 Operation operations; 102 int callCount; 103 bool useBranches; 104 int threadCount; 105 OffsetType offsetType; 106 BindingType bindingType; 107 }; 108 109 AtomicCounterTest (Context& context, const char* name, const char* description, const TestSpec& spec); 110 ~AtomicCounterTest (void); 111 112 void init (void); 113 void deinit (void); 114 IterateResult iterate (void); 115 116 private: 117 const TestSpec m_spec; 118 119 bool checkAndLogCounterValues (TestLog& log, const vector<deUint32>& counters) const; 120 bool checkAndLogCallValues (TestLog& log, const vector<deUint32>& increments, const vector<deUint32>& decrements, const vector<deUint32>& preGets, const vector<deUint32>& postGets, const vector<deUint32>& gets) const; 121 void splitBuffer (const vector<deUint32>& buffer, vector<deUint32>& increments, vector<deUint32>& decrements, vector<deUint32>& preGets, vector<deUint32>& postGets, vector<deUint32>& gets) const; 122 deUint32 getInitialValue (void) const { return m_spec.callCount * m_spec.threadCount + 1; } 123 124 static string generateShaderSource (const TestSpec& spec); 125 static void getCountersValues (vector<deUint32>& counterValues, const vector<deUint32>& values, int ndx, int counterCount); 126 static bool checkRange (TestLog& log, const vector<deUint32>& values, const vector<deUint32>& min, const vector<deUint32>& max); 127 static bool checkUniquenessAndLinearity (TestLog& log, const vector<deUint32>& values); 128 static bool checkPath (const vector<deUint32>& increments, const vector<deUint32>& decrements, int initialValue, const TestSpec& spec); 129 130 int getOperationCount (void) const; 131 132 AtomicCounterTest& operator= (const AtomicCounterTest&); 133 AtomicCounterTest (const AtomicCounterTest&); 134 }; 135 136 int AtomicCounterTest::getOperationCount (void) const 137 { 138 int count = 0; 139 140 if (m_spec.operations & OPERATION_INC) 141 count++; 142 143 if (m_spec.operations & OPERATION_DEC) 144 count++; 145 146 if (m_spec.operations == OPERATION_GET) 147 count++; 148 else if (m_spec.operations & OPERATION_GET) 149 count += 2; 150 151 return count; 152 } 153 154 AtomicCounterTest::AtomicCounterTest (Context& context, const char* name, const char* description, const TestSpec& spec) 155 : TestCase (context, name, description) 156 , m_spec (spec) 157 { 158 } 159 160 AtomicCounterTest::~AtomicCounterTest (void) 161 { 162 } 163 164 void AtomicCounterTest::init (void) 165 { 166 } 167 168 void AtomicCounterTest::deinit (void) 169 { 170 } 171 172 string AtomicCounterTest::generateShaderSource (const TestSpec& spec) 173 { 174 std::ostringstream src; 175 176 src 177 << "#version 310 es\n" 178 << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"; 179 180 { 181 bool wroteLayout = false; 182 183 switch (spec.bindingType) 184 { 185 case BINDINGTYPE_INVALID_DEFAULT: 186 src << "layout(binding=10000"; 187 wroteLayout = true; 188 break; 189 190 default: 191 // Do nothing 192 break; 193 } 194 195 switch (spec.offsetType) 196 { 197 case OFFSETTYPE_DEFAULT_AUTO: 198 if (!wroteLayout) 199 src << "layout(binding=1, "; 200 else 201 src << ", "; 202 203 src << "offset=4"; 204 wroteLayout = true; 205 break; 206 207 case OFFSETTYPE_RESET_DEFAULT: 208 DE_ASSERT(spec.atomicCounterCount > 2); 209 210 if (!wroteLayout) 211 src << "layout(binding=1, "; 212 else 213 src << ", "; 214 215 src << "offset=" << (4 * spec.atomicCounterCount/2); 216 wroteLayout = true; 217 break; 218 219 case OFFSETTYPE_INVALID_DEFAULT: 220 if (!wroteLayout) 221 src << "layout(binding=1, "; 222 else 223 src << ", "; 224 225 src << "offset=1"; 226 wroteLayout = true; 227 break; 228 229 default: 230 // Do nothing 231 break; 232 } 233 234 if (wroteLayout) 235 src << ") uniform atomic_uint;\n"; 236 } 237 238 src 239 << "layout(binding = 1, std430) buffer Output {\n"; 240 241 if ((spec.operations & OPERATION_GET) != 0 && spec.operations != OPERATION_GET) 242 src << " uint preGet[" << spec.threadCount * spec.atomicCounterCount * spec.callCount << "];\n"; 243 244 if ((spec.operations & OPERATION_INC) != 0) 245 src << " uint increment[" << spec.threadCount * spec.atomicCounterCount * spec.callCount << "];\n"; 246 247 if ((spec.operations & OPERATION_DEC) != 0) 248 src << " uint decrement[" << spec.threadCount * spec.atomicCounterCount * spec.callCount << "];\n"; 249 250 if ((spec.operations & OPERATION_GET) != 0 && spec.operations != OPERATION_GET) 251 src << " uint postGet[" << spec.threadCount * spec.atomicCounterCount * spec.callCount << "];\n"; 252 253 if (spec.operations == OPERATION_GET) 254 src << " uint get[" << spec.threadCount * spec.atomicCounterCount * spec.callCount << "];\n"; 255 256 src << "} sb_in;\n\n"; 257 258 for (int counterNdx = 0; counterNdx < spec.atomicCounterCount; counterNdx++) 259 { 260 bool layoutStarted = false; 261 262 if (spec.offsetType == OFFSETTYPE_RESET_DEFAULT && counterNdx == spec.atomicCounterCount/2) 263 src << "layout(binding=1, offset=0) uniform atomic_uint;\n"; 264 265 switch (spec.bindingType) 266 { 267 case BINDINGTYPE_BASIC: 268 layoutStarted = true; 269 src << "layout(binding=1"; 270 break; 271 272 case BINDINGTYPE_INVALID: 273 layoutStarted = true; 274 src << "layout(binding=10000"; 275 break; 276 277 case BINDINGTYPE_INVALID_DEFAULT: 278 // Nothing 279 break; 280 281 default: 282 DE_ASSERT(false); 283 } 284 285 switch (spec.offsetType) 286 { 287 case OFFSETTYPE_NONE: 288 if (layoutStarted) 289 src << ") "; 290 291 src << "uniform atomic_uint counter" << counterNdx << ";\n"; 292 293 break; 294 295 case OFFSETTYPE_BASIC: 296 if (!layoutStarted) 297 src << "layout("; 298 else 299 src << ", "; 300 301 src << "offset=" << (counterNdx * 4) << ") uniform atomic_uint counter" << counterNdx << ";\n"; 302 303 break; 304 305 case OFFSETTYPE_INVALID_DEFAULT: 306 if (layoutStarted) 307 src << ") "; 308 309 src << "uniform atomic_uint counter" << counterNdx << ";\n"; 310 311 break; 312 313 case OFFSETTYPE_INVALID: 314 if (!layoutStarted) 315 src << "layout("; 316 else 317 src << ", "; 318 319 src << "offset=" << (1 + counterNdx * 2) << ") uniform atomic_uint counter" << counterNdx << ";\n"; 320 321 break; 322 323 case OFFSETTYPE_INVALID_OVERLAPPING: 324 if (!layoutStarted) 325 src << "layout("; 326 else 327 src << ", "; 328 329 src << "offset=0) uniform atomic_uint counter" << counterNdx << ";\n"; 330 331 break; 332 333 case OFFSETTYPE_REVERSE: 334 if (!layoutStarted) 335 src << "layout("; 336 else 337 src << ", "; 338 339 src << "offset=" << (spec.atomicCounterCount - counterNdx - 1) * 4 << ") uniform atomic_uint counter" << (spec.atomicCounterCount - counterNdx - 1) << ";\n"; 340 341 break; 342 343 case OFFSETTYPE_FIRST_AUTO: 344 DE_ASSERT(spec.atomicCounterCount > 2); 345 346 if (counterNdx + 1 == spec.atomicCounterCount) 347 { 348 if (!layoutStarted) 349 src << "layout("; 350 else 351 src << ", "; 352 353 src << "offset=0) uniform atomic_uint counter0;\n"; 354 } 355 else if (counterNdx == 0) 356 { 357 if (!layoutStarted) 358 src << "layout("; 359 else 360 src << ", "; 361 362 src << "offset=4) uniform atomic_uint counter1;\n"; 363 } 364 else 365 { 366 if (layoutStarted) 367 src << ") "; 368 369 src << "uniform atomic_uint counter" << (counterNdx + 1) << ";\n"; 370 } 371 372 break; 373 374 case OFFSETTYPE_DEFAULT_AUTO: 375 if (counterNdx + 1 == spec.atomicCounterCount) 376 { 377 if (!layoutStarted) 378 src << "layout("; 379 else 380 src << ", "; 381 382 src << "offset=0) uniform atomic_uint counter0;\n"; 383 } 384 else 385 { 386 if (layoutStarted) 387 src << ") "; 388 389 src << "uniform atomic_uint counter" << (counterNdx + 1) << ";\n"; 390 } 391 392 break; 393 394 case OFFSETTYPE_RESET_DEFAULT: 395 if (layoutStarted) 396 src << ") "; 397 398 if (counterNdx < spec.atomicCounterCount/2) 399 src << "uniform atomic_uint counter" << (counterNdx + spec.atomicCounterCount/2) << ";\n"; 400 else 401 src << "uniform atomic_uint counter" << (counterNdx - spec.atomicCounterCount/2) << ";\n"; 402 403 break; 404 405 default: 406 DE_ASSERT(false); 407 } 408 } 409 410 src 411 << "\n" 412 << "void main (void)\n" 413 << "{\n"; 414 415 if (spec.callCount > 1) 416 src << "\tfor (uint i = 0u; i < " << spec.callCount << "u; i++)\n"; 417 418 src 419 << "\t{\n" 420 << "\t\tuint id = (gl_GlobalInvocationID.x"; 421 422 if (spec.callCount > 1) 423 src << " * "<< spec.callCount << "u"; 424 425 if (spec.callCount > 1) 426 src << " + i)"; 427 else 428 src << ")"; 429 430 if (spec.atomicCounterCount > 1) 431 src << " * " << spec.atomicCounterCount << "u"; 432 433 src << ";\n"; 434 435 for (int counterNdx = 0; counterNdx < spec.atomicCounterCount; counterNdx++) 436 { 437 if ((spec.operations & OPERATION_GET) != 0 && spec.operations != OPERATION_GET) 438 src << "\t\tsb_in.preGet[id + " << counterNdx << "u] = atomicCounter(counter" << counterNdx << ");\n"; 439 440 if (spec.useBranches && ((spec.operations & (OPERATION_INC|OPERATION_DEC)) == (OPERATION_INC|OPERATION_DEC))) 441 { 442 src 443 << "\t\tif (((gl_GlobalInvocationID.x" << (spec.callCount > 1 ? " + i" : "") << ") % 2u) == 0u)\n" 444 << "\t\t{\n" 445 << "\t\t\tsb_in.increment[id + " << counterNdx << "u] = atomicCounterIncrement(counter" << counterNdx << ");\n" 446 << "\t\t\tsb_in.decrement[id + " << counterNdx << "u] = uint(-1);\n" 447 << "\t\t}\n" 448 << "\t\telse\n" 449 << "\t\t{\n" 450 << "\t\t\tsb_in.decrement[id + " << counterNdx << "u] = atomicCounterDecrement(counter" << counterNdx << ") + 1u;\n" 451 << "\t\t\tsb_in.increment[id + " << counterNdx << "u] = uint(-1);\n" 452 << "\t\t}\n"; 453 } 454 else 455 { 456 if ((spec.operations & OPERATION_INC) != 0) 457 { 458 if (spec.useBranches) 459 { 460 src 461 << "\t\tif (((gl_GlobalInvocationID.x" << (spec.callCount > 1 ? " + i" : "") << ") % 2u) == 0u)\n" 462 << "\t\t{\n" 463 << "\t\t\tsb_in.increment[id + " << counterNdx << "u] = atomicCounterIncrement(counter" << counterNdx << ");\n" 464 << "\t\t}\n" 465 << "\t\telse\n" 466 << "\t\t{\n" 467 << "\t\t\tsb_in.increment[id + " << counterNdx << "u] = uint(-1);\n" 468 << "\t\t}\n"; 469 470 } 471 else 472 src << "\t\tsb_in.increment[id + " << counterNdx << "u] = atomicCounterIncrement(counter" << counterNdx << ");\n"; 473 } 474 475 if ((spec.operations & OPERATION_DEC) != 0) 476 { 477 if (spec.useBranches) 478 { 479 src 480 << "\t\tif (((gl_GlobalInvocationID.x" << (spec.callCount > 1 ? " + i" : "") << ") % 2u) == 0u)\n" 481 << "\t\t{\n" 482 << "\t\t\tsb_in.decrement[id + " << counterNdx << "u] = atomicCounterDecrement(counter" << counterNdx << ") + 1u;\n" 483 << "\t\t}\n" 484 << "\t\telse\n" 485 << "\t\t{\n" 486 << "\t\t\tsb_in.decrement[id + " << counterNdx << "u] = uint(-1);\n" 487 << "\t\t}\n"; 488 489 } 490 else 491 src << "\t\tsb_in.decrement[id + " << counterNdx << "u] = atomicCounterDecrement(counter" << counterNdx << ") + 1u;\n"; 492 } 493 } 494 495 if ((spec.operations & OPERATION_GET) != 0 && spec.operations != OPERATION_GET) 496 src << "\t\tsb_in.postGet[id + " << counterNdx << "u] = atomicCounter(counter" << counterNdx << ");\n"; 497 498 if ((spec.operations == OPERATION_GET) != 0) 499 { 500 if (spec.useBranches) 501 { 502 src 503 << "\t\tif (((gl_GlobalInvocationID.x" << (spec.callCount > 1 ? " + i" : "") << ") % 2u) == 0u)\n" 504 << "\t\t{\n" 505 << "\t\t\tsb_in.get[id + " << counterNdx << "u] = atomicCounter(counter" << counterNdx << ");\n" 506 << "\t\t}\n" 507 << "\t\telse\n" 508 << "\t\t{\n" 509 << "\t\t\tsb_in.get[id + " << counterNdx << "u] = uint(-1);\n" 510 << "\t\t}\n"; 511 } 512 else 513 src << "\t\tsb_in.get[id + " << counterNdx << "u] = atomicCounter(counter" << counterNdx << ");\n"; 514 } 515 } 516 517 src 518 << "\t}\n" 519 << "}\n"; 520 521 return src.str(); 522 } 523 524 bool AtomicCounterTest::checkAndLogCounterValues (TestLog& log, const vector<deUint32>& counters) const 525 { 526 tcu::ScopedLogSection counterSection (log, "Counter info", "Show initial value, current value and expected value of each counter."); 527 bool isOk = true; 528 529 // Check that atomic counters have sensible results 530 for (int counterNdx = 0; counterNdx < (int)counters.size(); counterNdx++) 531 { 532 const deUint32 value = counters[counterNdx]; 533 const deUint32 initialValue = getInitialValue(); 534 deUint32 expectedValue = (deUint32)-1; 535 536 if ((m_spec.operations & OPERATION_INC) != 0 && (m_spec.operations & OPERATION_DEC) == 0) 537 expectedValue = initialValue + (m_spec.useBranches ? m_spec.threadCount*m_spec.callCount - m_spec.threadCount*m_spec.callCount/2 : m_spec.threadCount*m_spec.callCount); 538 539 if ((m_spec.operations & OPERATION_INC) == 0 && (m_spec.operations & OPERATION_DEC) != 0) 540 expectedValue = initialValue - (m_spec.useBranches ? m_spec.threadCount*m_spec.callCount - m_spec.threadCount*m_spec.callCount/2 : m_spec.threadCount*m_spec.callCount); 541 542 if ((m_spec.operations & OPERATION_INC) != 0 && (m_spec.operations & OPERATION_DEC) != 0) 543 expectedValue = initialValue + (m_spec.useBranches ? m_spec.threadCount*m_spec.callCount - m_spec.threadCount*m_spec.callCount/2 : 0) - (m_spec.useBranches ? m_spec.threadCount*m_spec.callCount/2 : 0); 544 545 if ((m_spec.operations & OPERATION_INC) == 0 && (m_spec.operations & OPERATION_DEC) == 0) 546 expectedValue = initialValue; 547 548 log << TestLog::Message << "atomic_uint counter" << counterNdx << " initial value: " << initialValue << ", value: " << value << ", expected: " << expectedValue << (value == expectedValue ? "" : ", failed!") << TestLog::EndMessage; 549 550 if (value != expectedValue) 551 isOk = false; 552 } 553 554 return isOk; 555 } 556 557 void AtomicCounterTest::splitBuffer (const vector<deUint32>& buffer, vector<deUint32>& increments, vector<deUint32>& decrements, vector<deUint32>& preGets, vector<deUint32>& postGets, vector<deUint32>& gets) const 558 { 559 const int bufferValueCount = m_spec.callCount * m_spec.threadCount * m_spec.atomicCounterCount; 560 561 int firstPreGet = -1; 562 int firstPostGet = -1; 563 int firstGet = -1; 564 int firstInc = -1; 565 int firstDec = -1; 566 567 increments.clear(); 568 decrements.clear(); 569 preGets.clear(); 570 postGets.clear(); 571 gets.clear(); 572 573 if (m_spec.operations == OPERATION_GET) 574 firstGet = 0; 575 else if (m_spec.operations == OPERATION_INC) 576 firstInc = 0; 577 else if (m_spec.operations == OPERATION_DEC) 578 firstDec = 0; 579 else if (m_spec.operations == (OPERATION_GET|OPERATION_INC)) 580 { 581 firstPreGet = 0; 582 firstInc = bufferValueCount; 583 firstPostGet = bufferValueCount * 2; 584 } 585 else if (m_spec.operations == (OPERATION_GET|OPERATION_DEC)) 586 { 587 firstPreGet = 0; 588 firstDec = bufferValueCount; 589 firstPostGet = bufferValueCount * 2; 590 } 591 else if (m_spec.operations == (OPERATION_GET|OPERATION_DEC|OPERATION_INC)) 592 { 593 firstPreGet = 0; 594 firstInc = bufferValueCount; 595 firstDec = bufferValueCount * 2; 596 firstPostGet = bufferValueCount * 3; 597 } 598 else if (m_spec.operations == (OPERATION_DEC|OPERATION_INC)) 599 { 600 firstInc = 0; 601 firstDec = bufferValueCount; 602 } 603 else 604 DE_ASSERT(false); 605 606 for (int threadNdx = 0; threadNdx < m_spec.threadCount; threadNdx++) 607 { 608 for (int callNdx = 0; callNdx < m_spec.callCount; callNdx++) 609 { 610 for (int counterNdx = 0; counterNdx < m_spec.atomicCounterCount; counterNdx++) 611 { 612 const int id = ((threadNdx * m_spec.callCount) + callNdx) * m_spec.atomicCounterCount + counterNdx; 613 614 if (firstInc != -1) 615 increments.push_back(buffer[firstInc + id]); 616 617 if (firstDec != -1) 618 decrements.push_back(buffer[firstDec + id]); 619 620 if (firstPreGet != -1) 621 preGets.push_back(buffer[firstPreGet + id]); 622 623 if (firstPostGet != -1) 624 postGets.push_back(buffer[firstPostGet + id]); 625 626 if (firstGet != -1) 627 gets.push_back(buffer[firstGet + id]); 628 } 629 } 630 } 631 } 632 633 void AtomicCounterTest::getCountersValues (vector<deUint32>& counterValues, const vector<deUint32>& values, int ndx, int counterCount) 634 { 635 counterValues.resize(values.size()/counterCount, 0); 636 637 DE_ASSERT(values.size() % counterCount == 0); 638 639 for (int valueNdx = 0; valueNdx < (int)counterValues.size(); valueNdx++) 640 counterValues[valueNdx] = values[valueNdx * counterCount + ndx]; 641 } 642 643 bool AtomicCounterTest::checkRange (TestLog& log, const vector<deUint32>& values, const vector<deUint32>& min, const vector<deUint32>& max) 644 { 645 int failedCount = 0; 646 647 DE_ASSERT(values.size() == min.size()); 648 DE_ASSERT(values.size() == max.size()); 649 650 for (int valueNdx = 0; valueNdx < (int)values.size(); valueNdx++) 651 { 652 if (values[valueNdx] != (deUint32)-1) 653 { 654 if (!deInRange32(values[valueNdx], min[valueNdx], max[valueNdx])) 655 { 656 if (failedCount < 20) 657 log << TestLog::Message << "Value " << values[valueNdx] << " not in range [" << min[valueNdx] << ", " << max[valueNdx] << "]." << TestLog::EndMessage; 658 failedCount++; 659 } 660 } 661 } 662 663 if (failedCount > 20) 664 log << TestLog::Message << "Number of values not in range: " << failedCount << ", displaying first 20 values." << TestLog::EndMessage; 665 666 return failedCount == 0; 667 } 668 669 bool AtomicCounterTest::checkUniquenessAndLinearity (TestLog& log, const vector<deUint32>& values) 670 { 671 vector<deUint32> counts; 672 int failedCount = 0; 673 deUint32 minValue = (deUint32)-1; 674 deUint32 maxValue = 0; 675 676 DE_ASSERT(!values.empty()); 677 678 for (int valueNdx = 0; valueNdx < (int)values.size(); valueNdx++) 679 { 680 if (values[valueNdx] != (deUint32)-1) 681 { 682 minValue = std::min(minValue, values[valueNdx]); 683 maxValue = std::max(maxValue, values[valueNdx]); 684 } 685 } 686 687 counts.resize(maxValue - minValue + 1, 0); 688 689 for (int valueNdx = 0; valueNdx < (int)values.size(); valueNdx++) 690 { 691 if (values[valueNdx] != (deUint32)-1) 692 counts[values[valueNdx] - minValue]++; 693 } 694 695 for (int countNdx = 0; countNdx < (int)counts.size(); countNdx++) 696 { 697 if (counts[countNdx] != 1) 698 { 699 if (failedCount < 20) 700 log << TestLog::Message << "Value " << (minValue + countNdx) << " is not unique. Returned " << counts[countNdx] << " times." << TestLog::EndMessage; 701 702 failedCount++; 703 } 704 } 705 706 if (failedCount > 20) 707 log << TestLog::Message << "Number of values not unique: " << failedCount << ", displaying first 20 values." << TestLog::EndMessage; 708 709 return failedCount == 0; 710 } 711 712 bool AtomicCounterTest::checkPath (const vector<deUint32>& increments, const vector<deUint32>& decrements, int initialValue, const TestSpec& spec) 713 { 714 const deUint32 lastValue = initialValue + (spec.useBranches ? spec.threadCount*spec.callCount - spec.threadCount*spec.callCount/2 : 0) - (spec.useBranches ? spec.threadCount*spec.callCount/2 : 0); 715 bool isOk = true; 716 717 vector<deUint32> incrementCounts; 718 vector<deUint32> decrementCounts; 719 720 deUint32 minValue = 0xFFFFFFFFu; 721 deUint32 maxValue = 0; 722 723 for (int valueNdx = 0; valueNdx < (int)increments.size(); valueNdx++) 724 { 725 if (increments[valueNdx] != (deUint32)-1) 726 { 727 minValue = std::min(minValue, increments[valueNdx]); 728 maxValue = std::max(maxValue, increments[valueNdx]); 729 } 730 } 731 732 for (int valueNdx = 0; valueNdx < (int)decrements.size(); valueNdx++) 733 { 734 if (decrements[valueNdx] != (deUint32)-1) 735 { 736 minValue = std::min(minValue, decrements[valueNdx]); 737 maxValue = std::max(maxValue, decrements[valueNdx]); 738 } 739 } 740 741 minValue = std::min(minValue, (deUint32)initialValue); 742 maxValue = std::max(maxValue, (deUint32)initialValue); 743 744 incrementCounts.resize(maxValue - minValue + 1, 0); 745 decrementCounts.resize(maxValue - minValue + 1, 0); 746 747 for (int valueNdx = 0; valueNdx < (int)increments.size(); valueNdx++) 748 { 749 if (increments[valueNdx] != (deUint32)-1) 750 incrementCounts[increments[valueNdx] - minValue]++; 751 } 752 753 for (int valueNdx = 0; valueNdx < (int)decrements.size(); valueNdx++) 754 { 755 if (decrements[valueNdx] != (deUint32)-1) 756 decrementCounts[decrements[valueNdx] - minValue]++; 757 } 758 759 int pos = initialValue - minValue; 760 761 while (incrementCounts[pos] + decrementCounts[pos] != 0) 762 { 763 if (incrementCounts[pos] > 0 && pos >= (int)(lastValue - minValue)) 764 { 765 // If can increment and incrementation would move us away from result value, increment 766 incrementCounts[pos]--; 767 pos++; 768 } 769 else if (decrementCounts[pos] > 0) 770 { 771 // If can, decrement 772 decrementCounts[pos]--; 773 pos--; 774 } 775 else if (incrementCounts[pos] > 0) 776 { 777 // If increment moves closer to result value and can't decrement, increment 778 incrementCounts[pos]--; 779 pos++; 780 } 781 else 782 DE_ASSERT(false); 783 784 if (pos < 0 || pos >= (int)incrementCounts.size()) 785 break; 786 } 787 788 if (minValue + pos != lastValue) 789 isOk = false; 790 791 for (int valueNdx = 0; valueNdx < (int)incrementCounts.size(); valueNdx++) 792 { 793 if (incrementCounts[valueNdx] != 0) 794 isOk = false; 795 } 796 797 for (int valueNdx = 0; valueNdx < (int)decrementCounts.size(); valueNdx++) 798 { 799 if (decrementCounts[valueNdx] != 0) 800 isOk = false; 801 } 802 803 return isOk; 804 } 805 806 bool AtomicCounterTest::checkAndLogCallValues (TestLog& log, const vector<deUint32>& increments, const vector<deUint32>& decrements, const vector<deUint32>& preGets, const vector<deUint32>& postGets, const vector<deUint32>& gets) const 807 { 808 bool isOk = true; 809 810 for (int counterNdx = 0; counterNdx < m_spec.atomicCounterCount; counterNdx++) 811 { 812 vector<deUint32> counterIncrements; 813 vector<deUint32> counterDecrements; 814 vector<deUint32> counterPreGets; 815 vector<deUint32> counterPostGets; 816 vector<deUint32> counterGets; 817 818 getCountersValues(counterIncrements, increments, counterNdx, m_spec.atomicCounterCount); 819 getCountersValues(counterDecrements, decrements, counterNdx, m_spec.atomicCounterCount); 820 getCountersValues(counterPreGets, preGets, counterNdx, m_spec.atomicCounterCount); 821 getCountersValues(counterPostGets, postGets, counterNdx, m_spec.atomicCounterCount); 822 getCountersValues(counterGets, gets, counterNdx, m_spec.atomicCounterCount); 823 824 if (m_spec.operations == OPERATION_GET) 825 { 826 tcu::ScopedLogSection valueCheck(log, ("counter" + de::toString(counterNdx) + " value check").c_str(), ("Check that counter" + de::toString(counterNdx) + " values haven't changed.").c_str()); 827 int changedValues = 0; 828 829 for (int valueNdx = 0; valueNdx < (int)gets.size(); valueNdx++) 830 { 831 if ((!m_spec.useBranches || gets[valueNdx] != (deUint32)-1) && gets[valueNdx] != getInitialValue()) 832 { 833 if (changedValues < 20) 834 log << TestLog::Message << "atomicCounter(counter" << counterNdx << ") returned " << gets[valueNdx] << " expected " << getInitialValue() << TestLog::EndMessage; 835 isOk = false; 836 changedValues++; 837 } 838 } 839 840 if (changedValues == 0) 841 log << TestLog::Message << "All values returned by atomicCounter(counter" << counterNdx << ") match initial value " << getInitialValue() << "." << TestLog::EndMessage; 842 else if (changedValues > 20) 843 log << TestLog::Message << "Total number of invalid values returned by atomicCounter(counter" << counterNdx << ") " << changedValues << " displaying first 20 values." << TestLog::EndMessage; 844 } 845 else if ((m_spec.operations & (OPERATION_INC|OPERATION_DEC)) == (OPERATION_INC|OPERATION_DEC)) 846 { 847 tcu::ScopedLogSection valueCheck(log, ("counter" + de::toString(counterNdx) + " path check").c_str(), ("Check that there is order in which counter" + de::toString(counterNdx) + " increments and decrements could have happened.").c_str()); 848 if (!checkPath(counterIncrements, counterDecrements, getInitialValue(), m_spec)) 849 { 850 isOk = false; 851 log << TestLog::Message << "No possible order of calls to atomicCounterIncrement(counter" << counterNdx << ") and atomicCounterDecrement(counter" << counterNdx << ") found." << TestLog::EndMessage; 852 } 853 else 854 log << TestLog::Message << "Found possible order of calls to atomicCounterIncrement(counter" << counterNdx << ") and atomicCounterDecrement(counter" << counterNdx << ")." << TestLog::EndMessage; 855 } 856 else if ((m_spec.operations & OPERATION_INC) != 0) 857 { 858 { 859 tcu::ScopedLogSection uniquenesCheck(log, ("counter" + de::toString(counterNdx) + " check uniqueness and linearity").c_str(), ("Check that counter" + de::toString(counterNdx) + " returned only unique and linear values.").c_str()); 860 861 if (!checkUniquenessAndLinearity(log, counterIncrements)) 862 { 863 isOk = false; 864 log << TestLog::Message << "atomicCounterIncrement(counter" << counterNdx << ") returned non unique values." << TestLog::EndMessage; 865 } 866 else 867 log << TestLog::Message << "atomicCounterIncrement(counter" << counterNdx << ") returned only unique values." << TestLog::EndMessage; 868 } 869 870 if (isOk && ((m_spec.operations & OPERATION_GET) != 0)) 871 { 872 tcu::ScopedLogSection uniquenesCheck(log, ("counter" + de::toString(counterNdx) + " check range").c_str(), ("Check that counter" + de::toString(counterNdx) + " returned only values values between previous and next atomicCounter(counter" + de::toString(counterNdx) + ").").c_str()); 873 874 if (!checkRange(log, counterIncrements, counterPreGets, counterPostGets)) 875 { 876 isOk = false; 877 log << TestLog::Message << "atomicCounterIncrement(counter" << counterNdx << ") returned value that is not between previous and next call to atomicCounter(counter" << counterNdx << ")." << TestLog::EndMessage; 878 } 879 else 880 log << TestLog::Message << "atomicCounterIncrement(counter" << counterNdx << ") returned only values between previous and next call to atomicCounter(counter" << counterNdx << ")." << TestLog::EndMessage; 881 } 882 } 883 else if ((m_spec.operations & OPERATION_DEC) != 0) 884 { 885 { 886 tcu::ScopedLogSection uniquenesCheck(log, ("counter" + de::toString(counterNdx) + " check uniqueness and linearity").c_str(), ("Check that counter" + de::toString(counterNdx) + " returned only unique and linear values.").c_str()); 887 888 if (!checkUniquenessAndLinearity(log, counterDecrements)) 889 { 890 isOk = false; 891 log << TestLog::Message << "atomicCounterDecrement(counter" << counterNdx << ") returned non unique values." << TestLog::EndMessage; 892 } 893 else 894 log << TestLog::Message << "atomicCounterDecrement(counter" << counterNdx << ") returned only unique values." << TestLog::EndMessage; 895 } 896 897 if (isOk && ((m_spec.operations & OPERATION_GET) != 0)) 898 { 899 tcu::ScopedLogSection uniquenesCheck(log, ("counter" + de::toString(counterNdx) + " check range").c_str(), ("Check that counter" + de::toString(counterNdx) + " returned only values values between previous and next atomicCounter(counter" + de::toString(counterNdx) + ".").c_str()); 900 901 if (!checkRange(log, counterDecrements, counterPostGets, counterPreGets)) 902 { 903 isOk = false; 904 log << TestLog::Message << "atomicCounterDecrement(counter" << counterNdx << ") returned value that is not between previous and next call to atomicCounter(counter" << counterNdx << ")." << TestLog::EndMessage; 905 } 906 else 907 log << TestLog::Message << "atomicCounterDecrement(counter" << counterNdx << ") returned only values between previous and next call to atomicCounter(counter" << counterNdx << ")." << TestLog::EndMessage; 908 } 909 } 910 } 911 912 return isOk; 913 } 914 915 TestCase::IterateResult AtomicCounterTest::iterate (void) 916 { 917 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 918 TestLog& log = m_testCtx.getLog(); 919 const glu::Buffer counterBuffer (m_context.getRenderContext()); 920 const glu::Buffer outputBuffer (m_context.getRenderContext()); 921 const glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() << glu::ShaderSource(glu::SHADERTYPE_COMPUTE, generateShaderSource(m_spec))); 922 923 const deInt32 counterBufferSize = m_spec.atomicCounterCount * 4; 924 const deInt32 ssoSize = m_spec.atomicCounterCount * m_spec.callCount * m_spec.threadCount * 4 * getOperationCount(); 925 926 log << program; 927 928 if (m_spec.offsetType == OFFSETTYPE_INVALID || m_spec.offsetType == OFFSETTYPE_INVALID_DEFAULT || m_spec.bindingType == BINDINGTYPE_INVALID || m_spec.bindingType == BINDINGTYPE_INVALID_DEFAULT || m_spec.offsetType == OFFSETTYPE_INVALID_OVERLAPPING) 929 { 930 if (program.isOk()) 931 { 932 log << TestLog::Message << "Expected program to fail, but compilation passed." << TestLog::EndMessage; 933 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Compile succeeded"); 934 return STOP; 935 } 936 else 937 { 938 log << TestLog::Message << "Compilation failed as expected." << TestLog::EndMessage; 939 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Compile failed"); 940 return STOP; 941 } 942 } 943 else if (!program.isOk()) 944 { 945 log << TestLog::Message << "Compile failed." << TestLog::EndMessage; 946 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Compile failed"); 947 return STOP; 948 } 949 950 gl.useProgram(program.getProgram()); 951 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()"); 952 953 // Create output buffer 954 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer); 955 gl.bufferData(GL_SHADER_STORAGE_BUFFER, ssoSize, NULL, GL_STATIC_DRAW); 956 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create output buffer"); 957 958 // Create atomic counter buffer 959 { 960 vector<deUint32> data(m_spec.atomicCounterCount, getInitialValue()); 961 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *counterBuffer); 962 gl.bufferData(GL_SHADER_STORAGE_BUFFER, counterBufferSize, &(data[0]), GL_STATIC_DRAW); 963 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create buffer for atomic counters"); 964 } 965 966 // Bind output buffer 967 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, *outputBuffer); 968 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup output buffer"); 969 970 // Bind atomic counter buffer 971 gl.bindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 1, *counterBuffer); 972 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup atomic counter buffer"); 973 974 // Dispath compute 975 gl.dispatchCompute(m_spec.threadCount, 1, 1); 976 GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()"); 977 978 gl.finish(); 979 GLU_EXPECT_NO_ERROR(gl.getError(), "glFinish()"); 980 981 vector<deUint32> output(ssoSize/4, 0); 982 vector<deUint32> counters(m_spec.atomicCounterCount, 0); 983 984 // Read back output buffer 985 { 986 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer); 987 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()"); 988 989 void* ptr = gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, (GLsizeiptr)(output.size() * sizeof(deUint32)), GL_MAP_READ_BIT); 990 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()"); 991 992 deMemcpy(&(output[0]), ptr, (int)output.size() * sizeof(deUint32)); 993 994 if (!gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER)) 995 { 996 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer()"); 997 TCU_CHECK_MSG(false, "Mapped buffer corrupted"); 998 } 999 1000 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, 0); 1001 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()"); 1002 } 1003 1004 // Read back counter buffer 1005 { 1006 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *counterBuffer); 1007 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()"); 1008 1009 void* ptr = gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, (GLsizeiptr)(counters.size() * sizeof(deUint32)), GL_MAP_READ_BIT); 1010 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()"); 1011 1012 deMemcpy(&(counters[0]), ptr, (int)counters.size() * sizeof(deUint32)); 1013 1014 if (!gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER)) 1015 { 1016 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer()"); 1017 TCU_CHECK_MSG(false, "Mapped buffer corrupted"); 1018 } 1019 1020 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, 0); 1021 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()"); 1022 } 1023 1024 bool isOk = true; 1025 1026 if (!checkAndLogCounterValues(log, counters)) 1027 isOk = false; 1028 1029 { 1030 vector<deUint32> increments; 1031 vector<deUint32> decrements; 1032 vector<deUint32> preGets; 1033 vector<deUint32> postGets; 1034 vector<deUint32> gets; 1035 1036 splitBuffer(output, increments, decrements, preGets, postGets, gets); 1037 1038 if (!checkAndLogCallValues(log, increments, decrements, preGets, postGets, gets)) 1039 isOk = false; 1040 } 1041 1042 if (isOk) 1043 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1044 else 1045 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1046 1047 return STOP; 1048 } 1049 1050 string specToTestName (const AtomicCounterTest::TestSpec& spec) 1051 { 1052 std::ostringstream stream; 1053 1054 stream << spec.atomicCounterCount << (spec.atomicCounterCount == 1 ? "_counter" : "_counters"); 1055 stream << "_" << spec.callCount << (spec.callCount == 1 ? "_call" : "_calls"); 1056 stream << "_" << spec.threadCount << (spec.threadCount == 1 ? "_thread" : "_threads"); 1057 1058 return stream.str(); 1059 } 1060 1061 string specToTestDescription (const AtomicCounterTest::TestSpec& spec) 1062 { 1063 std::ostringstream stream; 1064 bool firstOperation = 0; 1065 1066 stream 1067 << "Test "; 1068 1069 if ((spec.operations & AtomicCounterTest::OPERATION_GET) != 0) 1070 { 1071 stream << "atomicCounter()"; 1072 firstOperation = false; 1073 } 1074 1075 if ((spec.operations & AtomicCounterTest::OPERATION_INC) != 0) 1076 { 1077 if (!firstOperation) 1078 stream << ", "; 1079 1080 stream << " atomicCounterIncrement()"; 1081 firstOperation = false; 1082 } 1083 1084 if ((spec.operations & AtomicCounterTest::OPERATION_DEC) != 0) 1085 { 1086 if (!firstOperation) 1087 stream << ", "; 1088 1089 stream << " atomicCounterDecrement()"; 1090 firstOperation = false; 1091 } 1092 1093 stream << " calls with "; 1094 1095 if (spec.useBranches) 1096 stream << " branches, "; 1097 1098 stream << spec.atomicCounterCount << " atomic counters, " << spec.callCount << " calls and " << spec.threadCount << " threads."; 1099 1100 return stream.str(); 1101 } 1102 1103 string operationToName (const AtomicCounterTest::Operation& operations, bool useBranch) 1104 { 1105 std::ostringstream stream; 1106 bool first = true; 1107 1108 if ((operations & AtomicCounterTest::OPERATION_GET) != 0) 1109 { 1110 stream << "get"; 1111 first = false; 1112 } 1113 1114 if ((operations & AtomicCounterTest::OPERATION_INC) != 0) 1115 { 1116 if (!first) 1117 stream << "_"; 1118 1119 stream << "inc"; 1120 first = false; 1121 } 1122 1123 if ((operations & AtomicCounterTest::OPERATION_DEC) != 0) 1124 { 1125 if (!first) 1126 stream << "_"; 1127 1128 stream << "dec"; 1129 first = false; 1130 } 1131 1132 if (useBranch) 1133 stream << "_branch"; 1134 1135 return stream.str(); 1136 } 1137 1138 string operationToDescription (const AtomicCounterTest::Operation& operations, bool useBranch) 1139 { 1140 std::ostringstream stream; 1141 bool firstOperation = 0; 1142 1143 stream 1144 << "Test "; 1145 1146 if ((operations & AtomicCounterTest::OPERATION_GET) != 0) 1147 { 1148 stream << "atomicCounter()"; 1149 firstOperation = false; 1150 } 1151 1152 if ((operations & AtomicCounterTest::OPERATION_INC) != 0) 1153 { 1154 if (!firstOperation) 1155 stream << ", "; 1156 1157 stream << " atomicCounterIncrement()"; 1158 firstOperation = false; 1159 } 1160 1161 if ((operations & AtomicCounterTest::OPERATION_DEC) != 0) 1162 { 1163 if (!firstOperation) 1164 stream << ", "; 1165 1166 stream << " atomicCounterDecrement()"; 1167 firstOperation = false; 1168 } 1169 1170 1171 if (useBranch) 1172 stream << " calls with branches."; 1173 else 1174 stream << "."; 1175 1176 return stream.str(); 1177 } 1178 1179 string layoutTypesToName (const AtomicCounterTest::BindingType& bindingType, const AtomicCounterTest::OffsetType& offsetType) 1180 { 1181 std::ostringstream stream; 1182 1183 switch (bindingType) 1184 { 1185 case AtomicCounterTest::BINDINGTYPE_BASIC: 1186 // Nothing 1187 break; 1188 1189 case AtomicCounterTest::BINDINGTYPE_INVALID: 1190 stream << "invalid_binding"; 1191 break; 1192 1193 default: 1194 DE_ASSERT(false); 1195 } 1196 1197 if (bindingType != AtomicCounterTest::BINDINGTYPE_BASIC && offsetType != AtomicCounterTest::OFFSETTYPE_NONE) 1198 stream << "_"; 1199 1200 switch (offsetType) 1201 { 1202 case AtomicCounterTest::OFFSETTYPE_BASIC: 1203 stream << "basic_offset"; 1204 break; 1205 1206 case AtomicCounterTest::OFFSETTYPE_REVERSE: 1207 stream << "reverse_offset"; 1208 break; 1209 1210 case AtomicCounterTest::OFFSETTYPE_INVALID: 1211 stream << "invalid_offset"; 1212 break; 1213 1214 case AtomicCounterTest::OFFSETTYPE_FIRST_AUTO: 1215 stream << "first_offset_set"; 1216 break; 1217 1218 case AtomicCounterTest::OFFSETTYPE_DEFAULT_AUTO: 1219 stream << "default_offset_set"; 1220 break; 1221 1222 case AtomicCounterTest::OFFSETTYPE_RESET_DEFAULT: 1223 stream << "reset_default_offset"; 1224 break; 1225 1226 case AtomicCounterTest::OFFSETTYPE_NONE: 1227 // Do nothing 1228 break; 1229 1230 default: 1231 DE_ASSERT(false); 1232 } 1233 1234 return stream.str(); 1235 } 1236 1237 string layoutTypesToDesc (const AtomicCounterTest::BindingType& bindingType, const AtomicCounterTest::OffsetType& offsetType) 1238 { 1239 std::ostringstream stream; 1240 1241 switch (bindingType) 1242 { 1243 case AtomicCounterTest::BINDINGTYPE_BASIC: 1244 stream << "Test using atomic counters with explicit layout bindings and"; 1245 break; 1246 1247 case AtomicCounterTest::BINDINGTYPE_INVALID: 1248 stream << "Test using atomic counters with invalid explicit layout bindings and"; 1249 break; 1250 1251 case AtomicCounterTest::BINDINGTYPE_INVALID_DEFAULT: 1252 stream << "Test using atomic counters with invalid default layout binding and"; 1253 break; 1254 1255 default: 1256 DE_ASSERT(false); 1257 } 1258 1259 switch (offsetType) 1260 { 1261 case AtomicCounterTest::OFFSETTYPE_NONE: 1262 stream << " no explicit offsets."; 1263 break; 1264 1265 case AtomicCounterTest::OFFSETTYPE_BASIC: 1266 stream << "explicit continuos offsets."; 1267 break; 1268 1269 case AtomicCounterTest::OFFSETTYPE_REVERSE: 1270 stream << "reversed explicit offsets."; 1271 break; 1272 1273 case AtomicCounterTest::OFFSETTYPE_INVALID: 1274 stream << "invalid explicit offsets."; 1275 break; 1276 1277 case AtomicCounterTest::OFFSETTYPE_FIRST_AUTO: 1278 stream << "only first counter with explicit offset."; 1279 break; 1280 1281 case AtomicCounterTest::OFFSETTYPE_DEFAULT_AUTO: 1282 stream << "default offset."; 1283 break; 1284 1285 case AtomicCounterTest::OFFSETTYPE_RESET_DEFAULT: 1286 stream << "default offset specified twice."; 1287 break; 1288 1289 default: 1290 DE_ASSERT(false); 1291 } 1292 1293 return stream.str(); 1294 } 1295 1296 } // Anonymous 1297 1298 AtomicCounterTests::AtomicCounterTests (Context& context) 1299 : TestCaseGroup(context, "atomic_counter", "Atomic counter tests") 1300 { 1301 // Runtime use tests 1302 { 1303 const int counterCounts[] = 1304 { 1305 1, 4, 8 1306 }; 1307 1308 const int callCounts[] = 1309 { 1310 1, 5, 100 1311 }; 1312 1313 const int threadCounts[] = 1314 { 1315 1, 10, 5000 1316 }; 1317 1318 const AtomicCounterTest::Operation operations[] = 1319 { 1320 AtomicCounterTest::OPERATION_GET, 1321 AtomicCounterTest::OPERATION_INC, 1322 AtomicCounterTest::OPERATION_DEC, 1323 1324 (AtomicCounterTest::Operation)(AtomicCounterTest::OPERATION_INC|AtomicCounterTest::OPERATION_GET), 1325 (AtomicCounterTest::Operation)(AtomicCounterTest::OPERATION_DEC|AtomicCounterTest::OPERATION_GET), 1326 1327 (AtomicCounterTest::Operation)(AtomicCounterTest::OPERATION_INC|AtomicCounterTest::OPERATION_DEC), 1328 (AtomicCounterTest::Operation)(AtomicCounterTest::OPERATION_INC|AtomicCounterTest::OPERATION_DEC|AtomicCounterTest::OPERATION_GET) 1329 }; 1330 1331 for (int operationNdx = 0; operationNdx < DE_LENGTH_OF_ARRAY(operations); operationNdx++) 1332 { 1333 const AtomicCounterTest::Operation operation = operations[operationNdx]; 1334 1335 for (int branch = 0; branch < 2; branch++) 1336 { 1337 const bool useBranch = (branch == 1); 1338 1339 TestCaseGroup* operationGroup = new TestCaseGroup(m_context, operationToName(operation, useBranch).c_str(), operationToDescription(operation, useBranch).c_str()); 1340 1341 for (int counterCountNdx = 0; counterCountNdx < DE_LENGTH_OF_ARRAY(counterCounts); counterCountNdx++) 1342 { 1343 const int counterCount = counterCounts[counterCountNdx]; 1344 1345 for (int callCountNdx = 0; callCountNdx < DE_LENGTH_OF_ARRAY(callCounts); callCountNdx++) 1346 { 1347 const int callCount = callCounts[callCountNdx]; 1348 1349 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++) 1350 { 1351 const int threadCount = threadCounts[threadCountNdx]; 1352 1353 if (threadCount * callCount * counterCount > 10000) 1354 continue; 1355 1356 if (useBranch && threadCount * callCount == 1) 1357 continue; 1358 1359 AtomicCounterTest::TestSpec spec; 1360 1361 spec.atomicCounterCount = counterCount; 1362 spec.operations = operation; 1363 spec.callCount = callCount; 1364 spec.useBranches = useBranch; 1365 spec.threadCount = threadCount; 1366 spec.bindingType = AtomicCounterTest::BINDINGTYPE_BASIC; 1367 spec.offsetType = AtomicCounterTest::OFFSETTYPE_NONE; 1368 1369 operationGroup->addChild(new AtomicCounterTest(m_context, specToTestName(spec).c_str(), specToTestDescription(spec).c_str(), spec)); 1370 } 1371 } 1372 } 1373 1374 addChild(operationGroup); 1375 } 1376 } 1377 } 1378 1379 { 1380 TestCaseGroup* layoutGroup = new TestCaseGroup(m_context, "layout", "Layout qualifier tests."); 1381 1382 const int counterCounts[] = { 1, 8 }; 1383 const int callCounts[] = { 1, 5 }; 1384 const int threadCounts[] = { 1, 1000 }; 1385 1386 const AtomicCounterTest::Operation operations[] = 1387 { 1388 (AtomicCounterTest::Operation)(AtomicCounterTest::OPERATION_INC|AtomicCounterTest::OPERATION_GET), 1389 (AtomicCounterTest::Operation)(AtomicCounterTest::OPERATION_DEC|AtomicCounterTest::OPERATION_GET), 1390 (AtomicCounterTest::Operation)(AtomicCounterTest::OPERATION_INC|AtomicCounterTest::OPERATION_DEC) 1391 }; 1392 1393 const AtomicCounterTest::OffsetType offsetTypes[] = 1394 { 1395 AtomicCounterTest::OFFSETTYPE_REVERSE, 1396 AtomicCounterTest::OFFSETTYPE_FIRST_AUTO, 1397 AtomicCounterTest::OFFSETTYPE_DEFAULT_AUTO, 1398 AtomicCounterTest::OFFSETTYPE_RESET_DEFAULT 1399 }; 1400 1401 for (int offsetTypeNdx = 0; offsetTypeNdx < DE_LENGTH_OF_ARRAY(offsetTypes); offsetTypeNdx++) 1402 { 1403 const AtomicCounterTest::OffsetType offsetType = offsetTypes[offsetTypeNdx]; 1404 1405 TestCaseGroup* layoutQualifierGroup = new TestCaseGroup(m_context, layoutTypesToName(AtomicCounterTest::BINDINGTYPE_BASIC, offsetType).c_str(), layoutTypesToDesc(AtomicCounterTest::BINDINGTYPE_BASIC, offsetType).c_str()); 1406 1407 for (int operationNdx = 0; operationNdx < DE_LENGTH_OF_ARRAY(operations); operationNdx++) 1408 { 1409 const AtomicCounterTest::Operation operation = operations[operationNdx]; 1410 1411 TestCaseGroup* operationGroup = new TestCaseGroup(m_context, operationToName(operation, false).c_str(), operationToDescription(operation, false).c_str()); 1412 1413 for (int counterCountNdx = 0; counterCountNdx < DE_LENGTH_OF_ARRAY(counterCounts); counterCountNdx++) 1414 { 1415 const int counterCount = counterCounts[counterCountNdx]; 1416 1417 if (offsetType == AtomicCounterTest::OFFSETTYPE_FIRST_AUTO && counterCount < 3) 1418 continue; 1419 1420 if (offsetType == AtomicCounterTest::OFFSETTYPE_DEFAULT_AUTO && counterCount < 2) 1421 continue; 1422 1423 if (offsetType == AtomicCounterTest::OFFSETTYPE_RESET_DEFAULT && counterCount < 2) 1424 continue; 1425 1426 if (offsetType == AtomicCounterTest::OFFSETTYPE_REVERSE && counterCount < 2) 1427 continue; 1428 1429 for (int callCountNdx = 0; callCountNdx < DE_LENGTH_OF_ARRAY(callCounts); callCountNdx++) 1430 { 1431 const int callCount = callCounts[callCountNdx]; 1432 1433 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++) 1434 { 1435 const int threadCount = threadCounts[threadCountNdx]; 1436 1437 AtomicCounterTest::TestSpec spec; 1438 1439 spec.atomicCounterCount = counterCount; 1440 spec.operations = operation; 1441 spec.callCount = callCount; 1442 spec.useBranches = false; 1443 spec.threadCount = threadCount; 1444 spec.bindingType = AtomicCounterTest::BINDINGTYPE_BASIC; 1445 spec.offsetType = offsetType; 1446 1447 operationGroup->addChild(new AtomicCounterTest(m_context, specToTestName(spec).c_str(), specToTestDescription(spec).c_str(), spec)); 1448 } 1449 } 1450 } 1451 layoutQualifierGroup->addChild(operationGroup); 1452 } 1453 layoutGroup->addChild(layoutQualifierGroup); 1454 } 1455 1456 { 1457 TestCaseGroup* invalidGroup = new TestCaseGroup(m_context, "invalid", "Test invalid layouts"); 1458 1459 { 1460 AtomicCounterTest::TestSpec spec; 1461 1462 spec.atomicCounterCount = 1; 1463 spec.operations = AtomicCounterTest::OPERATION_INC; 1464 spec.callCount = 1; 1465 spec.useBranches = false; 1466 spec.threadCount = 1; 1467 spec.bindingType = AtomicCounterTest::BINDINGTYPE_INVALID; 1468 spec.offsetType = AtomicCounterTest::OFFSETTYPE_NONE; 1469 1470 invalidGroup->addChild(new AtomicCounterTest(m_context, "invalid_binding", "Test layout qualifiers with invalid binding.", spec)); 1471 } 1472 1473 { 1474 AtomicCounterTest::TestSpec spec; 1475 1476 spec.atomicCounterCount = 1; 1477 spec.operations = AtomicCounterTest::OPERATION_INC; 1478 spec.callCount = 1; 1479 spec.useBranches = false; 1480 spec.threadCount = 1; 1481 spec.bindingType = AtomicCounterTest::BINDINGTYPE_INVALID_DEFAULT; 1482 spec.offsetType = AtomicCounterTest::OFFSETTYPE_NONE; 1483 1484 invalidGroup->addChild(new AtomicCounterTest(m_context, "invalid_default_binding", "Test layout qualifiers with invalid default binding.", spec)); 1485 } 1486 1487 { 1488 AtomicCounterTest::TestSpec spec; 1489 1490 spec.atomicCounterCount = 1; 1491 spec.operations = AtomicCounterTest::OPERATION_INC; 1492 spec.callCount = 1; 1493 spec.useBranches = false; 1494 spec.threadCount = 1; 1495 spec.bindingType = AtomicCounterTest::BINDINGTYPE_BASIC; 1496 spec.offsetType = AtomicCounterTest::OFFSETTYPE_INVALID; 1497 1498 invalidGroup->addChild(new AtomicCounterTest(m_context, "invalid_offset_align", "Test layout qualifiers with invalid alignment offset.", spec)); 1499 } 1500 1501 { 1502 AtomicCounterTest::TestSpec spec; 1503 1504 spec.atomicCounterCount = 2; 1505 spec.operations = AtomicCounterTest::OPERATION_INC; 1506 spec.callCount = 1; 1507 spec.useBranches = false; 1508 spec.threadCount = 1; 1509 spec.bindingType = AtomicCounterTest::BINDINGTYPE_BASIC; 1510 spec.offsetType = AtomicCounterTest::OFFSETTYPE_INVALID_OVERLAPPING; 1511 1512 invalidGroup->addChild(new AtomicCounterTest(m_context, "invalid_offset_overlap", "Test layout qualifiers with invalid overlapping offset.", spec)); 1513 } 1514 1515 { 1516 AtomicCounterTest::TestSpec spec; 1517 1518 spec.atomicCounterCount = 1; 1519 spec.operations = AtomicCounterTest::OPERATION_INC; 1520 spec.callCount = 1; 1521 spec.useBranches = false; 1522 spec.threadCount = 1; 1523 spec.bindingType = AtomicCounterTest::BINDINGTYPE_BASIC; 1524 spec.offsetType = AtomicCounterTest::OFFSETTYPE_INVALID_DEFAULT; 1525 1526 invalidGroup->addChild(new AtomicCounterTest(m_context, "invalid_default_offset", "Test layout qualifiers with invalid default offset.", spec)); 1527 } 1528 1529 layoutGroup->addChild(invalidGroup); 1530 } 1531 1532 addChild(layoutGroup); 1533 } 1534 } 1535 1536 AtomicCounterTests::~AtomicCounterTests (void) 1537 { 1538 } 1539 1540 void AtomicCounterTests::init (void) 1541 { 1542 } 1543 1544 } // Functional 1545 } // gles31 1546 } // deqp 1547
