Do not add InstantiatedTypeArgument entries into cache as they cannot be canonicalized. Limit the m…

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 29 matching lines @@
 DEFINE_FLAG(bool, trace_runtime_calls, false, "Trace runtime calls");
 DEFINE_FLAG(int, optimization_counter_threshold, 2000,
     "Function's usage-counter value before it is optimized, -1 means never");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, trace_type_checks);
 DECLARE_FLAG(bool, report_usage_count);
 DECLARE_FLAG(int, deoptimization_counter_threshold);
 DEFINE_FLAG(charp, optimization_filter, NULL, "Optimize only named function");
 DEFINE_FLAG(bool, trace_failed_optimization_attempts, false,
     "Traces all failed optimization attempts");
+DEFINE_FLAG(int, max_subtype_cache_entries, 100,
+    "Maximum number of subtype cache entries (number of checks cached).");
 
 
 DEFINE_RUNTIME_ENTRY(TraceFunctionEntry, 1) {
   ASSERT(arguments.Count() == kTraceFunctionEntryRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.At(0));
   const String& function_name = String::Handle(function.name());
   const String& class_name =
       String::Handle(Class::Handle(function.Owner()).Name());
   OS::Print("> Entering '%s.%s'\n",
       class_name.ToCString(), function_name.ToCString());
@@ skipping 428 matching lines @@
     }
     instantiator_type_arguments = instantiator.GetTypeArguments();
   }
 
   intptr_t last_instance_class_id = -1;
   AbstractTypeArguments& last_instance_type_arguments =
       AbstractTypeArguments::Handle();
   AbstractTypeArguments& last_instantiator_type_arguments =
       AbstractTypeArguments::Handle();
   Bool& last_result = Bool::Handle();
-  intptr_t len = new_cache.NumberOfChecks();
+  const intptr_t len = new_cache.NumberOfChecks();
+  if (len >= FLAG_max_subtype_cache_entries) {
+    return;
+  }
   for (intptr_t i = 0; i < len; ++i) {
     new_cache.GetCheck(
         i,
         &last_instance_class_id,
         &last_instance_type_arguments,
         &last_instantiator_type_arguments,
         &last_result);
     if ((last_instance_class_id == instance_class.id()) &&
         (last_instance_type_arguments.raw() == instance_type_arguments.raw()) &&
         (last_instantiator_type_arguments.raw() ==
          instantiator_type_arguments.raw())) {
       if (FLAG_trace_type_checks) {
         OS::Print("%"Pd" ", i);
         if (type_arguments_replaced) {
           PrintTypeCheck("Duplicate cache entry (canonical.)", instance, type,
               instantiator_type_arguments, result);
         } else {
           PrintTypeCheck("WARNING Duplicate cache entry", instance, type,
               instantiator_type_arguments, result);
         }
       }
       // Can occur if we have canonicalized arguments.
       // TODO(srdjan): Investigate why this assert can fail.
       // ASSERT(type_arguments_replaced);
       return;
     }
   }
-  new_cache.AddCheck(instance_class.id(),
-                     instance_type_arguments,
-                     instantiator_type_arguments,
-                     result);
+  if (!instantiator_type_arguments.IsInstantiatedTypeArguments()) {
+    new_cache.AddCheck(instance_class.id(),
+                       instance_type_arguments,
+                       instantiator_type_arguments,
+                       result);
+  }
   if (FLAG_trace_type_checks) {
     AbstractType& test_type = AbstractType::Handle(type.raw());
     if (!test_type.IsInstantiated()) {
       test_type = type.InstantiateFrom(instantiator_type_arguments);
     }
-    OS::Print("  Updated test cache %p ix:%"Pd":\n"
+    OS::Print("  Updated test cache %p ix: %"Pd" with (%"Pd", %p, %p, %s)\n"
         "    [%p %s %"Pd", %p %s]\n"
         "    [%p %s %"Pd", %p %s] %s\n",
         new_cache.raw(),
         len,
+        instance_class.id(),
+
+        instance_type_arguments.raw(),
+        instantiator_type_arguments.raw(),
+        result.ToCString(),
+
         instance_class.raw(),
         instance_class.ToCString(),
         instance_class.id(),
         instance_type_arguments.raw(),
         instance_type_arguments.ToCString(),
+
         test_type.type_class(),
         Class::Handle(test_type.type_class()).ToCString(),
         Class::Handle(test_type.type_class()).id(),
         instantiator_type_arguments.raw(),
         instantiator_type_arguments.ToCString(),
         result.ToCString());
   }
 }
 
 
@@ skipping 1330 matching lines @@
     intptr_t line, column;
     script.GetTokenLocation(token_pos, &line, &column);
     String& line_string = String::Handle(script.GetLine(line));
     OS::Print("  Function: %s\n", top_function.ToFullyQualifiedCString());
     OS::Print("  Line %"Pd": '%s'\n", line, line_string.ToCString());
   }
 }
 
 
 }  // namespace dart