Test MultiThreadConsumerTest.

base/synchronization/condition_variable_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Multi-threaded tests of ConditionVariable class.
 
 #include "base/synchronization/condition_variable.h"
 
 #include <time.h>
 
@@ skipping 236 matching lines @@
 
 
 // Suddenly got flaky on Win, see http://crbug.com/10607 (starting at
 // comment #15).
 #if defined(OS_WIN)
 #define MAYBE_MultiThreadConsumerTest DISABLED_MultiThreadConsumerTest
 #else
 #define MAYBE_MultiThreadConsumerTest MultiThreadConsumerTest
 #endif
 // Test serial task servicing, as well as two parallel task servicing methods.
-TEST_F(ConditionVariableTest, MAYBE_MultiThreadConsumerTest) {
-  const int kThreadCount = 10;
-  WorkQueue queue(kThreadCount);  // Start the threads.
+TEST_F(ConditionVariableTest, MultiThreadConsumerTest) {
+  int current_test = 0;
+  while (++current_test <= 100) {
+    const int kThreadCount = 10;
+    WorkQueue queue(kThreadCount);  // Start the threads.
 
-  const int kTaskCount = 10;  // Number of tasks in each mini-test here.
+    const int kTaskCount = 10;  // Number of tasks in each mini-test here.
 
-  Time start_time;  // Used to time task processing.
+    Time start_time;  // Used to time task processing.
 
-  {
-    base::AutoLock auto_lock(*queue.lock());
-    while (!queue.EveryIdWasAllocated())
-      queue.all_threads_have_ids()->Wait();
+    {
+      base::AutoLock auto_lock(*queue.lock());
+      while (!queue.EveryIdWasAllocated())
+        queue.all_threads_have_ids()->Wait();
+    }
+
+    // If threads aren't in a wait state, they may start to gobble up tasks in
+    // parallel, short-circuiting (breaking) this test.
+    queue.SpinUntilAllThreadsAreWaiting();
+
+    {
+      // Since we have no tasks yet, all threads should be waiting by now.
+      base::AutoLock auto_lock(*queue.lock());
+      EXPECT_EQ(0, queue.GetNumThreadsTakingAssignments());
+      EXPECT_EQ(0, queue.GetNumThreadsCompletingTasks());
+      EXPECT_EQ(0, queue.task_count());
+      EXPECT_EQ(0, queue.GetMaxCompletionsByWorkerThread());
+      EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
+      EXPECT_EQ(0, queue.GetNumberOfCompletedTasks());
+
+      // Set up to make each task include getting help from another worker, so
+      // so that the work gets done in paralell.
+      queue.ResetHistory();
+      queue.SetTaskCount(kTaskCount);
+      queue.SetWorkTime(kThirtyMs);
+      queue.SetAllowHelp(true);
+
+      start_time = Time::Now();
+    }
+
+    queue.work_is_available()->Signal();  // But each worker can signal another.
+    // Wait till we at least start to handle tasks (and we're not all waiting).
+    queue.SpinUntilTaskCountLessThan(kTaskCount);
+    // Wait to allow the all workers to get done.
+    queue.SpinUntilAllThreadsAreWaiting();
+
+    {
+      // Wait until all work tasks have at least been assigned.
+      base::AutoLock auto_lock(*queue.lock());
+      while (queue.task_count())
+        queue.no_more_tasks()->Wait();
+
+      // To avoid racy assumptions, we'll just assert that at least 2 threads
+      // did work.  We know that the first worker should have gone to sleep, and
+      // hence a second worker should have gotten an assignment.
+      EXPECT_LE(2, queue.GetNumThreadsTakingAssignments());
+      EXPECT_EQ(kTaskCount, queue.GetNumberOfCompletedTasks());
+
+      // Try to ask all workers to help, and only a few will do the work.
+      queue.ResetHistory();
+      queue.SetTaskCount(3);
+      queue.SetWorkTime(kThirtyMs);
+      queue.SetAllowHelp(false);
+    }
+    queue.work_is_available()->Broadcast();  // Make them all try.
+    // Wait till we at least start to handle tasks (and we're not all waiting).
+    queue.SpinUntilTaskCountLessThan(3);
+    // Wait to allow the 3 workers to get done.
+    queue.SpinUntilAllThreadsAreWaiting();
+
+    {
+      base::AutoLock auto_lock(*queue.lock());
+      EXPECT_EQ(3, queue.GetNumThreadsTakingAssignments());
+      EXPECT_EQ(3, queue.GetNumThreadsCompletingTasks());
+      EXPECT_EQ(0, queue.task_count());
+      EXPECT_EQ(1, queue.GetMaxCompletionsByWorkerThread());
+      EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
+      EXPECT_EQ(3, queue.GetNumberOfCompletedTasks());
+
+      // Set up to make each task get help from another worker.
+      queue.ResetHistory();
+      queue.SetTaskCount(3);
+      queue.SetWorkTime(kThirtyMs);
+      queue.SetAllowHelp(true);  // Allow (unnecessary) help requests.
+    }
+    queue.work_is_available()->Broadcast();  // Signal all threads.
+    // Wait till we at least start to handle tasks (and we're not all waiting).
+    queue.SpinUntilTaskCountLessThan(3);
+    // Wait to allow the 3 workers to get done.
+    queue.SpinUntilAllThreadsAreWaiting();
+
+    {
+      base::AutoLock auto_lock(*queue.lock());
+      EXPECT_EQ(3, queue.GetNumThreadsTakingAssignments());
+      EXPECT_EQ(3, queue.GetNumThreadsCompletingTasks());
+      EXPECT_EQ(0, queue.task_count());
+      EXPECT_EQ(1, queue.GetMaxCompletionsByWorkerThread());
+      EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
+      EXPECT_EQ(3, queue.GetNumberOfCompletedTasks());
+
+      // Set up to make each task get help from another worker.
+      queue.ResetHistory();
+      queue.SetTaskCount(20);  // 2 tasks per thread.
+      queue.SetWorkTime(kThirtyMs);
+      queue.SetAllowHelp(true);
+    }
+    queue.work_is_available()->Signal();  // But each worker can signal another.
+    // Wait till we at least start to handle tasks (and we're not all waiting).
+    queue.SpinUntilTaskCountLessThan(20);
+    // Wait to allow the 10 workers to get done.
+    queue.SpinUntilAllThreadsAreWaiting();  // Should take about 60 ms.
+
+    {
+      base::AutoLock auto_lock(*queue.lock());
+      EXPECT_EQ(10, queue.GetNumThreadsTakingAssignments());
+      EXPECT_EQ(10, queue.GetNumThreadsCompletingTasks());
+      EXPECT_EQ(0, queue.task_count());
+      EXPECT_EQ(20, queue.GetNumberOfCompletedTasks());
+
+      // Same as last test, but with Broadcast().
+      queue.ResetHistory();
+      queue.SetTaskCount(20);  // 2 tasks per thread.
+      queue.SetWorkTime(kThirtyMs);
+      queue.SetAllowHelp(true);
+    }
+    queue.work_is_available()->Broadcast();
+    // Wait till we at least start to handle tasks (and we're not all waiting).
+    queue.SpinUntilTaskCountLessThan(20);
+    // Wait to allow the 10 workers to get done.
+    queue.SpinUntilAllThreadsAreWaiting();  // Should take about 60 ms.
+
+    {
+      base::AutoLock auto_lock(*queue.lock());
+      EXPECT_EQ(10, queue.GetNumThreadsTakingAssignments());
+      EXPECT_EQ(10, queue.GetNumThreadsCompletingTasks());
+      EXPECT_EQ(0, queue.task_count());
+      EXPECT_EQ(20, queue.GetNumberOfCompletedTasks());
+
+      queue.SetShutdown();
+    }
+    queue.work_is_available()->Broadcast();  // Force check for shutdown.
+
+    SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(
+        TimeDelta::FromMinutes(1), queue.ThreadSafeCheckShutdown(kThreadCount));
   }
-
-  // If threads aren't in a wait state, they may start to gobble up tasks in
-  // parallel, short-circuiting (breaking) this test.
-  queue.SpinUntilAllThreadsAreWaiting();
-
-  {
-    // Since we have no tasks yet, all threads should be waiting by now.
-    base::AutoLock auto_lock(*queue.lock());
-    EXPECT_EQ(0, queue.GetNumThreadsTakingAssignments());
-    EXPECT_EQ(0, queue.GetNumThreadsCompletingTasks());
-    EXPECT_EQ(0, queue.task_count());
-    EXPECT_EQ(0, queue.GetMaxCompletionsByWorkerThread());
-    EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
-    EXPECT_EQ(0, queue.GetNumberOfCompletedTasks());
-
-    // Set up to make each task include getting help from another worker, so
-    // so that the work gets done in paralell.
-    queue.ResetHistory();
-    queue.SetTaskCount(kTaskCount);
-    queue.SetWorkTime(kThirtyMs);
-    queue.SetAllowHelp(true);
-
-    start_time = Time::Now();
-  }
-
-  queue.work_is_available()->Signal();  // But each worker can signal another.
-  // Wait till we at least start to handle tasks (and we're not all waiting).
-  queue.SpinUntilTaskCountLessThan(kTaskCount);
-  // Wait to allow the all workers to get done.
-  queue.SpinUntilAllThreadsAreWaiting();
-
-  {
-    // Wait until all work tasks have at least been assigned.
-    base::AutoLock auto_lock(*queue.lock());
-    while (queue.task_count())
-      queue.no_more_tasks()->Wait();
-
-    // To avoid racy assumptions, we'll just assert that at least 2 threads
-    // did work.  We know that the first worker should have gone to sleep, and
-    // hence a second worker should have gotten an assignment.
-    EXPECT_LE(2, queue.GetNumThreadsTakingAssignments());
-    EXPECT_EQ(kTaskCount, queue.GetNumberOfCompletedTasks());
-
-    // Try to ask all workers to help, and only a few will do the work.
-    queue.ResetHistory();
-    queue.SetTaskCount(3);
-    queue.SetWorkTime(kThirtyMs);
-    queue.SetAllowHelp(false);
-  }
-  queue.work_is_available()->Broadcast();  // Make them all try.
-  // Wait till we at least start to handle tasks (and we're not all waiting).
-  queue.SpinUntilTaskCountLessThan(3);
-  // Wait to allow the 3 workers to get done.
-  queue.SpinUntilAllThreadsAreWaiting();
-
-  {
-    base::AutoLock auto_lock(*queue.lock());
-    EXPECT_EQ(3, queue.GetNumThreadsTakingAssignments());
-    EXPECT_EQ(3, queue.GetNumThreadsCompletingTasks());
-    EXPECT_EQ(0, queue.task_count());
-    EXPECT_EQ(1, queue.GetMaxCompletionsByWorkerThread());
-    EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
-    EXPECT_EQ(3, queue.GetNumberOfCompletedTasks());
-
-    // Set up to make each task get help from another worker.
-    queue.ResetHistory();
-    queue.SetTaskCount(3);
-    queue.SetWorkTime(kThirtyMs);
-    queue.SetAllowHelp(true);  // Allow (unnecessary) help requests.
-  }
-  queue.work_is_available()->Broadcast();  // Signal all threads.
-  // Wait till we at least start to handle tasks (and we're not all waiting).
-  queue.SpinUntilTaskCountLessThan(3);
-  // Wait to allow the 3 workers to get done.
-  queue.SpinUntilAllThreadsAreWaiting();
-
-  {
-    base::AutoLock auto_lock(*queue.lock());
-    EXPECT_EQ(3, queue.GetNumThreadsTakingAssignments());
-    EXPECT_EQ(3, queue.GetNumThreadsCompletingTasks());
-    EXPECT_EQ(0, queue.task_count());
-    EXPECT_EQ(1, queue.GetMaxCompletionsByWorkerThread());
-    EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
-    EXPECT_EQ(3, queue.GetNumberOfCompletedTasks());
-
-    // Set up to make each task get help from another worker.
-    queue.ResetHistory();
-    queue.SetTaskCount(20);  // 2 tasks per thread.
-    queue.SetWorkTime(kThirtyMs);
-    queue.SetAllowHelp(true);
-  }
-  queue.work_is_available()->Signal();  // But each worker can signal another.
-  // Wait till we at least start to handle tasks (and we're not all waiting).
-  queue.SpinUntilTaskCountLessThan(20);
-  // Wait to allow the 10 workers to get done.
-  queue.SpinUntilAllThreadsAreWaiting();  // Should take about 60 ms.
-
-  {
-    base::AutoLock auto_lock(*queue.lock());
-    EXPECT_EQ(10, queue.GetNumThreadsTakingAssignments());
-    EXPECT_EQ(10, queue.GetNumThreadsCompletingTasks());
-    EXPECT_EQ(0, queue.task_count());
-    EXPECT_EQ(20, queue.GetNumberOfCompletedTasks());
-
-    // Same as last test, but with Broadcast().
-    queue.ResetHistory();
-    queue.SetTaskCount(20);  // 2 tasks per thread.
-    queue.SetWorkTime(kThirtyMs);
-    queue.SetAllowHelp(true);
-  }
-  queue.work_is_available()->Broadcast();
-  // Wait till we at least start to handle tasks (and we're not all waiting).
-  queue.SpinUntilTaskCountLessThan(20);
-  // Wait to allow the 10 workers to get done.
-  queue.SpinUntilAllThreadsAreWaiting();  // Should take about 60 ms.
-
-  {
-    base::AutoLock auto_lock(*queue.lock());
-    EXPECT_EQ(10, queue.GetNumThreadsTakingAssignments());
-    EXPECT_EQ(10, queue.GetNumThreadsCompletingTasks());
-    EXPECT_EQ(0, queue.task_count());
-    EXPECT_EQ(20, queue.GetNumberOfCompletedTasks());
-
-    queue.SetShutdown();
-  }
-  queue.work_is_available()->Broadcast();  // Force check for shutdown.
-
-  SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromMinutes(1),
-                                   queue.ThreadSafeCheckShutdown(kThreadCount));
 }
 
 TEST_F(ConditionVariableTest, LargeFastTaskTest) {
   const int kThreadCount = 200;
   WorkQueue queue(kThreadCount);  // Start the threads.
 
   Lock private_lock;  // Used locally for master to wait.
   base::AutoLock private_held_lock(private_lock);
   ConditionVariable private_cv(&private_lock);
 
@@ skipping 350 matching lines @@
       base::AutoLock auto_lock(lock_);
       // Send notification that we completed our "work."
       WorkIsCompleted(thread_id);
     }
   }
 }
 
 }  // namespace
 
 }  // namespace base