- Do not repeatedly allocate and release Monitor objects.

runtime/vm/thread_barrier.h

 // Copyright (c) 2015, 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.
 
 #ifndef VM_THREAD_BARRIER_H_
 #define VM_THREAD_BARRIER_H_
 
 #include "vm/globals.h"
 #include "vm/os_thread.h"
 #include "vm/lockers.h"
@@ skipping 28 matching lines @@
 // /* Idle while tasks are working */     fooWork();         barWork();
 // barrier.Sync();                        barrier_->Sync();  barrier_->Sync();
 // collectResultsFromTasks();             barrier_->Exit();  barrier_->Exit();
 // barrier.Exit();
 //
 // Note that the calls to Sync() "line up" in time, but there is no such
 // guarantee for Exit().
 //
 class ThreadBarrier {
  public:
-  explicit ThreadBarrier(intptr_t num_threads)
+  explicit ThreadBarrier(intptr_t num_threads,
+                         Monitor* monitor,
+                         Monitor* done_monitor)
     : num_threads_(num_threads),
+      monitor_(monitor),
       remaining_(num_threads),
       parity_(false),
+      done_monitor_(done_monitor),
       done_(false) {
     ASSERT(remaining_ > 0);
   }
 
   void Sync() {
-    MonitorLocker ml(&monitor_);
+    MonitorLocker ml(monitor_);
     ASSERT(remaining_ > 0);
     if (--remaining_ > 0) {
       // I'm not last to arrive; wait until next round.
       bool old_parity = parity_;
       while (parity_ == old_parity) {
         ml.Wait();
       }
     } else {
       // Last one to arrive initiates the next round.
       remaining_ = num_threads_;
       parity_ = !parity_;
       // Tell everyone else about the new round.
       ml.NotifyAll();
     }
   }
 
   void Exit() {
     bool last = false;
     {
-      MonitorLocker ml(&monitor_);
+      MonitorLocker ml(monitor_);
       ASSERT(remaining_ > 0);
       last = (--remaining_ == 0);
     }
     if (last) {
       // Last one to exit sets done_.
-      MonitorLocker ml(&done_monitor_);
+      MonitorLocker ml(done_monitor_);
       ASSERT(!done_);
       done_ = true;
       // Tell the destructor in case it's already waiting.
       ml.Notify();
     }
   }
 
   ~ThreadBarrier() {
-    MonitorLocker ml(&done_monitor_);
+    MonitorLocker ml(done_monitor_);
     // Wait for everyone to exit before destroying the monitors.
     while (!done_) {
       ml.Wait();
     }
     ASSERT(remaining_ == 0);
   }
 
  private:
   const intptr_t num_threads_;
 
-  Monitor monitor_;
+  Monitor* monitor_;
   intptr_t remaining_;
   bool parity_;
 
-  Monitor done_monitor_;  // TODO(koda): Try to optimize this away.
+  Monitor* done_monitor_;  // TODO(koda): Try to optimize this away.
   bool done_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadBarrier);
 };
 
 }  // namespace dart
 
 #endif  // VM_THREAD_BARRIER_H_