VM thread shutdown.

runtime/vm/dart.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/dart.h"
 
 #include "vm/code_observers.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
@@ skipping 20 matching lines @@
 #include "vm/virtual_memory.h"
 #include "vm/zone.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, print_class_table);
 DECLARE_FLAG(bool, trace_isolates);
 DECLARE_FLAG(bool, trace_time_all);
 DEFINE_FLAG(bool, keep_code, false,
             "Keep deoptimized code for profiling.");
+DEFINE_FLAG(bool, shutdown, true, "Do a clean shutdown of the VM");
 
 Isolate* Dart::vm_isolate_ = NULL;
 ThreadPool* Dart::thread_pool_ = NULL;
 DebugInfo* Dart::pprof_symbol_generator_ = NULL;
 ReadOnlyHandles* Dart::predefined_handles_ = NULL;
 
 // Structure for managing read-only global handles allocation used for
 // creating global read-only handles that are pre created and initialized
 // for use across all isolates. Having these global pre created handles
 // stored in the vm isolate ensures that we don't constantly create and
@@ skipping 138 matching lines @@
   Isolate::SetInterruptCallback(interrupt);
   Isolate::SetUnhandledExceptionCallback(unhandled);
   Isolate::SetShutdownCallback(shutdown);
 
   ServiceIsolate::Run();
 
   return NULL;
 }
 
 
+// This waits until only the VM isolate remains in the list.
+void Dart::WaitForIsolateShutdown() {
+  ASSERT(!Isolate::creation_enabled_);
+  MonitorLocker ml(Isolate::isolates_list_monitor_);
+  while ((Isolate::isolates_list_head_ != NULL) &&
+         (Isolate::isolates_list_head_->next_ != NULL)) {
+    ml.Wait();
+  }
+  ASSERT(Isolate::isolates_list_head_ == Dart::vm_isolate());
+}
+
+
 const char* Dart::Cleanup() {
-  // Shutdown the service isolate before shutting down the thread pool.
-  ServiceIsolate::Shutdown();
-#if 0
-  // Ideally we should shutdown the VM isolate here, but the thread pool
-  // shutdown does not seem to ensure that all the threads have stopped
-  // execution before it terminates, this results in racing isolates.
+  ASSERT(Isolate::Current() == NULL);
   if (vm_isolate_ == NULL) {
     return "VM already terminated.";
   }
 
-  ASSERT(Isolate::Current() == NULL);
+  // Shut dwon profiling.

[turnidge, 2015/09/15 16:48:22]

dwon -> down

+  Profiler::Shutdown();
 
-  delete thread_pool_;
-  thread_pool_ = NULL;
+  if (FLAG_shutdown) {
+    // Disable the creation of new isolates.
+    Isolate::DisableIsolateCreation();
 
-  // Set the VM isolate as current isolate.
-  Thread::EnsureInit();
-  Thread::EnterIsolate(vm_isolate_);
+    // Send the OOB Kill message to all remaining application isolates.
+    Isolate::KillAllIsolates();
 
-  // There is a planned and known asymmetry here: We exit one scope for the VM
-  // isolate to account for the scope that was entered in Dart_InitOnce.
-  Dart_ExitScope();
+    // Shutdown the service isolate.
+    ServiceIsolate::Shutdown();
 
-  ShutdownIsolate();
-  vm_isolate_ = NULL;
+    // Wait for all application isolates and the service isolate to shutdown
+    // before shutting down the thread pool.
+    WaitForIsolateShutdown();
 
-  TargetCPUFeatures::Cleanup();
-  StoreBuffer::ShutDown();
-#endif
+    // Shutdown the thread pool. On return, all thread pool threads have exited.
+    delete thread_pool_;
+    thread_pool_ = NULL;
 
-  Profiler::Shutdown();
+    // Set the VM isolate as current isolate.
+    Thread::EnsureInit();
+    Thread::EnterIsolate(vm_isolate_);
+
+    ShutdownIsolate();
+    vm_isolate_ = NULL;
+    ASSERT(Isolate::IsolateListLength() == 0);
+
+    TargetCPUFeatures::Cleanup();
+    StoreBuffer::ShutDown();
+  } else {
+    // Shutdown the service isolate.
+    ServiceIsolate::Shutdown();
+  }
+
   CodeObservers::DeleteAll();
   Timeline::Shutdown();
   Metric::Cleanup();
 
   return NULL;
 }
 
 
 Isolate* Dart::CreateIsolate(const char* name_prefix,
                              const Dart_IsolateFlags& api_flags) {
@@ skipping 140 matching lines @@
   return predefined_handles_->handles_.IsValidScopedHandle(address);
 }
 
 
 bool Dart::IsReadOnlyApiHandle(Dart_Handle handle) {
   ASSERT(predefined_handles_ != NULL);
   return predefined_handles_->api_handles_.IsValidHandle(handle);
 }
 
 }  // namespace dart