Only reload libraries when they may have been modified.

runtime/vm/isolate_reload.h

 // 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.
 
 #ifndef VM_ISOLATE_RELOAD_H_
 #define VM_ISOLATE_RELOAD_H_
 
+#include "include/dart_tools_api.h"
+
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/log.h"
 
 DECLARE_FLAG(bool, trace_reload);
 DECLARE_FLAG(bool, trace_reload_verbose);
 
 // 'Trace Isolate Reload' TIR_Print
 #if defined(_MSC_VER)
 #define TIR_Print(format, ...) \
     if (FLAG_trace_reload) Log::Current()->Print(format, __VA_ARGS__)
 #else
 #define TIR_Print(format, ...) \
     if (FLAG_trace_reload) Log::Current()->Print(format, ##__VA_ARGS__)
 #endif
 
 // 'Verbose Trace Isolate Reload' VTIR_Print
 #if defined(_MSC_VER)
 #define VTIR_Print(format, ...) \
     if (FLAG_trace_reload_verbose) Log::Current()->Print(format, __VA_ARGS__)
 #else
 #define VTIR_Print(format, ...) \
     if (FLAG_trace_reload_verbose) Log::Current()->Print(format, ##__VA_ARGS__)
 #endif
 
 namespace dart {
 
+class BitVector;
 class GrowableObjectArray;
 class Isolate;
 class Library;
+class ObjectPointerVisitor;
+class ObjectStore;
 class RawError;
 class RawGrowableObjectArray;
 class RawLibrary;
 class RawObject;
 class RawString;
-class ObjectPointerVisitor;
-class ObjectStore;
+class Script;
 class UpdateClassesVisitor;
 
 class IsolateReloadContext {
  public:
   explicit IsolateReloadContext(Isolate* isolate);
   ~IsolateReloadContext();
 
-  void StartReload();
+  void StartReload(bool force_reload);
   void FinishReload();
   void AbortReload(const Error& error);
 
   RawLibrary* saved_root_library() const;
 
   RawGrowableObjectArray* saved_libraries() const;
 
   void ReportError(const Error& error);
   void ReportError(const String& error_msg);
   void ReportSuccess();
 
+  bool reload_skipped() const { return reload_skipped_; }
+
   bool has_error() const { return has_error_; }
   RawError* error() const { return error_; }
 
+  int64_t reload_timestamp() const { return reload_timestamp_; }
+
   static bool IsSameField(const Field& a, const Field& b);
   static bool IsSameLibrary(const Library& a_lib, const Library& b_lib);
   static bool IsSameClass(const Class& a, const Class& b);
 
   RawClass* FindOriginalClass(const Class& cls);
 
   bool IsDirty(const Library& lib);
 
   // Prefers old classes when we are in the middle of a reload.
   RawClass* GetClassForHeapWalkAt(intptr_t cid);
 
   void RegisterClass(const Class& new_cls);
 
   // Finds the library private key for |replacement_or_new| or return null
   // if |replacement_or_new| is new.
   RawString* FindLibraryPrivateKey(const Library& replacement_or_new);
 
   int64_t start_time_micros() const { return start_time_micros_; }
 
+  static Dart_FileModifiedCallback file_modified_callback() {
+    return file_modified_callback_;
+  }
+  static void SetFileModifiedCallback(Dart_FileModifiedCallback callback) {
+    file_modified_callback_ = callback;
+  }
+
  private:
   void set_saved_root_library(const Library& value);
 
   void set_saved_libraries(const GrowableObjectArray& value);
 
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   Isolate* isolate() { return isolate_; }
   ObjectStore* object_store();
 
   void EnsuredUnoptimizedCodeForStack();
   void DeoptimizeDependentCode();
 
   void Checkpoint();
 
   void CheckpointClasses();
 
-  // Is |lib| a library whose sources have not changed?
-  bool IsCleanLibrary(const Library& lib);
+  bool ScriptModifiedSince(const Script& script, int64_t since);
+  BitVector* FindModifiedLibraries(bool force_reload);
+
   void CheckpointLibraries();
 
   bool ValidateReload();
 
   void Rollback();
 
   void RollbackClasses();
   void RollbackLibraries();
 
 #ifdef DEBUG
   void VerifyMaps();
 #endif
 
   void Commit();
 
   void PostCommit();
 
   void ClearReplacedObjectBits();
 
   // atomic_install:
   void MarkAllFunctionsForRecompilation();
   void ResetUnoptimizedICsOnStack();
   void ResetMegamorphicCaches();
   void InvalidateWorld();
 
   int64_t start_time_micros_;
+  int64_t reload_timestamp_;
   Isolate* isolate_;
+  bool reload_skipped_;
   bool has_error_;
 
   intptr_t saved_num_cids_;
   RawClass** saved_class_table_;
 
   intptr_t num_saved_libs_;
   struct LibraryInfo {
     bool dirty;
   };
   MallocGrowableArray<LibraryInfo> library_infos_;
 
+  // A bit vector indicating which of the original libraries were modified.
+  BitVector* modified_libs_;
+
   RawClass* OldClassOrNull(const Class& replacement_or_new);
 
   RawLibrary* OldLibraryOrNull(const Library& replacement_or_new);
   void BuildLibraryMapping();
 
   void AddClassMapping(const Class& replacement_or_new,
                        const Class& original);
 
   void AddLibraryMapping(const Library& replacement_or_new,
                          const Library& original);
@@ skipping 16 matching lines @@
   RawArray* old_libraries_set_storage_;
   RawArray* library_map_storage_;
   RawArray* become_map_storage_;
   RawGrowableObjectArray* become_enum_mappings_;
   RawLibrary* saved_root_library_;
   RawGrowableObjectArray* saved_libraries_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&saved_libraries_); }
 
   friend class Isolate;
   friend class Class;  // AddStaticFieldMapping, AddEnumBecomeMapping.
+
+  static Dart_FileModifiedCallback file_modified_callback_;
 };
 
 }  // namespace dart
 
 #endif   // VM_ISOLATE_RELOAD_H_