[scheduler] Add WakeupBudgetPool.

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

 // Copyright 2017 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/budget_pool.h"
 
 #include <cstdint>
 
 #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/WebFrameScheduler.h"
 #include "platform/scheduler/base/real_time_domain.h"
 #include "platform/scheduler/child/scheduler_tqm_delegate.h"
 #include "platform/scheduler/renderer/renderer_scheduler_impl.h"
 #include "platform/scheduler/renderer/task_queue_throttler.h"
 #include "platform/scheduler/renderer/throttled_time_domain.h"
 #include "platform/scheduler/renderer/web_frame_scheduler_impl.h"
 
 namespace blink {
 namespace scheduler {
 
 namespace {
 
+base::Optional<base::TimeTicks> NextTaskRunTime(base::TimeTicks now,
+                                                TaskQueue* queue) {
+  if (queue->HasPendingImmediateWork())
+    return now;
+  return queue->GetNextScheduledWakeUp();
+}
+
 std::string PointerToId(void* pointer) {
   return base::StringPrintf(
       "0x%" PRIx64,
       static_cast<uint64_t>(reinterpret_cast<uintptr_t>(pointer)));
 }
 
 }  // namespace
 
 BudgetPool::BudgetPool(const char* name,
                        BudgetPoolController* budget_pool_controller)
     : name_(name),
       budget_pool_controller_(budget_pool_controller),
       is_enabled_(true) {}
 
 BudgetPool::~BudgetPool() {}
 
 const char* BudgetPool::Name() const {
   return name_;
 }
 
 void BudgetPool::AddQueue(base::TimeTicks now, TaskQueue* queue) {
   budget_pool_controller_->AddQueueToBudgetPool(queue, this);
   associated_task_queues_.insert(queue);
 
   if (!is_enabled_ || !budget_pool_controller_->IsThrottled(queue))
     return;
 
-  budget_pool_controller_->BlockQueue(now, queue);
+  base::Optional<base::TimeTicks> next_desired_run_time =
+      NextTaskRunTime(now, queue);
+
+  if (next_desired_run_time && !CanRunTasksAt(next_desired_run_time.value())) {
+    budget_pool_controller_->BlockQueue(GetBlockType(), now, queue);
+  }
+}
+
+void BudgetPool::UnregisterQueue(TaskQueue* queue) {
+  budget_pool_controller_->RemoveQueueFromBudgetPool(queue, this);
+  associated_task_queues_.erase(queue);
 }
 
 void BudgetPool::RemoveQueue(base::TimeTicks now, TaskQueue* queue) {
   budget_pool_controller_->RemoveQueueFromBudgetPool(queue, this);

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

Would it be confusing to call UnregisterQueue(queue) here?

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

I think yes. But given that I though about this too, let's introduce internal
DissociateQueue method.

   associated_task_queues_.erase(queue);
 
   if (!is_enabled_ || !budget_pool_controller_->IsThrottled(queue))
     return;
 
   budget_pool_controller_->UnblockQueue(now, queue);
 }
 
 void BudgetPool::EnableThrottling(LazyNow* lazy_now) {
   if (is_enabled_)
@@ skipping 28 matching lines @@
 }
 
 void BudgetPool::Close() {
   DCHECK_EQ(0u, associated_task_queues_.size());
 
   budget_pool_controller_->UnregisterBudgetPool(this);
 }
 
 void BudgetPool::BlockThrottledQueues(base::TimeTicks now) {
   for (TaskQueue* queue : associated_task_queues_)
-    budget_pool_controller_->BlockQueue(now, queue);
+    budget_pool_controller_->BlockQueue(GetBlockType(), now, queue);
 }
 
 CPUTimeBudgetPool::CPUTimeBudgetPool(
     const char* name,
     BudgetPoolController* budget_pool_controller,
     base::TimeTicks now)
     : BudgetPool(name, budget_pool_controller),
       last_checkpoint_(now),
       cpu_percentage_(1) {}
 
 CPUTimeBudgetPool::~CPUTimeBudgetPool() {}
 
+QueueBlockType CPUTimeBudgetPool::GetBlockType() const {
+  return QueueBlockType::FULL;
+}
+
 void CPUTimeBudgetPool::SetMaxBudgetLevel(
     base::TimeTicks now,
     base::Optional<base::TimeDelta> max_budget_level) {
   Advance(now);
   max_budget_level_ = max_budget_level;
   EnforceBudgetLevelRestrictions();
 }
 
 void CPUTimeBudgetPool::SetMaxThrottlingDelay(
     base::TimeTicks now,
@@ skipping 22 matching lines @@
   Advance(now);
   current_budget_level_ += budget_level;
   EnforceBudgetLevelRestrictions();
 }
 
 void CPUTimeBudgetPool::SetReportingCallback(
     base::Callback<void(base::TimeDelta)> reporting_callback) {
   reporting_callback_ = reporting_callback;
 }
 
-bool CPUTimeBudgetPool::HasEnoughBudgetToRun(base::TimeTicks now) {
-  return now >= GetNextAllowedRunTime();
+bool CPUTimeBudgetPool::CanRunTasksAt(base::TimeTicks now) const {
+  return now >= GetNextAllowedRunTime(now);
 }
 
-base::TimeTicks CPUTimeBudgetPool::GetNextAllowedRunTime() {
+bool CPUTimeBudgetPool::CanRunTasksUntil(base::TimeTicks now,
+                                         base::TimeTicks moment) const {
+  return CanRunTasksAt(now);
+}
+
+base::TimeTicks CPUTimeBudgetPool::GetNextAllowedRunTime(
+    base::TimeTicks desired_run_time) const {
   if (!is_enabled_ || current_budget_level_.InMicroseconds() >= 0) {
     return last_checkpoint_;
   } else {
     // Subtract because current_budget is negative.
     return last_checkpoint_ +
            (-current_budget_level_ + min_budget_level_to_run_) /
                cpu_percentage_;
   }
 }
 
-void CPUTimeBudgetPool::RecordTaskRunTime(base::TimeTicks start_time,
+void CPUTimeBudgetPool::RecordTaskRunTime(TaskQueue* queue,
+                                          base::TimeTicks start_time,
                                           base::TimeTicks end_time) {
   DCHECK_LE(start_time, end_time);
   Advance(end_time);
   if (is_enabled_) {
     base::TimeDelta old_budget_level = current_budget_level_;
     current_budget_level_ -= (end_time - start_time);
     EnforceBudgetLevelRestrictions();
 
     if (!reporting_callback_.is_null() && old_budget_level.InSecondsF() > 0 &&
         current_budget_level_.InSecondsF() < 0) {
       reporting_callback_.Run(-current_budget_level_ / cpu_percentage_);
     }
   }
 }
 
+void CPUTimeBudgetPool::OnTaskQueueHasWork(TaskQueue* queue,
+                                           base::TimeTicks now,
+                                           base::TimeTicks desired_run_time) {
+  if (!CanRunTasksAt(desired_run_time)) {
+    budget_pool_controller_->BlockQueue(GetBlockType(), now, queue);
+  } else {
+    budget_pool_controller_->UnblockQueue(now, queue);
+  }
+}
+
+void CPUTimeBudgetPool::OnWakeup(base::TimeTicks now) {}
+
 void CPUTimeBudgetPool::AsValueInto(base::trace_event::TracedValue* state,
                                     base::TimeTicks now) const {
   state->BeginDictionary(name_);
 
   state->SetString("name", name_);
   state->SetDouble("time_budget", cpu_percentage_);
   state->SetDouble("time_budget_level_in_seconds",
                    current_budget_level_.InSecondsF());
   state->SetDouble("last_checkpoint_seconds_ago",
                    (now - last_checkpoint_).InSecondsF());
@@ skipping 35 matching lines @@
         std::min(current_budget_level_, max_budget_level_.value());
   }
   if (max_throttling_delay_) {
     // Current budget level may be negative.
     current_budget_level_ =
         std::max(current_budget_level_,
                  -max_throttling_delay_.value() * cpu_percentage_);
   }
 }
 
+WakeupBudgetPool::WakeupBudgetPool(const char* name,
+                                   BudgetPoolController* budget_pool_controller,
+                                   base::TimeTicks now)
+    : BudgetPool(name, budget_pool_controller),
+      wakeups_per_second_(1),
+      last_wakeup_(now) {}
+
+WakeupBudgetPool::~WakeupBudgetPool() {}
+
+QueueBlockType WakeupBudgetPool::GetBlockType() const {
+  return QueueBlockType::NEW_TASKS_ONLY;
+}
+
+void WakeupBudgetPool::SetWakeupRate(base::TimeTicks now,
+                                     double wakeups_per_second) {
+  last_wakeup_ = now;
+  wakeups_per_second_ = wakeups_per_second;
+}
+
+void WakeupBudgetPool::SetWakeupDuration(base::TimeTicks now,
+                                         base::TimeDelta duration) {
+  last_wakeup_ = now;
+  wakeup_duration_ = duration;
+}
+
+void WakeupBudgetPool::RecordTaskRunTime(TaskQueue* queue,
+                                         base::TimeTicks start_time,
+                                         base::TimeTicks end_time) {
+  base::Optional<base::TimeTicks> next_desired_run_time =
+      NextTaskRunTime(end_time, queue);
+
+  if (next_desired_run_time && !CanRunTasksAt(next_desired_run_time.value()))
+    budget_pool_controller_->BlockQueue(GetBlockType(), end_time, queue);
+}
+
+base::TimeTicks WakeupBudgetPool::NextWakeup() const {
+  // Subtract 1 microsecond to work with time alignment in task queue throttler.

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

What happens if you don't do that?

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

Alignment in PumpThrottledTasks happens. Improved comments to explain it.

+  return last_wakeup_ + base::TimeDelta::FromSeconds(1 / wakeups_per_second_) -
+         base::TimeDelta::FromMicroseconds(1);
+}
+
+bool WakeupBudgetPool::CanRunTasksAt(base::TimeTicks now) const {
+  if (now < last_wakeup_ + wakeup_duration_)

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

Shouldn't that be <= ?

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

Added a comment.

+    return true;
+  return now >= NextWakeup();
+}
+
+bool WakeupBudgetPool::CanRunTasksUntil(base::TimeTicks now,
+                                        base::TimeTicks moment) const {
+  DCHECK_LE(now, moment);
+  return now < last_wakeup_ + wakeup_duration_ &&

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

Ditto.

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

Acknowledged.

+         moment < last_wakeup_ + wakeup_duration_;
+}
+
+base::TimeTicks WakeupBudgetPool::GetNextAllowedRunTime(
+    base::TimeTicks desired_run_time) const {
+  if (desired_run_time <= last_wakeup_ + wakeup_duration_) {
+    return desired_run_time;
+  }
+  return std::max(desired_run_time, NextWakeup());
+}
+
+void WakeupBudgetPool::OnTaskQueueHasWork(TaskQueue* queue,
+                                          base::TimeTicks now,
+                                          base::TimeTicks desired_run_time) {
+  if (!CanRunTasksAt(desired_run_time)) {
+    budget_pool_controller_->BlockQueue(GetBlockType(), now, queue);

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

Maybe swap the order of these to avoid the negation?

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

Done.

+  } else {
+    budget_pool_controller_->UnblockQueue(now, queue);
+  }
+}
+
+void WakeupBudgetPool::OnWakeup(base::TimeTicks now) {
+  last_wakeup_ = now;
+}
+
+void WakeupBudgetPool::AsValueInto(base::trace_event::TracedValue* state,
+                                   base::TimeTicks now) const {
+  state->BeginDictionary(name_);
+
+  state->SetString("name", name_);
+  state->SetDouble("wakeups_per_second_rate", wakeups_per_second_);
+  state->SetDouble("wakeup_duration_in_seconds", wakeup_duration_.InSecondsF());
+  state->SetDouble("last_wakeup_seconds_ago",
+                   (now - last_wakeup_).InSecondsF());
+  state->SetBoolean("is_enabled", is_enabled_);
+
+  state->BeginArray("task_queues");
+  for (TaskQueue* queue : associated_task_queues_) {
+    state->AppendString(PointerToId(queue));
+  }
+  state->EndArray();
+
+  state->EndDictionary();
+}
+
 }  // namespace scheduler
 }  // namespace blink