Collect only optimizable function samples....

src/runtime-profiler.cc

 // Copyright 2010 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 55 matching lines @@
   Handle<Object> function_;  // Weak handle.
   int64_t start_;
 };
 
 
 // Optimization sampler constants.
 static const int kSamplerFrameCount = 2;
 static const int kSamplerFrameWeight[kSamplerFrameCount] = { 2, 1 };
 static const int kSamplerWindowSize = 16;
 
 static const int kSamplerTicksDelta = 32;

[Kasper Lund, 2010/12/08 14:54:15]

kSamplerTicksBetweenThresholdAdjustment.

 
 static const int kSamplerThresholdInit = 3;
 static const int kSamplerThresholdMin = 1;
 static const int kSamplerThresholdDelta = 1;
 
 static const int kSamplerThresholdSizeFactorInit = 3;
 static const int kSamplerThresholdSizeFactorMin = 1;
 static const int kSamplerThresholdSizeFactorDelta = 1;
 
 static const int kSizeLimit = 1500;
 
 static int sampler_threshold = kSamplerThresholdInit;
 static int sampler_threshold_size_factor = kSamplerThresholdSizeFactorInit;
 
+static const int kStateWindowSize = 128;
+static bool state_window[kStateWindowSize];

[Kasper Lund, 2010/12/08 14:54:15]

To me the name is of this is somewhat weird. If it's a state window it should
contain states. Maybe it would be nicer with an enum SampleState { JS, NON_JS }
and have a window of those? It's not clear what true means - and what false
means.

+static int state_window_position = 0;
+static int in_JS_state = 0;

[Kasper Lund, 2010/12/08 14:54:15]

static int state_counts[2] = { 0, } and then use state_counts[state] to get to
either in_JS_state or not_in_JS_state.

+static int not_in_JS_state = 0;
+
+static int sampler_ticks = kSamplerTicksDelta;

[Kasper Lund, 2010/12/08 14:54:15]

This name doesn't really relay much information. It's the number of ticks? Hmm -
how about something ala 'sampler_ticks_until_threshold_adjustment'?

 
 // The JSFunctions in the sampler window are not GC safe. Old-space
 // pointers are not cleared during mark-sweep collection and therefore
 // the window might contain stale pointers. The window is updated on
 // scavenges and (parts of it) cleared on mark-sweep and
 // mark-sweep-compact.
 static Object* sampler_window[kSamplerWindowSize] = { NULL, };
 static int sampler_window_position = 0;
 static int sampler_window_weight[kSamplerWindowSize] = { 0, };
 
@@ skipping 149 matching lines @@
       int delay = current->Delay();
       if (IsOptimizable(*function)) {
         Optimize(*function, true, delay);
       }
     }
     delete current;
     current = next;
   }
   optimize_soon_list = NULL;
 
+  float js_ratio = in_JS_state / static_cast<float>(

[Kasper Lund, 2010/12/08 14:54:15]

Maybe comment on what this ratio means or change the variable name to make it
(even) more obvious.

+      in_JS_state + not_in_JS_state);
+
   // Run through the JavaScript frames and collect them. If we already
   // have a sample of the function, we mark it for optimizations
   // (eagerly or lazily).
   JSFunction* samples[kSamplerFrameCount];
   int count = 0;
   for (JavaScriptFrameIterator it;
        count < kSamplerFrameCount && !it.done();
        it.Advance()) {
     JavaScriptFrame* frame = it.frame();
     JSFunction* function = JSFunction::cast(frame->function());
+
+    if (sampler_ticks > 0) {

[Kasper Lund, 2010/12/08 14:54:15]

Add a comment that explains what this does.

+      sampler_ticks--;
+      if (sampler_ticks == 0) {
+        if (sampler_threshold > kSamplerThresholdMin) {
+          sampler_threshold -= kSamplerThresholdDelta;
+        }
+        sampler_ticks = kSamplerTicksDelta;
+      }
+    }
+
+    if (!IsOptimizable(function) && !function->IsMarkedForLazyRecompilation()) {

[Kasper Lund, 2010/12/08 14:54:15]

Please explain what you're trying to filter out here through a comment.

+      continue;
+    }
+
+    samples[count++] = function;
+
     int function_size = function->shared()->SourceSize();
     int threshold_size_factor;
-    if (function_size > kSizeLimit) {
-      threshold_size_factor = sampler_threshold_size_factor;
-    } else {
-      threshold_size_factor = 1;
+    threshold_size_factor = (function_size > kSizeLimit)

[Kasper Lund, 2010/12/08 14:54:15]

Why not initialize threshold_size_factor directly in the declaration of the
variable?

+        ? sampler_threshold_size_factor
+        : 1;
+
+    int threshold = sampler_threshold * threshold_size_factor;
+
+    if (js_ratio < .2) {

[fschneider, 2010/12/08 14:33:33]

These constants need some comments about the rationale behind.

[Kasper Lund, 2010/12/08 14:54:15]

0.2, 0.5, 0.75. I agree that you should explain the rationale behind the
threshold adjustments. Why does it make sense?

+      threshold = kStateWindowSize;
+    } else if (js_ratio < .5) {
+      threshold *= 3;
+    } else if (js_ratio < .75) {
+      threshold *= 2;
     }
 
-    int threshold = sampler_threshold * threshold_size_factor;
-    samples[count++] = function;
     if (function->IsMarkedForLazyRecompilation()) {
       Code* unoptimized = function->shared()->code();
       int nesting = unoptimized->allow_osr_at_loop_nesting_level();
       if (nesting == 0) AttemptOnStackReplacement(function);
       int new_nesting = Min(nesting + 1, Code::kMaxLoopNestingMarker);
       unoptimized->set_allow_osr_at_loop_nesting_level(new_nesting);
     } else if (LookupSample(function) >= threshold) {
-      if (IsOptimizable(function)) {
-        Optimize(function, false, 0);
-        CompilationCache::MarkForEagerOptimizing(Handle<JSFunction>(function));
-      }
+      Optimize(function, false, 0);
+      CompilationCache::MarkForEagerOptimizing(Handle<JSFunction>(function));
     }
   }
 
   // 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 < count; i++) {
     AddSample(samples[i], kSamplerFrameWeight[i]);
   }
 }
@@ skipping 24 matching lines @@
   }
 }
 
 
 bool IsEqual(void* first, void* second) {
   return first == second;
 }
 
 
 void RuntimeProfiler::Setup() {
+  for (int i = 0; i < kStateWindowSize; i++) {
+    state_window[i] = false;
+  }
+  in_JS_state = 0;
+  not_in_JS_state = kStateWindowSize;
   ClearSampleBuffer();
   // If the ticker hasn't already started, make sure to do so to get
   // the ticks for the runtime profiler.
   if (IsEnabled()) Logger::EnsureTickerStarted();
 }
 
 
 void RuntimeProfiler::Reset() {
   sampler_threshold = kSamplerThresholdInit;
+  sampler_ticks = kSamplerTicksDelta;
   sampler_threshold_size_factor = kSamplerThresholdSizeFactorInit;
 }
 
 
 void RuntimeProfiler::TearDown() {
   // Nothing to do.
 }
 
 
 Object** RuntimeProfiler::SamplerWindowAddress() {
   return sampler_window;
 }
 
 
 int RuntimeProfiler::SamplerWindowSize() {
   return kSamplerWindowSize;
 }
 
 
+void AddStateSample(bool in_js_state) {

[Kasper Lund, 2010/12/08 14:54:15]

Use enum SampleState for the parameter.

[Kasper Lund, 2010/12/08 14:54:15]

Make this function static.

+  if (state_window[state_window_position]) {

[Kasper Lund, 2010/12/08 14:54:15]

state_counts[state_window[state_window_position]]--; No branches.

+    in_JS_state--;

[fschneider, 2010/12/08 14:33:33]

is_js_state vs in_JS_state: These variable names are confusing. Please choose
something that does not only differ in capitalization.

+  } else {
+    not_in_JS_state--;
+  }
+  state_window[state_window_position] = in_js_state;
+  if (in_js_state) {

[Kasper Lund, 2010/12/08 14:54:15]

state_counts[state]++; No branches.

+    in_JS_state++;
+  } else {
+    not_in_JS_state++;
+  }
+  state_window_position = (state_window_position + 1) &

[Kasper Lund, 2010/12/08 14:54:15]

ASSERT(IsPowerOf2(kStateWindowSize));

+      (kStateWindowSize - 1);
+}
+
+
 bool RuntimeProfilerRateLimiter::SuspendIfNecessary() {
   static const int kNonJSTicksThreshold = 100;
   // We suspend the runtime profiler thread when not running
   // JavaScript. If the CPU profiler is active we must not do this
   // because it samples both JavaScript and C++ code.
   if (RuntimeProfiler::IsEnabled() &&
       !CpuProfiler::is_profiling() &&
       !(FLAG_prof && FLAG_prof_auto)) {
     if (Top::IsInJSState()) {
+      AddStateSample(true);
       non_js_ticks_ = 0;
     } else {
+      AddStateSample(false);
       if (non_js_ticks_ < kNonJSTicksThreshold) {
         ++non_js_ticks_;
       } else {
         if (Top::WaitForJSState()) return true;
       }
     }
   }
   return false;
 }
 
 
 } }  // namespace v8::internal