- Implement Isolate.pause and Isolate.resume.

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 "lib/mirrors.h"
@@ skipping 65 matching lines @@
 #if defined(DEBUG)
   // Check that it is safe to access this handler.
   void CheckAccess();
 #endif
   bool IsCurrentIsolate() const;
   virtual Isolate* isolate() const { return isolate_; }
   bool UnhandledExceptionCallbackHandler(const Object& message,
                                          const UnhandledException& error);
 
  private:
+  // Keep in sync with isolate_patch.dart.
+  enum {
+    kPauseMsg = 1,
+    kResumeMsg
+  };
+
+  void HandleLibMessage(const Array& message);
   bool ProcessUnhandledException(const Object& message, const Error& result);
   RawFunction* ResolveCallbackFunction();
   Isolate* isolate_;
 };
 
 
 IsolateMessageHandler::IsolateMessageHandler(Isolate* isolate)
     : isolate_(isolate) {
 }
 
 
 IsolateMessageHandler::~IsolateMessageHandler() {
 }
 
 const char* IsolateMessageHandler::name() const {
   return isolate_->name();
 }
 
 
+void IsolateMessageHandler::HandleLibMessage(const Array& message) {

[siva, 2014/07/01 21:42:56]

Would be good to document the message formats here, e.g:
Messages handled have the following format:

Pause an isolate => unused, kPauseMsg, pauseCapability, resumeCapability
Resume an isolate => unused, kResumeMsg, pauseCapability, resumeCapability

[Ivan Posva, 2014/07/03 12:51:16]

Done.

+  if (message.Length() < 2) return;
+  const Object& type = Object::Handle(I, message.At(1));
+  if (!type.IsSmi()) return;
+  const Smi& msg_type = Smi::Cast(type);
+  switch (msg_type.Value()) {
+    case kPauseMsg: {
+      if (message.Length() != 4) return;
+      Object& obj = Object::Handle(I, message.At(2));
+      if (!obj.IsCapability()) return;
+      if (!I->VerifyPauseCapability(Capability::Cast(obj))) return;
+      obj = message.At(3);
+      if (!obj.IsCapability()) return;
+      if (I->AddPauseCapability(Capability::Cast(obj))) {
+        increment_paused();
+      }
+      break;
+    }
+    case kResumeMsg: {
+      if (message.Length() != 4) return;
+      Object& obj = Object::Handle(I, message.At(2));
+      if (!obj.IsCapability()) return;
+      if (!I->VerifyPauseCapability(Capability::Cast(obj))) return;
+      obj = message.At(3);
+      if (!obj.IsCapability()) return;
+      if (I->RemovePauseCapability(Capability::Cast(obj))) {
+        decrement_paused();
+      }
+      break;
+    }
+#if DEBUG

[siva, 2014/07/01 21:42:56]

#if defined(DEBUG) to be consistent.

[Ivan Posva, 2014/07/03 12:51:16]

Done.

+    // Malformed OOB messages are silently ignored in release builds.
+    default:
+      UNREACHABLE();
+      break;
+#endif  // DEBUG
+  }
+}
+
+
 void IsolateMessageHandler::MessageNotify(Message::Priority priority) {
   if (priority >= Message::kOOBPriority) {
     // Handle out of band messages even if the isolate is busy.
     I->ScheduleInterrupts(Isolate::kMessageInterrupt);
   }
   Dart_MessageNotifyCallback callback = I->message_notify_callback();
   if (callback) {
     // Allow the embedder to handle message notification.
     (*callback)(Api::CastIsolate(I));
   }
 }
 
 
 bool IsolateMessageHandler::HandleMessage(Message* message) {
   StartIsolateScope start_scope(I);
   StackZone zone(I);
   HandleScope handle_scope(I);
   // TODO(turnidge): Rework collection total dart execution.  This can
   // overcount when other things (gc, compilation) are active.
   TIMERSCOPE(isolate_, time_dart_execution);
 
   // If the message is in band we lookup the handler to dispatch to.  If the
   // receive port was closed, we drop the message without deserializing it.
   Object& msg_handler = Object::Handle(I);
   if (!message->IsOOB()) {
     msg_handler = DartLibraryCalls::LookupHandler(message->dest_port());
     if (msg_handler.IsError()) {
+      delete message;
       return ProcessUnhandledException(Object::null_instance(),
                                        Error::Cast(msg_handler));
     }
     if (msg_handler.IsNull()) {
       // If the port has been closed then the message will be dropped at this
       // point. Make sure to post to the delivery failure port in that case.
       if (message->RedirectToDeliveryFailurePort()) {
         PortMap::PostMessage(message);
       } else {
         delete message;
       }
       return true;
     }
   }
 
   // Parse the message.
   SnapshotReader reader(message->data(), message->len(), Snapshot::kMessage, I);
   const Object& msg_obj = Object::Handle(I, reader.ReadObject());
   if (msg_obj.IsError()) {
     // An error occurred while reading the message.
+    delete message;
     return ProcessUnhandledException(Object::null_instance(),
                                      Error::Cast(msg_obj));
   }
   if (!msg_obj.IsNull() && !msg_obj.IsInstance()) {
     // TODO(turnidge): We need to decide what an isolate does with
     // malformed messages.  If they (eventually) come from a remote
     // machine, then it might make sense to drop the message entirely.
     // In the case that the message originated locally, which is
     // always true for now, then this should never occur.
     UNREACHABLE();
   }
 
   Instance& msg = Instance::Handle(I);
   msg ^= msg_obj.raw();  // Can't use Instance::Cast because may be null.
 
   bool success = true;
   if (message->IsOOB()) {
-    ASSERT(msg.IsArray());
-    const Object& oob_tag = Object::Handle(I, Array::Cast(msg).At(0));
-    ASSERT(oob_tag.IsSmi());
-    switch (Smi::Cast(oob_tag).Value()) {
-      case Message::kServiceOOBMsg: {
-        Service::HandleIsolateMessage(I, msg);
-        break;
-      }
-      default: {
-        UNREACHABLE();
-        break;
+    // OOB messages are expected to be fixed length arrays where the first
+    // element is a Smi describing the OOB destination. Messages that do not
+    // confirm to this layout are silently ignored.
+    if (msg.IsArray()) {
+      const Array& oob_msg = Array::Cast(msg);
+      if (oob_msg.Length() > 0) {
+        const Object& oob_tag = Object::Handle(I, oob_msg.At(0));
+        if (oob_tag.IsSmi()) {
+          switch (Smi::Cast(oob_tag).Value()) {
+            case Message::kServiceOOBMsg: {
+              Service::HandleIsolateMessage(I, oob_msg);
+              break;
+            }
+            case Message::kIsolateLibOOBMsg: {
+              HandleLibMessage(oob_msg);
+              break;
+            }
+#if DEBUG

[siva, 2014/07/01 21:42:56]

Ditto.

[Ivan Posva, 2014/07/03 12:51:16]

Done.

+            // Malformed OOB messages are silently ignored in release builds.
+            default: {
+              UNREACHABLE();
+              break;
+            }
+#endif  // DEBUG
+          }
+        }
       }
     }
   } else {
     const Object& result = Object::Handle(I,
         DartLibraryCalls::HandleMessage(msg_handler, msg));
     if (result.IsError()) {
       success = ProcessUnhandledException(msg, Error::Cast(result));
     } else {
       ASSERT(result.IsNull());
     }
@@ skipping 123 matching lines @@
 
 #define REUSABLE_HANDLE_INITIALIZERS(object)                                   \
   object##_handle_(NULL),
 
 Isolate::Isolate()
     : store_buffer_(),
       message_notify_callback_(NULL),
       name_(NULL),
       start_time_(OS::GetCurrentTimeMicros()),
       main_port_(0),
+      pause_capability_(0),
+      terminate_capability_(0),
       heap_(NULL),
       object_store_(NULL),
       top_context_(Context::null()),
       top_exit_frame_info_(0),
       init_callback_data_(NULL),
       environment_callback_(NULL),
       library_tag_handler_(NULL),
       api_state_(NULL),
       stub_code_(NULL),
       debugger_(NULL),
@@ skipping 123 matching lines @@
   ApiState* state = new ApiState();
   ASSERT(state != NULL);
   result->set_api_state(state);
 
   // Initialize stack top and limit in case we are running the isolate in the
   // main thread.
   // TODO(5411455): Need to figure out how to set the stack limit for the
   // main thread.
   result->SetStackLimitFromCurrentTOS(reinterpret_cast<uword>(&result));
   result->set_main_port(PortMap::CreatePort(result->message_handler()));
+  result->set_pause_capability(result->random()->NextUInt64());
+  result->set_terminate_capability(result->random()->NextUInt64());
+
   result->BuildName(name_prefix);
 
   result->debugger_ = new Debugger();
   result->debugger_->Initialize(result);
   if (FLAG_trace_isolates) {
     if (name_prefix == NULL || strcmp(name_prefix, "vm-isolate") != 0) {
       OS::Print("[+] Starting isolate:\n"
                 "\tisolate:    %s\n", result->name());
     }
   }
@@ skipping 110 matching lines @@
   IsolateSpawnState* state = spawn_state();
   if (state != NULL) {
     ASSERT(this == state->isolate());
     Run();
   }
   mutex_->Unlock();
   return true;
 }
 
 
+bool Isolate::VerifyPauseCapability(const Capability& capability) {
+  return !capability.IsNull() && (pause_capability() == capability.Id());
+}
+
+
+bool Isolate::AddPauseCapability(const Capability& capability) {
+  const GrowableObjectArray& caps = GrowableObjectArray::Handle(
+      this, object_store()->pause_capabilities());
+  Capability& current = Capability::Handle(this);
+  intptr_t insertion_index = -1;
+  for (intptr_t i = 0; i < caps.Length(); i++) {
+    current ^= caps.At(i);
+    if (current.IsNull()) {
+      if (insertion_index < 0) {
+        insertion_index = i;
+      }
+    } else if (current.Id() == capability.Id()) {
+      return false;
+    }
+  }
+  if (insertion_index < 0) {
+    caps.Add(capability);
+  } else {
+    caps.SetAt(insertion_index, capability);
+  }
+  return true;
+}
+
+
+bool Isolate::RemovePauseCapability(const Capability& capability) {
+  const GrowableObjectArray& caps = GrowableObjectArray::Handle(
+       this, object_store()->pause_capabilities());
+  Capability& current = Capability::Handle(this);
+  for (intptr_t i = 0; i < caps.Length(); i++) {
+    current ^= caps.At(i);
+    if (!current.IsNull() && (current.Id() == capability.Id())) {
+      // Remove the matching capability from the list.
+      current = Capability::null();
+      caps.SetAt(i, current);
+      return true;
+    }
+  }
+  return false;
+}
+
+
 static void StoreError(Isolate* isolate, const Object& obj) {
   ASSERT(obj.IsError());
   isolate->object_store()->set_sticky_error(Error::Cast(obj));
 }
 
 
 static bool RunIsolate(uword parameter) {
   Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
   IsolateSpawnState* state = NULL;
   {
@@ skipping 159 matching lines @@
 
 
 class FinalizeWeakPersistentHandlesVisitor : public HandleVisitor {
  public:
   FinalizeWeakPersistentHandlesVisitor() : HandleVisitor(Isolate::Current()) {
   }
 
   void VisitHandle(uword addr) {
     FinalizablePersistentHandle* handle =
         reinterpret_cast<FinalizablePersistentHandle*>(addr);
-    handle->UpdateUnreachable(isolate());
+    handle->UpdateUnreachable(I);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FinalizeWeakPersistentHandlesVisitor);
 };
 
 
 void Isolate::Shutdown() {
   ASSERT(this == Isolate::Current());
   ASSERT(top_resource() == NULL);
@@ skipping 419 matching lines @@
   Library& lib = Library::Handle();
   if (library_url()) {
     const String& lib_url = String::Handle(String::New(library_url()));
     lib = Library::LookupLibrary(lib_url);
     if (lib.IsNull() || lib.IsError()) {
       const String& msg = String::Handle(String::NewFormatted(
           "Unable to find library '%s'.", library_url()));
       return LanguageError::New(msg);
     }
   } else {
-    lib = isolate()->object_store()->root_library();
+    lib = I->object_store()->root_library();
   }
   ASSERT(!lib.IsNull());
 
   // Resolve the function.
   const String& func_name = String::Handle(String::New(function_name()));
 
   if (class_name() == NULL) {
     const Function& func = Function::Handle(lib.LookupLocalFunction(func_name));
     if (func.IsNull()) {
       const String& msg = String::Handle(String::NewFormatted(
@@ skipping 21 matching lines @@
           "Unable to resolve static method '%s.%s' in library '%s'.",
           class_name(), function_name(),
           (library_url() != NULL ? library_url() : script_url())));
     return LanguageError::New(msg);
   }
   return func.raw();
 }
 
 
 void IsolateSpawnState::Cleanup() {
-  SwitchIsolateScope switch_scope(isolate());
+  SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart