| OLD | NEW |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
| 4 | 4 |
| 5 #include "platform/scheduler/renderer/task_queue_throttler.h" | 5 #include "platform/scheduler/renderer/task_queue_throttler.h" |
| 6 | 6 |
| 7 #include <cstdint> | 7 #include <cstdint> |
| 8 | 8 |
| 9 #include "base/format_macros.h" | 9 #include "base/format_macros.h" |
| 10 #include "base/logging.h" | 10 #include "base/logging.h" |
| (...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 80 TaskQueueThrottler::TimeBudgetPool::~TimeBudgetPool() {} | 80 TaskQueueThrottler::TimeBudgetPool::~TimeBudgetPool() {} |
| 81 | 81 |
| 82 void TaskQueueThrottler::TimeBudgetPool::SetTimeBudget(base::TimeTicks now, | 82 void TaskQueueThrottler::TimeBudgetPool::SetTimeBudget(base::TimeTicks now, |
| 83 double cpu_percentage) { | 83 double cpu_percentage) { |
| 84 Advance(now); | 84 Advance(now); |
| 85 cpu_percentage_ = cpu_percentage; | 85 cpu_percentage_ = cpu_percentage; |
| 86 } | 86 } |
| 87 | 87 |
| 88 void TaskQueueThrottler::TimeBudgetPool::AddQueue(base::TimeTicks now, | 88 void TaskQueueThrottler::TimeBudgetPool::AddQueue(base::TimeTicks now, |
| 89 TaskQueue* queue) { | 89 TaskQueue* queue) { |
| 90 std::pair<TaskQueueMap::iterator, bool> insert_result = | 90 Metadata& metadata = task_queue_throttler_->queue_details_[queue]; |
| 91 task_queue_throttler_->queue_details_.insert( | |
| 92 std::make_pair(queue, Metadata(0, queue->IsQueueEnabled()))); | |
| 93 Metadata& metadata = insert_result.first->second; | |
| 94 DCHECK(!metadata.time_budget_pool); | 91 DCHECK(!metadata.time_budget_pool); |
| 95 metadata.time_budget_pool = this; | 92 metadata.time_budget_pool = this; |
| 96 | 93 |
| 97 associated_task_queues_.insert(queue); | 94 associated_task_queues_.insert(queue); |
| 98 | 95 |
| 99 if (!is_enabled_ || !metadata.IsThrottled()) | 96 if (!metadata.IsThrottled()) |
| 100 return; | 97 return; |
| 101 | 98 |
| 102 queue->SetQueueEnabled(false); | 99 queue->SetQueueEnabled(false); |
| 103 | 100 |
| 104 task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, now, queue, | 101 task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, now, queue, |
| 105 GetNextAllowedRunTime()); | 102 GetNextAllowedRunTime()); |
| 106 } | 103 } |
| 107 | 104 |
| 108 void TaskQueueThrottler::TimeBudgetPool::RemoveQueue(base::TimeTicks now, | 105 void TaskQueueThrottler::TimeBudgetPool::RemoveQueue(base::TimeTicks now, |
| 109 TaskQueue* queue) { | 106 TaskQueue* queue) { |
| 110 auto find_it = task_queue_throttler_->queue_details_.find(queue); | 107 auto find_it = task_queue_throttler_->queue_details_.find(queue); |
| 111 DCHECK(find_it != task_queue_throttler_->queue_details_.end() && | 108 DCHECK(find_it != task_queue_throttler_->queue_details_.end() && |
| 112 find_it->second.time_budget_pool == this); | 109 find_it->second.time_budget_pool == this); |
| 113 find_it->second.time_budget_pool = nullptr; | 110 find_it->second.time_budget_pool = nullptr; |
| 114 bool is_throttled = find_it->second.IsThrottled(); | 111 bool is_throttled = find_it->second.IsThrottled(); |
| 115 | 112 |
| 116 task_queue_throttler_->MaybeDeleteQueueMetadata(find_it); | 113 task_queue_throttler_->MaybeDeleteQueueMetadata(find_it); |
| 117 associated_task_queues_.erase(queue); | 114 associated_task_queues_.erase(queue); |
| 118 | 115 |
| 119 if (!is_enabled_ || !is_throttled) | 116 if (is_throttled) |
| 120 return; | 117 return; |
| 121 | 118 |
| 122 task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, now, queue, | 119 task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, now, queue, |
| 123 base::nullopt); | 120 base::nullopt); |
| 124 } | 121 } |
| 125 | 122 |
| 126 void TaskQueueThrottler::TimeBudgetPool::EnableThrottling(LazyNow* lazy_now) { | 123 void TaskQueueThrottler::TimeBudgetPool::EnableThrottling(LazyNow* lazy_now) { |
| 127 if (is_enabled_) | 124 if (is_enabled_) |
| 128 return; | 125 return; |
| 129 is_enabled_ = true; | 126 is_enabled_ = true; |
| (...skipping 134 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 264 void TaskQueueThrottler::SetQueueEnabled(TaskQueue* task_queue, bool enabled) { | 261 void TaskQueueThrottler::SetQueueEnabled(TaskQueue* task_queue, bool enabled) { |
| 265 TaskQueueMap::iterator find_it = queue_details_.find(task_queue); | 262 TaskQueueMap::iterator find_it = queue_details_.find(task_queue); |
| 266 | 263 |
| 267 if (find_it == queue_details_.end()) { | 264 if (find_it == queue_details_.end()) { |
| 268 task_queue->SetQueueEnabled(enabled); | 265 task_queue->SetQueueEnabled(enabled); |
| 269 return; | 266 return; |
| 270 } | 267 } |
| 271 | 268 |
| 272 find_it->second.enabled = enabled; | 269 find_it->second.enabled = enabled; |
| 273 | 270 |
| 274 if (!find_it->second.IsThrottled()) { | 271 if (!find_it->second.IsThrottled()) |
| 275 task_queue->SetQueueEnabled(enabled); | |
| 276 return; | 272 return; |
| 277 } | |
| 278 | 273 |
| 279 // We don't enable the queue here because it's throttled and there might be | 274 // We don't enable the queue here because it's throttled and there might be |
| 280 // tasks in it's work queue that would execute immediatly rather than after | 275 // tasks in it's work queue that would execute immediatly rather than after |
| 281 // PumpThrottledTasks runs. | 276 // PumpThrottledTasks runs. |
| 282 if (!enabled) { | 277 if (!enabled) { |
| 283 task_queue->SetQueueEnabled(false); | 278 task_queue->SetQueueEnabled(false); |
| 284 MaybeSchedulePumpQueue(FROM_HERE, tick_clock_->NowTicks(), task_queue, | 279 MaybeSchedulePumpQueue(FROM_HERE, tick_clock_->NowTicks(), task_queue, |
| 285 base::nullopt); | 280 base::nullopt); |
| 286 } | 281 } |
| 287 } | 282 } |
| (...skipping 299 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 587 | 582 |
| 588 queue->SetQueueEnabled(false); | 583 queue->SetQueueEnabled(false); |
| 589 queue->SetTimeDomain(time_domain_.get()); | 584 queue->SetTimeDomain(time_domain_.get()); |
| 590 MaybeSchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue, | 585 MaybeSchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue, |
| 591 GetNextAllowedRunTime(lazy_now.Now(), queue)); | 586 GetNextAllowedRunTime(lazy_now.Now(), queue)); |
| 592 } | 587 } |
| 593 } | 588 } |
| 594 | 589 |
| 595 } // namespace scheduler | 590 } // namespace scheduler |
| 596 } // namespace blink | 591 } // namespace blink |
| OLD | NEW |