Use a condition variable to control busy threads in dispatch_apply test

The dispatch_apply test sometimes fails in multicore machines.  The
failed function is test_apply_contended which tests if dispatch_apply
can make progress and finish with N concurrent busy threads running,
where N is the number of CPUs.  According to the testing log, it fails
because some busy threads already finish before dispatch_apply() is
invoked.

This happens because the test uses the ITERS_PER_SECOND variable to
control the number of iteration of the loop in the busy thread and
optimistically __hope__ the execution time is long enough to complete
the test. But sometimes this hope fails when the testing machine has
greater computing power and more CPU cores.

Instead of using ITERS_PER_SECOND, which makes an assumption about the
computing power of the test machine, a condition variable is used to
control execution of busy threads. It makes sure the busy thread can
only finish after dispatch_apply completes.

Author: Chun Chen Hsu

tests/dispatch_apply.c

@@ -37,15 +37,7 @@ static volatile int32_t busy_threads_started, busy_threads_finished;
 /*
  * Keep a thread busy, spinning on the CPU.
  */
-#if TARGET_OS_EMBEDDED
-// iPhone 4
-#define ITERS_PER_SECOND 50000000UL
-#elif __s390x__
-#define ITERS_PER_SECOND 15000000000UL
-#else
-// On a 2.7 4-core i5 iMac12,2, one thread of this loop runs at ROUGHLY:
-#define ITERS_PER_SECOND 1000000000UL
-#endif
+static volatile int all_done = 0;
 
 /* Fiddling with j in the middle and hitting this global will hopefully keep
  * the optimizer from cutting the whole thing out as dead code.
@@ -54,14 +46,16 @@ static volatile unsigned int busythread_useless;
 void busythread(void *ignored)
 {
 	(void)ignored;
-	uint64_t i = 0, j = 0;
+	/* prevent i and j been optimized out */
+	volatile uint64_t i = 0, j = 0;
 
 	OSAtomicIncrement32(&busy_threads_started);
 
-	for(i = 0; i < 2*ITERS_PER_SECOND; i++)
+	while(!all_done)
 	{
 		if(i == 500000) { j -= busythread_useless; }
 		j += i;
+		i += 1;
 	}
 
 	OSAtomicIncrement32(&busy_threads_finished);
@@ -109,6 +103,9 @@ void test_apply_contended(dispatch_queue_t dq)
 	test_long("contended: count", count, final);
 	test_long("contended: threads finished before apply", after, 0);
 
+	/* Release busy threads by setting all_done to 1 */
+        all_done = 1;
+
 	dispatch_group_wait(grp, DISPATCH_TIME_FOREVER);
 	dispatch_release(grp);