More reload status and bug fixes

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/bit_vector.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 423 matching lines @@
   // 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());
 
   // Check to see which libraries have been modified.
   modified_libs_ = FindModifiedLibraries(force_reload);
   if (!modified_libs_->Contains(root_lib.index())) {
     ASSERT(modified_libs_->IsEmpty());
     reload_skipped_ = true;
-    TIR_Print("Skipping reload.  No libraries were modified\n");
+    TIR_Print("---- SKIPPING RELOAD (No libraries were modified)\n");
     return;
   }
 
+  TIR_Print("---- STARTING RELOAD\n");
+
   // Preallocate storage for maps.
   old_classes_set_storage_ =
       HashTables::New<UnorderedHashSet<ClassMapTraits> >(4);
   class_map_storage_ =
       HashTables::New<UnorderedHashMap<ClassMapTraits> >(4);
   old_libraries_set_storage_ =
       HashTables::New<UnorderedHashSet<LibraryMapTraits> >(4);
   library_map_storage_ =
       HashTables::New<UnorderedHashMap<LibraryMapTraits> >(4);
   become_map_storage_ =
@@ skipping 18 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);
   }
+
+  BackgroundCompiler::Enable();
+
   if (result.IsUnwindError()) {
     // Ignore an unwind error because the isolate is dead.
     return;
   }
+
   if (result.IsError()) {
     FinalizeFailedLoad(Error::Cast(result));
   }
 }
 
 
 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);
@@ skipping 19 matching lines @@
 }
 
 
 // FinalizeLoading will be called *before* Reload() returns but will not be
 // called if the embedder fails to load sources.
 void IsolateReloadContext::FinalizeLoading() {
   if (reload_skipped_) {
     return;
   }
   BuildLibraryMapping();
-  TIR_Print("---- DONE FINALIZING\n");
+  TIR_Print("---- LOAD SUCCEEDED\n");
   if (ValidateReload()) {
     Commit();
     PostCommit();
     isolate()->set_last_reload_timestamp(reload_timestamp_);
   } else {
     ReportReasonsForCancelling();
     Rollback();
   }
   // ValidateReload mutates the direct subclass information and does
   // not remove dead subclasses.  Rebuild the direct subclass
   // information from scratch.
   RebuildDirectSubclasses();
 
   CommonFinalizeTail();
 }
 
 
 // FinalizeFailedLoad will be called *before* Reload() returns and will only
 // be called if the embedder fails to load sources.
 void IsolateReloadContext::FinalizeFailedLoad(const Error& error) {
+  TIR_Print("---- LOAD FAILED, ABORTING RELOAD\n");
   AddReasonForCancelling(new Aborted(zone_, error));
   ReportReasonsForCancelling();
   Rollback();
   CommonFinalizeTail();
 }
 
 
 void IsolateReloadContext::CommonFinalizeTail() {
-  BackgroundCompiler::Enable();
   ReportOnJSON(js_);
 }
 
+
 void IsolateReloadContext::ReportOnJSON(JSONStream* stream) {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", "ReloadReport");
   jsobj.AddProperty("success", !HasReasonsForCancelling());
   {
     JSONObject details(&jsobj, "details");
     if (HasReasonsForCancelling()) {
       // Reload was rejected.
       JSONArray array(&jsobj, "notices");
       for (intptr_t i = 0; i < reasons_to_cancel_reload_.length(); i++) {
@@ skipping 234 matching lines @@
       }
     }
   }
 
   return modified_libs;
 }
 
 
 void IsolateReloadContext::CheckpointLibraries() {
   TIMELINE_SCOPE(CheckpointLibraries);
-
+  TIR_Print("---- CHECKPOINTING LIBRARIES\n");
   // Save the root library in case we abort the reload.
   const Library& root_lib =
       Library::Handle(object_store()->root_library());
   set_saved_root_library(root_lib);
 
   // Save the old libraries array in case we abort the reload.
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(object_store()->libraries());
   set_saved_libraries(libs);
 
@@ skipping 79 matching lines @@
   if (!saved_root_lib.IsNull()) {
     object_store()->set_root_library(saved_root_lib);
   }
 
   set_saved_root_library(Library::Handle());
   set_saved_libraries(GrowableObjectArray::Handle());
 }
 
 
 void IsolateReloadContext::Rollback() {
+  TIR_Print("---- ROLLING BACK");
   RollbackClasses();
   RollbackLibraries();
 }
 
 
 #ifdef DEBUG
 void IsolateReloadContext::VerifyMaps() {
   TIMELINE_SCOPE(VerifyMaps);
   Class& cls = Class::Handle();
   Class& new_cls = Class::Handle();
@@ skipping 23 matching lines @@
     }
   }
   class_map.Release();
   reverse_class_map.Release();
 }
 #endif
 
 
 void IsolateReloadContext::Commit() {
   TIMELINE_SCOPE(Commit);
-  TIR_Print("---- COMMITTING REVERSE MAP\n");
+  TIR_Print("---- COMMITTING RELOAD\n");
 
   // Note that the object heap contains before and after instances
   // used for morphing. It is therefore important that morphing takes
   // place prior to any heap walking.
   // So please keep this code at the top of Commit().
   if (HasInstanceMorphers()) {
     // Perform shape shifting of instances if necessary.
     MorphInstances();
   }
 
@@ skipping 249 matching lines @@
   free(saved_class_table_);
   saved_class_table_ = NULL;
   Become::ElementsForwardIdentity(before, after);
 }
 
 
 bool IsolateReloadContext::ValidateReload() {
   TIMELINE_SCOPE(ValidateReload);
   if (reload_aborted()) return false;
 
+  TIR_Print("---- VALIDATING RELOAD\n");
+
   // 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));
@@ skipping 364 matching lines @@
         ASSERT(!super_cls.IsNull());
         super_cls.AddDirectSubclass(cls);
       }
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart