[scheduler] Bunch of improvements for blink scheduler tracing

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 45 matching lines @@
 
 template <class T>
 base::Optional<T> Max(const base::Optional<T>& a, const base::Optional<T>& b) {
   if (!b)
     return a;
   if (!a)
     return b;
   return std::max(a.value(), b.value());
 }
 
+std::string PointerToId(void* pointer) {
+  return base::StringPrintf(
+      "%" PRIx64, static_cast<uint64_t>(reinterpret_cast<uintptr_t>(pointer)));
+}
+
 }  // namespace
 
 TaskQueueThrottler::TimeBudgetPool::TimeBudgetPool(
     const char* name,
     TaskQueueThrottler* task_queue_throttler,
     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),
@@ skipping 49 matching lines @@
 
   task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, now, queue,
                                                 base::nullopt);
 }
 
 void TaskQueueThrottler::TimeBudgetPool::EnableThrottling(LazyNow* lazy_now) {
   if (is_enabled_)
     return;
   is_enabled_ = true;
 
+  TRACE_EVENT0(task_queue_throttler_->tracing_category_,
+               "TaskQueueThrottler_TimeBudgetPool_EnableThrottling");
+
   BlockThrottledQueues(lazy_now->Now());
 }
 
 void TaskQueueThrottler::TimeBudgetPool::DisableThrottling(LazyNow* lazy_now) {
   if (!is_enabled_)
     return;
   is_enabled_ = false;
 
+  TRACE_EVENT0(task_queue_throttler_->tracing_category_,
+               "TaskQueueThrottler_TimeBudgetPool_DisableThrottling");
+
   for (TaskQueue* queue : associated_task_queues_) {
     if (!task_queue_throttler_->IsThrottled(queue))
       continue;
 
     task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, lazy_now->Now(),
                                                   queue, base::nullopt);
   }
 
   // TODO(altimin): We need to disable TimeBudgetQueues here or they will
   // regenerate extra time budget when they are disabled.
@@ skipping 66 matching lines @@
   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());
   state->SetBoolean("is_enabled", is_enabled_);
 
   state->BeginArray("task_queues");
   for (TaskQueue* queue : associated_task_queues_) {
-    state->AppendString(base::StringPrintf(
-        "%" PRIx64, static_cast<uint64_t>(reinterpret_cast<uintptr_t>(queue))));
+    state->AppendString(PointerToId(queue));
   }
   state->EndArray();
 
   state->EndDictionary();
 }
 
 void TaskQueueThrottler::TimeBudgetPool::Advance(base::TimeTicks now) {
   if (now > last_checkpoint_) {
     if (is_enabled_) {
       current_budget_level_ += cpu_percentage_ * (now - last_checkpoint_);
@@ skipping 127 matching lines @@
     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_TaskQueueUntrottled",
+    TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueUnthrottled",
                  "task_queue", task_queue);
   }
 }
 
 bool TaskQueueThrottler::IsThrottled(TaskQueue* task_queue) const {
   auto find_it = queue_details_.find(task_queue);
   if (find_it == queue_details_.end())
     return false;
   return find_it->second.IsThrottled();
 }
@@ skipping 157 matching lines @@
 }
 
 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());
   }
 
+  state->SetBoolean("allow_throttling", allow_throttling_);
+
   state->BeginDictionary("time_budget_pools");
-
   for (const auto& map_entry : time_budget_pools_) {
     TaskQueueThrottler::TimeBudgetPool* pool = map_entry.first;
     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())
     return nullptr;
   return find_it->second.time_budget_pool;
 }
@@ skipping 38 matching lines @@
     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.IsThrottled())
       continue;
 
     TaskQueue* queue = map_entry.first;
 
     queue->SetQueueEnabled(false);
     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