Allow the resolved names cache to be lazily created like the exported names cache.

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/become.h"
@@ skipping 10075 matching lines @@
   }
   static uword Hash(const Object& obj) { return String::Cast(obj).Hash(); }
 };
 typedef UnorderedHashMap<StringEqualsTraits> ResolvedNamesMap;
 
 
 // Returns true if the name is found in the cache, false no cache hit.
 // obj is set to the cached entry. It may be null, indicating that the
 // name does not resolve to anything in this library.
 bool Library::LookupResolvedNamesCache(const String& name, Object* obj) const {
+  if (resolved_names() == Array::null()) {
+    return false;
+  }
   ResolvedNamesMap cache(resolved_names());
   bool present = false;
   *obj = cache.GetOrNull(name, &present);
 // Mutator compiler thread may add entries and therefore
 // change 'resolved_names()' while running a background compilation;
 // ASSERT that 'resolved_names()' has not changed only in mutator.
 #if defined(DEBUG)
   if (Thread::Current()->IsMutatorThread()) {
     ASSERT(cache.Release().raw() == resolved_names());
   } else {
     // Release must be called in debug mode.
     cache.Release();
   }
 #endif
   return present;
 }
 
 
 // Add a name to the resolved name cache. This name resolves to the
 // given object in this library scope. obj may be null, which means
 // the name does not resolve to anything in this library scope.
 void Library::AddToResolvedNamesCache(const String& name,
                                       const Object& obj) const {
   if (!FLAG_use_lib_cache || Compiler::IsBackgroundCompilation()) {
     return;
   }
+  if (resolved_names() == Array::null()) {
+    InitResolvedNamesCache();
+  }
   ResolvedNamesMap cache(resolved_names());
   cache.UpdateOrInsert(name, obj);
   StorePointer(&raw_ptr()->resolved_names_, cache.Release().raw());
 }
 
 
 bool Library::LookupExportedNamesCache(const String& name, Object* obj) const {
   ASSERT(FLAG_use_exp_cache);
   if (exported_names() == Array::null()) {
     return false;
@@ skipping 14 matching lines @@
 #endif
   return present;
 }
 
 void Library::AddToExportedNamesCache(const String& name,
                                       const Object& obj) const {
   if (!FLAG_use_exp_cache || Compiler::IsBackgroundCompilation()) {
     return;
   }
   if (exported_names() == Array::null()) {
-    AllocateExportedNamesCache();
+    InitExportedNamesCache();
   }
   ResolvedNamesMap cache(exported_names());
   cache.UpdateOrInsert(name, obj);
   StorePointer(&raw_ptr()->exported_names_, cache.Release().raw());
 }
 
 
 void Library::InvalidateResolvedName(const String& name) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Object& entry = Object::Handle(zone);
   if (LookupResolvedNamesCache(name, &entry)) {
     // TODO(koda): Support deleted sentinel in snapshots and remove only 'name'.
-    InvalidateResolvedNamesCache();
+    ClearResolvedNamesCache();
   }
   // When a new name is added to a library, we need to invalidate all
   // caches that contain an entry for this name. If the name was previously
   // looked up but could not be resolved, the cache contains a null entry.
   GrowableObjectArray& libs = GrowableObjectArray::Handle(
       zone, thread->isolate()->object_store()->libraries());
   Library& lib = Library::Handle(zone);
   intptr_t num_libs = libs.Length();
   for (intptr_t i = 0; i < num_libs; i++) {
     lib ^= libs.At(i);
     if (lib.LookupExportedNamesCache(name, &entry)) {
-      lib.InitExportedNamesCache();
+      lib.ClearExportedNamesCache();
     }
   }
 }
 
 
-void Library::InvalidateResolvedNamesCache() const {
-  const intptr_t kInvalidatedCacheSize = 16;
-  InitResolvedNamesCache(kInvalidatedCacheSize);
-}
-
-
 // Invalidate all exported names caches in the isolate.
 void Library::InvalidateExportedNamesCaches() {
   GrowableObjectArray& libs = GrowableObjectArray::Handle(
       Isolate::Current()->object_store()->libraries());
   Library& lib = Library::Handle();
   intptr_t num_libs = libs.Length();
   for (intptr_t i = 0; i < num_libs; i++) {
     lib ^= libs.At(i);
-    lib.InitExportedNamesCache();
+    lib.ClearExportedNamesCache();
   }
 }
 
 
 void Library::GrowDictionary(const Array& dict, intptr_t dict_size) const {
   // TODO(iposva): Avoid exponential growth.
   intptr_t new_dict_size = dict_size * 2;
   const Array& new_dict =
       Array::Handle(Array::New(new_dict_size + 1, Heap::kOld));
   // Rehash all elements from the original dictionary
@@ skipping 178 matching lines @@
       ASSERT(dict.At(new_index) == Object::null());
       dict.SetAt(new_index, entry);
       dict.SetAt(index, Object::null_object());
     }
   }
 
   // Update used count.
   intptr_t used_elements = Smi::Value(Smi::RawCast(dict.At(dict_size))) - 1;
   dict.SetAt(dict_size, Smi::Handle(zone, Smi::New(used_elements)));
 
