[scheduler] Add WakeupBudgetPool.

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc

 // Copyright 2015 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 "platform/scheduler/renderer/task_queue_throttler.h"
 
 #include <cstdint>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 126 matching lines @@
   if (!task_queue->IsEmpty()) {
     LazyNow lazy_now(tick_clock_);
     OnQueueNextWakeUpChanged(task_queue,
                              NextTaskRunTime(&lazy_now, task_queue).value());
   }
 }
 
 void TaskQueueThrottler::DecreaseThrottleRefCount(TaskQueue* task_queue) {
   TaskQueueMap::iterator iter = queue_details_.find(task_queue);
 
-  if (iter == queue_details_.end() ||
-      --iter->second.throttling_ref_count != 0) {
+  if (iter == queue_details_.end())
     return;
-  }
+  if (iter->second.throttling_ref_count == 0)

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

That looks really weird.  Is this papering over a bug elsewhere?

[altimin, 2017/04/25 13:22:35]

There is a special test ensuring that extra DecreaseThrottleRefCount do nothing.
I assumed that there are usages in the wild with this.

I'm strongly in favour of RAII approach, where instead of Increase/Decrease ref
count methods you can get a handle of sorts (instead of
IncreaseThrottleRefCount)  and reset/destroy it when needed (instead of
DecreaseThrottleRefCount). I may do it a follow-up patch.

+    return;
+  if (--iter->second.throttling_ref_count != 0)
+    return;
 
   TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueUnthrottled",
                "task_queue", task_queue);
 
   task_queue->SetObserver(nullptr);
 
   MaybeDeleteQueueMetadata(iter);
 
   if (!allow_throttling_)
     return;
@@ skipping 10 matching lines @@
   if (find_it == queue_details_.end())
     return false;
   return find_it->second.throttling_ref_count > 0;
 }
 
 void TaskQueueThrottler::UnregisterTaskQueue(TaskQueue* task_queue) {
   auto find_it = queue_details_.find(task_queue);
   if (find_it == queue_details_.end())
     return;
 
-  LazyNow lazy_now(tick_clock_);
   std::unordered_set<BudgetPool*> budget_pools = find_it->second.budget_pools;
   for (BudgetPool* budget_pool : budget_pools) {
-    budget_pool->RemoveQueue(lazy_now.Now(), task_queue);
+    budget_pool->UnregisterQueue(task_queue);
   }
 
   // Iterator may have been deleted by BudgetPool::RemoveQueue, so don't
   // use it here.
   queue_details_.erase(task_queue);
 
   // NOTE: Observer is automatically unregistered when unregistering task queue.
 }
 
 void TaskQueueThrottler::OnQueueNextWakeUpChanged(
     TaskQueue* queue,
     base::TimeTicks next_wake_up) {
   if (!task_runner_->RunsTasksOnCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(forward_immediate_work_callback_, queue, next_wake_up));
     return;
   }
 
   TRACE_EVENT0(tracing_category_,
                "TaskQueueThrottler::OnQueueNextWakeUpChanged");
 
   // We don't expect this to get called for disabled queues, but we can't DCHECK
   // because of the above thread hop.  Just bail out if the queue is disabled.
   if (!queue->IsQueueEnabled())
     return;
 
   base::TimeTicks now = tick_clock_->NowTicks();
+
+  auto find_it = queue_details_.find(queue);

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

I don't remember off hand if return value optimization kicks in here. Can this
be const ref? (not needed if RVO happens).

[altimin, 2017/04/25 13:22:35]

auto find_it is a common pattern here. I don't want to refactor all usages in
this patch (it's already too big). Maybe will address in a follow-up.

+  if (find_it == queue_details_.end())
+    return;
+
+  for (BudgetPool* budget_pool : find_it->second.budget_pools) {
+    budget_pool->OnTaskQueueHasWork(queue, now, next_wake_up);
+  }
+
+  base::TimeTicks next_allowed_run_time =
+      GetNextAllowedRunTime(queue, now, next_wake_up);
+  // TODO(altimin): Remove after moving to budget pools completely.
   MaybeSchedulePumpThrottledTasks(
-      FROM_HERE, now,
-      std::max(GetNextAllowedRunTime(now, queue), next_wake_up));
+      FROM_HERE, now, std::max(next_wake_up, next_allowed_run_time));
 }
 
 void TaskQueueThrottler::PumpThrottledTasks() {
   TRACE_EVENT0(tracing_category_, "TaskQueueThrottler::PumpThrottledTasks");
   pending_pump_throttled_tasks_runtime_.reset();
 
   LazyNow lazy_now(tick_clock_);
   base::Optional<base::TimeTicks> next_scheduled_delayed_task;
 
+  for (const auto& it : budget_pools_)

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

uber nit: s/it/pair ;)

[altimin, 2017/04/25 13:22:35]

Done.

+    it.first->OnWakeup(lazy_now.Now());
+
   for (const TaskQueueMap::value_type& map_entry : queue_details_) {
     TaskQueue* task_queue = map_entry.first;
-    if (task_queue->IsEmpty() || !IsThrottled(task_queue))
+    if (task_queue->IsEmpty() || !task_queue->IsQueueEnabled() ||
+        !IsThrottled(task_queue)) {
       continue;
+    }
 
-    // Don't enable queues whose budget pool doesn't allow them to run now.
-    base::TimeTicks next_allowed_run_time =
-        GetNextAllowedRunTime(lazy_now.Now(), task_queue);
     base::Optional<base::TimeTicks> next_desired_run_time =
         NextTaskRunTime(&lazy_now, task_queue);
 
-    if (next_desired_run_time &&
-        next_allowed_run_time > next_desired_run_time.value()) {
+    if (!next_desired_run_time) {
+      // This task queue does not any tasks.

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

Looks like you're missing a word in the comment.

[altimin, 2017/04/25 13:22:35]

Done.

+      task_queue->InsertFence(TaskQueue::InsertFencePosition::NOW);

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

Is it possible to get here?  The queue has to be empty for NextTaskRunTime to
return nullopt right?

[altimin, 2017/04/25 13:22:35]

Done.

+      continue;
+    }
+
+    base::TimeTicks next_run_time = GetNextAllowedRunTime(
+        task_queue, lazy_now.Now(), next_desired_run_time.value());
+
+    if (next_run_time > lazy_now.Now()) {
       TRACE_EVENT1(
           tracing_category_,
           "TaskQueueThrottler::PumpThrottledTasks_ExpensiveTaskThrottled",
           "throttle_time_in_seconds",
-          (next_allowed_run_time - next_desired_run_time.value()).InSecondsF());
+          (next_run_time - next_desired_run_time.value()).InSecondsF());
 
-      // Schedule a pump for queue which was disabled because of time budget.
       next_scheduled_delayed_task =
-          Min(next_scheduled_delayed_task, next_allowed_run_time);
+          Min(next_scheduled_delayed_task, next_run_time);
 
       continue;
     }
 
-    next_scheduled_delayed_task =
-        Min(next_scheduled_delayed_task, task_queue->GetNextScheduledWakeUp());
+    base::Optional<base::TimeTicks> next_wake_up =
+        task_queue->GetNextScheduledWakeUp();
 
-    if (next_allowed_run_time > lazy_now.Now())
+    if (next_wake_up) {
+      next_scheduled_delayed_task =
+          Min(next_scheduled_delayed_task,
+              GetNextAllowedRunTime(task_queue, lazy_now.Now(),
+                                    next_wake_up.value()));
+    }
+
+    if (CanRunTasksUntil(task_queue, lazy_now.Now(),
+                         next_desired_run_time.value())) {
+      // Remove fence if we can new tasks until next wakeup.
+      task_queue->RemoveFence();
       continue;
+    }
 
     // Remove previous fence and install a new one, allowing all tasks posted
     // on |task_queue| up until this point to run and block all further tasks.
     task_queue->InsertFence(TaskQueue::InsertFencePosition::NOW);
   }
 
   // Maybe schedule a call to TaskQueueThrottler::PumpThrottledTasks if there is
   // a pending delayed task or a throttled task ready to run.
   // NOTE: posting a non-delayed task in the future will result in
   // TaskQueueThrottler::OnTimeDomainHasImmediateWork being called.
@@ skipping 42 matching lines @@
 }
 
 CPUTimeBudgetPool* TaskQueueThrottler::CreateCPUTimeBudgetPool(
     const char* name) {
   CPUTimeBudgetPool* time_budget_pool =
       new CPUTimeBudgetPool(name, this, tick_clock_->NowTicks());
   budget_pools_[time_budget_pool] = base::WrapUnique(time_budget_pool);
   return time_budget_pool;
 }
 
+WakeupBudgetPool* TaskQueueThrottler::CreateWakeupBudgetPool(const char* name) {
+  WakeupBudgetPool* wakeup_budget_pool =
+      new WakeupBudgetPool(name, this, tick_clock_->NowTicks());
+  budget_pools_[wakeup_budget_pool] = base::WrapUnique(wakeup_budget_pool);
+  return wakeup_budget_pool;
+}
+
 void TaskQueueThrottler::OnTaskRunTimeReported(TaskQueue* task_queue,
                                                base::TimeTicks start_time,
                                                base::TimeTicks end_time) {
   if (!IsThrottled(task_queue))
     return;
 
   auto find_it = queue_details_.find(task_queue);
   if (find_it == queue_details_.end())
     return;
 
   for (BudgetPool* budget_pool : find_it->second.budget_pools) {
-    budget_pool->RecordTaskRunTime(start_time, end_time);
-    if (!budget_pool->HasEnoughBudgetToRun(end_time))
+    budget_pool->RecordTaskRunTime(task_queue, start_time, end_time);
+    if (!budget_pool->CanRunTasksAt(end_time))
       budget_pool->BlockThrottledQueues(end_time);
   }
 }
 
-void TaskQueueThrottler::BlockQueue(base::TimeTicks now, TaskQueue* queue) {
+void TaskQueueThrottler::BlockQueue(QueueBlockType block_type,
+                                    base::TimeTicks now,
+                                    TaskQueue* queue) {
   if (!IsThrottled(queue))
     return;
 
-  queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
+  if (block_type == QueueBlockType::FULL) {
+    queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
+  } else {  // block_type == BlockType::NEW_TASKS_ONLY
+    if (!queue->HasFence()) {
+      queue->InsertFence(TaskQueue::InsertFencePosition::NOW);
+    }
+  }
   SchedulePumpQueue(FROM_HERE, now, queue);
 }
 
 void TaskQueueThrottler::AsValueInto(base::trace_event::TracedValue* state,
                                      base::TimeTicks now) const {
   if (pending_pump_throttled_tasks_runtime_) {
     state->SetDouble(
         "next_throttled_tasks_pump_in_seconds",
         (pending_pump_throttled_tasks_runtime_.value() - now).InSecondsF());
   }
@@ skipping 42 matching lines @@
   find_it->second.budget_pools.erase(budget_pool);
 
   MaybeDeleteQueueMetadata(find_it);
 }
 
 void TaskQueueThrottler::UnregisterBudgetPool(BudgetPool* budget_pool) {
   budget_pools_.erase(budget_pool);
 }
 
 void TaskQueueThrottler::UnblockQueue(base::TimeTicks now, TaskQueue* queue) {
-  SchedulePumpQueue(FROM_HERE, now, queue);
+  if (queue->HasFence())

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

I hope we don't get tempted to use fences for some other reason.  Maybe add a
DCHECK when adding a queue to check there is no pre-existing fence.

[altimin, 2017/04/25 13:22:36]

Actually, we don't need this condition here.

+    SchedulePumpQueue(FROM_HERE, now, queue);
 }
 
 void TaskQueueThrottler::SchedulePumpQueue(
     const tracked_objects::Location& from_here,
     base::TimeTicks now,
     TaskQueue* queue) {
-  if (!IsThrottled(queue))
+  if (!IsThrottled(queue) || !queue->IsQueueEnabled())
     return;
 
   LazyNow lazy_now(now);
   base::Optional<base::TimeTicks> next_desired_run_time =
       NextTaskRunTime(&lazy_now, queue);
-  if (!next_desired_run_time)
+  if (!next_desired_run_time) {
     return;
-
-  base::Optional<base::TimeTicks> next_run_time =
-      Max(next_desired_run_time, GetNextAllowedRunTime(now, queue));
+  }
+  base::Optional<base::TimeTicks> next_run_time;
+  if (next_desired_run_time) {
+    next_run_time =
+        GetNextAllowedRunTime(queue, now, next_desired_run_time.value());
+  }
 
   MaybeSchedulePumpThrottledTasks(from_here, now, next_run_time.value());
 }
 
-base::TimeTicks TaskQueueThrottler::GetNextAllowedRunTime(base::TimeTicks now,
-                                                          TaskQueue* queue) {
+base::TimeTicks TaskQueueThrottler::GetNextAllowedRunTime(
+    TaskQueue* queue,
+    base::TimeTicks now,

[alex clarke (OOO till 29th), 2017/04/21 09:14:19]

I'm not 100% on this, but I wonder if things would be any simpler if we left the
clamping to |now| up to the caller.

[altimin, 2017/04/25 13:22:35]

Agreed.

+    base::TimeTicks desired_run_time) {
   base::TimeTicks next_run_time = now;
 
   auto find_it = queue_details_.find(queue);
   if (find_it == queue_details_.end())
     return next_run_time;
 
   for (BudgetPool* budget_pool : find_it->second.budget_pools) {
-    next_run_time =
-        std::max(next_run_time, budget_pool->GetNextAllowedRunTime());
+    next_run_time = std::max(
+        next_run_time, budget_pool->GetNextAllowedRunTime(desired_run_time));
   }
 
   return next_run_time;
 }
 
+bool TaskQueueThrottler::CanRunTasksAt(TaskQueue* queue,
+                                       base::TimeTicks moment) {
+  auto find_it = queue_details_.find(queue);
+  if (find_it == queue_details_.end())
+    return true;
+
+  for (BudgetPool* budget_pool : find_it->second.budget_pools) {
+    if (!budget_pool->CanRunTasksAt(moment))
+      return false;
+  }
+
+  return true;
+}
+
+bool TaskQueueThrottler::CanRunTasksUntil(TaskQueue* queue,
+                                          base::TimeTicks now,
+                                          base::TimeTicks moment) {
+  auto find_it = queue_details_.find(queue);
+  if (find_it == queue_details_.end())
+    return true;
+
+  for (BudgetPool* budget_pool : find_it->second.budget_pools) {
+    if (!budget_pool->CanRunTasksUntil(now, moment))
+      return false;
+  }
+
+  return true;
+}
+
 void TaskQueueThrottler::MaybeDeleteQueueMetadata(TaskQueueMap::iterator it) {
   if (it->second.throttling_ref_count == 0 && it->second.budget_pools.empty())
     queue_details_.erase(it);
 }
 
 void TaskQueueThrottler::DisableThrottling() {
   if (!allow_throttling_)
     return;
 
   allow_throttling_ = false;
@@ skipping 34 matching lines @@
     queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
     queue->SetTimeDomain(time_domain_.get());
     SchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue);
   }
 
   TRACE_EVENT0(tracing_category_, "TaskQueueThrottler_EnableThrottling");
 }
 
 }  // namespace scheduler
 }  // namespace blink