- Do not repeatedly allocate and release Monitor objects.

runtime/vm/isolate_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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/globals.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/thread_barrier.h"
@@ skipping 113 matching lines @@
 //
 // Go through a number of rounds of scheduling interrupts and waiting until all
 // unsynchronized busy-waiting tasks observe it (in the current implementation,
 // the exact latency depends on cache coherence). Synchronization is then used
 // to ensure that the response to the interrupt, i.e., starting a new round,
 // happens *after* the interrupt is observed. Without this synchronization, the
 // compiler and/or CPU could reorder operations to make the tasks observe the
 // round update *before* the interrupt is set.
 TEST_CASE(StackLimitInterrupts) {
   Isolate* isolate = Thread::Current()->isolate();
-  ThreadBarrier barrier(InterruptChecker::kTaskCount + 1);
+  ThreadBarrier barrier(InterruptChecker::kTaskCount + 1,
+                        isolate->heap()->barrier(),
+                        isolate->heap()->barrier_done());
   // Start all tasks. They will busy-wait until interrupted in the first round.
   for (intptr_t task = 0; task < InterruptChecker::kTaskCount; task++) {
     Dart::thread_pool()->Run(new InterruptChecker(isolate, &barrier));
   }
   // Wait for all tasks to get ready for the first round.
   barrier.Sync();
   for (intptr_t i = 0; i < InterruptChecker::kIterations; ++i) {
     isolate->ScheduleInterrupts(Isolate::kVMInterrupt);
     // Wait for all tasks to observe the interrupt.
     barrier.Sync();
@@ skipping 97 matching lines @@
   // Restore, then clear interrupts.  The world is as it was.
   interrupt_bits = isolate->GetAndClearInterrupts();
   EXPECT_EQ(kMessageInterrupt, interrupt_bits);
   EXPECT_EQ(IsolateTestHelper::GetStackLimit(isolate),
             IsolateTestHelper::GetSavedStackLimit(isolate));
   EXPECT_EQ(kZero, IsolateTestHelper::GetDeferredInterruptsMask(isolate));
   EXPECT_EQ(kZero, IsolateTestHelper::GetDeferredInterrupts(isolate));
 }
 
 }  // namespace dart