Revert VM thread cleanup

runtime/vm/thread_pool_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/os.h"
 #include "vm/lockers.h"
 #include "vm/thread_pool.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 DECLARE_FLAG(int, worker_timeout_millis);
 
 
+class ThreadPoolTestPeer {
+ public:
+  // When the pool has an exit monitor, workers notify a monitor just
+  // before they exit.  This is only used in tests to make sure that
+  // Shutdown works.
+  static void SetExitMonitor(Monitor* exit_monitor, int* exit_count) {
+    ThreadPool::exit_monitor_ = exit_monitor;
+    ThreadPool::exit_count_ = exit_count;
+  }
+};
+
+
 UNIT_TEST_CASE(ThreadPool_Create) {
   ThreadPool thread_pool;
 }
 
 
 class TestTask : public ThreadPool::Task {
  public:
   TestTask(Monitor* sync, bool* done)
       : sync_(sync), done_(done) {
   }
@@ skipping 44 matching lines @@
     while (!done[i]) {
       ml.Wait();
     }
     EXPECT(done[i]);
   }
 }
 
 
 class SleepTask : public ThreadPool::Task {
  public:
-  explicit SleepTask(
-      Monitor* sync, int* started_count, int* slept_count, int millis)
-      : sync_(sync),
-        started_count_(started_count),
-        slept_count_(slept_count),
-        millis_(millis) {
+  explicit SleepTask(int millis)
+      : millis_(millis) {
   }
 
   virtual void Run() {
-    {
-      MonitorLocker ml(sync_);
-      *started_count_ = *started_count_ + 1;
-      ml.Notify();
-    }
-    // Sleep so we can be sure the ThreadPool destructor blocks until we're
-    // done.
     OS::Sleep(millis_);
-    {
-      MonitorLocker ml(sync_);
-      *slept_count_ = *slept_count_ + 1;
-      // No notification here. The main thread is blocked in ThreadPool
-      // shutdown waiting for this thread to finish.
-    }
   }
 
  private:
-  Monitor* sync_;
-  int* started_count_;
-  int* slept_count_;
   int millis_;
 };
 
 
 UNIT_TEST_CASE(ThreadPool_WorkerShutdown) {
-  const int kTaskCount = 10;
-  Monitor sync;
-  int slept_count = 0;
-  int started_count = 0;
+  Monitor exit_sync;
+  int exit_count = 0;
+  MonitorLocker ml(&exit_sync);
 
   // Set up the ThreadPool so that workers notify before they exit.
   ThreadPool* thread_pool = new ThreadPool();
+  ThreadPoolTestPeer::SetExitMonitor(&exit_sync, &exit_count);
 
   // Run a single task.
-  for (int i = 0; i < kTaskCount; i++) {
-    thread_pool->Run(new SleepTask(&sync, &started_count, &slept_count, 2));
-  }
+  thread_pool->Run(new SleepTask(2));
 
-  {
-    // Wait for everybody to start.
-    MonitorLocker ml(&sync);
-    while (started_count < kTaskCount) {
-      ml.Wait();
-    }
-  }
-
-  // Kill the thread pool while the workers are sleeping.
+  // Kill the thread pool.
   delete thread_pool;
   thread_pool = NULL;
 
-  int final_count = 0;
-  {
-    MonitorLocker ml(&sync);
-    final_count = slept_count;
+  // Wait for the workers to terminate.
+  while (exit_count == 0) {
+    ml.Wait();
   }
-
-  // We should have waited for all the workers to finish, so they all should
-  // have had a chance to increment slept_count.
-  EXPECT_EQ(kTaskCount, final_count);
+  EXPECT_EQ(1, exit_count);
 }
 
 
 UNIT_TEST_CASE(ThreadPool_WorkerTimeout) {
   // Adjust the worker timeout so that we timeout quickly.
   int saved_timeout = FLAG_worker_timeout_millis;
   FLAG_worker_timeout_millis = 1;
 
   ThreadPool thread_pool;
   EXPECT_EQ(0U, thread_pool.workers_started());
@@ skipping 30 matching lines @@
   SpawnTask(ThreadPool* pool, Monitor* sync, int todo, int total, int* done)
       : pool_(pool), sync_(sync), todo_(todo), total_(total), done_(done) {
   }
 
   virtual void Run() {
     todo_--;  // Subtract one for current task.
     int child_todo = todo_ / 2;
 
     // Spawn 0-2 children.
     if (todo_ > 0) {
-      pool_->Run(new SpawnTask(
-          pool_, sync_, todo_ - child_todo, total_, done_));
+      pool_->Run(
+          new SpawnTask(pool_, sync_, todo_ - child_todo, total_, done_));
     }
     if (todo_ > 1) {
-      pool_->Run(new SpawnTask(pool_, sync_, child_todo, total_, done_));
+      pool_->Run(
+          new SpawnTask(pool_, sync_, child_todo, total_, done_));
     }
 
     {
       MonitorLocker ml(sync_);
       (*done_)++;
       if (*done_ >= total_) {
         ml.Notify();
       }
     }
   }
@@ skipping 16 matching lines @@
       new SpawnTask(&thread_pool, &sync, kTotalTasks, kTotalTasks, &done));
   {
     MonitorLocker ml(&sync);
     while (done < kTotalTasks) {
       ml.Wait();
     }
   }
   EXPECT_EQ(kTotalTasks, done);
 }
 
+
 }  // namespace dart