Fix a bug that caused the runtime profiler to sample huge amounts of stack fr...

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 254 matching lines @@
     }
     delete current;
     current = next;
   }
   optimize_soon_list = NULL;
 
   // 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;
+  int sample_count = 0;
+  int frame_count = 0;
   for (JavaScriptFrameIterator it;
-       count < kSamplerFrameCount && !it.done();
+       frame_count++ < kSamplerFrameCount && !it.done();
        it.Advance()) {
     JavaScriptFrame* frame = it.frame();
     JSFunction* function = JSFunction::cast(frame->function());
 
     // Adjust threshold each time we have processed
     // a certain number of ticks.
     if (sampler_ticks_until_threshold_adjustment > 0) {
       sampler_ticks_until_threshold_adjustment--;
       if (sampler_ticks_until_threshold_adjustment <= 0) {
         // If the threshold is not already at the minimum
         // modify and reset the ticks until next adjustment.
         if (sampler_threshold > kSamplerThresholdMin) {
           sampler_threshold -= kSamplerThresholdDelta;
           sampler_ticks_until_threshold_adjustment =
               kSamplerTicksBetweenThresholdAdjustment;
         }
       }
     }
 
     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);
     }
 
     // Do not record non-optimizable functions.
     if (!IsOptimizable(function)) continue;
-    samples[count++] = function;
+    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;
     int current_js_ratio = NoBarrier_Load(&js_ratio);
 
     // Adjust threshold depending on the ratio of time spent
@@ skipping 10 matching lines @@
 
     if (LookupSample(function) >= threshold) {
       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++) {
+  for (int i = 0; i < sample_count; i++) {
     AddSample(samples[i], kSamplerFrameWeight[i]);
   }
 }
 
 
 void RuntimeProfiler::OptimizeSoon(JSFunction* function) {
   if (!IsOptimizable(function)) return;
   PendingListNode* node = new PendingListNode(function);
   node->set_next(optimize_soon_list);
   optimize_soon_list = node;
@@ skipping 90 matching lines @@
       } else {
         if (Top::WaitForJSState()) return true;
       }
     }
   }
   return false;
 }
 
 
 } }  // namespace v8::internal