-  InvalidateResolvedNamesCache();
+  ClearResolvedNamesCache();
   InvalidateExportedNamesCaches();
 
   return true;
 }
 
 
 void Library::AddClass(const Class& cls) const {
   ASSERT(!Compiler::IsBackgroundCompilation());
   const String& class_name = String::Handle(cls.Name());
   AddObject(cls, class_name);
@@ skipping 392 matching lines @@
 
 
 static RawArray* NewDictionary(intptr_t initial_size) {
   const Array& dict = Array::Handle(Array::New(initial_size + 1, Heap::kOld));
   // The last element of the dictionary specifies the number of in use slots.
   dict.SetAt(initial_size, Smi::Handle(Smi::New(0)));
   return dict.raw();
 }
 
 
-void Library::InitResolvedNamesCache(intptr_t size) const {
+void Library::InitResolvedNamesCache() const {
   ASSERT(Thread::Current()->IsMutatorThread());
   StorePointer(&raw_ptr()->resolved_names_,
-               HashTables::New<ResolvedNamesMap>(size));
+               HashTables::New<ResolvedNamesMap>(64));
 }
 
 
-void Library::AllocateExportedNamesCache() const {
+void Library::ClearResolvedNamesCache() const {
+  ASSERT(Thread::Current()->IsMutatorThread());
+  StorePointer(&raw_ptr()->resolved_names_, Array::null());
+}
+
+
+void Library::InitExportedNamesCache() const {
   StorePointer(&raw_ptr()->exported_names_,
                HashTables::New<ResolvedNamesMap>(16));
 }
 
 
-void Library::InitExportedNamesCache() const {
-  if (exported_names() != Array::null()) {
-    StorePointer(&raw_ptr()->exported_names_,
-                 HashTables::New<ResolvedNamesMap>(16));
-  }
+void Library::ClearExportedNamesCache() const {
+  StorePointer(&raw_ptr()->exported_names_, Array::null());
 }
 
 
 void Library::InitClassDictionary() const {
   // TODO(iposva): Find reasonable initial size.
   const int kInitialElementCount = 16;
   StorePointer(&raw_ptr()->dictionary_, NewDictionary(kInitialElementCount));
 }
 
 
@@ skipping 18 matching lines @@
   Zone* zone = thread->zone();
   ASSERT(thread->IsMutatorThread());
   // Force the url to have a hash code.
   url.Hash();
   const bool dart_scheme = url.StartsWith(Symbols::DartScheme());
   const bool dart_private_scheme =
       dart_scheme && url.StartsWith(Symbols::DartSchemePrivate());
   const Library& result = Library::Handle(zone, Library::New());
   result.StorePointer(&result.raw_ptr()->name_, Symbols::Empty().raw());
   result.StorePointer(&result.raw_ptr()->url_, url.raw());
-  result.StorePointer(&result.raw_ptr()->resolved_names_,
-                      Object::empty_array().raw());
+  result.StorePointer(&result.raw_ptr()->resolved_names_, Array::null());
   result.StorePointer(&result.raw_ptr()->exported_names_, Array::null());
   result.StorePointer(&result.raw_ptr()->dictionary_,
                       Object::empty_array().raw());
   result.StorePointer(&result.raw_ptr()->metadata_,
                       GrowableObjectArray::New(4, Heap::kOld));
   result.StorePointer(&result.raw_ptr()->toplevel_class_, Class::null());
   result.StorePointer(
       &result.raw_ptr()->patch_classes_,
       GrowableObjectArray::New(Object::empty_array(), Heap::kOld));
   result.StorePointer(&result.raw_ptr()->imports_, Object::empty_array().raw());
@@ skipping 12 matching lines @@
     // frames.
     result.set_debuggable(FLAG_show_invisible_frames);
   } else {
     // Default to debuggable for all other libraries.
     result.set_debuggable(true);
   }
   result.set_is_dart_scheme(dart_scheme);
   result.StoreNonPointer(&result.raw_ptr()->load_state_,
                          RawLibrary::kAllocated);
   result.StoreNonPointer(&result.raw_ptr()->index_, -1);
-  const intptr_t kInitialNameCacheSize = 64;
-  result.InitResolvedNamesCache(kInitialNameCacheSize);
   result.InitClassDictionary();
   result.InitImportList();
   result.AllocatePrivateKey();
   if (import_core_lib) {
     const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
     const Namespace& ns = Namespace::Handle(
         zone,
         Namespace::New(core_lib, Object::null_array(), Object::null_array()));
     result.AddImport(ns);
@@ skipping 12231 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart