Initial isolate reload support

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 "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/text_buffer.h"
 #include "vm/class_finalizer.h"
 #include "vm/code_observers.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
 #include "vm/dart_api_message.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
+#include "vm/isolate_reload.h"
 #include "vm/lockers.h"
 #include "vm/log.h"
 #include "vm/message_handler.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/object.h"
 #include "vm/os_thread.h"
 #include "vm/port.h"
 #include "vm/profiler.h"
 #include "vm/reusable_handles.h"
@@ skipping 95 matching lines @@
   thread->DeferOOBMessageInterrupts();
 }
 
 
 NoOOBMessageScope::~NoOOBMessageScope() {
   thread()->RestoreOOBMessageInterrupts();
 }
 
 
 
+NoReloadScope::NoReloadScope(Isolate* isolate, Thread* thread)
+    : StackResource(thread),
+      isolate_(isolate) {
+  ASSERT(isolate_ != NULL);
+  isolate_->no_reload_scope_depth_++;
+  ASSERT(isolate_->no_reload_scope_depth_ >= 0);
+}
+
+
+NoReloadScope::~NoReloadScope() {
+  isolate_->no_reload_scope_depth_--;
+  ASSERT(isolate_->no_reload_scope_depth_ >= 0);
+}
+
+
 void Isolate::RegisterClass(const Class& cls) {
+  NOT_IN_PRODUCT(
+    if (IsReloading()) {
+      reload_context()->RegisterClass(cls);
+      return;
+    }
+  )
   class_table()->Register(cls);
 }
 
 
 void Isolate::RegisterClassAt(intptr_t index, const Class& cls) {
   class_table()->RegisterAt(index, cls);
 }
 
 
 void Isolate::ValidateClassTable() {
@@ skipping 469 matching lines @@
         return MessageHandler::kShutdown;
       }
     }
   }
   return MessageHandler::kError;
 }
 
 
 MessageHandler::MessageStatus IsolateMessageHandler::ProcessUnhandledException(
     const Error& result) {
+  NOT_IN_PRODUCT(
+    if (I->IsReloading()) {
+      I->ReportReloadError(result);
+      return kOK;
+    }
+  )
   // Generate the error and stacktrace strings for the error message.
   String& exc_str = String::Handle(T->zone());
   String& stacktrace_str = String::Handle(T->zone());
   if (result.IsUnhandledException()) {
     Zone* zone = T->zone();
     const UnhandledException& uhe = UnhandledException::Cast(result);
     const Instance& exception = Instance::Handle(zone, uhe.exception());
     Object& tmp = Object::Handle(zone);
     tmp = DartLibraryCalls::ToString(exception);
     if (!tmp.IsString()) {
@@ skipping 141 matching lines @@
       is_service_isolate_(false),
       stacktrace_(NULL),
       stack_frame_index_(-1),
       last_allocationprofile_accumulator_reset_timestamp_(0),
       last_allocationprofile_gc_timestamp_(0),
       object_id_ring_(NULL),
       tag_table_(GrowableObjectArray::null()),
       deoptimized_code_array_(GrowableObjectArray::null()),
       sticky_error_(Error::null()),
       background_compiler_(NULL),
+      background_compiler_disabled_count_(0),
       pending_service_extension_calls_(GrowableObjectArray::null()),
       registered_service_extension_handlers_(GrowableObjectArray::null()),
       metrics_list_head_(NULL),
       compilation_allowed_(true),
       all_classes_finalized_(false),
       next_(NULL),
       pause_loop_monitor_(NULL),
       field_invalidation_gen_(kInvalidGen),
       loading_invalidation_gen_(kInvalidGen),
       top_level_parsing_count_(0),
       field_list_mutex_(new Mutex()),
       boxed_field_list_(GrowableObjectArray::null()),
       disabling_field_list_(GrowableObjectArray::null()),
       spawn_count_monitor_(new Monitor()),
-      spawn_count_(0) {
+      spawn_count_(0),
+      has_attempted_reload_(false),
+      no_reload_scope_depth_(0),
+      reload_context_(NULL) {
   NOT_IN_PRODUCT(FlagsCopyFrom(api_flags));
   // TODO(asiva): A Thread is not available here, need to figure out
   // how the vm_tag (kEmbedderTagId) can be set, these tags need to
   // move to the OSThread structure.
   set_user_tag(UserTags::kDefaultUserTag);
 }
 
 #undef REUSABLE_HANDLE_SCOPE_INIT
 #undef REUSABLE_HANDLE_INITIALIZERS
 
@@ skipping 196 matching lines @@
     // as 'load in progres'. Set the status to 'loaded'.
     if (lib.LoadInProgress()) {
       lib.SetLoaded();
     }
     lib.InitExportedNamesCache();
   }
   TokenStream::CloseSharedTokenList(this);
 }
 
 
+bool Isolate::CanReload() const {
+#ifndef PRODUCT
+  return (!ServiceIsolate::IsServiceIsolateDescendant(this) &&
+          is_runnable() && !IsReloading() && no_reload_scope_depth_ == 0);
+#else
+  return false;
+#endif
+}
+
+
+#ifndef PRODUCT
+void Isolate::ReportReloadError(const Error& error) {
+  ASSERT(IsReloading());
+  reload_context_->AbortReload(error);
+  delete reload_context_;
+  reload_context_ = NULL;
+}
+
+
+void Isolate::OnStackReload() {
+  UNREACHABLE();
+}
+
+
+void Isolate::ReloadSources(bool test_mode) {
+  ASSERT(!IsReloading());
+  has_attempted_reload_ = true;
+  reload_context_ = new IsolateReloadContext(this, test_mode);
+  reload_context_->StartReload();
+}
+
+#endif
+
+
+void Isolate::DoneFinalizing() {
+  NOT_IN_PRODUCT(
+    if (IsReloading()) {
+      reload_context_->FinishReload();
+      if (reload_context_->has_error() && reload_context_->test_mode()) {
+        // If the reload has an error and we are in test mode keep the reload
+        // context on the isolate so that it can be used by unit tests.
+        return;
+      }
+      if (!reload_context_->has_error()) {
+        reload_context_->ReportSuccess();
+      }
+      delete reload_context_;
+      reload_context_ = NULL;
+    }
+  )
+}
+
+
+
 bool Isolate::MakeRunnable() {
   ASSERT(Isolate::Current() == NULL);
 
   MutexLocker ml(mutex_);
   // Check if we are in a valid state to make the isolate runnable.
   if (is_runnable() == true) {
     return false;  // Already runnable.
   }
   // Set the isolate as runnable and if we are being spawned schedule
   // isolate on thread pool for execution.
@@ skipping 654 matching lines @@
   // 'disabling_field_list_' access via mutator and background compilation
   // threads is guarded with a monitor. This means that we can visit it only
   // when at safepoint or the field_list_mutex_ lock has been taken.
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&disabling_field_list_));
 
   // Visit objects in the debugger.
   if (FLAG_support_debugger) {
     debugger()->VisitObjectPointers(visitor);
   }
 
+  NOT_IN_PRODUCT(
+    // Visit objects that are being used for isolate reload.
+    if (reload_context() != NULL) {
+      reload_context()->VisitObjectPointers(visitor);
+    }
+  )
+
   // Visit objects that are being used for deoptimization.
   if (deopt_context() != NULL) {
     deopt_context()->VisitObjectPointers(visitor);
   }
 
   // Visit objects in all threads (e.g., Dart stack, handles in zones).
   thread_registry()->VisitObjectPointers(visitor, validate_frames);
 }
 
 
 void Isolate::VisitWeakPersistentHandles(HandleVisitor* visitor) {
   if (api_state() != NULL) {
     api_state()->VisitWeakHandles(visitor);
   }
 }
 
 
 void Isolate::PrepareForGC() {
   thread_registry()->PrepareForGC();
 }
 
 
