Enables clean VM shutdown.

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 138 matching lines @@
   void NotifyPauseOnStart();
   void NotifyPauseOnExit();
 
 #if defined(DEBUG)
   // Check that it is safe to access this handler.
   void CheckAccess();
 #endif
   bool IsCurrentIsolate() const;
   virtual Isolate* isolate() const { return isolate_; }
 
- private:
   // Keep both these enums in sync with isolate_patch.dart.
   // The different Isolate API message types.
   enum {
     kPauseMsg = 1,
     kResumeMsg = 2,
     kPingMsg = 3,
     kKillMsg = 4,
     kAddExitMsg = 5,
     kDelExitMsg = 6,
     kAddErrorMsg = 7,
     kDelErrorMsg = 8,
     kErrorFatalMsg = 9,
   };
   // The different Isolate API message priorities for ping and kill messages.
   enum {
     kImmediateAction = 0,
     kBeforeNextEventAction = 1,
     kAsEventAction = 2
   };
 
+ private:
   // 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_;
 };
 
 
 IsolateMessageHandler::IsolateMessageHandler(Isolate* isolate)
@@ skipping 924 matching lines @@
       listeners.SetAt(i + 1, Object::null_instance());
       return;
     }
   }
 }
 
 
 void Isolate::NotifyExitListeners() {
   const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
       this, this->object_store()->exit_listeners());
-  if (listeners.IsNull()) return;
+  if (listeners.IsNull()) {
+    return;
+  }
 
   SendPort& listener = SendPort::Handle(this);
   Instance& response = Instance::Handle(this);
   for (intptr_t i = 0; i < listeners.Length(); i += 2) {
     listener ^= listeners.At(i);
     if (!listener.IsNull()) {
       Dart_Port port_id = listener.Id();
       uint8_t* data = NULL;
       intptr_t len = 0;
       response ^= listeners.At(i + 1);
@@ skipping 185 matching lines @@
   }
   {
     // Shut the isolate down.
     SwitchIsolateScope switch_scope(isolate);
     Dart::ShutdownIsolate();
   }
 }
 
 
 void Isolate::Run() {
-  message_handler()->Run(Dart::thread_pool(),
-                         RunIsolate,
+  message_handler()->Run(RunIsolate,
                          ShutdownIsolate,
                          reinterpret_cast<uword>(this));
 }
 
 
 uword Isolate::GetAndClearInterrupts() {
   MutexLocker ml(mutex_);
   if (stack_limit_ == saved_stack_limit_) {
     return 0;  // No interrupt was requested.
   }
@@ skipping 121 matching lines @@
     PortMap::ClosePorts(message_handler());
 
     // Fail fast if anybody tries to post any more messsages to this isolate.
     delete message_handler();
     set_message_handler(NULL);
 
     // Dump all accumulated timer data for the isolate.
     timer_list_.ReportTimers();
 
     // Write out the coverage data if collection has been enabled.
-    CodeCoverage::Write(this);
+    if (this != Dart::vm_isolate()) {
+      CodeCoverage::Write(this);
+    }
 
     // Finalize any weak persistent handles with a non-null referent.
     FinalizeWeakPersistentHandlesVisitor visitor;
     api_state()->weak_persistent_handles().VisitHandles(&visitor);
     api_state()->prologue_weak_persistent_handles().VisitHandles(&visitor);
 
     if (FLAG_trace_isolates) {
       heap()->PrintSizes();
       megamorphic_cache_table()->PrintSizes();
       Symbols::DumpStats();
@@ skipping 405 matching lines @@
 
 
 template<class T>
 T* Isolate::AllocateReusableHandle() {
   T* handle = reinterpret_cast<T*>(reusable_handles_.AllocateScopedHandle());
   T::initializeHandle(handle, T::null());
   return handle;
 }
 
 
+class IsolateKillerVisitor : public IsolateVisitor {
+ public:
+  explicit IsolateKillerVisitor(const Array& msg)
+      : IsolateVisitor(), msg_(Array::Handle(msg.raw())) {
+    ASSERT(msg_.Length() == 4);
+    msg_.SetAt(0, Smi::Handle(Smi::New(Message::kIsolateLibOOBMsg)));
+    msg_.SetAt(1, Smi::Handle(Smi::New(IsolateMessageHandler::kKillMsg)));
+    msg_.SetAt(3, Smi::Handle(Smi::New(
+        IsolateMessageHandler::kBeforeNextEventAction)));

[turnidge, 2015/06/30 22:15:46]

We discusssed offline that it should be possible to kill an isolate without
forging this specific kill message.  Instead you would add a new kind of
interrupt bit.  But that approach has the drawback that the isolate, if idle,
will not notice that the interrupt bit has been set.  I am ok with this approach
for now but I am noting that it is (almost) possible to do this w/out all of
these messages/capabilities when killing from the VM itself.

[zra, 2015/07/20 22:23:38]

Acknowledged.

+  }
+
+  void VisitIsolate(Isolate* isolate) {
+    ASSERT(isolate != NULL);
+    if ((isolate == Isolate::Current()) ||
+        ServiceIsolate::IsServiceIsolate(isolate) ||
+        (isolate == Dart::vm_isolate())) {
+      return;
+    }
+    SendKillMessageTo(isolate);
+  }
+
+ private:
+  void SendKillMessageTo(Isolate* isolate) {
+    // Set the capability field of the kill message with the right capability
+    // for the isolate we are sending the message to.
+    msg_.SetAt(2, Capability::Handle(
+        Capability::New(isolate->terminate_capability())));
+
+    uint8_t* data = NULL;
+    MessageWriter writer(&data, &allocator, false);
+    writer.WriteMessage(msg_);
+
+    PortMap::PostMessage(new Message(isolate->main_port(),
+                                     data, writer.BytesWritten(),
+                                     Message::kOOBPriority));
+  }
+
+  Array& msg_;
+};
+
+
+void Isolate::KillAllIsolates(Isolate* isolate) {

[turnidge, 2015/06/30 22:15:46]

Will the "isolate" param always be the current isolate?

[zra, 2015/07/20 22:23:38]

No. It should always be the service isolate. I've added an assert.

+  const Array& msg = Array::Handle(isolate, Array::New(4));
+  IsolateKillerVisitor visitor(msg);
+  VisitIsolates(&visitor);
+}
+
+
 static RawInstance* DeserializeObject(Isolate* isolate,
                                       Zone* zone,
                                       uint8_t* obj_data,
                                       intptr_t obj_len) {
   if (obj_data == NULL) {
     return Instance::null();
   }
   MessageSnapshotReader reader(obj_data,
                                obj_len,
                                isolate,
@@ skipping 174 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart