Lazy loading of deferred libraries

runtime/vm/object.cc

 // Copyright (c) 2012, 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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 1011 matching lines @@
   object_store->set_external_two_byte_string_class(cls);
   RegisterPrivateClass(cls, Symbols::ExternalTwoByteString(), core_lib);
   pending_classes.Add(cls);
 
   // Pre-register the isolate library so the native class implementations
   // can be hooked up before compiling it.
   Library& isolate_lib =
       Library::Handle(isolate, Library::LookupLibrary(Symbols::DartIsolate()));
   if (isolate_lib.IsNull()) {
     isolate_lib = Library::NewLibraryHelper(Symbols::DartIsolate(), true);
+    isolate_lib.SetLoadRequested();
     isolate_lib.Register();
     isolate->object_store()->set_bootstrap_library(ObjectStore::kIsolate,
                                                    isolate_lib);
   }
   ASSERT(!isolate_lib.IsNull());
   ASSERT(isolate_lib.raw() == Library::IsolateLibrary());
 
   cls = Class::New<Capability>();
   RegisterPrivateClass(cls, Symbols::_CapabilityImpl(), isolate_lib);
   pending_classes.Add(cls);
@@ skipping 108 matching lines @@
 
   cls = Class::New<WeakProperty>();
   object_store->set_weak_property_class(cls);
   RegisterPrivateClass(cls, Symbols::_WeakProperty(), core_lib);
 
   // Pre-register the mirrors library so we can place the vm class
   // MirrorReference there rather than the core library.
   lib = Library::LookupLibrary(Symbols::DartMirrors());
   if (lib.IsNull()) {
     lib = Library::NewLibraryHelper(Symbols::DartMirrors(), true);
+    lib.SetLoadRequested();
     lib.Register();
     isolate->object_store()->set_bootstrap_library(ObjectStore::kMirrors,
                                                    lib);
   }
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::MirrorsLibrary());
 
   cls = Class::New<MirrorReference>();
   RegisterPrivateClass(cls, Symbols::_MirrorReference(), lib);
 
   // Pre-register the profiler library so we can place the vm class
   // UserTag there rather than the core library.
   lib = Library::LookupLibrary(Symbols::DartProfiler());
   if (lib.IsNull()) {
     lib = Library::NewLibraryHelper(Symbols::DartProfiler(), true);
+    lib.SetLoadRequested();
     lib.Register();
     isolate->object_store()->set_bootstrap_library(ObjectStore::kProfiler,
                                                    lib);
   }
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::ProfilerLibrary());
 
   lib = Library::LookupLibrary(Symbols::DartProfiler());
   ASSERT(!lib.IsNull());
   cls = Class::New<UserTag>();
   RegisterPrivateClass(cls, Symbols::_UserTag(), lib);
   pending_classes.Add(cls);
 
   // Setup some default native field classes which can be extended for
   // specifying native fields in dart classes.
   Library::InitNativeWrappersLibrary(isolate);
   ASSERT(isolate->object_store()->native_wrappers_library() != Library::null());
 
   // Pre-register the typed_data library so the native class implementations
   // can be hooked up before compiling it.
   lib = Library::LookupLibrary(Symbols::DartTypedData());
   if (lib.IsNull()) {
     lib = Library::NewLibraryHelper(Symbols::DartTypedData(), true);
+    lib.SetLoadRequested();
     lib.Register();
     isolate->object_store()->set_bootstrap_library(ObjectStore::kTypedData,
                                                    lib);
   }
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::TypedDataLibrary());
   const intptr_t typed_data_class_array_length =
       RawObject::NumberOfTypedDataClasses();
   Array& typed_data_classes =
       Array::Handle(Array::New(typed_data_class_array_length));
@@ skipping 7100 matching lines @@
 
 void Library::SetName(const String& name) const {
   // Only set name once.
   ASSERT(!Loaded());
   ASSERT(name.IsSymbol());
   StorePointer(&raw_ptr()->name_, name.raw());
 }
 
 
 void Library::SetLoadInProgress() const {
-  // Should not be already loaded.
+  // Must not already be in the process of being loaded.
+  ASSERT(raw_ptr()->load_state_ <= RawLibrary::kLoadRequested);
+  raw_ptr()->load_state_ = RawLibrary::kLoadInProgress;
+}
+
+
+void Library::SetLoadRequested() const {
+  // Must not be already loaded.
   ASSERT(raw_ptr()->load_state_ == RawLibrary::kAllocated);
-  raw_ptr()->load_state_ = RawLibrary::kLoadInProgress;
+  raw_ptr()->load_state_ = RawLibrary::kLoadRequested;
 }
 
 
 void Library::SetLoaded() const {
   // Should not be already loaded or just allocated.
-  ASSERT(LoadInProgress());
+  ASSERT(LoadInProgress() || LoadRequested());
   raw_ptr()->load_state_ = RawLibrary::kLoaded;
 }
 
 
 void Library::SetLoadError() const {
   // Should not be already loaded or just allocated.
-  ASSERT(LoadInProgress());
+  ASSERT(LoadInProgress() || LoadRequested());
   raw_ptr()->load_state_ = RawLibrary::kLoadError;
 }
 
 
 static RawString* MakeClassMetaName(const Class& cls) {
   String& cname = String::Handle(cls.Name());
   return String::Concat(Symbols::At(), cname);
 }
 
 
@@ skipping 846 matching lines @@
 
 RawLibrary* Library::New(const String& url) {
   return NewLibraryHelper(url, false);
 }
 
 
 void Library::InitCoreLibrary(Isolate* isolate) {
   const String& core_lib_url = Symbols::DartCore();
   const Library& core_lib =
       Library::Handle(Library::NewLibraryHelper(core_lib_url, false));
+  core_lib.SetLoadRequested();
   core_lib.Register();
   isolate->object_store()->set_bootstrap_library(ObjectStore::kCore, core_lib);
   isolate->object_store()->set_root_library(Library::Handle());
 
   // Hook up predefined classes without setting their library pointers. These
   // classes are coming from the VM isolate, and are shared between multiple
   // isolates so setting their library pointers would be wrong.
   const Class& cls = Class::Handle(Object::dynamic_class());
   core_lib.AddObject(cls, String::Handle(cls.Name()));
 }
@@ skipping 17 matching lines @@
 
 
 void Library::InitNativeWrappersLibrary(Isolate* isolate) {
   static const int kNumNativeWrappersClasses = 4;
   ASSERT(kNumNativeWrappersClasses > 0 && kNumNativeWrappersClasses < 10);
   const String& native_flds_lib_url = Symbols::DartNativeWrappers();
   const Library& native_flds_lib = Library::Handle(
       Library::NewLibraryHelper(native_flds_lib_url, false));
   const String& native_flds_lib_name = Symbols::DartNativeWrappersLibName();
   native_flds_lib.SetName(native_flds_lib_name);
+  native_flds_lib.SetLoadRequested();
   native_flds_lib.Register();
+  native_flds_lib.SetLoadInProgress();
   isolate->object_store()->set_native_wrappers_library(native_flds_lib);
   static const char* const kNativeWrappersClass = "NativeFieldWrapperClass";
   static const int kNameLength = 25;
   ASSERT(kNameLength == (strlen(kNativeWrappersClass) + 1 + 1));
   char name_buffer[kNameLength];
   String& cls_name = String::Handle();
   for (int fld_cnt = 1; fld_cnt <= kNumNativeWrappersClasses; fld_cnt++) {
     OS::SNPrint(name_buffer,
                 kNameLength,
                 "%s%d",
                 kNativeWrappersClass,
                 fld_cnt);
     cls_name = Symbols::New(name_buffer);
     Class::NewNativeWrapper(native_flds_lib, cls_name, fld_cnt);
   }
+  native_flds_lib.SetLoaded();
 }
 
 
 // Returns library with given url in current isolate, or NULL.
 RawLibrary* Library::LookupLibrary(const String &url) {
   Isolate* isolate = Isolate::Current();
   Library& lib = Library::Handle(isolate, Library::null());
   String& lib_url = String::Handle(isolate, String::null());
   GrowableObjectArray& libs = GrowableObjectArray::Handle(
       isolate, isolate->object_store()->libraries());
@@ skipping 348 matching lines @@
   }
   return Class::null();
 }
 
 
 void LibraryPrefix::set_is_loaded() const {
   raw_ptr()->is_loaded_ = true;
 }
 
 
