Initial support for count-based profiling

src/runtime-profiler.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 129 matching lines @@
   // any back edge in any unoptimized frame will trigger on-stack
   // replacement for that frame.
   if (FLAG_trace_osr) {
     PrintF("[patching stack checks in ");
     function->PrintName();
     PrintF(" for on-stack replacement]\n");
   }
 
   // Get the stack check stub code object to match against.  We aren't
   // prepared to generate it, but we don't expect to have to.
-  StackCheckStub check_stub;
+  bool found_code = false;
   Code* stack_check_code = NULL;
-  if (check_stub.FindCodeInCache(&stack_check_code)) {
+  if (FLAG_count_based_interrupts) {
+    InterruptStub interrupt_stub;
+    found_code = interrupt_stub.FindCodeInCache(&stack_check_code);
+  } else {
+    StackCheckStub check_stub;
+    found_code = check_stub.FindCodeInCache(&stack_check_code);
+  }
+  if (found_code) {
     Code* replacement_code =
         isolate_->builtins()->builtin(Builtins::kOnStackReplacement);
     Code* unoptimized_code = shared->code();
     Deoptimizer::PatchStackCheckCode(unoptimized_code,
                                      stack_check_code,
                                      replacement_code);
   }
 }
 
 
@@ skipping 85 matching lines @@
           !any_ic_changed_ &&
           total_code_generated_ > 0 &&
           total_code_generated_ < 2000) {
         // If no code was generated and no IC was patched since the last tick,
         // but a little code has already been generated since last Reset(),
         // then type info might already be stable and we can optimize now.
         Optimize(function, "stable on startup");
       } else {
         function->shared()->set_profiler_ticks(ticks + 1);
       }
-    } else {  // !FLAG_counting_profiler
+    } else {  // !FLAG_watch_ic_patching
       samples[sample_count++] = function;
 
       int function_size = function->shared()->SourceSize();
       int threshold_size_factor = (function_size > kSizeLimit)
           ? sampler_threshold_size_factor_
           : 1;
 
       int threshold = sampler_threshold_ * threshold_size_factor;
 
       if (LookupSample(function) >= threshold) {
         Optimize(function, "sampler window lookup");
       }
     }
   }
   if (FLAG_watch_ic_patching) {
     any_ic_changed_ = false;
     code_generated_ = false;
-  } else {  // !FLAG_counting_profiler
+  } else {  // !FLAG_watch_ic_patching
     // Add the collected functions as samples. It's important not to do
     // this as part of collecting them because this will interfere with
     // the sample lookup in case of recursive functions.
     for (int i = 0; i < sample_count; i++) {
       AddSample(samples[i], kSamplerFrameWeight[i]);
     }
   }
 }
 
 
 void RuntimeProfiler::NotifyTick() {
+  if (FLAG_count_based_interrupts) return;
   isolate_->stack_guard()->RequestRuntimeProfilerTick();
 }
 
 
 void RuntimeProfiler::SetUp() {
   ASSERT(has_been_globally_set_up_);
   if (!FLAG_watch_ic_patching) {
     ClearSampleBuffer();
   }
   // If the ticker hasn't already started, make sure to do so to get
   // the ticks for the runtime profiler.
   if (IsEnabled()) isolate_->logger()->EnsureTickerStarted();
 }
 
 
 void RuntimeProfiler::Reset() {
   if (FLAG_watch_ic_patching) {
     total_code_generated_ = 0;
-  } else {  // !FLAG_counting_profiler
+  } else {  // !FLAG_watch_ic_patching
     sampler_threshold_ = kSamplerThresholdInit;
     sampler_threshold_size_factor_ = kSamplerThresholdSizeFactorInit;
     sampler_ticks_until_threshold_adjustment_ =
         kSamplerTicksBetweenThresholdAdjustment;
   }
 }
 
 
 void RuntimeProfiler::TearDown() {
   // Nothing to do.
@@ skipping 88 matching lines @@
 
 bool RuntimeProfilerRateLimiter::SuspendIfNecessary() {
   if (!RuntimeProfiler::IsSomeIsolateInJS()) {
     return RuntimeProfiler::WaitForSomeIsolateToEnterJS();
   }
   return false;
 }
 
 
 } }  // namespace v8::internal