Add support for interrupting an isolate in the vm. Interrupts are

runtime/vm/isolate.cc

 // Copyright (c) 2011, 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 "vm/assert.h"
 #include "vm/bigint_store.h"
@@ skipping 44 matching lines @@
       bigint_store_(NULL),
       top_exit_frame_info_(0),
       init_callback_data_(NULL),
       library_tag_handler_(NULL),
       api_state_(NULL),
       stub_code_(NULL),
       code_index_table_(NULL),
       debugger_(NULL),
       long_jump_base_(NULL),
       timer_list_(),
+      mutex_(new Mutex()),
       stack_limit_(0),
+      saved_stack_limit_(0),
       ast_node_id_(AstNode::kNoId) {
 }
 
 
 Isolate::~Isolate() {
   delete message_queue_;
   delete heap_;
   delete object_store_;
   // Do not delete stack resources: top_resource_ and current_zone_.
   delete bigint_store_;
   delete api_state_;
   delete stub_code_;
   delete code_index_table_;
+  delete mutex_;
+  mutex_ = NULL;  // Fail fast if interrupts are scheduled on a dead isolate.
 }
 
 
 static bool StandardPostMessageCallback(Dart_Isolate dart_isolate,
                                         Dart_Port dest_port,
                                         Dart_Port reply_port,
                                         Dart_Message dart_message) {
   Isolate* isolate = reinterpret_cast<Isolate*>(dart_isolate);
   ASSERT(isolate != NULL);
   PortMessage* message = new PortMessage(dest_port, reply_port, dart_message);
@@ skipping 55 matching lines @@
   uword stack_size = Isolate::kDefaultStackSize - Isolate::kStackSizeBuffer;
   return stack_size;
 }
 
 
 void Isolate::SetStackLimitFromCurrentTOS(uword stack_top_value) {
   SetStackLimit(stack_top_value - GetSpecifiedStackSize());
 }
 
 
 void Isolate::SetStackLimit(uword limit) {

[siva, 2011/12/17 00:05:38]

ASSERT(limit != (~static_cast<uword>(0) & ~kInterruptsMask));

-  stack_limit_ = limit;
+  MutexLocker ml(mutex_);
+  if (stack_limit_ == saved_stack_limit_) {
+    // No interrupt pending, set stack_limit_ too.
+    stack_limit_ = limit;
+  }
+  saved_stack_limit_ = limit;
+}
+
+
+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();
+  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();
+}
+
+
+uword Isolate::GetAndClearInterrupts() {
+  MutexLocker ml(mutex_);
+  if (stack_limit_ == saved_stack_limit_) {
+    return 0;  // No interrupt was requested.
+  }
+  uword interrupt_bits = stack_limit_ & kInterruptsMask;
+  stack_limit_ = saved_stack_limit_;
+  return interrupt_bits;
 }
 
 
 static int MostCalledFunctionFirst(const Function* const* a,
                                    const Function* const* b) {
   if ((*a)->invocation_counter() > (*b)->invocation_counter()) {
     return -1;
   } else if ((*a)->invocation_counter() < (*b)->invocation_counter()) {
     return 1;
   } else {
@@ skipping 58 matching lines @@
     DebugInfo::UnregisterAllSections();
   }
 
   // TODO(5411455): For now just make sure there are no current isolates
   // as we are shutting down the isolate.
   SetCurrent(NULL);
 }
 
 
 Dart_IsolateCreateCallback Isolate::create_callback_ = NULL;
+Dart_IsolateInterruptCallback Isolate::interrupt_callback_ = NULL;
 
 
 void Isolate::SetCreateCallback(Dart_IsolateCreateCallback cb) {
   create_callback_ = cb;
 }
 
 
 Dart_IsolateCreateCallback Isolate::CreateCallback() {
   return create_callback_;
 }
 
 
+void Isolate::SetInterruptCallback(Dart_IsolateInterruptCallback cb) {
+  interrupt_callback_ = cb;
+}
+
+
+Dart_IsolateInterruptCallback Isolate::InterruptCallback() {
+  return interrupt_callback_;
+}
+
+
 static RawInstance* DeserializeMessage(void* data) {
   // Create a snapshot object using the buffer.
   const Snapshot* snapshot = Snapshot::SetupFromBuffer(data);
   ASSERT(snapshot->IsMessageSnapshot());
 
   // Read object back from the snapshot.
   Isolate* isolate = Isolate::Current();
   SnapshotReader reader(snapshot, isolate->heap(), isolate->object_store());
   Instance& instance = Instance::Handle();
   instance ^= reader.ReadObject();
@@ skipping 63 matching lines @@
   }
 
   // Visit the top context which is stored in the isolate.
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&top_context_));
 
   // Visit objects in the debugger.
   debugger()->VisitObjectPointers(visitor);
 }
 
 }  // namespace dart