Eliminate excessive increment of deoptimization counters (e.g., with deep recursion of deoptimized function). Instead increment deoptimization_count for all (inlined) functions at deoptimization point if deoptimization was triggered from function's optimized code. Cases where that is not the case are OSR codes, lazy-deopts and code disabling due to loading/finalizing classes or guard invalidation.

Srdjan Mitrovic · Srdjan Mitrovic · commit 6d0be9b1ecc3 · 2015-12-29T15:48:51.000-08:00
Rename deoptimization_counter_threshold to max_deoptimization_counter_threshold. BUG= R=johnmccutchan@google.com Review URL: https://codereview.chromium.org/1557533002 .
diff --git a/runtime/vm/code_generator.cc b/runtime/vm/code_generator.cc
@@ -57,7 +57,7 @@ DEFINE_FLAG(bool, trace_patching, false, "Trace patching of code.");
 DEFINE_FLAG(bool, trace_runtime_calls, false, "Trace runtime calls");
 DEFINE_FLAG(bool, trace_type_checks, false, "Trace runtime type checks.");
 
-DECLARE_FLAG(int, deoptimization_counter_threshold);
+DECLARE_FLAG(int, max_deoptimization_counter_threshold);
 DECLARE_FLAG(bool, enable_inlining_annotations);
 DECLARE_FLAG(bool, trace_compiler);
 DECLARE_FLAG(bool, trace_optimizing_compiler);
