OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "cc/raster/one_copy_tile_task_worker_pool.h" | 5 #include "cc/raster/one_copy_tile_task_worker_pool.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <limits> | 8 #include <limits> |
9 | 9 |
10 #include "base/strings/stringprintf.h" | 10 #include "base/strings/stringprintf.h" |
(...skipping 196 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
207 : kMaxBytesPerCopyOperation), | 207 : kMaxBytesPerCopyOperation), |
208 use_partial_raster_(use_partial_raster), | 208 use_partial_raster_(use_partial_raster), |
209 bytes_scheduled_since_last_flush_(0), | 209 bytes_scheduled_since_last_flush_(0), |
210 max_staging_buffer_usage_in_bytes_(max_staging_buffer_usage_in_bytes), | 210 max_staging_buffer_usage_in_bytes_(max_staging_buffer_usage_in_bytes), |
211 use_rgba_4444_texture_format_(use_rgba_4444_texture_format), | 211 use_rgba_4444_texture_format_(use_rgba_4444_texture_format), |
212 staging_buffer_usage_in_bytes_(0), | 212 staging_buffer_usage_in_bytes_(0), |
213 free_staging_buffer_usage_in_bytes_(0), | 213 free_staging_buffer_usage_in_bytes_(0), |
214 staging_buffer_expiration_delay_( | 214 staging_buffer_expiration_delay_( |
215 base::TimeDelta::FromMilliseconds(kStagingBufferExpirationDelayMs)), | 215 base::TimeDelta::FromMilliseconds(kStagingBufferExpirationDelayMs)), |
216 reduce_memory_usage_pending_(false), | 216 reduce_memory_usage_pending_(false), |
217 weak_ptr_factory_(this), | 217 weak_ptr_factory_(this) { |
218 task_set_finished_weak_ptr_factory_(this) { | |
219 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( | 218 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( |
220 this, "OneCopyTileTaskWorkerPool", base::ThreadTaskRunnerHandle::Get()); | 219 this, "OneCopyTileTaskWorkerPool", base::ThreadTaskRunnerHandle::Get()); |
221 reduce_memory_usage_callback_ = | 220 reduce_memory_usage_callback_ = |
222 base::Bind(&OneCopyTileTaskWorkerPool::ReduceMemoryUsage, | 221 base::Bind(&OneCopyTileTaskWorkerPool::ReduceMemoryUsage, |
223 weak_ptr_factory_.GetWeakPtr()); | 222 weak_ptr_factory_.GetWeakPtr()); |
224 } | 223 } |
225 | 224 |
226 OneCopyTileTaskWorkerPool::~OneCopyTileTaskWorkerPool() { | 225 OneCopyTileTaskWorkerPool::~OneCopyTileTaskWorkerPool() { |
227 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( | 226 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( |
228 this); | 227 this); |
229 } | 228 } |
230 | 229 |
231 TileTaskRunner* OneCopyTileTaskWorkerPool::AsTileTaskRunner() { | 230 TileTaskRunner* OneCopyTileTaskWorkerPool::AsTileTaskRunner() { |
232 return this; | 231 return this; |
233 } | 232 } |
234 | 233 |
235 void OneCopyTileTaskWorkerPool::SetClient(TileTaskRunnerClient* client) { | |
236 client_ = client; | |
237 } | |
238 | |
239 void OneCopyTileTaskWorkerPool::Shutdown() { | 234 void OneCopyTileTaskWorkerPool::Shutdown() { |
240 TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::Shutdown"); | 235 TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::Shutdown"); |
241 | 236 |
242 TaskGraph empty; | 237 TaskGraph empty; |
243 task_graph_runner_->ScheduleTasks(namespace_token_, &empty); | 238 task_graph_runner_->ScheduleTasks(namespace_token_, &empty); |
244 task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_); | 239 task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_); |
245 | 240 |
246 base::AutoLock lock(lock_); | 241 base::AutoLock lock(lock_); |
247 | 242 |
248 if (buffers_.empty()) | 243 if (buffers_.empty()) |
249 return; | 244 return; |
250 | 245 |
251 ReleaseBuffersNotUsedSince(base::TimeTicks() + base::TimeDelta::Max()); | 246 ReleaseBuffersNotUsedSince(base::TimeTicks() + base::TimeDelta::Max()); |
252 DCHECK_EQ(staging_buffer_usage_in_bytes_, 0); | 247 DCHECK_EQ(staging_buffer_usage_in_bytes_, 0); |
253 DCHECK_EQ(free_staging_buffer_usage_in_bytes_, 0); | 248 DCHECK_EQ(free_staging_buffer_usage_in_bytes_, 0); |
254 } | 249 } |
255 | 250 |
256 void OneCopyTileTaskWorkerPool::ScheduleTasks(TileTaskQueue* queue) { | 251 void OneCopyTileTaskWorkerPool::ScheduleTasks(TaskGraph* graph) { |
257 TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::ScheduleTasks"); | 252 TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::ScheduleTasks"); |
258 | 253 |
259 if (tasks_pending_.none()) | 254 ScheduleTasksOnOriginThread(this, graph); |
260 TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this); | |
261 | |
262 // Mark all task sets as pending. | |
263 tasks_pending_.set(); | |
264 | |
265 size_t priority = kTileTaskPriorityBase; | |
266 | |
267 graph_.Reset(); | |
268 | |
269 // Cancel existing OnTaskSetFinished callbacks. | |
270 task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs(); | |
271 | |
272 scoped_refptr<TileTask> new_task_set_finished_tasks[kNumberOfTaskSets]; | |
273 | |
274 size_t task_count[kNumberOfTaskSets] = {0}; | |
275 | |
276 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) { | |
277 new_task_set_finished_tasks[task_set] = CreateTaskSetFinishedTask( | |
278 task_runner_.get(), | |
279 base::Bind(&OneCopyTileTaskWorkerPool::OnTaskSetFinished, | |
280 task_set_finished_weak_ptr_factory_.GetWeakPtr(), task_set)); | |
281 } | |
282 | |
283 for (TileTaskQueue::Item::Vector::const_iterator it = queue->items.begin(); | |
284 it != queue->items.end(); ++it) { | |
285 const TileTaskQueue::Item& item = *it; | |
286 RasterTask* task = item.task; | |
287 DCHECK(!task->HasCompleted()); | |
288 | |
289 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) { | |
290 if (!item.task_sets[task_set]) | |
291 continue; | |
292 | |
293 ++task_count[task_set]; | |
294 | |
295 graph_.edges.push_back( | |
296 TaskGraph::Edge(task, new_task_set_finished_tasks[task_set].get())); | |
297 } | |
298 | |
299 InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++); | |
300 } | |
301 | |
302 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) { | |
303 InsertNodeForTask(&graph_, new_task_set_finished_tasks[task_set].get(), | |
304 kTaskSetFinishedTaskPriorityBase + task_set, | |
305 task_count[task_set]); | |
306 } | |
307 | |
308 ScheduleTasksOnOriginThread(this, &graph_); | |
309 | 255 |
310 // Barrier to sync any new resources to the worker context. | 256 // Barrier to sync any new resources to the worker context. |
311 resource_provider_->output_surface() | 257 resource_provider_->output_surface() |
312 ->context_provider() | 258 ->context_provider() |
313 ->ContextGL() | 259 ->ContextGL() |
314 ->OrderingBarrierCHROMIUM(); | 260 ->OrderingBarrierCHROMIUM(); |
315 | 261 |
316 task_graph_runner_->ScheduleTasks(namespace_token_, &graph_); | 262 task_graph_runner_->ScheduleTasks(namespace_token_, graph); |
317 | |
318 std::copy(new_task_set_finished_tasks, | |
319 new_task_set_finished_tasks + kNumberOfTaskSets, | |
320 task_set_finished_tasks_); | |
321 | |
322 TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state", | |
323 StateAsValue()); | |
324 } | 263 } |
325 | 264 |
326 void OneCopyTileTaskWorkerPool::CheckForCompletedTasks() { | 265 void OneCopyTileTaskWorkerPool::CheckForCompletedTasks() { |
327 TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::CheckForCompletedTasks"); | 266 TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::CheckForCompletedTasks"); |
328 | 267 |
329 task_graph_runner_->CollectCompletedTasks(namespace_token_, | 268 task_graph_runner_->CollectCompletedTasks(namespace_token_, |
330 &completed_tasks_); | 269 &completed_tasks_); |
331 | 270 |
332 for (Task::Vector::const_iterator it = completed_tasks_.begin(); | 271 for (Task::Vector::const_iterator it = completed_tasks_.begin(); |
333 it != completed_tasks_.end(); ++it) { | 272 it != completed_tasks_.end(); ++it) { |
(...skipping 445 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
779 if (busy_buffers_.front()->last_usage > time) | 718 if (busy_buffers_.front()->last_usage > time) |
780 return; | 719 return; |
781 | 720 |
782 busy_buffers_.front()->DestroyGLResources(gl); | 721 busy_buffers_.front()->DestroyGLResources(gl); |
783 RemoveStagingBuffer(busy_buffers_.front().get()); | 722 RemoveStagingBuffer(busy_buffers_.front().get()); |
784 busy_buffers_.pop_front(); | 723 busy_buffers_.pop_front(); |
785 } | 724 } |
786 } | 725 } |
787 } | 726 } |
788 | 727 |
789 void OneCopyTileTaskWorkerPool::OnTaskSetFinished(TaskSet task_set) { | |
790 TRACE_EVENT1("cc", "OneCopyTileTaskWorkerPool::OnTaskSetFinished", "task_set", | |
791 task_set); | |
792 | |
793 DCHECK(tasks_pending_[task_set]); | |
794 tasks_pending_[task_set] = false; | |
795 if (tasks_pending_.any()) { | |
796 TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", | |
797 "state", StateAsValue()); | |
798 } else { | |
799 TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this); | |
800 } | |
801 client_->DidFinishRunningTileTasks(task_set); | |
802 } | |
803 | |
804 scoped_refptr<base::trace_event::ConvertableToTraceFormat> | |
805 OneCopyTileTaskWorkerPool::StateAsValue() const { | |
806 scoped_refptr<base::trace_event::TracedValue> state = | |
807 new base::trace_event::TracedValue(); | |
808 | |
809 state->BeginArray("tasks_pending"); | |
810 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) | |
811 state->AppendBoolean(tasks_pending_[task_set]); | |
812 state->EndArray(); | |
813 state->BeginDictionary("staging_state"); | |
814 StagingStateAsValueInto(state.get()); | |
815 state->EndDictionary(); | |
816 | |
817 return state; | |
818 } | |
819 | |
820 void OneCopyTileTaskWorkerPool::StagingStateAsValueInto( | |
821 base::trace_event::TracedValue* staging_state) const { | |
822 base::AutoLock lock(lock_); | |
823 | |
824 staging_state->SetInteger("staging_buffer_count", | |
825 static_cast<int>(buffers_.size())); | |
826 staging_state->SetInteger("busy_count", | |
827 static_cast<int>(busy_buffers_.size())); | |
828 staging_state->SetInteger("free_count", | |
829 static_cast<int>(free_buffers_.size())); | |
830 } | |
831 | |
832 } // namespace cc | 728 } // namespace cc |
OLD | NEW |