- Account for number of pending tasks in old-space collections.

runtime/vm/isolate.cc

 // Copyright (c) 2013, 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/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "vm/code_observers.h"
@@ skipping 582 matching lines @@
   Simulator* sim = Simulator::Current();  // May allocate a simulator.
   ASSERT(simulator() == sim);  // This isolate's simulator is the current one.
   stack_top_value = sim->StackTop();
   // The overflow area is accounted for by the simulator.
 #endif
   SetStackLimit(stack_top_value - GetSpecifiedStackSize());
 }
 
 
 void Isolate::SetStackLimit(uword limit) {
+  // The isolate setting the stack limit is not necessarily the isolate which
+  // the stack limit is being set on.
   MutexLocker ml(mutex_);
   if (stack_limit_ == saved_stack_limit_) {
     // No interrupt pending, set stack_limit_ too.
     stack_limit_ = limit;
   }
   saved_stack_limit_ = limit;
 }
 
 
 bool Isolate::GetStackBounds(uword* lower, uword* upper) {
   uword stack_lower = stack_limit();
   if (stack_lower == kUwordMax) {
     stack_lower = saved_stack_limit();
   }
   if (stack_lower == kUwordMax) {
     return false;
   }
   uword stack_upper = stack_lower + GetSpecifiedStackSize();
   *lower = stack_lower;
   *upper = stack_upper;
   return true;
 }
 
 
 void Isolate::ScheduleInterrupts(uword interrupt_bits) {
-  // TODO(turnidge): Can't use MutexLocker here because MutexLocker is
-  // a StackResource, which requires a current isolate.  Should
-  // MutexLocker really be a StackResource?
-  mutex_->Lock();
+  MutexLocker ml(mutex_);
   ASSERT((interrupt_bits & ~kInterruptsMask) == 0);  // Must fit in mask.
   if (stack_limit_ == saved_stack_limit_) {
     stack_limit_ = (~static_cast<uword>(0)) & ~kInterruptsMask;
   }
   stack_limit_ |= interrupt_bits;
-  mutex_->Unlock();
 }
 
 
 void Isolate::DoneLoading() {
   GrowableObjectArray& libs =
       GrowableObjectArray::Handle(this, object_store()->libraries());
   Library& lib = Library::Handle(this);
   intptr_t num_libs = libs.Length();
   for (intptr_t i = 0; i < num_libs; i++) {
     lib ^= libs.At(i);
     // If this library was loaded with Dart_LoadLibrary, it was marked
     // as 'load in progres'. Set the status to 'loaded'.
     if (lib.LoadInProgress()) {
       lib.SetLoaded();
     }
   }
 }
 
 
 bool Isolate::MakeRunnable() {
   ASSERT(Isolate::Current() == NULL);
-  // Can't use MutexLocker here because MutexLocker is
-  // a StackResource, which requires a current isolate.
-  mutex_->Lock();
+  MutexLocker ml(mutex_);
   // Check if we are in a valid state to make the isolate runnable.
   if (is_runnable_ == true) {
-    mutex_->Unlock();
     return false;  // Already runnable.
   }
   // Set the isolate as runnable and if we are being spawned schedule
   // isolate on thread pool for execution.
   is_runnable_ = true;
   if (!Service::IsServiceIsolate(this)) {
     message_handler()->set_pause_on_start(FLAG_pause_isolates_on_start);
     message_handler()->set_pause_on_exit(FLAG_pause_isolates_on_exit);
   }
   IsolateSpawnState* state = spawn_state();
   if (state != NULL) {
     ASSERT(this == state->isolate());
     Run();
   }
-  mutex_->Unlock();
   return true;
 }
 
 
 bool Isolate::VerifyPauseCapability(const Capability& capability) const {
   return !capability.IsNull() && (pause_capability() == capability.Id());
 }
 
 
 bool Isolate::AddResumeCapability(const Capability& capability) {
@@ skipping 717 matching lines @@
   return func.raw();
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart