Implemented schema change for the isolate reload operation.

runtime/vm/isolate_reload.cc

 // Copyright (c) 2016, 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_reload.h"
 
 #include "vm/become.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
@@ skipping 26 matching lines @@
 
 #define I (isolate())
 #define Z (thread->zone())
 
 #define TIMELINE_SCOPE(name)                                                   \
     TimelineDurationScope tds##name(Thread::Current(),                         \
                                    Timeline::GetIsolateStream(),               \
                                    #name)
 
 
+InstanceMorpher::InstanceMorpher(const Class& from, const Class& to)
+  : from_(from), to_(to), mapping_() {
+  ComputeMapping();
+  before_ = new ZoneGrowableArray<const Instance*>();
+  after_ = new ZoneGrowableArray<const Instance*>();
+  ASSERT(from_.id() == to_.id());
+  cid_ = from_.id();
+}
+
+
+void InstanceMorpher::AddObject(RawObject* object) const {
+  ASSERT(object->GetClassId() == cid());
+  const Instance& instance = Instance::Cast(Object::Handle(object));
+  before_->Add(&instance);
+}
+
+
+void InstanceMorpher::ComputeMapping() {
+  if (from_.NumTypeArguments()) {
+    // Add copying of the optional type argument field.
+    intptr_t from_offset = from_.type_arguments_field_offset();
+    ASSERT(from_offset != Class::kNoTypeArguments);
+    intptr_t to_offset = to_.type_arguments_field_offset();
+    ASSERT(to_offset != Class::kNoTypeArguments);
+    mapping_.Add(from_offset);
+    mapping_.Add(to_offset);
+  }
+
+  // Add copying of the instance fields if matching by name.
+  // Note: currently the type of the fields are ignored.
+  const Array& from_fields = Array::Handle(from_.OffsetToFieldMap());
+  const Array& to_fields = Array::Handle(to_.OffsetToFieldMap());
+  Field& from_field = Field::Handle();
+  Field& to_field = Field::Handle();
+  String& from_name = String::Handle();
+  String& to_name = String::Handle();
+  for (intptr_t i = 0; i < from_fields.Length(); i++) {
+    if (from_fields.At(i) == Field::null()) continue;  // Ignore non-fields.
+    from_field = Field::RawCast(from_fields.At(i));
+    ASSERT(from_field.is_instance());
+    from_name = from_field.name();
+    // We now have to find where this field is in the to class.
+    for (intptr_t j = 0; j < to_fields.Length(); j++) {
+      if (to_fields.At(j) == Field::null()) continue;  // Ignore non-fields.
+      to_field = Field::RawCast(to_fields.At(j));
+      ASSERT(to_field.is_instance());
+      to_name = to_field.name();
+      if (from_name.Equals(to_name)) {
+        // Success
+        mapping_.Add(from_field.Offset());
+        mapping_.Add(to_field.Offset());
+      }
+    }
+  }
+}
+
+
+RawInstance* InstanceMorpher::Morph(const Instance& instance) const {
+  const Instance& result = Instance::Handle(Instance::New(to_));
+  // Morph the context from instance to result using mapping_.
+  for (intptr_t i = 0; i < mapping_.length(); i +=2) {
+    intptr_t from_offset = mapping_.At(i);
+    intptr_t to_offset = mapping_.At(i+1);
+    const Object& value =
+        Object::Handle(instance.RawGetFieldAtOffset(from_offset));
+    result.RawSetFieldAtOffset(to_offset, value);
+  }
+  // Convert the instance into a filler object.
+  Become::MakeDummyObject(instance);
+  return result.raw();
+}
+
+
+void InstanceMorpher::CreateMorphedCopies() const {
+  for (intptr_t i = 0; i < before()->length(); i++) {
+    const Instance& copy = Instance::Handle(Morph(*before()->At(i)));
+    after()->Add(&copy);
+  }
+}
+
+
+void InstanceMorpher::DumpFormatFor(const Class& cls) const {
+  LogBlock blocker;

[Cutch, 2016/07/26 17:10:16]

Remove this LogBlock -- the one in Dump should be sufficient.

[bakster, 2016/07/26 18:01:47]

Done.

+  THR_Print("%s\n", cls.ToCString());
+  if (cls.NumTypeArguments()) {
+    intptr_t field_offset = cls.type_arguments_field_offset();
+    ASSERT(field_offset != Class::kNoTypeArguments);
+    THR_Print("  - @%" Pd " <type arguments>\n", field_offset);
+  }
+  const Array& fields = Array::Handle(cls.OffsetToFieldMap());
+  Field& field = Field::Handle();
+  String& name = String::Handle();
+  for (intptr_t i = 0; i < fields.Length(); i++) {
+    if (fields.At(i) != Field::null()) {
+      field = Field::RawCast(fields.At(i));
+      ASSERT(field.is_instance());
+      name = field.name();
+      THR_Print("  - @%" Pd " %s\n", field.Offset(), name.ToCString());
+    }
+  }
+
+  THR_Print("Mapping: ");
+  for (int i = 0; i < mapping_.length(); i +=2) {
+    THR_Print(" %" Pd "->%" Pd,  mapping_.At(i),  mapping_.At(i+1));
+  }
+  THR_Print("\n");
+}
+
+
+void InstanceMorpher::Dump() const {
+  LogBlock blocker;
+  THR_Print("Morphing from ");
+  DumpFormatFor(from_);
+  THR_Print("To ");
+  DumpFormatFor(to_);
+  THR_Print("\n");
+}
+
+
+void ReasonForCancelling::Report(IsolateReloadContext* context) {
+  const Error& error = Error::Handle(ToError());
+  context->ReportError(error);
+}
+
+
+RawError* ReasonForCancelling::ToError() {
+  // By default create the error returned from ToString.
+  const String& message = String::Handle(ToString());
+  return LanguageError::New(message);
+}
+
+
+RawString* ReasonForCancelling::ToString() {
+  UNREACHABLE();
+  return NULL;
+}
+
+
+RawError* IsolateReloadContext::error() const {
+  ASSERT(has_error());
+  // Report the first error to the surroundings.
+  const Error& error =
+      Error::Handle(reasons_to_cancel_reload_.At(0)->ToError());
+  OS::Print("[[%s]]\n", error.ToCString());
+  return error.raw();
+}
+
 class ScriptUrlSetTraits {
  public:
   static bool ReportStats() { return false; }
   static const char* Name() { return "ScriptUrlSetTraits"; }
 
   static bool IsMatch(const Object& a, const Object& b) {
     if (!a.IsString() || !b.IsString()) {
       return false;
     }
 
@@ skipping 116 matching lines @@
       String::Handle(a_lib.IsNull() ? String::null() : a_lib.url());
   const String& b_lib_url =
       String::Handle(b_lib.IsNull() ? String::null() : b_lib.url());
   return a_lib_url.Equals(b_lib_url);
 }
 
 
 IsolateReloadContext::IsolateReloadContext(Isolate* isolate)
     : start_time_micros_(OS::GetCurrentMonotonicMicros()),
       isolate_(isolate),
-      has_error_(false),
       saved_num_cids_(-1),
       saved_class_table_(NULL),
       num_saved_libs_(-1),
+      instance_morphers_(),
+      reasons_to_cancel_reload_(),
+      cid_mapper_(),
       script_uri_(String::null()),
       error_(Error::null()),
       old_classes_set_storage_(Array::null()),
       class_map_storage_(Array::null()),
       old_libraries_set_storage_(Array::null()),
       library_map_storage_(Array::null()),
       become_map_storage_(Array::null()),
       become_enum_mappings_(GrowableObjectArray::null()),
       saved_root_library_(Library::null()),
       saved_libraries_(GrowableObjectArray::null()) {
   // NOTE: DO NOT ALLOCATE ANY RAW OBJECTS HERE. The IsolateReloadContext is not
   // associated with the isolate yet and if a GC is triggered here the raw
   // objects will not be properly accounted for.
 }
 
 
 IsolateReloadContext::~IsolateReloadContext() {
 }
 
 
 void IsolateReloadContext::ReportError(const Error& error) {
-  has_error_ = true;
-  error_ = error.raw();
   if (FLAG_trace_reload) {
     THR_Print("ISO-RELOAD: Error: %s\n", error.ToErrorCString());
   }
   ServiceEvent service_event(I, ServiceEvent::kIsolateReload);
   service_event.set_reload_error(&error);
   Service::HandleEvent(&service_event);
 }
 
 
-void IsolateReloadContext::ReportError(const String& error_msg) {
-  ReportError(LanguageError::Handle(LanguageError::New(error_msg)));
-}
-
-
 void IsolateReloadContext::ReportSuccess() {
   ServiceEvent service_event(I, ServiceEvent::kIsolateReload);
   Service::HandleEvent(&service_event);
 }
 
 
+class Aborted : public ReasonForCancelling {
+ public:
+  explicit Aborted(const Error& error)
+      : ReasonForCancelling(), error_(error) { }
+
+ private:
+  const Error& error_;
+
+  RawError* ToError() { return error_.raw(); }
+  RawString* ToString() {
+    return String::NewFormatted("%s", error_.ToErrorCString());
+  }
+};
+
+
 void IsolateReloadContext::StartReload() {
   TIMELINE_SCOPE(Reload);
   Thread* thread = Thread::Current();
   ASSERT(isolate() == thread->isolate());
 
   // Grab root library before calling CheckpointBeforeReload.
   const Library& root_lib = Library::Handle(object_store()->root_library());
   ASSERT(!root_lib.IsNull());
   const String& root_lib_url = String::Handle(root_lib.url());
 
@@ skipping 34 matching lines @@
     TransitionVMToNative transition(thread);
     Api::Scope api_scope(thread);
 
     Dart_Handle retval =
         (I->library_tag_handler())(Dart_kScriptTag,
                                    Api::NewHandle(thread, Library::null()),
                                    Api::NewHandle(thread, root_lib_url.raw()));
     result = Api::UnwrapHandle(retval);
   }
   if (result.IsError()) {
-    ReportError(Error::Cast(result));
+    const Error& error = Error::Cast(result);
+    AddReasonForCancelling(new Aborted(error));
   }
 }
 
 
 void IsolateReloadContext::RegisterClass(const Class& new_cls) {
   const Class& old_cls = Class::Handle(OldClassOrNull(new_cls));
   if (old_cls.IsNull()) {
     I->class_table()->Register(new_cls);
 
     if (FLAG_identity_reload) {
@@ skipping 17 matching lines @@
 }
 
 
 void IsolateReloadContext::FinishReload() {
   BuildLibraryMapping();
   TIR_Print("---- DONE FINALIZING\n");
   if (ValidateReload()) {
     Commit();
     PostCommit();
   } else {
+    ReportReasonsForCancelling();
     Rollback();
   }
   // ValidateReload mutates the direct subclass information and does
   // not remove dead subclasses.  Rebuild the direct subclass
   // information from scratch.
   RebuildDirectSubclasses();
 
   if (FLAG_write_protect_code) {
     // Disable code page write protection while we are reloading.
     I->heap()->WriteProtectCode(true);
   }
 
   BackgroundCompiler::Enable();
 }
 
 
 void IsolateReloadContext::AbortReload(const Error& error) {
-  ReportError(error);
+  AddReasonForCancelling(new Aborted(error));
+  ReportReasonsForCancelling();
   Rollback();
 }
 
 
 void IsolateReloadContext::EnsuredUnoptimizedCodeForStack() {
   TIMELINE_SCOPE(EnsuredUnoptimizedCodeForStack);
   StackFrameIterator it(StackFrameIterator::kDontValidateFrames);
 
   Function& func = Function::Handle();
   while (it.HasNextFrame()) {
@@ skipping 228 matching lines @@
   class_map.Release();
   reverse_class_map.Release();
 }
 #endif
 
 
 void IsolateReloadContext::Commit() {
   TIMELINE_SCOPE(Commit);
   TIR_Print("---- COMMITTING REVERSE MAP\n");
 
+  // Perform shape shifting of instances if necessary.
+  if (HasInstanceMorphers()) {
+    MorphInstances();

[Cutch, 2016/07/26 17:10:16]

Calling MorphInstances resets the saved_class_table. This should probably be
moved further down in this function.

[bakster, 2016/07/26 18:01:47]

The placement will be documents.

+  }
+
 #ifdef DEBUG
   VerifyMaps();
 #endif
 
   {
     TIMELINE_SCOPE(CopyStaticFieldsAndPatchFieldsAndFunctions);
     // Copy static field values from the old classes to the new classes.
     // Patch fields and functions in the old classes so that they retain
     // the old script.
     Class& cls = Class::Handle();
@@ skipping 61 matching lines @@
     }
 
     // Initialize library side table.
     library_infos_.SetLength(libs.Length());
     for (intptr_t i = 0; i < libs.Length(); i++) {
       lib = Library::RawCast(libs.At(i));
       // Mark the library dirty if it comes after the libraries we saved.
       library_infos_[i].dirty = i >= num_saved_libs_;
     }
   }
 

[Cutch, 2016/07/26 17:10:16]

call MorphInstances here instead

[bakster, 2016/07/26 18:01:47]

Acknowledged.

   {
     const GrowableObjectArray& become_enum_mappings =
         GrowableObjectArray::Handle(become_enum_mappings_);
     UnorderedHashMap<BecomeMapTraits> become_map(become_map_storage_);
     intptr_t replacement_count = become_map.NumOccupied() +
                                  become_enum_mappings.Length() / 2;
     const Array& before =
         Array::Handle(Array::New(replacement_count, Heap::kOld));
     const Array& after =
         Array::Handle(Array::New(replacement_count, Heap::kOld));
@@ skipping 53 matching lines @@
 
 void IsolateReloadContext::PostCommit() {
   TIMELINE_SCOPE(PostCommit);
   set_saved_root_library(Library::Handle());
   set_saved_libraries(GrowableObjectArray::Handle());
   InvalidateWorld();
   TIR_Print("---- DONE COMMIT\n");
 }
 
 
+void IsolateReloadContext::AddReasonForCancelling(ReasonForCancelling* reason) {
+  reasons_to_cancel_reload_.Add(reason);
+}
+
+
+void IsolateReloadContext::AddInstanceMorpher(InstanceMorpher* morpher) {
+  instance_morphers_.Add(morpher);
+  cid_mapper_.Insert(morpher);
+}
+
+
+void IsolateReloadContext::ReportReasonsForCancelling() {
+  ASSERT(HasReasonsForCancelling());
+  for (int i = 0; i < reasons_to_cancel_reload_.length(); i++) {
+    reasons_to_cancel_reload_.At(i)->Report(this);
+  }
+}
+
+
+// The ObjectLocator is used for collecting instances that
+// needs to be morphed.
+class ObjectLocator : public ObjectVisitor {
+ public:
+  explicit ObjectLocator(IsolateReloadContext* context)
+      : context_(context), count_(0) {
+  }
+
+  void VisitObject(RawObject* obj) {
+    InstanceMorpher* morpher =
+        context_->cid_mapper_.LookupValue(obj->GetClassId());
+    if (morpher != NULL) {
+      morpher->AddObject(obj);
+      count_++;
+    }
+  }
+
+  // Return the number of located objects for morphing.
+  intptr_t count() { return count_; }
+ private:

[Cutch, 2016/07/26 17:10:16]

blank line between count() and private:

[bakster, 2016/07/26 18:01:47]

Done.

+  IsolateReloadContext* context_;
+  intptr_t count_;
+};
+
+
+void IsolateReloadContext::MorphInstances() {
+  TIMELINE_SCOPE(MorphInstances);
+  ASSERT(HasInstanceMorphers());
+  if (FLAG_trace_reload) {
+    LogBlock blocker;
+    TIR_Print("MorphInstance: \n");
+    for (intptr_t i = 0; i < instance_morphers_.length(); i++) {
+      instance_morphers_.At(i)->Dump();
+    }
+  }
+
+  // Find all objects that need to be morphed.
+  ObjectLocator locator(this);
+  isolate()->heap()->VisitObjects(&locator);
+
+  // Return if no objects are located.
+  intptr_t count = locator.count();
+  if (count == 0) return;
+
+  TIR_Print("Found %" Pd " object%s subject to morphing.\n",
+            count, (count > 1) ? "s" : "");
+
+  Array& before = Array::Handle();
+  Array& after = Array::Handle();
+  { // Prevent GC to take place due object format confusion.
+    // Hint: More than one class share the same cid.
+    NoHeapGrowthControlScope scope;
+    for (intptr_t i = 0; i < instance_morphers_.length(); i++) {
+      instance_morphers_.At(i)->CreateMorphedCopies();
+    }
+    // Create the inputs for Become.
+    intptr_t index = 0;
+    before = Array::New(count);
+    after = Array::New(count);
+    for (intptr_t i = 0; i < instance_morphers_.length(); i++) {
+      InstanceMorpher* morpher = instance_morphers_.At(i);
+      for (intptr_t j = 0; j < morpher->before()->length(); j++) {
+        before.SetAt(index, *morpher->before()->At(j));
+        after.SetAt(index, *morpher->after()->At(j));
+        index++;
+      }
+    }
+    ASSERT(index == count);
+  }
+
+  // This is important: The saved class table (describing before objects)
+  // must be zapped to prevent the forwarding in GetClassForHeapWalkAt.
+  // Instance will from now be described by the isolate's class table.
+  free(saved_class_table_);
+  saved_class_table_ = NULL;
+  Become::ElementsForwardIdentity(before, after);
+}
+
+
 bool IsolateReloadContext::ValidateReload() {
   TIMELINE_SCOPE(ValidateReload);
-  if (has_error_) {
-    return false;
-  }
+  if (has_error()) return false;
 
   // Validate libraries.
   {
     ASSERT(library_map_storage_ != Array::null());
     UnorderedHashMap<LibraryMapTraits> map(library_map_storage_);
     UnorderedHashMap<LibraryMapTraits>::Iterator it(&map);
     Library& lib = Library::Handle();
     Library& new_lib = Library::Handle();
     while (it.MoveNext()) {
       const intptr_t entry = it.Current();
       new_lib = Library::RawCast(map.GetKey(entry));
       lib = Library::RawCast(map.GetPayload(entry, 0));
       if (new_lib.raw() != lib.raw()) {
-        if (!lib.CanReload(new_lib)) {
-          map.Release();
-          return false;
-        }
+        lib.CheckReload(new_lib, this);
       }
     }
     map.Release();
   }
 
   // Validate classes.
   {
     ASSERT(class_map_storage_ != Array::null());
     UnorderedHashMap<ClassMapTraits> map(class_map_storage_);
     UnorderedHashMap<ClassMapTraits>::Iterator it(&map);
     Class& cls = Class::Handle();
     Class& new_cls = Class::Handle();
     while (it.MoveNext()) {
       const intptr_t entry = it.Current();
       new_cls = Class::RawCast(map.GetKey(entry));
       cls = Class::RawCast(map.GetPayload(entry, 0));
       if (new_cls.raw() != cls.raw()) {
-        if (!cls.CanReload(new_cls)) {
-          map.Release();
-          return false;
-        }
+        cls.CheckReload(new_cls, this);
       }
     }
     map.Release();
   }
-  return true;
+
+  return !HasReasonsForCancelling();
 }
 
 
 RawClass* IsolateReloadContext::FindOriginalClass(const Class& cls) {
   return MappedClass(cls);
 }
 
 
 RawClass* IsolateReloadContext::GetClassForHeapWalkAt(intptr_t cid) {
   if (saved_class_table_ != NULL) {
@@ skipping 330 matching lines @@
         ASSERT(!super_cls.IsNull());
         super_cls.AddDirectSubclass(cls);
       }
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart