[scheduler] Add options to TaskQueue::InsertFence

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 81 matching lines @@
     double cpu_percentage) {
   Advance(now);
   cpu_percentage_ = cpu_percentage;
   EnforceBudgetLevelRestrictions();
 }
 
 void TaskQueueThrottler::TimeBudgetPool::AddQueue(base::TimeTicks now,
                                                   TaskQueue* queue) {
   std::pair<TaskQueueMap::iterator, bool> insert_result =
       task_queue_throttler_->queue_details_.insert(
-          std::make_pair(queue, Metadata(0, queue->IsQueueEnabled())));
+          std::make_pair(queue, Metadata()));
   Metadata& metadata = insert_result.first->second;
   DCHECK(!metadata.time_budget_pool);
   metadata.time_budget_pool = this;
 
   associated_task_queues_.insert(queue);
 
   if (!is_enabled_ || !task_queue_throttler_->IsThrottled(queue))
     return;
 
-  queue->SetQueueEnabled(false);
+  queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
 
   task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, now, queue,
                                                 GetNextAllowedRunTime());
 }
 
 void TaskQueueThrottler::TimeBudgetPool::RemoveQueue(base::TimeTicks now,
                                                      TaskQueue* queue) {
   auto find_it = task_queue_throttler_->queue_details_.find(queue);
   DCHECK(find_it != task_queue_throttler_->queue_details_.end() &&
          find_it->second.time_budget_pool == this);
@@ skipping 131 matching lines @@
     last_checkpoint_ = now;
   }
 }
 
 void TaskQueueThrottler::TimeBudgetPool::BlockThrottledQueues(
     base::TimeTicks now) {
   for (TaskQueue* queue : associated_task_queues_) {
     if (!task_queue_throttler_->IsThrottled(queue))
       continue;
 
-    queue->SetQueueEnabled(false);
+    queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
     task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, now, queue,
                                                   base::nullopt);
   }
 }
 
 void TaskQueueThrottler::TimeBudgetPool::EnforceBudgetLevelRestrictions() {
   if (max_budget_level_) {
     current_budget_level_ =
         std::min(current_budget_level_, max_budget_level_.value());
   }
   if (max_throttling_duration_) {
     // Current budget level may be negative.
     current_budget_level_ =
         std::max(current_budget_level_,
                  -max_throttling_duration_.value() * cpu_percentage_);
   }
 }
 
-// TODO(altimin): Control max_budget_level and max_throttling_duration
-// from Finch.
 TaskQueueThrottler::TaskQueueThrottler(
     RendererSchedulerImpl* renderer_scheduler,
     const char* tracing_category)
     : task_runner_(renderer_scheduler->ControlTaskRunner()),
       renderer_scheduler_(renderer_scheduler),
       tick_clock_(renderer_scheduler->tick_clock()),
       tracing_category_(tracing_category),
       time_domain_(new ThrottledTimeDomain(this, tracing_category)),
       allow_throttling_(true),
       weak_factory_(this) {
@@ skipping 13 matching lines @@
     TaskQueue* task_queue = map_entry.first;
     if (IsThrottled(task_queue)) {
       task_queue->SetTimeDomain(renderer_scheduler_->real_time_domain());
       task_queue->RemoveFence();
     }
   }
 
   renderer_scheduler_->UnregisterTimeDomain(time_domain_.get());
 }
 
-void TaskQueueThrottler::SetQueueEnabled(TaskQueue* task_queue, bool enabled) {
-  // Both the TaskQueueThrottler and other systems want to enable and disable
-  // task queues. The policy we've adopted to deal with this is:
-  //
-  // A task queue is disabled if either the TaskQueueThrottler or the caller
-  // vote to disable it.
-  //
-  // A task queue is enabled only if both the TaskQueueThrottler and the caller
-  // vote to enable it.
-  TaskQueueMap::iterator find_it = queue_details_.find(task_queue);
-
-  // If TaskQueueThrottler does not know about this queue, just call
-  // SetQueueEnabled directly.
-  if (find_it == queue_details_.end()) {
-    task_queue->SetQueueEnabled(enabled);
-    return;
-  }
-
-  // Remember the caller's preference so we know what to do when the task queue
-  // isn't throttled, or has budget to run.
-  find_it->second.enabled = enabled;
-
-  if (!IsThrottled(task_queue)) {
-    task_queue->SetQueueEnabled(enabled);
-    return;
-  }
-
-  if (enabled) {
-    // If the task queue is throttled and we want to enable it, we can't
-    // do it immediately due to task alignment requirement and we should
-    // schedule a call to PumpThrottledTasks.
-    MaybeSchedulePumpQueue(FROM_HERE, tick_clock_->NowTicks(), task_queue,
-                           base::nullopt);
-  } else {
-    task_queue->SetQueueEnabled(false);
-  }
-}
-
 void TaskQueueThrottler::IncreaseThrottleRefCount(TaskQueue* task_queue) {
   DCHECK_NE(task_queue, task_runner_.get());
 
-  std::pair<TaskQueueMap::iterator, bool> insert_result = queue_details_.insert(
-      std::make_pair(task_queue, Metadata(0 /* ref_count */,
-                                          task_queue->IsQueueEnabled())));
+  std::pair<TaskQueueMap::iterator, bool> insert_result =
+      queue_details_.insert(std::make_pair(task_queue, Metadata()));
+  insert_result.first->second.throttling_ref_count++;
 
-  if (insert_result.first->second.throttling_ref_count == 0) {
-    if (allow_throttling_) {
-      task_queue->SetTimeDomain(time_domain_.get());
-      task_queue->RemoveFence();
-      task_queue->SetQueueEnabled(false);
+  if (!allow_throttling_)
+    return;
 
-      if (!task_queue->IsEmpty()) {
-        if (task_queue->HasPendingImmediateWork()) {
-          OnTimeDomainHasImmediateWork(task_queue);
-        } else {
-          OnTimeDomainHasDelayedWork(task_queue);
-        }
-      }
+  // If ref_count is 1, the task queue is newly throttled.
+  if (insert_result.first->second.throttling_ref_count != 1)
+    return;
+
+  task_queue->SetTimeDomain(time_domain_.get());
+  // This blocks any tasks from |task_queue| until PumpThrottledTasks() to
+  // enforce task alignment.
+  task_queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
+
+  if (!task_queue->IsEmpty()) {
+    if (task_queue->HasPendingImmediateWork()) {
+      OnTimeDomainHasImmediateWork(task_queue);
+    } else {
+      OnTimeDomainHasDelayedWork(task_queue);
     }
-
-    TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueThrottled",
-                 "task_queue", task_queue);
   }
 
-  insert_result.first->second.throttling_ref_count++;
+  TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueThrottled",

[Sami, 2016/11/25 17:12:59]

Could you keep this at the top of the function so that any other events emitted
by function calls are logically ordered?

[altimin, 2016/11/25 17:44:10]

I want to emit this only when we are actually throttling queue, not just
increasing refcount. But I refactored it a bit.

+               "task_queue", task_queue);
 }
 
 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) {
-    bool enabled = iter->second.enabled;
-
     MaybeDeleteQueueMetadata(iter);
 
     if (allow_throttling_) {
       task_queue->SetTimeDomain(renderer_scheduler_->real_time_domain());
       task_queue->RemoveFence();
-      task_queue->SetQueueEnabled(enabled);
     }
 
     TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueUnthrottled",
                  "task_queue", task_queue);
   }
 }
 
 bool TaskQueueThrottler::IsThrottled(TaskQueue* task_queue) const {
   if (!allow_throttling_)
     return false;
@@ skipping 47 matching lines @@
 
 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 TaskQueueMap::value_type& map_entry : queue_details_) {
     TaskQueue* task_queue = map_entry.first;
-    if (!map_entry.second.enabled || task_queue->IsEmpty() ||
-        !IsThrottled(task_queue))
+    if (task_queue->IsEmpty() || !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()) {
       TRACE_EVENT1(
           tracing_category_,
           "TaskQueueThrottler::PumpThrottledTasks_ExpensiveTaskThrottled",
           "throttle_time_in_seconds",
           (next_allowed_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);
 
       continue;
     }
 
     next_scheduled_delayed_task =
         Min(next_scheduled_delayed_task, task_queue->GetNextScheduledWakeUp());
 
     if (next_allowed_run_time > lazy_now.Now())
       continue;
 
-    task_queue->SetQueueEnabled(true);
-    task_queue->InsertFence();
+    // 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.
   if (next_scheduled_delayed_task) {
     MaybeSchedulePumpThrottledTasks(FROM_HERE, lazy_now.Now(),
                                     *next_scheduled_delayed_task);
   }
@@ skipping 78 matching lines @@
     pool->AsValueInto(state, now);
   }
   state->EndDictionary();
 
   state->BeginDictionary("queue_details");
   for (const auto& map_entry : queue_details_) {
     state->BeginDictionaryWithCopiedName(PointerToId(map_entry.first));
 
     state->SetInteger("throttling_ref_count",
                       map_entry.second.throttling_ref_count);
-    state->SetBoolean("enabled", map_entry.second.enabled);
 
     state->EndDictionary();
   }
   state->EndDictionary();
 }
 
 TaskQueueThrottler::TimeBudgetPool*
 TaskQueueThrottler::GetTimeBudgetPoolForQueue(TaskQueue* queue) {
   auto find_it = queue_details_.find(queue);
   if (find_it == queue_details_.end())
@@ skipping 36 matching lines @@
 
   for (const auto& map_entry : queue_details_) {
     if (map_entry.second.throttling_ref_count == 0)
       continue;
 
     TaskQueue* queue = map_entry.first;
 
     queue->SetTimeDomain(renderer_scheduler_->GetActiveTimeDomain());
 
     queue->RemoveFence();
-    queue->SetQueueEnabled(map_entry.second.enabled);
   }
 
   pump_throttled_tasks_closure_.Cancel();
   pending_pump_throttled_tasks_runtime_ = base::nullopt;
 
   TRACE_EVENT0(tracing_category_, "TaskQueueThrottler_DisableThrottling");
 }
 
 void TaskQueueThrottler::EnableThrottling() {
   if (allow_throttling_)
     return;
 
   allow_throttling_ = true;
 
   LazyNow lazy_now(tick_clock_);
 
   for (const auto& map_entry : queue_details_) {
     if (map_entry.second.throttling_ref_count == 0)
       continue;
 
     TaskQueue* queue = map_entry.first;
 
-    queue->SetQueueEnabled(false);
+    // Throttling is enabled and task queue should be blocked immediately
+    // to enforce task alignment.
+    queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
     queue->SetTimeDomain(time_domain_.get());
     MaybeSchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue,
                            GetNextAllowedRunTime(lazy_now.Now(), queue));
   }
 
   TRACE_EVENT0(tracing_category_, "TaskQueueThrottler_EnableThrottling");
 }
 
 }  // namespace scheduler
 }  // namespace blink