Initial isolate reload support

runtime/vm/isolate.h

 // 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.
 
 #ifndef VM_ISOLATE_H_
 #define VM_ISOLATE_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/atomic.h"
@@ skipping 17 matching lines @@
 class Capability;
 class CodeIndexTable;
 class CompilerStats;
 class Debugger;
 class DeoptContext;
 class HandleScope;
 class HandleVisitor;
 class Heap;
 class ICData;
 class IsolateProfilerData;
+class IsolateReloadContext;
 class IsolateSpawnState;
 class Log;
 class MessageHandler;
 class Mutex;
 class Object;
 class ObjectIdRing;
 class ObjectPointerVisitor;
 class ObjectStore;
 class RawInstance;
 class RawArray;
 class RawContext;
 class RawDouble;
+class RawError;
+class RawField;
 class RawGrowableObjectArray;
 class RawMint;
 class RawObject;
 class RawInteger;
-class RawError;
-class RawField;
 class RawFloat32x4;
 class RawInt32x4;
 class RawUserTag;
 class SafepointHandler;
 class SampleBuffer;
 class SendPort;
 class ServiceIdZone;
 class Simulator;
 class StackResource;
 class StackZone;
@@ skipping 18 matching lines @@
 // Disallow OOB message handling within this scope.
 class NoOOBMessageScope : public StackResource {
  public:
   explicit NoOOBMessageScope(Thread* thread);
   ~NoOOBMessageScope();
  private:
   DISALLOW_COPY_AND_ASSIGN(NoOOBMessageScope);
 };
 
 
+// Disallow isolate reload.
+class NoReloadScope : public StackResource {
+ public:
+  NoReloadScope(Isolate* isolate, Thread* thread);
+  ~NoReloadScope();
+
+ private:
+  Isolate* isolate_;
+  DISALLOW_COPY_AND_ASSIGN(NoReloadScope);
+};
+
+
 class Isolate : public BaseIsolate {
  public:
   // Keep both these enums in sync with isolate_patch.dart.
   // The different Isolate API message types.
   enum LibMsgId {
     kPauseMsg = 1,
     kResumeMsg = 2,
     kPingMsg = 3,
     kKillMsg = 4,
     kAddExitMsg = 5,
@@ skipping 39 matching lines @@
   StoreBuffer* store_buffer() { return store_buffer_; }
 
   ThreadRegistry* thread_registry() const { return thread_registry_; }
   SafepointHandler* safepoint_handler() const { return safepoint_handler_; }
 
   ClassTable* class_table() { return &class_table_; }
   static intptr_t class_table_offset() {
     return OFFSET_OF(Isolate, class_table_);
   }
 
+  // Prefers old classes when we are in the middle of a reload.
+  RawClass* GetClassForHeapWalkAt(intptr_t cid);
+
   static intptr_t ic_miss_code_offset() {
     return OFFSET_OF(Isolate, ic_miss_code_);
   }
 
   Dart_MessageNotifyCallback message_notify_callback() const {
     return message_notify_callback_;
   }
   void set_message_notify_callback(Dart_MessageNotifyCallback value) {
     message_notify_callback_ = value;
   }
@@ skipping 67 matching lines @@
 
   void SetupInstructionsSnapshotPage(
       const uint8_t* instructions_snapshot_buffer);
   void SetupDataSnapshotPage(
       const uint8_t* instructions_snapshot_buffer);
 
   void ScheduleMessageInterrupts();
 
   // Marks all libraries as loaded.
   void DoneLoading();
+  void DoneFinalizing();
+
+  void OnStackReload();
+  void ReloadSources(bool test_mode = false);
 
   bool MakeRunnable();
   void Run();
 
   MessageHandler* message_handler() const { return message_handler_; }
   void set_message_handler(MessageHandler* value) { message_handler_ = value; }
 
   bool is_runnable() const { return is_runnable_; }
   void set_is_runnable(bool value) {
     is_runnable_ = value;
@@ skipping 131 matching lines @@
 
   BackgroundCompiler* background_compiler() const {
     return background_compiler_;
   }
   void set_background_compiler(BackgroundCompiler* value) {
     // Do not overwrite a background compiler (memory leak).
     ASSERT((value == NULL) || (background_compiler_ == NULL));
     background_compiler_ = value;
   }
 
+  void enable_background_compiler() {
+    background_compiler_disabled_count_--;
+    if (background_compiler_disabled_count_ < 0) {
+      FATAL("Mismatched number of calls to disable_background_compiler and "
+            "enable_background_compiler.");
+    }
+  }
+
+  void disable_background_compiler() {
+    background_compiler_disabled_count_++;
+  }
+
+  bool is_background_compiler_disabled() const {
+    return background_compiler_disabled_count_ > 0;
+  }
+
   void UpdateLastAllocationProfileAccumulatorResetTimestamp() {
     last_allocationprofile_accumulator_reset_timestamp_ =
         OS::GetCurrentTimeMillis();
   }
 
   int64_t last_allocationprofile_accumulator_reset_timestamp() const {
     return last_allocationprofile_accumulator_reset_timestamp_;
   }
 
   void UpdateLastAllocationProfileGCTimestamp() {
@@ skipping 24 matching lines @@
   // Mutator thread is used to aggregate compiler stats.
   CompilerStats* aggregate_compiler_stats() {
     ASSERT(HasMutatorThread());
     return mutator_thread_->compiler_stats();
   }
 
   VMTagCounters* vm_tag_counters() {
     return &vm_tag_counters_;
   }
 
+  bool IsReloading() const {
+    return reload_context_ != NULL;
+  }
+
+  IsolateReloadContext* reload_context() {
+    return reload_context_;
+  }
+
+  bool HasAttemptedReload() const {
+    return has_attempted_reload_;
+  }
+
+  bool CanReload() const;
+
+  void ReportReloadError(const Error& error);
+
   uword user_tag() const {
     return user_tag_;
   }
   static intptr_t user_tag_offset() {
     return OFFSET_OF(Isolate, user_tag_);
   }
   static intptr_t current_tag_offset() {
     return OFFSET_OF(Isolate, current_tag_);
   }
   static intptr_t default_tag_offset() {
@@ skipping 162 matching lines @@
   void Shutdown();
 
   void BuildName(const char* name_prefix);
 
   void ProfileIdle();
 
   // Visit all object pointers. Caller must ensure concurrent sweeper is not
   // running, and the visitor must not allocate.
   void VisitObjectPointers(ObjectPointerVisitor* visitor, bool validate_frames);
 
+

[Ivan Posva, 2016/05/16 20:58:59]

Extra empty line.

[Cutch, 2016/05/17 18:03:52]

Done.

   void set_user_tag(uword tag) {
     user_tag_ = tag;
   }
 
   RawGrowableObjectArray* GetAndClearPendingServiceExtensionCalls();
   RawGrowableObjectArray* pending_service_extension_calls() const {
     return pending_service_extension_calls_;
   }
   void set_pending_service_extension_calls(const GrowableObjectArray& value);
   RawGrowableObjectArray* registered_service_extension_handlers() const {
@@ skipping 83 matching lines @@
 
   VMTagCounters vm_tag_counters_;
   RawGrowableObjectArray* tag_table_;
 
   RawGrowableObjectArray* deoptimized_code_array_;
 
   RawError* sticky_error_;
 
   // Background compilation.
   BackgroundCompiler* background_compiler_;
+  intptr_t background_compiler_disabled_count_;
 
   // We use 6 list entries for each pending service extension calls.
   enum {
     kPendingHandlerIndex = 0,
     kPendingMethodNameIndex,
     kPendingKeysIndex,
     kPendingValuesIndex,
     kPendingReplyPortIndex,
     kPendingIdIndex,
     kPendingEntrySize
@@ skipping 32 matching lines @@
   RawGrowableObjectArray* boxed_field_list_;
   // List of fields that were disabling code while background compiler
   // was running.
   RawGrowableObjectArray* disabling_field_list_;
 
   // This guards spawn_count_. An isolate cannot complete shutdown and be
   // destroyed while there are child isolates in the midst of a spawn.
   Monitor* spawn_count_monitor_;
   intptr_t spawn_count_;
 
+  // Has a reload ever been attempted?
+  bool has_attempted_reload_;
+  intptr_t no_reload_scope_depth_;  // we can only reload when this is 0.
+  IsolateReloadContext* reload_context_;
+
 #define ISOLATE_METRIC_VARIABLE(type, variable, name, unit)                    \
   type metric_##variable##_;
   ISOLATE_METRIC_LIST(ISOLATE_METRIC_VARIABLE);
 #undef ISOLATE_METRIC_VARIABLE
 
 
   static Dart_IsolateCreateCallback create_callback_;
   static Dart_IsolateShutdownCallback shutdown_callback_;
   static Dart_IsolateInterruptCallback vmstats_callback_;
 
   static void WakePauseEventHandler(Dart_Isolate isolate);
 
   // Manage list of existing isolates.
   static bool AddIsolateToList(Isolate* isolate);
   static void RemoveIsolateFromList(Isolate* isolate);
 
   // This monitor protects isolates_list_head_, and creation_enabled_.
   static Monitor* isolates_list_monitor_;
   static Isolate* isolates_list_head_;
   static bool creation_enabled_;
 
 #define REUSABLE_FRIEND_DECLARATION(name)                                      \
   friend class Reusable##name##HandleScope;
 REUSABLE_HANDLE_LIST(REUSABLE_FRIEND_DECLARATION)
 #undef REUSABLE_FRIEND_DECLARATION
 
+  friend class Become;  // VisitObjectPointers
   friend class GCMarker;  // VisitObjectPointers
   friend class SafepointHandler;
   friend class Scavenger;  // VisitObjectPointers
   friend class ServiceIsolate;
   friend class Thread;
   friend class Timeline;
+  friend class NoReloadScope;  // reload_block
+
 
   DISALLOW_COPY_AND_ASSIGN(Isolate);
 };
 
 
 // When we need to execute code in an isolate, we use the
 // StartIsolateScope.
 class StartIsolateScope {
  public:
   explicit StartIsolateScope(Isolate* new_isolate)
@@ skipping 114 matching lines @@
   intptr_t* spawn_count_;
 
   Dart_IsolateFlags isolate_flags_;
   bool paused_;
   bool errors_are_fatal_;
 };
 
 }  // namespace dart
 
 #endif  // VM_ISOLATE_H_