@@ -677,7 +677,7 @@ DEFINE_RUNTIME_ENTRY(PatchStaticCall, 0) {
                                  target_code);
   caller_code.SetStaticCallTargetCodeAt(caller_frame->pc(), target_code);
   if (FLAG_trace_patching) {
-    OS::PrintErr("PatchStaticCall: patching caller pc %#" Px ""
+    THR_Print("PatchStaticCall: patching caller pc %#" Px ""
         " to '%s' new entry point %#" Px " (%s)\n",
         caller_frame->pc(),
         target_function.ToFullyQualifiedCString(),
@@ -1255,7 +1255,7 @@ static bool CanOptimizeFunction(const Function& function, Thread* thread) {
     return false;
   }
   if (function.deoptimization_counter() >=
-      FLAG_deoptimization_counter_threshold) {
+      FLAG_max_deoptimization_counter_threshold) {
     if (FLAG_trace_failed_optimization_attempts ||
         FLAG_stop_on_excessive_deoptimization) {
       OS::PrintErr("Too Many Deoptimizations: %s\n",
@@ -1707,6 +1707,9 @@ static void CopySavedRegisters(uword saved_registers_address,
 
 // Copies saved registers and caller's frame into temporary buffers.
 // Returns the stack size of unoptimized frame.
+// The calling code must be optimized, but its function may not have
+// have optimized code if the code is OSR code, or if the code was invalidated
+// through class loading/finalization or field guard.
 DEFINE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
                           2,
                           uword saved_registers_address,
@@ -1728,6 +1731,16 @@ DEFINE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
   ASSERT(caller_frame != NULL);
   const Code& optimized_code = Code::Handle(caller_frame->LookupDartCode());
   ASSERT(optimized_code.is_optimized());
+  const Function& top_function =
+      Function::Handle(thread->zone(), optimized_code.function());
+  const bool deoptimizing_code = top_function.HasOptimizedCode();
+  if (FLAG_trace_deoptimization) {
+    const Function& function = Function::Handle(optimized_code.function());
+    THR_Print("== Deoptimizing code for '%s', %s, %s\n",
+       function.ToFullyQualifiedCString(),
+       deoptimizing_code ? "code & frame" : "frame",
+       is_lazy_deopt ? "lazy-deopt" : "");
+  }
 
   // Copy the saved registers from the stack.
   fpu_register_t* fpu_registers;
@@ -1741,7 +1754,8 @@ DEFINE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
                        DeoptContext::kDestIsOriginalFrame,
                        fpu_registers,
                        cpu_registers,
-                       is_lazy_deopt != 0);
+                       is_lazy_deopt != 0,
+                       deoptimizing_code);
   isolate->set_deopt_context(deopt_context);
 
   // Stack size (FP - SP) in bytes.
diff --git a/runtime/vm/compiler.cc b/runtime/vm/compiler.cc
@@ -46,7 +46,7 @@ DEFINE_FLAG(bool, common_subexpression_elimination, true,
     "Do common subexpression elimination.");
 DEFINE_FLAG(bool, constant_propagation, true,
     "Do conditional constant propagation/unreachable code elimination.");
-DEFINE_FLAG(int, deoptimization_counter_threshold, 16,
+DEFINE_FLAG(int, max_deoptimization_counter_threshold, 16,
     "How many times we allow deoptimization before we disallow optimization.");
 DEFINE_FLAG(bool, disassemble, false, "Disassemble dart code.");
 DEFINE_FLAG(bool, disassemble_optimized, false, "Disassemble optimized code.");
@@ -639,7 +639,7 @@ bool CompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
           // Extract type feedback before the graph is built, as the graph
           // builder uses it to attach it to nodes.
           ASSERT(function.deoptimization_counter() <
-                 FLAG_deoptimization_counter_threshold);
+                 FLAG_max_deoptimization_counter_threshold);
 
           // 'Freeze' ICData in background compilation so that it does not
           // change while compiling.
diff --git a/runtime/vm/debugger.cc b/runtime/vm/debugger.cc
@@ -1444,7 +1444,8 @@ RawArray* Debugger::DeoptimizeToArray(Thread* thread,
                        DeoptContext::kDestIsAllocated,
                        NULL,
                        NULL,
-                       true);
+                       true,
+                       false /* deoptimizing_code */);
   isolate->set_deopt_context(deopt_context);
 
   deopt_context->FillDestFrame();
diff --git a/runtime/vm/deferred_objects.cc b/runtime/vm/deferred_objects.cc
@@ -173,16 +173,18 @@ void DeferredPcMarker::Materialize(DeoptContext* deopt_context) {
   *reinterpret_cast<RawObject**>(dest_addr) = code.raw();
 
   if (FLAG_trace_deoptimization_verbose) {
-    OS::PrintErr("materializing pc marker at 0x%" Px ": %s, %s\n",
-                 reinterpret_cast<uword>(slot()), code.ToCString(),
-                 function.ToCString());
+    THR_Print("materializing pc marker at 0x%" Px ": %s, %s\n",
+        reinterpret_cast<uword>(slot()), code.ToCString(),
+        function.ToCString());
   }
 
   // Increment the deoptimization counter. This effectively increments each
   // function occurring in the optimized frame.
-  function.set_deoptimization_counter(function.deoptimization_counter() + 1);
+  if (deopt_context->deoptimizing_code()) {
+    function.set_deoptimization_counter(function.deoptimization_counter() + 1);
+  }
   if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
-    OS::PrintErr("Deoptimizing %s (count %d)\n",
+    THR_Print("Deoptimizing '%s' (count %d)\n",
         function.ToFullyQualifiedCString(),
         function.deoptimization_counter());
   }
diff --git a/runtime/vm/deopt_instructions.cc b/runtime/vm/deopt_instructions.cc
@@ -27,7 +27,8 @@ DeoptContext::DeoptContext(const StackFrame* frame,
                            DestFrameOptions dest_options,
                            fpu_register_t* fpu_registers,
                            intptr_t* cpu_registers,
-                           bool is_lazy_deopt)
+                           bool is_lazy_deopt,
+                           bool deoptimizing_code)
     : code_(code.raw()),
       object_pool_(code.GetObjectPool()),
       deopt_info_(TypedData::null()),
@@ -47,7 +48,8 @@ DeoptContext::DeoptContext(const StackFrame* frame,
       deferred_slots_(NULL),
       deferred_objects_count_(0),
       deferred_objects_(NULL),
-      is_lazy_deopt_(is_lazy_deopt) {
+      is_lazy_deopt_(is_lazy_deopt),
+      deoptimizing_code_(deoptimizing_code) {
   const TypedData& deopt_info = TypedData::Handle(
       code.GetDeoptInfoAtPc(frame->pc(), &deopt_reason_, &deopt_flags_));
   ASSERT(!deopt_info.IsNull());
@@ -103,7 +105,7 @@ DeoptContext::DeoptContext(const StackFrame* frame,
   }
 
   if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
-    OS::PrintErr(
+    THR_Print(
         "Deoptimizing (reason %d '%s') at pc %#" Px " '%s' (count %d)\n",
         deopt_reason(),
         DeoptReasonToCString(deopt_reason()),
diff --git a/runtime/vm/deopt_instructions.h b/runtime/vm/deopt_instructions.h
@@ -23,19 +23,22 @@ class StackFrame;
 class TimelineEvent;
 
 // Holds all data relevant for execution of deoptimization instructions.
+// Structure is allocated in C-heap.
 class DeoptContext {
  public:
   enum DestFrameOptions {
     kDestIsOriginalFrame,   // Replace the original frame with deopt frame.
     kDestIsAllocated        // Write deopt frame to a buffer.
   };
 
+  // If 'deoptimizing_code' is false, only frame is being deoptimized.
   DeoptContext(const StackFrame* frame,
                const Code& code,
                DestFrameOptions dest_options,
                fpu_register_t* fpu_registers,
                intptr_t* cpu_registers,
-               bool is_lazy_deopt);
+               bool is_lazy_deopt,
+               bool deoptimizing_code);
   virtual ~DeoptContext();
 
   // Returns the offset of the dest fp from the dest sp.  Used in
@@ -97,6 +100,8 @@ class DeoptContext {
 
   bool is_lazy_deopt() const { return is_lazy_deopt_; }
 
+  bool deoptimizing_code() const { return deoptimizing_code_; }
+
   ICData::DeoptReasonId deopt_reason() const { return deopt_reason_; }
   bool HasDeoptFlag(ICData::DeoptFlags flag) {
     return (deopt_flags_ & flag) != 0;
@@ -232,6 +237,7 @@ class DeoptContext {
   DeferredObject** deferred_objects_;
 
   const bool is_lazy_deopt_;
+  const bool deoptimizing_code_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptContext);
 };
diff --git a/runtime/vm/flow_graph_inliner.cc b/runtime/vm/flow_graph_inliner.cc
@@ -59,7 +59,7 @@ DEFINE_FLAG(bool, enable_inlining_annotations, false,
             "Enable inlining annotations");
 
 DECLARE_FLAG(bool, compiler_stats);
-DECLARE_FLAG(int, deoptimization_counter_threshold);
+DECLARE_FLAG(int, max_deoptimization_counter_threshold);
 DECLARE_FLAG(bool, polymorphic_with_deopt);
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(bool, print_flow_graph_optimized);
@@ -639,7 +639,7 @@ class CallSiteInliner : public ValueObject {
 
     // Abort if this function has deoptimized too much.
     if (function.deoptimization_counter() >=
-        FLAG_deoptimization_counter_threshold) {
+        FLAG_max_deoptimization_counter_threshold) {
       function.set_is_inlinable(false);
       TRACE_INLINING(THR_Print("     Bailout: deoptimization threshold\n"));
       PRINT_INLINING_TREE("Deoptimization threshold exceeded",
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
@@ -7725,8 +7725,8 @@ class FieldDependentArray : public WeakCodeReferences {
   virtual void ReportSwitchingCode(const Code& code) {
     if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
       Function& function = Function::Handle(code.function());
-      THR_Print("Switching %s to unoptimized code because guard"
-                " on field %s was violated.\n",
+      THR_Print("Switching '%s' to unoptimized code because guard"
+                " on field '%s' was violated.\n",
                 function.ToFullyQualifiedCString(),
                 field_.ToCString());
     }
