Only reload libraries when they may have been modified.

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"
 #include "vm/dart_api_impl.h"
 #include "vm/hash_table.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/safepoint.h"
@@ skipping 154 matching lines @@
   const String& a_lib_url =
       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()),
+      reload_timestamp_(OS::GetCurrentTimeMillis()),

[Cutch, 2016/07/29 14:37:04]

Why does the reload context and the isolate have a reload timestamp? It looks
like you use the isolate's below.

[turnidge, 2016/07/29 17:37:37]

The isolate's reload timestamp is the timestamp of the last successful reload.

The IRC's reload timestamp is the timestamp that *will be* recorded if the
current reload succeeds.  This happens in isolate.cc.

I have renamed the isolate's timestamp to be "last_reload_timestamp" to make the
distinction more clear.  I have also moved setting the last_reload_timestamp
into isolate_reload.cc.

       isolate_(isolate),
+      reload_skipped_(false),
       has_error_(false),
       saved_num_cids_(-1),
       saved_class_table_(NULL),
       num_saved_libs_(-1),
+      modified_libs_(NULL),
       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()) {
@@ skipping 23 matching lines @@
   ReportError(LanguageError::Handle(LanguageError::New(error_msg)));
 }
 
 
 void IsolateReloadContext::ReportSuccess() {
   ServiceEvent service_event(I, ServiceEvent::kIsolateReload);
   Service::HandleEvent(&service_event);
 }
 
 
-void IsolateReloadContext::StartReload() {
+void IsolateReloadContext::StartReload(bool force_reload) {
   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());
 
+  // 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");
+    return;
+  }
+
   // 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 56 matching lines @@
   if (!old_cls.is_enum_class()) {
     new_cls.CopyCanonicalConstants(old_cls);
   }
   new_cls.CopyCanonicalType(old_cls);
   AddBecomeMapping(old_cls, new_cls);
   AddClassMapping(new_cls, old_cls);
 }
 
 
 void IsolateReloadContext::FinishReload() {
+  if (reload_skipped_) {
+    return;
+  }
   BuildLibraryMapping();
   TIR_Print("---- DONE FINALIZING\n");
   if (ValidateReload()) {
     Commit();
     PostCommit();
   } else {
     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.
+    // Re-enable code page write protection.
     I->heap()->WriteProtectCode(true);
   }
 
   BackgroundCompiler::Enable();
 }
 
 
 void IsolateReloadContext::AbortReload(const Error& error) {
   ReportError(error);
   Rollback();
@@ skipping 86 matching lines @@
       local_saved_class_table[i] = NULL;
     }
   }
   old_classes_set_storage_ = old_classes_set.Release().raw();
   // Assigning the field must be done after saving the class table.
   saved_class_table_ = local_saved_class_table;
   TIR_Print("---- System had %" Pd " classes\n", saved_num_cids_);
 }
 
 
-bool IsolateReloadContext::IsCleanLibrary(const Library& lib) {
-  return lib.is_dart_scheme();
+Dart_FileModifiedCallback IsolateReloadContext::file_modified_callback_ = NULL;
+
+
+bool IsolateReloadContext::ScriptModifiedSince(const Script& script,
+                                               int64_t since) {
+  if (file_modified_callback_ == NULL) {
+    return true;
+  }
+  // We use the resolved url to determine if the script has been modified.
+  const String& url = String::Handle(script.resolved_url());
+  const char* url_chars = url.ToCString();
+  return (*file_modified_callback_)(url_chars, since);
 }
 
 
+static void PropagateLibraryModified(
+    const ZoneGrowableArray<ZoneGrowableArray<intptr_t>* >* imported_by,
+    intptr_t lib_index,
+    BitVector* modified_libs) {
+  ZoneGrowableArray<intptr_t>* dep_libs = (*imported_by)[lib_index];
+  for (intptr_t i = 0; i < dep_libs->length(); i++) {
+    intptr_t dep_lib_index = (*dep_libs)[i];
+    if (!modified_libs->Contains(dep_lib_index)) {
+      modified_libs->Add(dep_lib_index);
+      PropagateLibraryModified(imported_by, dep_lib_index, modified_libs);
+    }
+  }
+}
+
+
+BitVector* IsolateReloadContext::FindModifiedLibraries(bool force_reload) {
+  Thread* thread = Thread::Current();
+  int64_t last_reload = I->reload_timestamp();
+
+  const GrowableObjectArray& libs =
+      GrowableObjectArray::Handle(object_store()->libraries());
+  Library& lib = Library::Handle();
+  Array& scripts = Array::Handle();
+  Script& script = Script::Handle();
+  intptr_t num_libs = libs.Length();
+
+  // Construct the imported-by graph.
+  ZoneGrowableArray<ZoneGrowableArray<intptr_t>* >* imported_by =
+      new ZoneGrowableArray<ZoneGrowableArray<intptr_t>* >(num_libs);
+  imported_by->SetLength(num_libs);
+  for (intptr_t i = 0; i < num_libs; i++) {
+    (*imported_by)[i] = new ZoneGrowableArray<intptr_t>();
+  }
+  Array& imports = Array::Handle();
+  Namespace& ns = Namespace::Handle();
+  Library& target = Library::Handle();
+
+  for (intptr_t lib_idx = 0; lib_idx < num_libs; lib_idx++) {
+    lib ^= libs.At(lib_idx);
+    ASSERT(lib_idx == lib.index());
+    if (lib.is_dart_scheme()) {
+      // We don't care about imports among dart scheme libraries.
+      continue;
+    }
+
+    // Add imports to the import-by graph.
+    imports = lib.imports();
+    for (intptr_t import_idx = 0; import_idx < imports.Length(); import_idx++) {
+      ns ^= imports.At(import_idx);
+      if (!ns.IsNull()) {
+        target = ns.library();
+        (*imported_by)[target.index()]->Add(lib.index());
+      }
+    }
+
+    // Add prefixed imports to the import-by graph.
+    DictionaryIterator entries(lib);
+    Object& entry = Object::Handle();
+    LibraryPrefix& prefix = LibraryPrefix::Handle();
+    while (entries.HasNext()) {
+      entry = entries.GetNext();
+      if (entry.IsLibraryPrefix()) {
+        prefix ^= entry.raw();
+        imports = prefix.imports();
+        for (intptr_t import_idx = 0; import_idx < imports.Length();
+             import_idx++) {
+          ns ^= imports.At(import_idx);
+          if (!ns.IsNull()) {
+            target = ns.library();
+            (*imported_by)[target.index()]->Add(lib.index());
+          }
+        }
+      }
+    }
+  }
+
+  BitVector* modified_libs = new(Z) BitVector(Z, num_libs);
+
+  for (intptr_t lib_idx = 0; lib_idx < num_libs; lib_idx++) {
+    lib ^= libs.At(lib_idx);
+    if (lib.is_dart_scheme() || modified_libs->Contains(lib_idx)) {
+      // We don't consider dart scheme libraries during reload.  If
+      // the modified libs set already contains this library, then we
+      // have already visited it.
+      continue;
+    }
+    scripts = lib.LoadedScripts();
+    for (intptr_t script_idx = 0; script_idx < scripts.Length(); script_idx++) {
+      script ^= scripts.At(script_idx);
+      if (force_reload) {
+        modified_libs->Add(lib_idx);
+        break;
+      }
+      if (ScriptModifiedSince(script, last_reload)) {

[Cutch, 2016/07/29 14:37:04]

maybe merge these two ifs:

if (force_reload || ScriptMOdifiedSince(script, last_reload))

[turnidge, 2016/07/29 17:37:37]

Done.

+        modified_libs->Add(lib_idx);
+        break;
+      }
+    }
+    if (modified_libs->Contains(lib_idx)) {
+      PropagateLibraryModified(imported_by, lib_idx, modified_libs);

[Cutch, 2016/07/29 14:37:04]

Could this be rolled into the if statement above?

if ... {
  modified_libs->Add(lib_idx);
  PropgateLibraryModified(imported_by, lib_idx, modified_libs);
}

[turnidge, 2016/07/29 17:37:37]

Done.

+    }
+  }
+
+  return modified_libs;
+}
+
+
 void IsolateReloadContext::CheckpointLibraries() {
   TIMELINE_SCOPE(CheckpointLibraries);
 
   // 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);
 
   // Make a filtered copy of the old libraries array. Keep "clean" libraries
   // that we will use instead of reloading.
   const GrowableObjectArray& new_libs = GrowableObjectArray::Handle(
       GrowableObjectArray::New(Heap::kOld));
   Library& lib = Library::Handle();
   UnorderedHashSet<LibraryMapTraits>
       old_libraries_set(old_libraries_set_storage_);
   num_saved_libs_ = 0;
   for (intptr_t i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
-    if (IsCleanLibrary(lib)) {
+    if (modified_libs_->Contains(i)) {
+      // We are going to reload this library. Clear the index.
+      lib.set_index(-1);
+    } else {
       // We are preserving this library across the reload, assign its new index
       lib.set_index(new_libs.Length());
       new_libs.Add(lib, Heap::kOld);
       num_saved_libs_++;
-    } else {
-      // We are going to reload this library. Clear the index.
-      lib.set_index(-1);
     }
     // Add old library to old libraries set.
     bool already_present = old_libraries_set.Insert(lib);
     ASSERT(!already_present);
   }
+  modified_libs_ = NULL;  // Renumbering the libraries has invalidated this.
   old_libraries_set_storage_ = old_libraries_set.Release().raw();
 
   // Reset the registered libraries to the filtered array.
   Library::RegisterLibraries(Thread::Current(), new_libs);
   // Reset the root library to null.
   object_store()->set_root_library(Library::Handle());
 }
 
 
 // While reloading everything we do must be reversible so that we can abort
@@ skipping 531 matching lines @@
   return lib.raw();
 }
 
 
 void IsolateReloadContext::BuildLibraryMapping() {
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(object_store()->libraries());
 
   Library& replacement_or_new = Library::Handle();
   Library& old = Library::Handle();
-  for (intptr_t i = 0; i < libs.Length(); i++) {
+  for (intptr_t i = num_saved_libs_; i < libs.Length(); i++) {
     replacement_or_new = Library::RawCast(libs.At(i));
-    if (IsCleanLibrary(replacement_or_new)) {
-      continue;
-    }
     old ^= OldLibraryOrNull(replacement_or_new);
     if (old.IsNull()) {
       if (FLAG_identity_reload) {
         TIR_Print("Could not find original library for %s\n",
                   replacement_or_new.ToCString());
         UNREACHABLE();
       }
       // New library.
       AddLibraryMapping(replacement_or_new, replacement_or_new);
     } else {
@@ skipping 87 matching lines @@
         ASSERT(!super_cls.IsNull());
         super_cls.AddDirectSubclass(cls);
       }
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart