Two simple profiler changes: 1) log sampling rate, 2) check current state before pausing & resuming.

src/log.cc

 // Copyright 2009 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 238 matching lines @@
 void Profiler::Engage() {
   OS::LogSharedLibraryAddresses();
 
   // Start thread processing the profiler buffer.
   running_ = true;
   Start();
 
   // Register to get ticks.
   Logger::ticker_->SetProfiler(this);
 
-  LOG(UncheckedStringEvent("profiler", "begin"));
+  Logger::ProfilerBeginEvent();
 }
 
 
 void Profiler::Disengage() {
   // Stop receiving ticks.
   Logger::ticker_->ClearProfiler();
 
   // Terminate the worker thread by setting running_ to false,
   // inserting a fake element in the queue and then wait for
   // the thread to terminate.
@@ skipping 25 matching lines @@
 Profiler* Logger::profiler_ = NULL;
 VMState* Logger::current_state_ = NULL;
 VMState Logger::bottom_state_(EXTERNAL);
 SlidingStateWindow* Logger::sliding_state_window_ = NULL;
 
 
 bool Logger::IsEnabled() {
   return Log::IsEnabled();
 }
 
+
+void Logger::ProfilerBeginEvent() {
+  if (!Log::IsEnabled()) return;
+  LogMessageBuilder msg;
+  msg.Append("profiler,\"begin\",%d\n", kSamplingIntervalMs);
+  msg.WriteToLogFile();
+}
+
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 
 void Logger::Preamble(const char* content) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (!Log::IsEnabled() || !FLAG_log_code) return;
   LogMessageBuilder msg;
   msg.WriteCStringToLogFile(content);
 #endif
 }
@@ skipping 487 matching lines @@
   msg.WriteToLogFile();
 }
 
 
 bool Logger::IsProfilerPaused() {
   return profiler_->paused();
 }
 
 
 void Logger::PauseProfiler() {
+  if (profiler_->paused()) {
+    return;
+  }
   profiler_->pause();
   if (FLAG_prof_lazy) {
     if (!FLAG_sliding_state_window) ticker_->Stop();
     FLAG_log_code = false;
     // Must be the same message as Log::kDynamicBufferSeal.
     LOG(UncheckedStringEvent("profiler", "pause"));
   }
 }
 
 
 void Logger::ResumeProfiler() {
-  if (!Log::IsEnabled()) return;
+  if (!profiler_->paused() || !Log::IsEnabled()) {
+    return;
+  }
   if (FLAG_prof_lazy) {
     LOG(UncheckedStringEvent("profiler", "resume"));
     FLAG_log_code = true;
     LogCompiledFunctions();
     if (!FLAG_sliding_state_window) ticker_->Start();
   }
   profiler_->resume();
 }
 
 
@@ skipping 151 matching lines @@
     } else {
       Log::OpenFile(FLAG_logfile);
     }
   }
 
   current_state_ = &bottom_state_;
 
   // as log is initialized early with V8, we can assume that JS execution
   // frames can never reach this point on stack
   int stack_var;
-  ticker_ = new Ticker(1, reinterpret_cast<uintptr_t>(&stack_var));
+  ticker_ = new Ticker(
+      kSamplingIntervalMs, reinterpret_cast<uintptr_t>(&stack_var));
 
   if (FLAG_sliding_state_window && sliding_state_window_ == NULL) {
     sliding_state_window_ = new SlidingStateWindow();
   }
 
   if (FLAG_prof) {
     profiler_ = new Profiler();
     if (!FLAG_prof_auto)
       profiler_->pause();
     profiler_->Engage();
@@ skipping 125 matching lines @@
     } else if (previous_->state_ == EXTERNAL) {
       // We are leaving V8.
       Heap::Protect();
     }
   }
 #endif
 }
 #endif
 
 } }  // namespace v8::internal