-void LibraryPrefix::LoadLibrary() const {
+bool LibraryPrefix::LoadLibrary() const {
   // Non-deferred prefixes are loaded.
   ASSERT(is_deferred_load() || is_loaded());
   if (is_loaded()) {
-    return;
+    return true;  // Load request has already completed.
   }
-  InvalidateDependentCode();
-  set_is_loaded();
+  ASSERT(is_deferred_load());
+  ASSERT(num_imports() == 1);
+  // This is a prefix for a deferred library. If the library is not loaded
+  // yet and isn't being loaded, call the library tag handler to schedule
+  // loading. Once all outstanding load requests have completed, the embedder
+  // will call the core library to:
+  // - invalidate dependent code of this prefix;
+  // - mark this prefixes as loaded;
+  // - complete the future associated with this prefix.
+  const Library& deferred_lib = Library::Handle(GetLibrary(0));
+  if (deferred_lib.Loaded()) {
+    this->set_is_loaded();
+    return true;
+  } else if (deferred_lib.LoadNotStarted()) {
+    deferred_lib.SetLoadRequested();
+    Isolate* isolate = Isolate::Current();
+    const String& lib_url = String::Handle(isolate, deferred_lib.url());
+    Dart_LibraryTagHandler handler = isolate->library_tag_handler();
+    handler(Dart_kImportTag,
+            Api::NewHandle(isolate, importer()),
+            Api::NewHandle(isolate, lib_url.raw()));
+  } else {
+    // Another load request is in flight.
+    ASSERT(deferred_lib.LoadRequested());
+  }
+  return false;  // Load request not yet completed.
 }
 
 
 RawArray* LibraryPrefix::dependent_code() const {
   return raw_ptr()->dependent_code_;
 }
 
 
 void LibraryPrefix::set_dependent_code(const Array& array) const {
   StorePointer(&raw_ptr()->dependent_code_, array.raw());
@@ skipping 38 matching lines @@
   ASSERT(is_deferred_load());
   ASSERT(!is_loaded());
   PrefixDependentArray a(*this);
   a.Register(code);
 }
 
 
 void LibraryPrefix::InvalidateDependentCode() const {
   PrefixDependentArray a(*this);
   a.DisableCode();
+  set_is_loaded();
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New() {
   ASSERT(Isolate::Current()->object_store()->library_prefix_class() !=
       Class::null());
   RawObject* raw = Object::Allocate(LibraryPrefix::kClassId,
                                     LibraryPrefix::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLibraryPrefix*>(raw);
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New(const String& name,
                                      const Namespace& import,
-                                     bool deferred_load) {
+                                     bool deferred_load,
+                                     const Library& importer) {
   const LibraryPrefix& result = LibraryPrefix::Handle(LibraryPrefix::New());
   result.set_name(name);
   result.set_num_imports(0);
+  result.set_importer(importer);
   result.raw_ptr()->is_deferred_load_ = deferred_load;
   result.raw_ptr()->is_loaded_ = !deferred_load;
   result.set_imports(Array::Handle(Array::New(kInitialSize)));
   result.AddImport(import);
   result.set_dependent_code(Object::null_array());
   return result.raw();
 }
 
 
 void LibraryPrefix::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 void LibraryPrefix::set_imports(const Array& value) const {
   StorePointer(&raw_ptr()->imports_, value.raw());
 }
 
 
 void LibraryPrefix::set_num_imports(intptr_t value) const {
   raw_ptr()->num_imports_ = value;
 }
 
 
+void LibraryPrefix::set_importer(const Library& value) const {
+  StorePointer(&raw_ptr()->importer_, value.raw());
+}
+
+
 const char* LibraryPrefix::ToCString() const {
   const char* kFormat = "LibraryPrefix:'%s'";
   const String& prefix = String::Handle(name());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, prefix.ToCString()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, prefix.ToCString());
   return chars;
 }
 
 
@@ skipping 9280 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart