Upon script loading deoptimize only functions whose owner has been subclassed, as that is the only…

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 14 matching lines @@
 bool ClassFinalizer::AllClassesFinalized() {
   ObjectStore* object_store = Isolate::Current()->object_store();
   const GrowableObjectArray& classes =
       GrowableObjectArray::Handle(object_store->pending_classes());
   return classes.Length() == 0;
 }
 
 
 // Removes optimized code once we load more classes, since --use_cha based
 // optimizations may have become invalid.
-// TODO(srdjan): Note which functions use which CHA decision and deoptimize
-// only the necessary ones.
-static void RemoveOptimizedCode() {
+// Only methods which owner classes where subclasses can be invalid.
+// TODO(srdjan): Be even more precise by recording the exact CHA optimziation.

[Florian Schneider, 2012/11/15 00:46:06]

s/optimziation/optimization/

[srdjan, 2012/11/15 01:04:44]

Done.

+static void RemoveOptimizedCode(
+    const GrowableArray<intptr_t>& added_subclasses_to_cids) {
   ASSERT(FLAG_use_cha);
+  if (added_subclasses_to_cids.is_empty()) return;
   // Deoptimize all live frames.
   DeoptimizeAll();
   // Switch all functions' code to unoptimized.
   const ClassTable& class_table = *Isolate::Current()->class_table();
   Class& cls = Class::Handle();
   Array& array = Array::Handle();
   Function& function = Function::Handle();
-  const intptr_t num_cids = class_table.NumCids();
-  for (intptr_t i = kInstanceCid; i < num_cids; i++) {
-    if (!class_table.HasValidClassAt(i)) continue;
-    cls = class_table.At(i);
+  for (intptr_t i = 0; i < added_subclasses_to_cids.length(); i++) {
+    intptr_t cid = added_subclasses_to_cids[i];
+    cls = class_table.At(cid);
     ASSERT(!cls.IsNull());
     array = cls.functions();
     intptr_t num_functions = array.IsNull() ? 0 : array.Length();
     for (intptr_t f = 0; f < num_functions; f++) {
       function ^= array.At(f);
       ASSERT(!function.IsNull());
       if (function.HasOptimizedCode()) {
         function.SwitchToUnoptimizedCode();
       }
     }
   }
 }
 
 
+void AddSuperType(const Type& type,
+                  GrowableArray<intptr_t>* finalized_super_classes) {
+  ASSERT(type.HasResolvedTypeClass());
+  if (type.IsObjectType()) {
+    return;
+  }
+  const Class& cls = Class::Handle(type.type_class());
+  ASSERT(cls.is_finalized());
+  const intptr_t cid = cls.id();
+  for (intptr_t i = 0; i < finalized_super_classes->length(); i++) {
+    if ((*finalized_super_classes)[i] == cid) {
+      // Already added.
+      return;
+    }
+  }
+  finalized_super_classes->Add(cid);
+  const Type& super_type = Type::Handle(cls.super_type());
+  AddSuperType(super_type, finalized_super_classes);
+}
+
+
+// Use array instead of set since we expect very few subclassed classes
+// to occur.
+static void CollectFinalizedSuperClasses(
+    const GrowableObjectArray& pending_classes,
+    GrowableArray<intptr_t>* finalized_super_classes) {
+  Class& cls = Class::Handle();
+  Type& super_type = Type::Handle();
+  for (intptr_t i = 0; i < pending_classes.Length(); i++) {
+    cls ^= pending_classes.At(i);
+    ASSERT(!cls.is_finalized());
+    super_type ^= cls.super_type();
+    if (!super_type.IsNull()) {
+      if (super_type.HasResolvedTypeClass() &&
+          Class::Handle(super_type.type_class()).is_finalized()) {
+        AddSuperType(super_type, finalized_super_classes);
+      }
+    }
+  }
+}
+
+
 // Class finalization occurs:
 // a) when bootstrap process completes (VerifyBootstrapClasses).
 // b) after the user classes are loaded (dart_api).
 bool ClassFinalizer::FinalizePendingClasses() {
   bool retval = true;
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ObjectStore* object_store = isolate->object_store();
   const Error& error = Error::Handle(object_store->sticky_error());
   if (!error.IsNull()) {
     return false;
   }
   if (AllClassesFinalized()) {
     return true;
   }
+
+  GrowableArray<intptr_t> added_subclasses_to_cids;
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     GrowableObjectArray& class_array = GrowableObjectArray::Handle();
     class_array = object_store->pending_classes();
     ASSERT(!class_array.IsNull());
+    // Collect superclasses that were already finalized before this run of
+    // finalization.
+    CollectFinalizedSuperClasses(class_array, &added_subclasses_to_cids);
     Class& cls = Class::Handle();
     // First resolve all superclasses.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       if (FLAG_trace_class_finalization) {
         OS::Print("Resolving super and interfaces: %s\n", cls.ToCString());
       }
       ResolveSuperType(cls);
       if (cls.is_interface()) {
         ResolveFactoryClass(cls);
@@ skipping 13 matching lines @@
       }
     }
     // Clear pending classes array.
     class_array = GrowableObjectArray::New();
     object_store->set_pending_classes(class_array);
   } else {
     retval = false;
   }
   isolate->set_long_jump_base(base);
   if (FLAG_use_cha) {
-    RemoveOptimizedCode();
+    RemoveOptimizedCode(added_subclasses_to_cids);
   }
   return retval;
 }
 
 
 // Adds all interfaces of cls into 'collected'. Duplicate entries may occur.
 // No cycles are allowed.
 void ClassFinalizer::CollectInterfaces(const Class& cls,
                                        const GrowableObjectArray& collected) {
   const Array& interface_array = Array::ZoneHandle(cls.interfaces());
@@ skipping 1519 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart