High resolution timer fix for Windows

base/message_loop/message_loop.cc

 // Copyright 2013 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 "base/message_loop/message_loop.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 109 matching lines @@
 MessageLoop::TaskObserver::~TaskObserver() {
 }
 
 MessageLoop::DestructionObserver::~DestructionObserver() {
 }
 
 //------------------------------------------------------------------------------
 
 MessageLoop::MessageLoop(Type type)
     : type_(type),
+      pending_high_res_tasks_(false),

[jamesr, 2014/07/18 04:45:37]

s/false/0/

[cpu_(ooo_6.6-7.5), 2014/07/18 22:53:10]

Done.

       nestable_tasks_allowed_(true),
 #if defined(OS_WIN)
       os_modal_loop_(false),
 #endif  // OS_WIN
       message_histogram_(NULL),
       run_loop_(NULL) {
   Init();
 
   pump_ = CreateMessagePumpForType(type).Pass();
 }
 
 MessageLoop::MessageLoop(scoped_ptr<MessagePump> pump)
     : pump_(pump.Pass()),
       type_(TYPE_CUSTOM),
+      pending_high_res_tasks_(false),

[jamesr, 2014/07/18 04:45:37]

s/false/0/

[cpu_(ooo_6.6-7.5), 2014/07/18 22:53:10]

Done.

       nestable_tasks_allowed_(true),
 #if defined(OS_WIN)
       os_modal_loop_(false),
 #endif  // OS_WIN
       message_histogram_(NULL),
       run_loop_(NULL) {
   DCHECK(pump_.get());
   Init();
 }
 
 MessageLoop::~MessageLoop() {
   DCHECK_EQ(this, current());
 
   DCHECK(!run_loop_);
 
   // Clean up any unprocessed tasks, but take care: deleting a task could
   // result in the addition of more tasks (e.g., via DeleteSoon).  We set a
   // limit on the number of times we will allow a deleted task to generate more
   // tasks.  Normally, we should only pass through this loop once or twice.  If
   // we end up hitting the loop limit, then it is probably due to one task that
   // is being stubborn.  Inspect the queues to see who is left.
   bool did_work;
   for (int i = 0; i < 100; ++i) {
     DeletePendingTasks();
     ReloadWorkQueue();
     // If we end up with empty queues, then break out of the loop.
     did_work = DeletePendingTasks();

[darin (slow to review), 2014/07/18 04:07:59]

notice how we delete some pending tasks here... this means we may not fully
decrement the high res task counter, which means we may leave the high res timer
running, right?

[jamesr, 2014/07/18 04:45:37]

Hmm, true. we should probably keep track of whether this message loop as
activated high res and deactivate if so on destruction

[cpu_(ooo_6.6-7.5), 2014/07/18 22:53:10]

added such variable.

     if (!did_work)
       break;
   }
   DCHECK(!did_work);
 
   // Let interested parties have one last shot at accessing this.
   FOR_EACH_OBSERVER(DestructionObserver, destruction_observers_,
                     WillDestroyCurrentMessageLoop());
 
   thread_task_runner_handle_.reset();
@@ skipping 181 matching lines @@
 void MessageLoop::RemoveTaskObserver(TaskObserver* task_observer) {
   DCHECK_EQ(this, current());
   task_observers_.RemoveObserver(task_observer);
 }
 
 bool MessageLoop::is_running() const {
   DCHECK_EQ(this, current());
   return run_loop_ != NULL;
 }
 
-bool MessageLoop::IsHighResolutionTimerEnabledForTesting() {
-  return incoming_task_queue_->IsHighResolutionTimerEnabledForTesting();
+bool MessageLoop::HasHighResolutionTasks() {
+  return incoming_task_queue_->HasHighResolutionTasks();
 }
 
 bool MessageLoop::IsIdleForTesting() {
   // We only check the imcoming queue|, since we don't want to lock the work
   // queue.
   return incoming_task_queue_->IsIdleForTesting();
 }
 
 //------------------------------------------------------------------------------
 
@@ skipping 47 matching lines @@
       "queue_duration",
       (start_time - pending_task.EffectiveTimePosted()).InMilliseconds());
   // When tracing memory for posted tasks it's more valuable to attribute the
   // memory allocations to the source function than generically to "RunTask".
   TRACE_EVENT_WITH_MEMORY_TAG2(
       "toplevel", "MessageLoop::RunTask",
       pending_task.posted_from.function_name(),  // Name for memory tracking.
       "src_file", pending_task.posted_from.file_name(),
       "src_func", pending_task.posted_from.function_name());
 
+  if (pending_task.is_high_res) {
+    pending_high_res_tasks_--;
+    CHECK(pending_high_res_tasks_ >= 0);
+  }
+
   DCHECK(nestable_tasks_allowed_);
   // Execute the task and assume the worst: It is probably not reentrant.
   nestable_tasks_allowed_ = false;
 
   // Before running the task, store the program counter where it was posted
   // and deliberately alias it to ensure it is on the stack if the task
   // crashes. Be careful not to assume that the variable itself will have the
   // expected value when displayed by the optimizer in an optimized build.
   // Look at a memory dump of the stack.
   const void* program_counter =
@@ skipping 65 matching lines @@
 uint64 MessageLoop::GetTaskTraceID(const PendingTask& task) {
   return (static_cast<uint64>(task.sequence_num) << 32) |
          ((static_cast<uint64>(reinterpret_cast<intptr_t>(this)) << 32) >> 32);
 }
 
 void MessageLoop::ReloadWorkQueue() {
   // We can improve performance of our loading tasks from the incoming queue to
   // |*work_queue| by waiting until the last minute (|*work_queue| is empty) to
   // load. That reduces the number of locks-per-task significantly when our
   // queues get large.
-  if (work_queue_.empty())
-    incoming_task_queue_->ReloadWorkQueue(&work_queue_);
+  if (work_queue_.empty()) {
+    pending_high_res_tasks_ +=
+        incoming_task_queue_->ReloadWorkQueue(&work_queue_);
+  }
 }
 
 void MessageLoop::ScheduleWork(bool was_empty) {
   // The Android UI message loop needs to get notified each time
   // a task is added to the incoming queue.
   if (was_empty || AlwaysNotifyPump(type_))
     pump_->ScheduleWork();
 }
 
 //------------------------------------------------------------------------------
@@ skipping 87 matching lines @@
 bool MessageLoop::DoIdleWork() {
   if (ProcessNextDelayedNonNestableTask())
     return true;
 
   if (run_loop_->quit_when_idle_received_)
     pump_->Quit();
 
   return false;
 }
 
+void MessageLoop::UpdateTimerGranularity() {
+#if defined(OS_WIN)
+  // Windows scheduler has by default ~15ms resolution. So, if we have high
+  // resolution tasks pending we need to temporarity increase the systemwide
+  // timer resolution to 1ms, and if we don't we need to go back to 15ms.
+  Time::ActivateHighResolutionTimer(pending_high_res_tasks_ > 0);
+#endif
+}
+
 void MessageLoop::DeleteSoonInternal(const tracked_objects::Location& from_here,
                                      void(*deleter)(const void*),
                                      const void* object) {
   PostNonNestableTask(from_here, Bind(deleter, object));
 }
 
 void MessageLoop::ReleaseSoonInternal(
     const tracked_objects::Location& from_here,
     void(*releaser)(const void*),
     const void* object) {
@@ skipping 82 matching lines @@
       persistent,
       mode,
       controller,
       delegate);
 }
 #endif
 
 #endif  // !defined(OS_NACL)
 
 }  // namespace base