Implemented more of the Isolate API

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 111 matching lines @@
   bool IsCurrentIsolate() const;
   virtual Isolate* isolate() const { return isolate_; }
 
  private:
   // Keep in sync with isolate_patch.dart.
   enum {
     kPauseMsg = 1,
     kResumeMsg = 2,
     kPingMsg = 3,
     kKillMsg = 4,
+    kAddExitMsg = 5,
+    kDelExitMsg = 6,
+    kAddErrorMsg = 7,
+    kDelErrorMsg = 8,
+    kErrorFatalMsg = 9,
 
     kImmediateAction = 0,
     kBeforeNextEventAction = 1,
     kAsEventAction = 2

[siva, 2015/03/06 23:56:04]

can these be in two enum blocks seems confusing to have two names with the same
values.

[Ivan Posva, 2015/03/07 04:20:39]

Done.

   };
 
   // A result of false indicates that the isolate should terminate the
   // processing of further events.
   bool HandleLibMessage(const Array& message);
 
   bool ProcessUnhandledException(const Error& result);
   Isolate* isolate_;
 };
 
@@ skipping 11 matching lines @@
 }
 
 
 // Isolate library OOB messages are fixed sized arrays which have the
 // following format:
 // [ OOB dispatch, Isolate library dispatch, <message specific data> ]
 bool IsolateMessageHandler::HandleLibMessage(const Array& message) {
   if (message.Length() < 2) return true;
   const Object& type = Object::Handle(I, message.At(1));
   if (!type.IsSmi()) return true;
-  const Smi& msg_type = Smi::Cast(type);
-  switch (msg_type.Value()) {
+  const intptr_t msg_type = Smi::Cast(type).Value();
+  switch (msg_type) {
     case kPauseMsg: {
       // [ OOB, kPauseMsg, pause capability, resume capability ]
       if (message.Length() != 4) return true;
       Object& obj = Object::Handle(I, message.At(2));
       if (!I->VerifyPauseCapability(obj)) return true;
       obj = message.At(3);
       if (!obj.IsCapability()) return true;
       if (I->AddResumeCapability(Capability::Cast(obj))) {
         increment_paused();
       }
@@ skipping 66 matching lines @@
         uint8_t* data = NULL;
         intptr_t len = 0;
         SerializeObject(message, &data, &len, false);
         this->PostMessage(new Message(Message::kIllegalPort,
                                       data, len,
                                       Message::kNormalPriority),
                           priority == kBeforeNextEventAction /* at_head */);
       }
       break;
     }
+    case kAddExitMsg:
+    case kDelExitMsg:
+    case kAddErrorMsg:
+    case kDelErrorMsg: {
+      // [ OOB, msg, listener port ]
+      if (message.Length() != 3) return true;
+      Object& obj = Object::Handle(I, message.At(2));

[siva, 2015/03/06 23:56:04]

const Object& obj = ...;

[Ivan Posva, 2015/03/07 04:20:39]

Done.

+      if (!obj.IsSendPort()) return true;

[siva, 2015/03/06 23:56:04]

Did we change the C++ style here, we always used to have this be written as
if (!obj.IsSendPort()) {
  return true;
}

[Ivan Posva, 2015/03/07 04:20:39]

There are 2628 places in the project that use the single line if-statement where
we are guaranteed not to continue below, because of a break in control flow.

+      const SendPort& listener = SendPort::Cast(obj);
+      switch (msg_type) {
+        case kAddExitMsg:
+          I->AddExitListener(listener);
+          break;
+        case kDelExitMsg:
+          I->RemoveExitListener(listener);
+          break;
+        case kAddErrorMsg:
+          I->AddErrorListener(listener);
+          break;
+        case kDelErrorMsg:
+          I->RemoveErrorListener(listener);
+          break;
+        default:
+          UNREACHABLE();
+      }
+      break;
+    }
+    case kErrorFatalMsg: {
+      // [ OOB, kErrorFatalMsg, terminate capability, val ]
+      if (message.Length() != 4) return true;
+      // Check that the terminate capability has been passed correctly.
+      Object& obj = Object::Handle(I, message.At(2));
+      if (!I->VerifyTerminateCapability(obj)) return true;
+      // Get the value to be set.
+      obj = message.At(3);
+      if (!obj.IsBool()) return true;
+      I->SetErrorsFatal(Bool::Cast(obj).value());
+      break;
+    }
 #if defined(DEBUG)
     // Malformed OOB messages are silently ignored in release builds.
     default:
       UNREACHABLE();
       break;
 #endif  // defined(DEBUG)
   }
   return true;
 }
 
