Implement resource-saving mode of Profiler.

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 160 matching lines @@
   ~Ticker() { if (IsActive()) Stop(); }
 
   void Tick(TickSample* sample) {
     if (IsProfiling()) stack_tracer_.Trace(sample);
     if (profiler_) profiler_->Insert(sample);
     if (window_) window_->AddState(sample->state);
   }
 
   void SetWindow(SlidingStateWindow* window) {
     window_ = window;
-    if (!IsActive()) Start();
+    if (!FLAG_prof_lazy && !IsActive()) Start();

[Søren Thygesen Gjesse, 2009/05/25 07:09:15]

I am not sure about this handling of the prof_lazy flag. The main reason for
implementing the sliding window average was to enable some display of it in
Chrome. This should be unrelated to dev tools - maybe in the task manager. This
is still not implemented, so I guess this is fine for now.

[Mikhail Naganov, 2009/05/25 08:23:43]

That's an important thing to know, thanks for noticing. I removed flag usage
from here, and also added checking of FLAG_sliding_state_window in
Pause/ResumeProfiler functions to avoid stopping/restarting Ticker when SSW is
enabled.

   }
 
   void ClearWindow() {
     window_ = NULL;
     if (!profiler_ && IsActive()) Stop();
   }
 
   void SetProfiler(Profiler* profiler) {
     profiler_ = profiler;
-    if (!IsActive()) Start();
+    if (!FLAG_prof_lazy && !IsActive()) Start();
   }
 
   void ClearProfiler() {
     profiler_ = NULL;
     if (!window_ && IsActive()) Stop();
   }
 
  private:
   SlidingStateWindow* window_;
   Profiler* profiler_;
@@ skipping 58 matching lines @@
 
 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.
   running_ = false;
   TickSample sample;
+  // Reset 'paused_' flag, otherwise semaphore may not be signalled.
+  resume();
   Insert(&sample);
   Join();
 
   LOG(UncheckedStringEvent("profiler", "end"));
 }
 
 
 void Profiler::Run() {
   TickSample sample;
   bool overflow = Logger::profiler_->Remove(&sample);
@@ skipping 809 matching lines @@
 }
 
 
 bool Logger::IsProfilerPaused() {
   return profiler_->paused();
 }
 
 
 void Logger::PauseProfiler() {
   profiler_->pause();
+  if (FLAG_prof_lazy) {
+    ticker_->Stop();
+    FLAG_log_code = false;
+    LOG(UncheckedStringEvent("profiler", "pause"));
+  }
 }
 
 
 void Logger::ResumeProfiler() {
+  if (FLAG_prof_lazy) {
+    LOG(UncheckedStringEvent("profiler", "resume"));
+    FLAG_log_code = true;
+    LogCompiledFunctions();
+    ticker_->Start();
+  }
   profiler_->resume();
 }
 
 
+bool Logger::IsProfilerSamplerActive() {
+  return ticker_->IsActive();
+}
+
+
 int Logger::GetLogLines(int from_pos, char* dest_buf, int max_size) {
   return Log::GetLogLines(from_pos, dest_buf, max_size);
 }
 
 
 void Logger::LogCompiledFunctions() {
   HandleScope scope;
   Handle<SharedFunctionInfo>* sfis = NULL;
   int compiled_funcs_count = 0;
 
@@ skipping 66 matching lines @@
     FLAG_log_code = true;
     FLAG_log_gc = true;
     FLAG_log_suspect = true;
     FLAG_log_handles = true;
     FLAG_log_regexp = true;
   }
 
   // --prof implies --log-code.
   if (FLAG_prof) FLAG_log_code = true;
 
+  // --prof_lazy controls --log-code, implies --noprof_auto.
+  if (FLAG_prof_lazy) {
+    FLAG_log_code = false;
+    FLAG_prof_auto = false;
+  }
+
   bool open_log_file = FLAG_log || FLAG_log_runtime || FLAG_log_api
       || FLAG_log_code || FLAG_log_gc || FLAG_log_handles || FLAG_log_suspect
-      || FLAG_log_regexp || FLAG_log_state_changes;
+      || FLAG_log_regexp || FLAG_log_state_changes || FLAG_prof_lazy;
 
   // If we're logging anything, we need to open the log file.
   if (open_log_file) {
     if (strcmp(FLAG_logfile, "-") == 0) {
       Log::OpenStdout();
     } else if (strcmp(FLAG_logfile, "*") == 0) {
       Log::OpenMemoryBuffer();
     } else if (strchr(FLAG_logfile, '%') != NULL) {
       // If there's a '%' in the log file name we have to expand
       // placeholders.
@@ skipping 64 matching lines @@
 void Logger::TearDown() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   // Stop the profiler before closing the file.
   if (profiler_ != NULL) {
     profiler_->Disengage();
     delete profiler_;
     profiler_ = NULL;
   }
 
   delete sliding_state_window_;
+  sliding_state_window_ = NULL;
 
   delete ticker_;
+  ticker_ = NULL;
 
   Log::Close();
 #endif
 }
 
 
 void Logger::EnableSlidingStateWindow() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   // If the ticker is NULL, Logger::Setup has not been called yet.  In
   // that case, we set the sliding_state_window flag so that the
@@ skipping 87 matching lines @@
     } else if (previous_->state_ == EXTERNAL) {
       // We are leaving V8.
       Heap::Protect();
     }
   }
 #endif
 }
 #endif
 
 } }  // namespace v8::internal