framework/delibs/dethread/deThreadTest.c

   1 /*-------------------------------------------------------------------------
   2  * drawElements Thread Library
   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 Thread library tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "deThreadTest.h"
  25 #include "deThread.h"
  26 #include "deMutex.h"
  27 #include "deSemaphore.h"
  28 #include "deMemory.h"
  29 #include "deRandom.h"
  30 #include "deAtomic.h"
  31 #include "deThreadLocal.h"
  32 #include "deSingleton.h"
  33 #include "deMemPool.h"
  34 #include "dePoolArray.h"
  35
  36 static void threadTestThr1 (void* arg)
  37 {
  38         deInt32 val = *((deInt32*)arg);
  39         DE_TEST_ASSERT(val == 123);
  40 }
  41
  42 static void threadTestThr2 (void* arg)
  43 {
  44         DE_UNREF(arg);
  45         deSleep(100);
  46 }
  47
  48 typedef struct ThreadData3_s
  49 {
  50         deUint8         bytes[16];
  51 } ThreadData3;
  52
  53 static void threadTestThr3 (void* arg)
  54 {
  55         ThreadData3* data = (ThreadData3*)arg;
  56         int ndx;
  57
  58         for (ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(data->bytes); ndx++)
  59                 DE_TEST_ASSERT(data->bytes[ndx] == 0);
  60
  61         for (ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(data->bytes); ndx++)
  62                 data->bytes[ndx] = 0xff;
  63 }
  64
  65 static void threadTestThr4 (void* arg)
  66 {
  67         deThreadLocal tls = *(deThreadLocal*)arg;
  68         deThreadLocal_set(tls, DE_NULL);
  69 }
  70
  71 #if defined(DE_THREAD_LOCAL)
  72
  73 static DE_THREAD_LOCAL int tls_testVar = 123;
  74
  75 static void tlsTestThr (void* arg)
  76 {
  77         DE_UNREF(arg);
  78         DE_TEST_ASSERT(tls_testVar == 123);
  79         tls_testVar = 104;
  80         DE_TEST_ASSERT(tls_testVar == 104);
  81 }
  82
  83 #endif
  84
  85 void deThread_selfTest (void)
  86 {
  87         /* Test sleep & yield. */
  88         deSleep(0);
  89         deSleep(100);
  90         deYield();
  91
  92         /* Thread test 1. */
  93         {
  94                 deInt32         val             = 123;
  95                 deBool          ret;
  96                 deThread        thread  = deThread_create(threadTestThr1, &val, DE_NULL);
  97                 DE_TEST_ASSERT(thread);
  98
  99                 ret = deThread_join(thread);
 100                 DE_TEST_ASSERT(ret);
 101
 102                 deThread_destroy(thread);
 103         }
 104
 105         /* Thread test 2. */
 106         {
 107                 deThread        thread  = deThread_create(threadTestThr2, DE_NULL, DE_NULL);
 108                 deInt32         ret;
 109                 DE_TEST_ASSERT(thread);
 110
 111                 ret = deThread_join(thread);
 112                 DE_TEST_ASSERT(ret);
 113
 114                 deThread_destroy(thread);
 115         }
 116
 117         /* Thread test 3. */
 118         {
 119                 ThreadData3     data;
 120                 deThread        thread;
 121                 deBool          ret;
 122                 int                     ndx;
 123
 124                 deMemset(&data, 0, sizeof(ThreadData3));
 125
 126                 thread = deThread_create(threadTestThr3, &data, DE_NULL);
 127                 DE_TEST_ASSERT(thread);
 128
 129                 ret = deThread_join(thread);
 130                 DE_TEST_ASSERT(ret);
 131
 132                 for (ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(data.bytes); ndx++)
 133                         DE_TEST_ASSERT(data.bytes[ndx] == 0xff);
 134
 135                 deThread_destroy(thread);
 136         }
 137
 138         /* Test tls. */
 139         {
 140                 deThreadLocal   tls;
 141                 deThread                thread;
 142
 143                 tls = deThreadLocal_create();
 144                 DE_TEST_ASSERT(tls);
 145
 146                 deThreadLocal_set(tls, (void*)(deUintptr)0xff);
 147
 148                 thread = deThread_create(threadTestThr4, &tls, DE_NULL);
 149                 deThread_join(thread);
 150                 deThread_destroy(thread);
 151
 152                 DE_TEST_ASSERT((deUintptr)deThreadLocal_get(tls) == 0xff);
 153                 deThreadLocal_destroy(tls);
 154         }
 155
 156 #if defined(DE_THREAD_LOCAL)
 157         {
 158                 deThread thread;
 159
 160                 DE_TEST_ASSERT(tls_testVar == 123);
 161                 tls_testVar = 1;
 162                 DE_TEST_ASSERT(tls_testVar == 1);
 163
 164                 thread = deThread_create(tlsTestThr, DE_NULL, DE_NULL);
 165                 deThread_join(thread);
 166                 deThread_destroy(thread);
 167
 168                 DE_TEST_ASSERT(tls_testVar == 1);
 169                 tls_testVar = 123;
 170         }
 171 #endif
 172 }
 173
 174 static void mutexTestThr1 (void* arg)
 175 {
 176         deMutex         mutex   = *((deMutex*)arg);
 177
 178         deMutex_lock(mutex);
 179         deMutex_unlock(mutex);
 180 }
 181
 182 typedef struct MutexData2_s
 183 {
 184         deMutex         mutex;
 185         deInt32         counter;
 186         deInt32         counter2;
 187         deInt32         maxVal;
 188 } MutexData2;
 189
 190 static void mutexTestThr2 (void* arg)
 191 {
 192         MutexData2* data = (MutexData2*)arg;
 193         deInt32 numIncremented = 0;
 194
 195         for (;;)
 196         {
 197                 deInt32 localCounter;
 198                 deMutex_lock(data->mutex);
 199
 200                 if (data->counter >= data->maxVal)
 201                 {
 202                         deMutex_unlock(data->mutex);
 203                         break;
 204                 }
 205
 206                 localCounter = data->counter;
 207                 deYield();
 208
 209                 DE_TEST_ASSERT(localCounter == data->counter);
 210                 localCounter += 1;
 211                 data->counter = localCounter;
 212
 213                 deMutex_unlock(data->mutex);
 214
 215                 numIncremented++;
 216         }
 217
 218         deMutex_lock(data->mutex);
 219         data->counter2 += numIncremented;
 220         deMutex_unlock(data->mutex);
 221 }
 222
 223 void mutexTestThr3 (void* arg)
 224 {
 225         deMutex mutex = *((deMutex*)arg);
 226         deBool  ret;
 227
 228         ret = deMutex_tryLock(mutex);
 229         DE_TEST_ASSERT(!ret);
 230 }
 231
 232 void deMutex_selfTest (void)
 233 {
 234         /* Default mutex from single thread. */
 235         {
 236                 deMutex mutex = deMutex_create(DE_NULL);
 237                 deBool  ret;
 238                 DE_TEST_ASSERT(mutex);
 239
 240                 deMutex_lock(mutex);
 241                 deMutex_unlock(mutex);
 242
 243                 /* Should succeed. */
 244                 ret = deMutex_tryLock(mutex);
 245                 DE_TEST_ASSERT(ret);
 246                 deMutex_unlock(mutex);
 247
 248                 deMutex_destroy(mutex);
 249         }
 250
 251         /* Recursive mutex. */
 252         {
 253                 deMutexAttributes       attrs;
 254                 deMutex                         mutex;
 255                 int                                     ndx;
 256                 int                                     numLocks        = 10;
 257
 258                 deMemset(&attrs, 0, sizeof(attrs));
 259
 260                 attrs.flags = DE_MUTEX_RECURSIVE;
 261
 262                 mutex = deMutex_create(&attrs);
 263                 DE_TEST_ASSERT(mutex);
 264
 265                 for (ndx = 0; ndx < numLocks; ndx++)
 266                         deMutex_lock(mutex);
 267
 268                 for (ndx = 0; ndx < numLocks; ndx++)
 269                         deMutex_unlock(mutex);
 270
 271                 deMutex_destroy(mutex);
 272         }
 273
 274         /* Mutex and threads. */
 275         {
 276                 deMutex         mutex;
 277                 deThread        thread;
 278
 279                 mutex = deMutex_create(DE_NULL);
 280                 DE_TEST_ASSERT(mutex);
 281
 282                 deMutex_lock(mutex);
 283
 284                 thread = deThread_create(mutexTestThr1, &mutex, DE_NULL);
 285                 DE_TEST_ASSERT(thread);
 286
 287                 deSleep(100);
 288                 deMutex_unlock(mutex);
 289
 290                 deMutex_lock(mutex);
 291                 deMutex_unlock(mutex);
 292
 293                 deThread_join(thread);
 294
 295                 deThread_destroy(thread);
 296                 deMutex_destroy(mutex);
 297         }
 298
 299         /* A bit more complex mutex test. */
 300         {
 301                 MutexData2      data;
 302                 deThread        threads[2];
 303                 int                     ndx;
 304
 305                 data.mutex      = deMutex_create(DE_NULL);
 306                 DE_TEST_ASSERT(data.mutex);
 307
 308                 data.counter    = 0;
 309                 data.counter2   = 0;
 310                 data.maxVal             = 1000;
 311
 312                 deMutex_lock(data.mutex);
 313
 314                 for (ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(threads); ndx++)
 315                 {
 316                         threads[ndx] = deThread_create(mutexTestThr2, &data, DE_NULL);
 317                         DE_TEST_ASSERT(threads[ndx]);
 318                 }
 319
 320                 deMutex_unlock(data.mutex);
 321
 322                 for (ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(threads); ndx++)
 323                 {
 324                         deBool ret = deThread_join(threads[ndx]);
 325                         DE_TEST_ASSERT(ret);
 326                         deThread_destroy(threads[ndx]);
 327                 }
 328
 329                 DE_TEST_ASSERT(data.counter == data.counter2);
 330                 DE_TEST_ASSERT(data.maxVal == data.counter);
 331
 332                 deMutex_destroy(data.mutex);
 333         }
 334
 335         /* tryLock() deadlock test. */
 336         {
 337                 deThread        thread;
 338                 deMutex         mutex   = deMutex_create(DE_NULL);
 339                 deBool          ret;
 340                 DE_TEST_ASSERT(mutex);
 341
 342                 deMutex_lock(mutex);
 343
 344                 thread = deThread_create(mutexTestThr3, &mutex, DE_NULL);
 345                 DE_TEST_ASSERT(mutex);
 346
 347                 ret = deThread_join(thread);
 348                 DE_TEST_ASSERT(ret);
 349
 350                 deMutex_unlock(mutex);
 351                 deMutex_destroy(mutex);
 352                 deThread_destroy(thread);
 353         }
 354 }
 355
 356 typedef struct TestBuffer_s
 357 {
 358         deUint32                buffer[32];
 359         deSemaphore             empty;
 360         deSemaphore             fill;
 361
 362         deUint32                producerHash;
 363         deUint32                consumerHash;
 364 } TestBuffer;
 365
 366 void producerThread (void* arg)
 367 {
 368         TestBuffer* buffer = (TestBuffer*)arg;
 369         deRandom        random;
 370         int                     ndx;
 371         int                     numToProduce    = 10000;
 372         int                     writePos                = 0;
 373
 374         deRandom_init(&random, 123);
 375
 376         for (ndx = 0; ndx <= numToProduce; ndx++)
 377         {
 378                 deUint32 val;
 379
 380                 if (ndx == numToProduce)
 381                 {
 382                         val = 0u; /* End. */
 383                 }
 384                 else
 385                 {
 386                         val = deRandom_getUint32(&random);
 387                         val = val ? val : 1u;
 388                 }
 389
 390                 deSemaphore_decrement(buffer->empty);
 391
 392                 buffer->buffer[writePos] = val;
 393                 writePos = (writePos + 1) % DE_LENGTH_OF_ARRAY(buffer->buffer);
 394
 395                 deSemaphore_increment(buffer->fill);
 396
 397                 buffer->producerHash ^= val;
 398         }
 399 }
 400
 401 void consumerThread (void* arg)
 402 {
 403         TestBuffer*     buffer  = (TestBuffer*)arg;
 404         int                     readPos = 0;
 405
 406         for (;;)
 407         {
 408                 deInt32 val;
 409
 410                 deSemaphore_decrement(buffer->fill);
 411
 412                 val = buffer->buffer[readPos];
 413                 readPos = (readPos + 1) % DE_LENGTH_OF_ARRAY(buffer->buffer);
 414
 415                 deSemaphore_increment(buffer->empty);
 416
 417                 buffer->consumerHash ^= val;
 418
 419                 if (val == 0)
 420                         break;
 421         }
 422 }
 423
 424 void deSemaphore_selfTest (void)
 425 {
 426         /* Basic test. */
 427         {
 428                 deSemaphore     semaphore       = deSemaphore_create(1, DE_NULL);
 429                 DE_TEST_ASSERT(semaphore);
 430
 431                 deSemaphore_increment(semaphore);
 432                 deSemaphore_decrement(semaphore);
 433                 deSemaphore_decrement(semaphore);
 434
 435                 deSemaphore_destroy(semaphore);
 436         }
 437
 438         /* Producer-consumer test. */
 439         {
 440                 TestBuffer      testBuffer;
 441                 deThread        producer;
 442                 deThread        consumer;
 443                 deBool          ret;
 444
 445                 deMemset(&testBuffer, 0, sizeof(testBuffer));
 446
 447                 testBuffer.empty        = deSemaphore_create(DE_LENGTH_OF_ARRAY(testBuffer.buffer), DE_NULL);
 448                 testBuffer.fill         = deSemaphore_create(0, DE_NULL);
 449
 450                 DE_TEST_ASSERT(testBuffer.empty && testBuffer.fill);
 451
 452                 consumer        = deThread_create(consumerThread, &testBuffer, DE_NULL);
 453                 producer        = deThread_create(producerThread, &testBuffer, DE_NULL);
 454
 455                 DE_TEST_ASSERT(consumer && producer);
 456
 457                 ret = deThread_join(consumer) &&
 458                           deThread_join(producer);
 459                 DE_TEST_ASSERT(ret);
 460
 461                 deThread_destroy(producer);
 462                 deThread_destroy(consumer);
 463
 464                 deSemaphore_destroy(testBuffer.empty);
 465                 deSemaphore_destroy(testBuffer.fill);
 466                 DE_TEST_ASSERT(testBuffer.producerHash == testBuffer.consumerHash);
 467         }
 468 }
 469
 470 void deAtomic_selfTest (void)
 471 {
 472         /* Single-threaded tests. */
 473         {
 474                 volatile deInt32 a = 11;
 475                 DE_TEST_ASSERT(deAtomicIncrementInt32(&a) == 12);
 476                 DE_TEST_ASSERT(a == 12);
 477                 DE_TEST_ASSERT(deAtomicIncrementInt32(&a) == 13);
 478                 DE_TEST_ASSERT(a == 13);
 479
 480                 a = -2;
 481                 DE_TEST_ASSERT(deAtomicIncrementInt32(&a) == -1);
 482                 DE_TEST_ASSERT(a == -1);
 483                 DE_TEST_ASSERT(deAtomicIncrementInt32(&a) == 0);
 484                 DE_TEST_ASSERT(a == 0);
 485
 486                 a = 11;
 487                 DE_TEST_ASSERT(deAtomicDecrementInt32(&a) == 10);
 488                 DE_TEST_ASSERT(a == 10);
 489                 DE_TEST_ASSERT(deAtomicDecrementInt32(&a) == 9);
 490                 DE_TEST_ASSERT(a == 9);
 491
 492                 a = 0;
 493                 DE_TEST_ASSERT(deAtomicDecrementInt32(&a) == -1);
 494                 DE_TEST_ASSERT(a == -1);
 495                 DE_TEST_ASSERT(deAtomicDecrementInt32(&a) == -2);
 496                 DE_TEST_ASSERT(a == -2);
 497
 498                 a = 0x7fffffff;
 499                 DE_TEST_ASSERT(deAtomicIncrementInt32(&a) == (int)0x80000000);
 500                 DE_TEST_ASSERT(a == (int)0x80000000);
 501                 DE_TEST_ASSERT(deAtomicDecrementInt32(&a) == (int)0x7fffffff);
 502                 DE_TEST_ASSERT(a == 0x7fffffff);
 503         }
 504
 505         {
 506                 volatile deUint32 a = 11;
 507                 DE_TEST_ASSERT(deAtomicIncrementUint32(&a) == 12);
 508                 DE_TEST_ASSERT(a == 12);
 509                 DE_TEST_ASSERT(deAtomicIncrementUint32(&a) == 13);
 510                 DE_TEST_ASSERT(a == 13);
 511
 512                 a = 0x7fffffff;
 513                 DE_TEST_ASSERT(deAtomicIncrementUint32(&a) == 0x80000000);
 514                 DE_TEST_ASSERT(a == 0x80000000);
 515                 DE_TEST_ASSERT(deAtomicDecrementUint32(&a) == 0x7fffffff);
 516                 DE_TEST_ASSERT(a == 0x7fffffff);
 517
 518                 a = 0xfffffffe;
 519                 DE_TEST_ASSERT(deAtomicIncrementUint32(&a) == 0xffffffff);
 520                 DE_TEST_ASSERT(a == 0xffffffff);
 521                 DE_TEST_ASSERT(deAtomicDecrementUint32(&a) == 0xfffffffe);
 522                 DE_TEST_ASSERT(a == 0xfffffffe);
 523         }
 524
 525         {
 526                 volatile deUint32 p;
 527
 528                 p = 0;
 529                 DE_TEST_ASSERT(deAtomicCompareExchange32(&p, 0, 1) == 0);
 530                 DE_TEST_ASSERT(p == 1);
 531
 532                 DE_TEST_ASSERT(deAtomicCompareExchange32(&p, 0, 2) == 1);
 533                 DE_TEST_ASSERT(p == 1);
 534
 535                 p = 7;
 536                 DE_TEST_ASSERT(deAtomicCompareExchange32(&p, 6, 8) == 7);
 537                 DE_TEST_ASSERT(p == 7);
 538
 539                 DE_TEST_ASSERT(deAtomicCompareExchange32(&p, 7, 8) == 7);
 540                 DE_TEST_ASSERT(p == 8);
 541         }
 542
 543 #if (DE_PTR_SIZE == 8)
 544         {
 545                 volatile deInt64 a = 11;
 546                 DE_TEST_ASSERT(deAtomicIncrementInt64(&a) == 12);
 547                 DE_TEST_ASSERT(a == 12);
 548                 DE_TEST_ASSERT(deAtomicIncrementInt64(&a) == 13);
 549                 DE_TEST_ASSERT(a == 13);
 550
 551                 a = -2;
 552                 DE_TEST_ASSERT(deAtomicIncrementInt64(&a) == -1);
 553                 DE_TEST_ASSERT(a == -1);
 554                 DE_TEST_ASSERT(deAtomicIncrementInt64(&a) == 0);
 555                 DE_TEST_ASSERT(a == 0);
 556
 557                 a = 11;
 558                 DE_TEST_ASSERT(deAtomicDecrementInt64(&a) == 10);
 559                 DE_TEST_ASSERT(a == 10);
 560                 DE_TEST_ASSERT(deAtomicDecrementInt64(&a) == 9);
 561                 DE_TEST_ASSERT(a == 9);
 562
 563                 a = 0;
 564                 DE_TEST_ASSERT(deAtomicDecrementInt64(&a) == -1);
 565                 DE_TEST_ASSERT(a == -1);
 566                 DE_TEST_ASSERT(deAtomicDecrementInt64(&a) == -2);
 567                 DE_TEST_ASSERT(a == -2);
 568
 569                 a = (deInt64)((1ull << 63) - 1ull);
 570                 DE_TEST_ASSERT(deAtomicIncrementInt64(&a) == (deInt64)(1ull << 63));
 571                 DE_TEST_ASSERT(a == (deInt64)(1ull << 63));
 572                 DE_TEST_ASSERT(deAtomicDecrementInt64(&a) == (deInt64)((1ull << 63) - 1));
 573                 DE_TEST_ASSERT(a == (deInt64)((1ull << 63) - 1));
 574         }
 575 #endif /* (DE_PTR_SIZE == 8) */
 576
 577         /* \todo [2012-10-26 pyry] Implement multi-threaded tests. */
 578 }
 579
 580 /* Singleton self-test. */
 581
 582 DE_DECLARE_POOL_ARRAY(deThreadArray, deThread);
 583
 584 static volatile deSingletonState        s_testSingleton                         = DE_SINGLETON_STATE_NOT_INITIALIZED;
 585 static volatile int                                     s_testSingletonInitCount        = 0;
 586 static deBool                                           s_testSingletonInitialized      = DE_FALSE;
 587 static volatile deBool                          s_singletonInitLock                     = DE_FALSE;
 588
 589 static void waitForSingletonInitLock (void)
 590 {
 591         for (;;)
 592         {
 593                 deMemoryReadWriteFence();
 594
 595                 if (s_singletonInitLock)
 596                         break;
 597         }
 598 }
 599
 600 static void initTestSingleton (void* arg)
 601 {
 602         int initTimeMs = *(const int*)arg;
 603
 604         if (initTimeMs >= 0)
 605                 deSleep((deUint32)initTimeMs);
 606
 607         deAtomicIncrement32(&s_testSingletonInitCount);
 608         s_testSingletonInitialized = DE_TRUE;
 609 }
 610
 611 static void singletonTestThread (void* arg)
 612 {
 613         waitForSingletonInitLock();
 614
 615         deInitSingleton(&s_testSingleton, initTestSingleton, arg);
 616         DE_TEST_ASSERT(s_testSingletonInitialized);
 617 }
 618
 619 static void resetTestState (void)
 620 {
 621         s_testSingleton                         = DE_SINGLETON_STATE_NOT_INITIALIZED;
 622         s_testSingletonInitCount        = 0;
 623         s_testSingletonInitialized      = DE_FALSE;
 624         s_singletonInitLock                     = DE_FALSE;
 625 }
 626
 627 static void runSingletonThreadedTest (int numThreads, int initTimeMs)
 628 {
 629         deMemPool*              tmpPool         = deMemPool_createRoot(DE_NULL, 0);
 630         deThreadArray*  threads         = tmpPool ? deThreadArray_create(tmpPool) : DE_NULL;
 631         int                             threadNdx;
 632
 633         resetTestState();
 634
 635         for (threadNdx = 0; threadNdx < numThreads; threadNdx++)
 636         {
 637                 deThread thread = deThread_create(singletonTestThread, &initTimeMs, DE_NULL);
 638                 DE_TEST_ASSERT(thread);
 639                 DE_TEST_ASSERT(deThreadArray_pushBack(threads, thread));
 640         }
 641
 642         /* All threads created - let them do initialization. */
 643         deMemoryReadWriteFence();
 644         s_singletonInitLock = DE_TRUE;
 645         deMemoryReadWriteFence();
 646
 647         for (threadNdx = 0; threadNdx < numThreads; threadNdx++)
 648         {
 649                 deThread thread = deThreadArray_get(threads, threadNdx);
 650                 DE_TEST_ASSERT(deThread_join(thread));
 651                 deThread_destroy(thread);
 652         }
 653
 654         /* Verify results. */
 655         DE_TEST_ASSERT(s_testSingletonInitialized);
 656         DE_TEST_ASSERT(s_testSingletonInitCount == 1);
 657
 658         deMemPool_destroy(tmpPool);
 659 }
 660
 661 void deSingleton_selfTest (void)
 662 {
 663         const struct
 664         {
 665                 int             numThreads;
 666                 int             initTimeMs;
 667                 int             repeatCount;
 668         } cases[] =
 669         {
 670         /*      #threads        time    #repeat */
 671                 { 1,            -1,             5       },
 672                 { 1,            1,              5       },
 673                 { 2,            -1,             20      },
 674                 { 2,            1,              20      },
 675                 { 4,            -1,             20      },
 676                 { 4,            1,              20      },
 677                 { 4,            5,              20      }
 678         };
 679         int caseNdx;
 680
 681         for (caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); caseNdx++)
 682         {
 683                 int             numThreads              = cases[caseNdx].numThreads;
 684                 int             initTimeMs              = cases[caseNdx].initTimeMs;
 685                 int             repeatCount             = cases[caseNdx].repeatCount;
 686                 int             subCaseNdx;
 687
 688                 for (subCaseNdx = 0; subCaseNdx < repeatCount; subCaseNdx++)
 689                         runSingletonThreadedTest(numThreads, initTimeMs);
 690         }
 691 }