@@ skipping 145 matching lines @@
   }
 
   // Invoke the isolate's unhandled exception callback if there is one.
   if (Isolate::UnhandledExceptionCallback() != NULL) {
     Dart_EnterScope();
     Dart_Handle error = Api::NewHandle(I, result.raw());
     (Isolate::UnhandledExceptionCallback())(error);
     Dart_ExitScope();
   }
 
-  I->object_store()->set_sticky_error(result);
-  return false;
+  // Generate the error and stacktrace strings for the error message.
+  String& exc_str = String::Handle(I);
+  String& stacktrace_str = String::Handle(I);
+  if (result.IsUnhandledException()) {
+    const UnhandledException& uhe = UnhandledException::Cast(result);
+    const Instance& exception = Instance::Handle(I, uhe.exception());
+    Object& tmp = Object::Handle(I);
+    tmp = DartLibraryCalls::ToString(exception);
+    if (!tmp.IsString()) {
+      tmp = String::New(exception.ToCString());
+    }
+    exc_str ^= tmp.raw();
+
+    const Instance& stacktrace = Instance::Handle(I, uhe.stacktrace());
+    tmp = DartLibraryCalls::ToString(stacktrace);
+    if (!tmp.IsString()) {
+      tmp = String::New(stacktrace.ToCString());
+    }
+    stacktrace_str ^= tmp.raw();;
+  } else {
+    exc_str = String::New(result.ToErrorCString());
+  }
+  I->NotifyErrorListeners(exc_str, stacktrace_str);
+
+  if (I->ErrorsFatal()) {
+    I->object_store()->set_sticky_error(result);
+    return false;
+  }
+  return true;
 }
 
 
 #if defined(DEBUG)
 // static
 void BaseIsolate::AssertCurrent(BaseIsolate* isolate) {
   ASSERT(isolate == Isolate::Current());
 }
 #endif  // defined(DEBUG)
 
@@ skipping 10 matching lines @@
 Isolate::Isolate()
     : vm_tag_(0),
       store_buffer_(),
       message_notify_callback_(NULL),
       name_(NULL),
       start_time_(OS::GetCurrentTimeMicros()),
       main_port_(0),
       origin_id_(0),
       pause_capability_(0),
       terminate_capability_(0),
+      errors_fatal_(true),
       heap_(NULL),
       object_store_(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),
       single_step_(false),
@@ skipping 45 matching lines @@
 Isolate::Isolate(Isolate* original)
     : vm_tag_(0),
       store_buffer_(true),
       class_table_(original->class_table()),
       message_notify_callback_(NULL),
       name_(NULL),
       start_time_(OS::GetCurrentTimeMicros()),
       main_port_(0),
       pause_capability_(0),
       terminate_capability_(0),
+      errors_fatal_(true),
       heap_(NULL),
       object_store_(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),
       single_step_(false),
@@ skipping 383 matching lines @@
       // Remove the matching capability from the list.
       current = Capability::null();
       caps.SetAt(i, current);
       return true;
     }
   }
   return false;
 }
 
 