+RawClass* Isolate::GetClassForHeapWalkAt(intptr_t cid) {
+  RawClass* raw_class = NULL;
+#ifndef PRODUCT
+  if (IsReloading()) {
+    raw_class = reload_context()->GetClassForHeapWalkAt(cid);
+  } else {
+    raw_class = class_table()->At(cid);
+  }
+#else
+  raw_class = class_table()->At(cid);
+#endif  // !PRODUCT
+  ASSERT(raw_class != NULL);
+  ASSERT(raw_class->ptr()->id_ == cid);
+  return raw_class;
+}
+
+
 static const char* ExceptionPauseInfoToServiceEnum(Dart_ExceptionPauseInfo pi) {
   switch (pi) {
     case kPauseOnAllExceptions:
       return "All";
     case kNoPauseOnExceptions:
       return "None";
     case kPauseOnUnhandledExceptions:
       return "Unhandled";
     default:
       UNIMPLEMENTED();
@@ skipping 23 matching lines @@
   jsobj.AddPropertyTimeMillis("startTime", start_time_millis);
   {
     JSONObject jsheap(&jsobj, "_heaps");
     heap()->PrintToJSONObject(Heap::kNew, &jsheap);
     heap()->PrintToJSONObject(Heap::kOld, &jsheap);
   }
 
   jsobj.AddProperty("runnable", is_runnable());
   jsobj.AddProperty("livePorts", message_handler()->live_ports());
   jsobj.AddProperty("pauseOnExit", message_handler()->should_pause_on_exit());
+  jsobj.AddProperty("_isReloading", IsReloading());
 
   if (debugger() != NULL) {
     if (!is_runnable()) {
       // Isolate is not yet runnable.
       ASSERT(debugger()->PauseEvent() == NULL);
       ServiceEvent pause_event(this, ServiceEvent::kNone);
       jsobj.AddProperty("pauseEvent", &pause_event);
     } else if (message_handler()->is_paused_on_start() ||
                message_handler()->should_pause_on_start()) {
       ASSERT(debugger()->PauseEvent() == NULL);
@@ skipping 413 matching lines @@
   if (pause_loop_monitor_ == NULL) {
     pause_loop_monitor_ = new Monitor();
   }
   Dart_EnterScope();
   MonitorLocker ml(pause_loop_monitor_);
 
   Dart_MessageNotifyCallback saved_notify_callback =
       message_notify_callback();
   set_message_notify_callback(Isolate::WakePauseEventHandler);
 
+  const bool had_isolate_reload_context = reload_context() != NULL;
+  const int64_t start_time_micros =
+      !had_isolate_reload_context ? 0 : reload_context()->start_time_micros();
   bool resume = false;
   while (true) {
     // Handle all available vm service messages, up to a resume
     // request.
     while (!resume && Dart_HasServiceMessages()) {
       ml.Exit();
       resume = Dart_HandleServiceMessages();
       ml.Enter();
     }
     if (resume) {
       break;
     }
 
+    if (had_isolate_reload_context && (reload_context() == NULL)) {
+      const int64_t reload_time_micros =
+          OS::GetCurrentMonotonicMicros() - start_time_micros;
+      double reload_millis =
+          MicrosecondsToMilliseconds(reload_time_micros);
+      OS::Print("Reloading has finished! (%.2f ms)\n", reload_millis);
+      break;
+    }
+
     // Wait for more service messages.
     Monitor::WaitResult res = ml.Wait();
     ASSERT(res == Monitor::kNotified);
   }
   set_message_notify_callback(saved_notify_callback);
   Dart_ExitScope();
 }
 
 
 void Isolate::VisitIsolates(IsolateVisitor* visitor) {
@@ skipping 503 matching lines @@
 void IsolateSpawnState::DecrementSpawnCount() {
   ASSERT(spawn_count_monitor_ != NULL);
   ASSERT(spawn_count_ != NULL);
   MonitorLocker ml(spawn_count_monitor_);
   ASSERT(*spawn_count_ > 0);
   *spawn_count_ = *spawn_count_ - 1;
   ml.Notify();
 }
 
 }  // namespace dart