[scheduler] Support setting maximal throttling duration

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 <iostream>  // FIXME
+
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "base/strings/stringprintf.h"
 #include "platform/scheduler/base/real_time_domain.h"
 #include "platform/scheduler/child/scheduler_tqm_delegate.h"
 #include "platform/scheduler/renderer/auto_advancing_virtual_time_domain.h"
 #include "platform/scheduler/renderer/renderer_scheduler_impl.h"
 #include "platform/scheduler/renderer/throttled_time_domain.h"
 #include "platform/scheduler/renderer/web_frame_scheduler_impl.h"
 #include "public/platform/WebFrameScheduler.h"
 
 namespace blink {
 namespace scheduler {
 
 namespace {
-const int kMaxBudgetLevelInSeconds = 1;
+constexpr base::TimeDelta kMaxBudgetLevel = base::TimeDelta::FromSeconds(1);
+constexpr base::TimeDelta kMaxThrottlingDuration =
+    base::TimeDelta::FromMinutes(1);
 
 base::Optional<base::TimeTicks> NextTaskRunTime(LazyNow* lazy_now,
                                                 TaskQueue* queue) {
   if (queue->HasPendingImmediateWork())
     return lazy_now->Now();
   return queue->GetNextScheduledWakeUp();
 }
 
 template <class T>
 T Min(const base::Optional<T>& optional, const T& value) {
@@ skipping 26 matching lines @@
   if (!a)
     return b;
   return std::max(a.value(), b.value());
 }
 
 }  // namespace
 
 TaskQueueThrottler::TimeBudgetPool::TimeBudgetPool(
     const char* name,
     TaskQueueThrottler* task_queue_throttler,
-    base::TimeTicks now)
+    base::TimeTicks now,
+    base::Optional<base::TimeDelta> max_budget_level,
+    base::Optional<base::TimeDelta> max_throttling_duration)
     : name_(name),
       task_queue_throttler_(task_queue_throttler),
-      max_budget_level_(base::TimeDelta::FromSeconds(kMaxBudgetLevelInSeconds)),
+      max_budget_level_(max_budget_level),
+      max_throttling_duration_(max_throttling_duration),
       last_checkpoint_(now),
       cpu_percentage_(1),
       is_enabled_(true) {}
 
 TaskQueueThrottler::TimeBudgetPool::~TimeBudgetPool() {}
 
 void TaskQueueThrottler::TimeBudgetPool::SetTimeBudget(base::TimeTicks now,
                                                        double cpu_percentage) {
   Advance(now);
   cpu_percentage_ = cpu_percentage;
+  EnforceMaximalThrottlingDuration();
 }
 
 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())));
   Metadata& metadata = insert_result.first->second;
   DCHECK(!metadata.time_budget_pool);
   metadata.time_budget_pool = this;
@@ skipping 68 matching lines @@
 base::TimeTicks TaskQueueThrottler::TimeBudgetPool::GetNextAllowedRunTime() {
   if (!is_enabled_ || current_budget_level_.InMicroseconds() >= 0) {
     return last_checkpoint_;
   } else {
     // Subtract because current_budget is negative.
     return last_checkpoint_ - current_budget_level_ / cpu_percentage_;
   }
 }
 
 void TaskQueueThrottler::TimeBudgetPool::RecordTaskRunTime(
-    base::TimeDelta task_run_time) {
-  if (is_enabled_)
-    current_budget_level_ -= task_run_time;
+    base::TimeTicks start_time,
+    base::TimeTicks end_time) {
+  Advance(end_time);

[alex clarke (OOO till 29th), 2016/10/14 16:37:22]

Maybe DCHECK_LE(start_time, end_time);

[altimin, 2016/10/17 10:48:37]

Done.

+  if (is_enabled_) {
+    current_budget_level_ -= (end_time - start_time);
+    EnforceMaximalThrottlingDuration();
+  }
 }
 
 const char* TaskQueueThrottler::TimeBudgetPool::Name() const {
   return name_;
 }
 
 void TaskQueueThrottler::TimeBudgetPool::AsValueInto(
     base::trace_event::TracedValue* state,
     base::TimeTicks now) const {
   state->BeginDictionary();
@@ skipping 11 matching lines @@
         "%" PRIx64, static_cast<uint64_t>(reinterpret_cast<uintptr_t>(queue))));
   }
   state->EndArray();
 
   state->EndDictionary();
 }
 
 void TaskQueueThrottler::TimeBudgetPool::Advance(base::TimeTicks now) {
   if (now > last_checkpoint_) {
     if (is_enabled_) {
-      current_budget_level_ = std::min(
-          current_budget_level_ + cpu_percentage_ * (now - last_checkpoint_),
-          max_budget_level_);
+      current_budget_level_ += cpu_percentage_ * (now - last_checkpoint_);
+      if (max_budget_level_) {
+        current_budget_level_ =
+            std::min(current_budget_level_, max_budget_level_.value());
+      }
     }
     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);
     task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, now, queue,
                                                   base::nullopt);
   }
 }
 