+// TODO(iposva): Remove duplicated code and start using some hash based
+// structure instead of these linear lookups.
+void Isolate::AddExitListener(const SendPort& listener) {
+  // Ensure a limit for the number of listeners remembered.
+  static const intptr_t kMaxListeners = kSmiMax / (6*kWordSize);

[siva, 2015/03/06 23:56:04]

spaces 6 * kWOrdSize

[Ivan Posva, 2015/03/07 04:20:39]

Done.

+
+  const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
+       this, object_store()->exit_listeners());
+  SendPort& current = SendPort::Handle(this);
+  intptr_t insertion_index = -1;
+  for (intptr_t i = 0; i < listeners.Length(); i++) {
+    current ^= listeners.At(i);
+    if (current.IsNull()) {
+      if (insertion_index < 0) {
+        insertion_index = i;
+      }
+    } else if (current.Id() == listener.Id()) {
+      return;
+    }
+  }
+  if (insertion_index < 0) {
+    if (listeners.Length() >= kMaxListeners) {
+      // Cannot grow the array of listeners beyond its max. Additional
+      // listeners are ignored. In practice will never happen as we will
+      // run out of memory beforehand.
+      return;
+    }
+    listeners.Add(listener);
+  } else {
+    listeners.SetAt(insertion_index, listener);
+  }
+}
+
+
+void Isolate::RemoveExitListener(const SendPort& listener) {
+  const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
+      this, object_store()->exit_listeners());
+  SendPort& current = SendPort::Handle(this);
+  for (intptr_t i = 0; i < listeners.Length(); i++) {
+    current ^= listeners.At(i);
+    if (!current.IsNull() && (current.Id() == listener.Id())) {
+      // Remove the matching listener from the list.
+      current = SendPort::null();
+      listeners.SetAt(i, current);
+      return;
+    }
+  }
+}
+
+
+void Isolate::NotifyExitListeners() {
+  const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
+      this, this->object_store()->exit_listeners());
+  SendPort& listener = SendPort::Handle(this);
+  for (intptr_t i = 0; i < listeners.Length(); i++) {
+    listener ^= listeners.At(i);
+    if (!listener.IsNull()) {
+      Dart_Port port_id = listener.Id();
+      uint8_t* data = NULL;
+      intptr_t len = 0;
+      SerializeObject(Object::null_instance(), &data, &len, false);
+      Message* msg = new Message(port_id, data, len, Message::kNormalPriority);
+      PortMap::PostMessage(msg);
+    }
+  }
+}
+
+
+void Isolate::AddErrorListener(const SendPort& listener) {
+  // Ensure a limit for the number of listeners remembered.
+  static const intptr_t kMaxListeners = kSmiMax / (6*kWordSize);
+
+  const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
+      this, object_store()->error_listeners());
+  SendPort& current = SendPort::Handle(this);
+  intptr_t insertion_index = -1;
+  for (intptr_t i = 0; i < listeners.Length(); i++) {
+    current ^= listeners.At(i);
+    if (current.IsNull()) {
+      if (insertion_index < 0) {
+        insertion_index = i;
+      }
+    } else if (current.Id() == listener.Id()) {
+      return;
+    }
+  }
+  if (insertion_index < 0) {
+    if (listeners.Length() >= kMaxListeners) {
+      // Cannot grow the array of listeners beyond its max. Additional
+      // listeners are ignored. In practice will never happen as we will
+      // run out of memory beforehand.
+      return;
+    }
+    listeners.Add(listener);
+  } else {
+    listeners.SetAt(insertion_index, listener);
+  }
+}
+
+
+void Isolate::RemoveErrorListener(const SendPort& listener) {
+  const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
+      this, object_store()->error_listeners());
+  SendPort& current = SendPort::Handle(this);
+  for (intptr_t i = 0; i < listeners.Length(); i++) {
+    current ^= listeners.At(i);
+    if (!current.IsNull() && (current.Id() == listener.Id())) {
+      // Remove the matching listener from the list.
+      current = SendPort::null();
+      listeners.SetAt(i, current);
+      return;
+    }
+  }
+}
+
+
+void Isolate::NotifyErrorListeners(const String& msg,
+                                   const String& stacktrace) {
+  const Array& arr = Array::Handle(this, Array::New(2));
+  arr.SetAt(0, msg);
+  arr.SetAt(1, stacktrace);
+  const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
+      this, this->object_store()->error_listeners());
+  SendPort& listener = SendPort::Handle(this);
+  for (intptr_t i = 0; i < listeners.Length(); i++) {
+    listener ^= listeners.At(i);
+    if (!listener.IsNull()) {
+      Dart_Port port_id = listener.Id();
+      uint8_t* data = NULL;
+      intptr_t len = 0;
+      SerializeObject(arr, &data, &len, false);
+      Message* msg = new Message(port_id, data, len, Message::kNormalPriority);
+      PortMap::PostMessage(msg);
+    }
+  }
+}
+
+
 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 212 matching lines @@
   // Remove this isolate from the list *before* we start tearing it down, to
   // avoid exposing it in a state of decay.
   RemoveIsolateFromList(this);
 
   // Create an area where we do have a zone and a handle scope so that we can
   // call VM functions while tearing this isolate down.
   {
     StackZone stack_zone(this);
     HandleScope handle_scope(this);
 
+    // Notify exit listeners that this isolate is shutting down.
+    NotifyExitListeners();
+
     // Clean up debugger resources.
     debugger()->Shutdown();
 
     // Close all the ports owned by this isolate.
     PortMap::ClosePorts(message_handler());
 
     // Fail fast if anybody tries to post any more messsages to this isolate.
     delete message_handler();
     set_message_handler(NULL);
 
@@ skipping 563 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart