Blink Scheduler: Trace CPUTimeBudgetPool's budget level.

Bug: 784442
Change-Id: I00bab82f67d2b47f02394831e9ef5126e3fd7a38
Reviewed-on: https://chromium-review.googlesource.com/794133
Commit-Queue: Greg Kraynov <kraynov@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#520947}

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

@@ -10,16 +10,27 @@
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "platform/scheduler/renderer/task_queue_throttler.h"
-#include "platform/scheduler/util/tracing_helper.h"
 
 namespace blink {
 namespace scheduler {
 
+namespace {
+
+double TimeDeltaToMilliseconds(const base::TimeDelta& value) {
+  return value.InMillisecondsF();
+}
+
+}  // namespace
+
 CPUTimeBudgetPool::CPUTimeBudgetPool(
     const char* name,
     BudgetPoolController* budget_pool_controller,
     base::TimeTicks now)
     : BudgetPool(name, budget_pool_controller),
+      current_budget_level_(base::TimeDelta(),
+                            "RendererScheduler.BackgroundBudgetMs",
+                            budget_pool_controller,
+                            TimeDeltaToMilliseconds),
       last_checkpoint_(now),
       cpu_percentage_(1) {}
 
@@ -86,7 +97,7 @@ base::Optional<base::TimeTicks> CPUTimeBudgetPool::GetTimeTasksCanRunUntil(
 
 base::TimeTicks CPUTimeBudgetPool::GetNextAllowedRunTime(
     base::TimeTicks desired_run_time) const {
-  if (!is_enabled_ || current_budget_level_.InMicroseconds() >= 0) {
+  if (!is_enabled_ || current_budget_level_->InMicroseconds() >= 0) {
     return last_checkpoint_;
   } else {
     // Subtract because current_budget is negative.
@@ -107,12 +118,12 @@ void CPUTimeBudgetPool::RecordTaskRunTime(TaskQueue* queue,
     EnforceBudgetLevelRestrictions();
 
     if (!reporting_callback_.is_null() && old_budget_level.InSecondsF() > 0 &&
-        current_budget_level_.InSecondsF() < 0) {
+        current_budget_level_->InSecondsF() < 0) {
       reporting_callback_.Run(-current_budget_level_ / cpu_percentage_);
     }
   }
 
-  if (current_budget_level_.InSecondsF() < 0)
+  if (current_budget_level_->InSecondsF() < 0)
     BlockThrottledQueues(end_time);
 }
 
@@ -127,12 +138,13 @@ void CPUTimeBudgetPool::OnWakeUp(base::TimeTicks now) {}
 
 void CPUTimeBudgetPool::AsValueInto(base::trace_event::TracedValue* state,
                                     base::TimeTicks now) const {
+  current_budget_level_.Trace();
   state->BeginDictionary(name_);
 
   state->SetString("name", name_);
   state->SetDouble("time_budget", cpu_percentage_);
   state->SetDouble("time_budget_level_in_seconds",
-                   current_budget_level_.InSecondsF());
+                   current_budget_level_->InSecondsF());
   state->SetDouble("last_checkpoint_seconds_ago",
                    (now - last_checkpoint_).InSecondsF());
   state->SetBoolean("is_enabled", is_enabled_);
@@ -157,6 +169,10 @@ void CPUTimeBudgetPool::AsValueInto(base::trace_event::TracedValue* state,
   state->EndDictionary();
 }
 
+void CPUTimeBudgetPool::OnTraceLogEnabled() {
+  current_budget_level_.Trace();
+}
+
 void CPUTimeBudgetPool::Advance(base::TimeTicks now) {
   if (now > last_checkpoint_) {
     if (is_enabled_) {
@@ -170,12 +186,12 @@ void CPUTimeBudgetPool::Advance(base::TimeTicks now) {
 void CPUTimeBudgetPool::EnforceBudgetLevelRestrictions() {
   if (max_budget_level_) {
     current_budget_level_ =
-        std::min(current_budget_level_, max_budget_level_.value());
+        std::min(current_budget_level_.value(), max_budget_level_.value());
   }
   if (max_throttling_delay_) {
     // Current budget level may be negative.
     current_budget_level_ =
-        std::max(current_budget_level_,
+        std::max(current_budget_level_.value(),
                  -max_throttling_delay_.value() * cpu_percentage_);
   }
 }

third_party/WebKit/Source/platform/scheduler/renderer/cpu_time_budget_pool.h

@@ -12,6 +12,7 @@
 #include "base/optional.h"
 #include "base/time/time.h"
 #include "platform/scheduler/base/lazy_now.h"
+#include "platform/scheduler/util/tracing_helper.h"
 
 namespace blink {
 namespace scheduler {
@@ -85,6 +86,7 @@ class PLATFORM_EXPORT CPUTimeBudgetPool : public BudgetPool {
   void OnWakeUp(base::TimeTicks now) final;
   void AsValueInto(base::trace_event::TracedValue* state,
                    base::TimeTicks now) const final;
+  void OnTraceLogEnabled();
 
  protected:
   QueueBlockType GetBlockType() const final;
@@ -115,7 +117,8 @@ class PLATFORM_EXPORT CPUTimeBudgetPool : public BudgetPool {
   // See CPUTimeBudgetPool::SetMinBudgetLevelToRun.
   base::TimeDelta min_budget_level_to_run_;
 
-  base::TimeDelta current_budget_level_;
+  TraceableCounter<base::TimeDelta, kTracingCategoryNameInfo>
+      current_budget_level_;
   base::TimeTicks last_checkpoint_;
   double cpu_percentage_;
 

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

@@ -1077,13 +1077,13 @@ void RendererSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
   main_thread_only().loading_task_estimated_cost =
       main_thread_only().loading_task_cost_estimator.expected_task_duration();
   bool loading_tasks_seem_expensive =
-      main_thread_only().loading_task_estimated_cost.get() >
+      main_thread_only().loading_task_estimated_cost >
       longest_jank_free_task_duration;
 
   main_thread_only().timer_task_estimated_cost =
       main_thread_only().timer_task_cost_estimator.expected_task_duration();
   bool timer_tasks_seem_expensive =
-      main_thread_only().timer_task_estimated_cost.get() >
+      main_thread_only().timer_task_estimated_cost >
       longest_jank_free_task_duration;
 
   main_thread_only().timer_tasks_seem_expensive = timer_tasks_seem_expensive;

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

@@ -244,6 +244,7 @@ void WebViewSchedulerImpl::OnTraceLogEnabled() {
   for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) {
     frame_scheduler->OnTraceLogEnabled();
   }
+  BackgroundCPUTimeBudgetPool()->OnTraceLogEnabled();
 }
 
 void WebViewSchedulerImpl::AsValueInto(

third_party/WebKit/Source/platform/scheduler/util/tracing_helper.h

@@ -145,14 +145,28 @@ class TraceableCounter {
     return *this;
   }
 
-  const T& get() const {
+  TraceableCounter& operator +=(const T& value) {
+    value_ += value;
+    Trace();
+    return *this;
+  }
+  TraceableCounter& operator -=(const T& value) {
+    value_ -= value;
+    Trace();
+    return *this;
+  }
+
+  const T& value() const {
     return value_;
   }
+  const T* operator ->() const {
+    return &value_;
+  }
   operator T() const {
     return value_;
   }
 
-  void Trace() {
+  void Trace() const {
     TRACE_COUNTER_ID1(category, name_, object_, converter_(value_));
   }
 
@@ -165,6 +179,24 @@ class TraceableCounter {
   DISALLOW_COPY(TraceableCounter);
 };
 
+// Add operators when it's needed.
+
+template <typename T, const char* category>
+constexpr T operator -(const TraceableCounter<T, category>& counter) {
+  return -counter.value();
+}
+
+template <typename T, const char* category>
+constexpr T operator /(const TraceableCounter<T, category>& lhs, const T& rhs) {
+  return lhs.value() / rhs;
+}
+
+template <typename T, const char* category>
+constexpr bool operator >(
+    const TraceableCounter<T, category>& lhs, const T& rhs) {
+  return lhs.value() > rhs;
+}
+
 }  // namespace scheduler
 }  // namespace blink