Tree-shaking: use a hash set for tracking live selectors, drop uncompiled functions.

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/compiler.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
@@ skipping 31 matching lines @@
 }
 
 
 Precompiler::Precompiler(Thread* thread) :
   thread_(thread),
   zone_(thread->zone()),
   isolate_(thread->isolate()),
   changed_(false),
   function_count_(0),
   class_count_(0),
+  selector_count_(0),
+  dropped_function_count_(0),
   libraries_(GrowableObjectArray::Handle(Z, I->object_store()->libraries())),
   pending_functions_(GrowableObjectArray::Handle(Z,
                                                  GrowableObjectArray::New())),
   collected_closures_(GrowableObjectArray::Handle(Z, I->collected_closures())),
-  sent_selectors_(GrowableObjectArray::Handle(Z, GrowableObjectArray::New())),
+  sent_selectors_(Z),
   error_(Error::Handle(Z)) {
 }
 
 
 void Precompiler::DoCompileAll() {
   // Drop all existing code so we can use the presence of code as an indicator
   // that we have already looked for the function's callees.
   ClearAllCode();
 
   // Start with the allocations and invocations that happen from C++.
   AddRoots();
 
   // TODO(rmacnak): Eagerly add field-invocation functions to all signature
   // classes so closure calls don't go through the runtime.
 
   // Compile newly found targets and add their callees until we reach a fixed
   // point.
   Iterate();
 
   CleanUp();
 
   if (FLAG_trace_precompiler) {
     OS::Print("Precompiled %" Pd " functions, %" Pd " dynamic types,"
               " %" Pd " dynamic selectors\n",
               function_count_,
               class_count_,
-              sent_selectors_.Length());
+              selector_count_);
+    OS::Print("Dropped %" Pd " functions\n",
+              dropped_function_count_);

[srdjan, 2015/08/05 18:20:08]

ISL_Print

[Cutch, 2015/08/05 18:25:05]

DBC: You may also want to put a:

LogBlock lb(Thread::Current());

At the top of ::DoCompileAll so that the output all precompiler traces are
output in a block.

[rmacnak, 2015/08/05 19:51:50]

Done.

   }
 
   I->set_compilation_allowed(false);
 }
 
 
 void Precompiler::ClearAllCode() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& functions = Array::Handle(Z);
@@ skipping 232 matching lines @@
       function ^= collected_closures_.RemoveLast();
       ProcessFunction(function);
     }
   }
 }
 
 
 void Precompiler::CleanUp() {
   I->set_collected_closures(GrowableObjectArray::Handle(Z));
 
-  // TODO(rmacnak): Drop functions without code, classes without functions, etc.
+  DropUncompiledFunctions();
+
+  // TODO(rmacnak): DropEmptyClasses();
 }
 
 
 void Precompiler::ProcessFunction(const Function& function) {
   if (!function.HasCode()) {
     function_count_++;
 
     if (FLAG_trace_precompiler) {
       OS::Print("Precompiling %" Pd " %s (%" Pd ", %s)\n",
                 function_count_,
@@ skipping 100 matching lines @@
 
 void Precompiler::AddFunction(const Function& function) {
   if (function.HasCode()) return;
 
   pending_functions_.Add(function);
   changed_ = true;
 }
 
 
 bool Precompiler::IsSent(const String& selector) {
-  ASSERT(selector.IsSymbol());
-
-  // TODO(rmacnak): Use a proper set.
-  for (intptr_t i = 0; i < sent_selectors_.Length(); i++) {
-    if (sent_selectors_.At(i) == selector.raw()) {
-      return true;
-    }
-  }
-
-  return false;
+  return sent_selectors_.Includes(selector);
 }
 
 
 void Precompiler::AddSelector(const String& selector) {
   if (!IsSent(selector)) {
+    sent_selectors_.Add(selector);
+    selector_count_++;
+    changed_ = true;
+
     if (FLAG_trace_precompiler) {
       OS::Print("Enqueueing selector %" Pd " %s\n",
-                sent_selectors_.Length(),
+                selector_count_,
                 selector.ToCString());
     }
 
-    sent_selectors_.Add(selector);
-    changed_ = true;
-
     if (!Field::IsGetterName(selector) &&
         !Field::IsSetterName(selector)) {
       // Regular method may be call-through-getter.
-      // TODO(rmacnak): Do not create the symbol if it does not already exist.

[rmacnak, 2015/08/05 18:11:54]

Turns out the vast majority of these selectors already have both the getter name
and simple name in the symbol table, so adding code to lookup an existing symbol
didn't save much.

-      String& getter = String::Handle(Field::GetterName(selector));
-      getter = Symbols::New(getter);
+      const String& getter = String::Handle(Field::GetterSymbol(selector));
       AddSelector(getter);
     }
   }
 }
 
 
 void Precompiler::AddClass(const Class& cls) {
   if (cls.is_allocated()) return;
 
   class_count_++;
@@ skipping 73 matching lines @@
         // if (function.HasCode()) continue;
 
         selector = function.name();
         if (IsSent(selector)) {
           AddFunction(function);
         }
 
         if (function.kind() == RawFunction::kRegularFunction &&
             !Field::IsGetterName(selector) &&
             !Field::IsSetterName(selector)) {
-          // TODO(rmacnak): Do not create the symbol if it does not already
-          // exist.
-          selector = Field::GetterName(selector);
-          selector = Symbols::New(selector);
+          selector = Field::GetterSymbol(selector);
           if (IsSent(selector)) {
             function = function.ImplicitClosureFunction();
             AddFunction(function);
           }
         }
       }
     }
   }
 }
 
+
+void Precompiler::DropUncompiledFunctions() {
+  Library& lib = Library::Handle(Z);
+  Class& cls = Class::Handle(Z);
+  Array& functions = Array::Handle(Z);
+  Function& function = Function::Handle(Z);
+  GrowableObjectArray& retained_functions = GrowableObjectArray::Handle(Z);
+  GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
+
+  for (intptr_t i = 0; i < libraries_.Length(); i++) {
+    lib ^= libraries_.At(i);
+    ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
+    while (it.HasNext()) {
+      cls = it.GetNextClass();
+      if (cls.IsDynamicClass()) {
+        continue;  // class 'dynamic' is in the read-only VM isolate.
+      }
+
+      functions = cls.functions();
+      retained_functions = GrowableObjectArray::New();
+      for (intptr_t j = 0; j < functions.Length(); j++) {
+        function ^= functions.At(j);
+        if (function.HasCode()) {
+          retained_functions.Add(function);
+        } else {
+          dropped_function_count_++;
+          if (FLAG_trace_precompiler) {
+            OS::Print("Precompilation dropping %s\n",

[srdjan, 2015/08/05 18:20:08]

ISL_Print

+                      function.ToLibNamePrefixedQualifiedCString());
+          }
+        }
+      }
+
+      functions = Array::New(retained_functions.Length(), Heap::kOld);
+      for (intptr_t j = 0; j < retained_functions.Length(); j++) {
+        function ^= retained_functions.At(j);
+        functions.SetAt(j, function);
+      }
+      cls.SetFunctions(functions);
+
+      closures = cls.closures();
+      if (!closures.IsNull()) {
+        for (intptr_t j = 0; j < closures.Length(); j++) {
+          function ^= closures.At(j);
+          ASSERT(function.HasCode());
+        }
+      }
+    }
+  }
+}
+
 }  // namespace dart