Schedule idle handler based on CPU usage.

content/renderer/render_thread_impl.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 82 matching lines @@
 using WebKit::WebFrame;
 using WebKit::WebNetworkStateNotifier;
 using WebKit::WebRuntimeFeatures;
 using WebKit::WebScriptController;
 using WebKit::WebString;
 using WebKit::WebStorageEventDispatcher;
 using WebKit::WebView;
 using content::RenderProcessObserver;
 
 namespace {
-static const int64 kInitialIdleHandlerDelayMs = 1000;
+static const int64 kLongIdleDelayMs = 30000;
+static const int64 kShortIdleDelayMs = 1000;
+static const int kIdleCPUUsageThresholdInPercents = 3;

[ulan, 2011/11/15 19:08:53]

I have chosen these values based on GeneralMixMemoryTest but I am not sure that
these values are optimal. Any suggestions are welcome.

 
 #if defined(TOUCH_UI)
 static const int kPopupListBoxMinimumRowHeight = 60;
 #endif
 
 // Keep the global RenderThreadImpl in a TLS slot so it is impossible to access
 // incorrectly from the wrong thread.
 static base::LazyInstance<base::ThreadLocalPointer<RenderThreadImpl> > lazy_tls(
     base::LINKER_INITIALIZED);
 
@@ skipping 71 matching lines @@
   if (RenderProcessImpl::InProcessPlugins())
     initialize_com_.reset(new base::win::ScopedCOMInitializer());
 #endif
 
   // In single process the single process is all there is.
   suspend_webkit_shared_timer_ = true;
   notify_webkit_of_modal_loop_ = true;
   plugin_refresh_allowed_ = true;
   widget_count_ = 0;
   hidden_widget_count_ = 0;
-  idle_notification_delay_in_ms_ = kInitialIdleHandlerDelayMs;
+  idle_delay_ms_ = kLongIdleDelayMs;
+  base::ProcessHandle handle = base::GetCurrentProcessHandle();
+#if defined(OS_MACOSX)
+  process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(handle,
+                                                                    NULL));
+#else
+  process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(handle));
+#endif
   task_factory_.reset(new ScopedRunnableMethodFactory<RenderThreadImpl>(this));
 
   appcache_dispatcher_.reset(new AppCacheDispatcher(Get()));
   indexed_db_dispatcher_.reset(new IndexedDBDispatcher());
 
   db_message_filter_ = new DBMessageFilter();
   AddFilter(db_message_filter_.get());
 
   vc_manager_ = new VideoCaptureImplManager();
   AddFilter(vc_manager_->video_capture_message_filter());
@@ skipping 184 matching lines @@
 }
 
 void RenderThreadImpl::SetResourceDispatcherDelegate(
     content::ResourceDispatcherDelegate* delegate) {
   resource_dispatcher()->set_delegate(delegate);
 }
 
 void RenderThreadImpl::WidgetHidden() {
   DCHECK(hidden_widget_count_ < widget_count_);
   hidden_widget_count_++;
-
-  if (!content::GetContentClient()->renderer()->
-          RunIdleHandlerWhenWidgetsHidden()) {
-    return;
-  }
-
   if (widget_count_ && hidden_widget_count_ == widget_count_)
-    ScheduleIdleHandler(kInitialIdleHandlerDelayMs);
+    ResetIdleTimer();
 }
 
 void RenderThreadImpl::WidgetRestored() {
   DCHECK_GT(hidden_widget_count_, 0);
   hidden_widget_count_--;
-  if (!content::GetContentClient()->renderer()->
-          RunIdleHandlerWhenWidgetsHidden()) {
-    return;
-  }
-
-  idle_timer_.Stop();
 }
 
 void RenderThreadImpl::EnsureWebKitInitialized() {
   if (webkit_platform_support_.get())
     return;
 
   v8::V8::SetCounterFunction(base::StatsTable::FindLocation);
   v8::V8::SetCreateHistogramFunction(CreateHistogram);
   v8::V8::SetAddHistogramSampleFunction(AddHistogramSample);
 
@@ skipping 88 matching lines @@
 
   WebRuntimeFeatures::enableFileSystem(
       !command_line.HasSwitch(switches::kDisableFileSystem));
 
   WebRuntimeFeatures::enableJavaScriptI18NAPI(
       !command_line.HasSwitch(switches::kDisableJavaScriptI18NAPI));
 
   WebRuntimeFeatures::enableQuota(true);
 
   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, WebKitInitialized());
+
+  ScheduleIdleHandler(kLongIdleDelayMs);
 }
 
 void RenderThreadImpl::RecordUserMetrics(const std::string& action) {
   Send(new ViewHostMsg_UserMetricsRecordAction(action));
 }
 
 base::SharedMemoryHandle RenderThreadImpl::HostAllocateSharedMemoryBuffer(
     uint32 buffer_size) {
   base::SharedMemoryHandle mem_handle;
   Send(new ChildProcessHostMsg_SyncAllocateSharedMemory(
                 buffer_size, &mem_handle));
   return mem_handle;
 }
 
 void RenderThreadImpl::RegisterExtension(v8::Extension* extension) {
   WebScriptController::registerExtension(extension);
   v8_extensions_.insert(extension->name());
 }
 
 bool RenderThreadImpl::IsRegisteredExtension(
     const std::string& v8_extension_name) const {
   return v8_extensions_.find(v8_extension_name) != v8_extensions_.end();
 }
 
