Do not count invocations but usage of a function, i.e., increment a function's counter at IC calls …

runtime/vm/code_generator_ia32.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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
 #include "vm/ast_printer.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/resolver.h"
 #include "vm/stub_code.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_ast, false, "Print abstract syntax tree.");
 DEFINE_FLAG(bool, print_scopes, false, "Print scopes of local variables.");
 DEFINE_FLAG(bool, trace_functions, false, "Trace entry of each function.");
 DEFINE_FLAG(bool, print_ic_in_optimized, false,
     "Debugging helper to identify potential performance pitfalls.");
-DEFINE_FLAG(int, optimization_invocation_threshold, 1000,
-    "Number of invocations before a function is optimized, -1 means never.");
+DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, enable_type_checks);
-DECLARE_FLAG(bool, report_invocation_count);
 DECLARE_FLAG(bool, trace_compiler);
 
 #define __ assembler_->
 
 
 CodeGeneratorState::CodeGeneratorState(CodeGenerator* codegen)
     : StackResource(Isolate::Current()),
       codegen_(codegen),
       parent_(codegen->state()) {
   if (parent_ != NULL) {
@@ skipping 155 matching lines @@
 
 // Pre entry code is called before the frame has been constructed:
 // - check for stack overflow.
 // - optionally count function invocations.
 // - optionally trigger optimizing compiler if invocation threshold has been
 //   reached.
 // Note that first 5 bytes may be patched with a jump.
 // TODO(srdjan): Add check that no object is inlined in the first
 // 5 bytes (length of a jump instruction).
 void CodeGenerator::GeneratePreEntryCode() {
-  // Do not optimize if:
-  // - we count invocations.
-  // - optimization disabled via negative 'optimization_invocation_threshold;
-  // - function is marked as non-optimizable.
-  // - type checks are enabled.
-  const bool may_optimize =
-      !FLAG_report_invocation_count &&
-      (FLAG_optimization_invocation_threshold >= 0) &&
-      !Isolate::Current()->debugger()->IsActive() &&
-      parsed_function_.function().is_optimizable();
-  // Count invocation and check.
-  if (FLAG_report_invocation_count || may_optimize) {
-    // TODO(turnidge): It would be nice to remove this nop.  Right now
-    // we need it to make sure the function is still patchable.
-    __ nop(5);
-    const Function& function =
-        Function::ZoneHandle(parsed_function_.function().raw());
-    __ LoadObject(EAX, function);
-    __ movl(EBX, FieldAddress(EAX, Function::invocation_counter_offset()));
-    __ incl(EBX);
-    if (may_optimize) {
-      __ cmpl(EBX, Immediate(FLAG_optimization_invocation_threshold));
-      __ j(GREATER, &StubCode::OptimizeInvokedFunctionLabel());
-    }
-    // EBX is an integer value (not an object).
-    __ movl(FieldAddress(EAX, Function::invocation_counter_offset()), EBX);
-  }
+  // TODO(srdjan): Still needed?
+  __ nop(5);
 }
 
 
 // Verify assumptions (in debug mode only).
 // - No two deopt descriptors have the same node id (deoptimization).
 // - No two ic-call descriptors have the same node id (type feedback).
 // - No two descriptors of same kind have the same PC.
 // A function without unique ids is marked as non-optimizable (e.g., because of
 // finally blocks).
 static void VerifyPcDescriptors(const PcDescriptors& descriptors,
@@ skipping 460 matching lines @@
 #ifdef DEBUG
   // Check that the entry stack size matches the exit stack size.
   __ movl(EDX, EBP);
   __ subl(EDX, ESP);
   ASSERT(locals_space_size() >= 0);
   __ cmpl(EDX, Immediate(locals_space_size()));
   Label wrong_stack;
   __ j(NOT_EQUAL, &wrong_stack, Assembler::kNearJump);
 #endif  // DEBUG.
 
+  if (!IsOptimizing()) {
+    // Count only in unoptimized code.
+    // TODO(srdjan): Replace the counting code with a type feedback
+    // collection and counting stub.
+    const Function& function =
+          Function::ZoneHandle(parsed_function_.function().raw());
+    __ LoadObject(EBX, function);
+    __ incl(FieldAddress(EBX, Function::usage_counter_offset()));
+    if (CodeGenerator::CanOptimize()) {
+      // Do not optimize if usage count must be reported.
+      __ cmpl(FieldAddress(EBX, Function::usage_counter_offset()),
+          Immediate(FLAG_optimization_counter_threshold));
+      Label not_yet_hot;
+      __ j(LESS_EQUAL, &not_yet_hot);
+      __ pushl(EAX);  // Preserve result.
+      __ pushl(EBX);  // Argument for runtime: function to optimize.
+      __ CallRuntimeFromDart(kOptimizeInvokedFunctionRuntimeEntry);
+      __ popl(EBX);  // Remove argument.
+      __ popl(EAX);  // Restore result.
+      __ Bind(&not_yet_hot);
+    }
+  }
   if (FLAG_trace_functions) {
+    const Function& function =
+          Function::ZoneHandle(parsed_function_.function().raw());
+    __ LoadObject(EBX, function);
     __ pushl(EAX);  // Preserve result.
-    const Function& function =
-        Function::ZoneHandle(parsed_function_.function().raw());
-    __ LoadObject(EBX, function);
     __ pushl(EBX);
     GenerateCallRuntime(AstNode::kNoId,
                         0,
                         kTraceFunctionExitRuntimeEntry);
     __ popl(EAX);  // Remove argument.
     __ popl(EAX);  // Restore result.
   }
   __ LeaveFrame();
   __ ret();
   // Add a NOP to make return code pattern 5 bytes long for patching
@@ skipping 1107 matching lines @@
 
   // Call operator.
   GenerateBinaryOperatorCall(node->id(), node->token_index(), node->Name());
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
-void CodeGenerator::CountBackwardLoop() {
-  Label done;
-  const Function& function =
-      Function::ZoneHandle(parsed_function_.function().raw());
-  __ LoadObject(EAX, function);
-  __ movl(EBX, FieldAddress(EAX, Function::invocation_counter_offset()));
-  __ incl(EBX);
-  if (!FLAG_report_invocation_count) {
-    // Prevent overflow.
-    __ cmpl(EBX, Immediate(FLAG_optimization_invocation_threshold));
-    __ j(GREATER, &done);
-  }
-  // EBX is an integer value (not an object).
-  __ movl(FieldAddress(EAX, Function::invocation_counter_offset()), EBX);
-  __ Bind(&done);
-}
-
-
 void CodeGenerator::VisitWhileNode(WhileNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   SourceLabel* label = node->label();
   __ Bind(label->continue_label());
   node->condition()->Visit(this);
   GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(NOT_EQUAL, label->break_label());
   node->body()->Visit(this);
-  CountBackwardLoop();
   __ jmp(label->continue_label());
   __ Bind(label->break_label());
 }
 
 
 void CodeGenerator::VisitDoWhileNode(DoWhileNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   SourceLabel* label = node->label();
   Label loop;
   __ Bind(&loop);
   node->body()->Visit(this);
-  CountBackwardLoop();
   __ Bind(label->continue_label());
   node->condition()->Visit(this);
   GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(EQUAL, &loop);
   __ Bind(label->break_label());
 }
 
 
 void CodeGenerator::VisitForNode(ForNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   node->initializer()->Visit(this);
   SourceLabel* label = node->label();
   Label loop;
   __ Bind(&loop);
   if (node->condition() != NULL) {
     node->condition()->Visit(this);
     GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
     __ popl(EAX);
     __ LoadObject(EDX, bool_true);
     __ cmpl(EAX, EDX);
     __ j(NOT_EQUAL, label->break_label());
   }
   node->body()->Visit(this);
-  CountBackwardLoop();
   __ Bind(label->continue_label());
   node->increment()->Visit(this);
   __ jmp(&loop);
   __ Bind(label->break_label());
 }
 
 
 void CodeGenerator::VisitJumpNode(JumpNode* node) {
   SourceLabel* label = node->label();
 
@@ skipping 819 matching lines @@
   const Error& error = Error::Handle(
       Parser::FormatError(script, token_index, "Error", format, args));
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32