+void TaskQueueThrottler::TimeBudgetPool::EnforceMaximalThrottlingDuration() {

[alex clarke (OOO till 29th), 2016/10/14 16:37:22]

Out of curiosity would it make sense to enforce max_budget_level_ and
max_throttling_duration_ in the same place?

[altimin, 2016/10/17 10:48:37]

Thanks! Done.

+  if (max_throttling_duration_) {
+    current_budget_level_ =
+        std::max(current_budget_level_,

[alex clarke (OOO till 29th), 2016/10/14 16:37:22]

Maybe add a comment pointing out the obvious: current_budget_level_ can be
negative.

[altimin, 2016/10/17 10:48:37]

Done.

+                 -max_throttling_duration_.value() * cpu_percentage_);
+  }
+}
+
 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)),
+      max_budget_level_(kMaxBudgetLevel),
+      max_throttling_duration_(kMaxThrottlingDuration),
       virtual_time_(false),
       weak_factory_(this) {
   pump_throttled_tasks_closure_.Reset(base::Bind(
       &TaskQueueThrottler::PumpThrottledTasks, weak_factory_.GetWeakPtr()));
   forward_immediate_work_callback_ =
       base::Bind(&TaskQueueThrottler::OnTimeDomainHasImmediateWork,
                  weak_factory_.GetWeakPtr());
 
   renderer_scheduler_->RegisterTimeDomain(time_domain_.get());
 }
@@ skipping 249 matching lines @@
 
     task_queue->SetTimeDomain(renderer_scheduler_->GetVirtualTimeDomain());
     task_queue->RemoveFence();
     task_queue->SetQueueEnabled(enabled);
   }
 }
 
 TaskQueueThrottler::TimeBudgetPool* TaskQueueThrottler::CreateTimeBudgetPool(
     const char* name) {
   TimeBudgetPool* time_budget_pool =
-      new TimeBudgetPool(name, this, tick_clock_->NowTicks());
+      new TimeBudgetPool(name, this, tick_clock_->NowTicks(), max_budget_level_,
+                         max_throttling_duration_);
   time_budget_pools_[time_budget_pool] = base::WrapUnique(time_budget_pool);
   return time_budget_pool;
 }
 
 void TaskQueueThrottler::OnTaskRunTimeReported(TaskQueue* task_queue,
                                                base::TimeTicks start_time,
                                                base::TimeTicks end_time) {
   if (!IsThrottled(task_queue))
     return;
 
   TimeBudgetPool* time_budget_pool = GetTimeBudgetPoolForQueue(task_queue);
   if (!time_budget_pool)
     return;
 
-  time_budget_pool->RecordTaskRunTime(end_time - start_time);
+  time_budget_pool->RecordTaskRunTime(start_time, end_time);
   if (!time_budget_pool->HasEnoughBudgetToRun(end_time))
     time_budget_pool->BlockThrottledQueues(end_time);
 }
 
 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 39 matching lines @@
   return std::max(now, time_budget_pool->GetNextAllowedRunTime());
 }
 
 void TaskQueueThrottler::MaybeDeleteQueueMetadata(TaskQueueMap::iterator it) {
   if (!it->second.IsThrottled() && !it->second.time_budget_pool)
     queue_details_.erase(it);
 }
 
 }  // namespace scheduler
 }  // namespace blink