-void RenderThreadImpl::ScheduleIdleHandler(int64 initial_delay_ms) {
-  idle_notification_delay_in_ms_ = initial_delay_ms;
-  idle_timer_.Stop();
-  idle_timer_.Start(FROM_HERE,
-      base::TimeDelta::FromMilliseconds(initial_delay_ms),
-      this, &RenderThreadImpl::IdleHandler);
-}
-
-void RenderThreadImpl::IdleHandler() {
-  #if !defined(OS_MACOSX) && defined(USE_TCMALLOC)
-  MallocExtension::instance()->ReleaseFreeMemory();
-#endif
-
-  v8::V8::IdleNotification();
-
-  // Schedule next invocation.
-  // Dampen the delay using the algorithm (if delay is in seconds):
-  //    delay = delay + 1 / (delay + 2)
-  // Using floor(delay) has a dampening effect such as:
-  //    1s, 1, 1, 2, 2, 2, 2, 3, 3, ...
-  // If the delay is in milliseconds, the above formula is equivalent to:
-  //    delay_ms / 1000 = delay_ms / 1000 + 1 / (delay_ms / 1000 + 2)
-  // which is equivalent to
-  //    delay_ms = delay_ms + 1000*1000 / (delay_ms + 2000).
-  // Note that idle_notification_delay_in_ms_ would be reset to
-  // kInitialIdleHandlerDelayMs in RenderThreadImpl::WidgetHidden.
-  ScheduleIdleHandler(idle_notification_delay_in_ms_ +
-                      1000000 / (idle_notification_delay_in_ms_ + 2000));
-
-  FOR_EACH_OBSERVER(RenderProcessObserver, observers_, IdleNotification());
-}
-
-int64 RenderThreadImpl::GetIdleNotificationDelayInMs() const {
-  return idle_notification_delay_in_ms_;
-}
-
-void RenderThreadImpl::SetIdleNotificationDelayInMs(
-    int64 idle_notification_delay_in_ms) {
-  idle_notification_delay_in_ms_ = idle_notification_delay_in_ms;
+void RenderThreadImpl::ResetIdleTimer() {
+  if (idle_delay_ms_ > kShortIdleDelayMs) {
+    idle_timer_.Stop();
+    ScheduleIdleHandler(kShortIdleDelayMs);
+  }
 }
 
 #if defined(OS_WIN)
 void RenderThreadImpl::PreCacheFont(const LOGFONT& log_font) {
   Send(new ChildProcessHostMsg_PreCacheFont(log_font));
 }
 
 void RenderThreadImpl::ReleaseCachedFonts() {
   Send(new ChildProcessHostMsg_ReleaseCachedFonts());
 }
@@ skipping 16 matching lines @@
 }
 
 void RenderThreadImpl::DoNotSuspendWebKitSharedTimer() {
   suspend_webkit_shared_timer_ = false;
 }
 
 void RenderThreadImpl::DoNotNotifyWebKitOfModalLoop() {
   notify_webkit_of_modal_loop_ = false;
 }
 
+void RenderThreadImpl::IdleHandler() {
+  // Dampen the delay using the algorithm (if delay is in seconds):
+  //    new_delay = delay + 1 / (delay + 2)
+  // Using floor(delay) has a dampening effect such as:
+  //    1s, 1, 1, 2, 2, 2, 2, 3, 3, ...
+  // If the delay is in milliseconds, the above formula is equivalent to:
+  //    new_delay_ms / 1000 = delay_ms / 1000 + 1 / (delay_ms / 1000 + 2)
+  // which is equivalent to
+  //    new_delay_ms = delay_ms + 1000*1000 / (delay_ms + 2000).
+  int64 new_delay_ms = idle_delay_ms_ + 1000000 / (idle_delay_ms_ + 2000);
+  if (process_metrics_->GetCPUUsage() < kIdleCPUUsageThresholdInPercents) {
+    new_delay_ms = kShortIdleDelayMs;
+    // Make sure that CPU usage was sampled for short delay, not long delay.
+    if (idle_delay_ms_ == kShortIdleDelayMs) {
+#if !defined(OS_MACOSX) && defined(USE_TCMALLOC)
+      MallocExtension::instance()->ReleaseFreeMemory();
+#endif
+      if (v8::V8::IdleNotification()) {
+        // V8 finished collecting garbage.
+        new_delay_ms = kLongIdleDelayMs;
+      }
+    }
+  }
+  ScheduleIdleHandler(new_delay_ms);
+}
+
 void RenderThreadImpl::OnSetZoomLevelForCurrentURL(const GURL& url,
                                                    double zoom_level) {
   RenderViewZoomer zoomer(url, zoom_level);
   content::RenderView::ForEach(&zoomer);
 }
 
 void RenderThreadImpl::OnDOMStorageEvent(
     const DOMStorageMsg_Event_Params& params) {
   if (!dom_storage_event_dispatcher_.get())
     dom_storage_event_dispatcher_.reset(WebStorageEventDispatcher::create());
@@ skipping 140 matching lines @@
 void RenderThreadImpl::OnNetworkStateChanged(bool online) {
   EnsureWebKitInitialized();
   WebNetworkStateNotifier::setOnLine(online);
 }
 
 void RenderThreadImpl::OnTempCrashWithData(const GURL& data) {
   content::GetContentClient()->SetActiveURL(data);
   CHECK(false);
 }
 
+void RenderThreadImpl::ScheduleIdleHandler(int64 delay_ms) {
+  idle_delay_ms_ = delay_ms;
+  idle_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(delay_ms),
+                    this, &RenderThreadImpl::IdleHandler);
+}
+
 scoped_refptr<base::MessageLoopProxy>
 RenderThreadImpl::GetFileThreadMessageLoopProxy() {
   DCHECK(message_loop() == MessageLoop::current());
   if (!file_thread_.get()) {
     file_thread_.reset(new base::Thread("Renderer::FILE"));
     file_thread_->Start();
   }
   return file_thread_->message_loop_proxy();
 }