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" |
11 #include "base/thread_task_runner_handle.h" | |
12 #include "base/trace_event/memory_dump_manager.h" | |
11 #include "base/trace_event/trace_event.h" | 13 #include "base/trace_event/trace_event.h" |
12 #include "base/trace_event/trace_event_argument.h" | 14 #include "base/trace_event/trace_event_argument.h" |
13 #include "cc/base/math_util.h" | 15 #include "cc/base/math_util.h" |
14 #include "cc/debug/traced_value.h" | 16 #include "cc/debug/traced_value.h" |
15 #include "cc/raster/raster_buffer.h" | 17 #include "cc/raster/raster_buffer.h" |
16 #include "cc/resources/platform_color.h" | 18 #include "cc/resources/platform_color.h" |
17 #include "cc/resources/resource_pool.h" | 19 #include "cc/resources/resource_format.h" |
20 #include "cc/resources/resource_util.h" | |
18 #include "cc/resources/scoped_resource.h" | 21 #include "cc/resources/scoped_resource.h" |
22 #include "gpu/GLES2/gl2extchromium.h" | |
19 #include "gpu/command_buffer/client/gles2_interface.h" | 23 #include "gpu/command_buffer/client/gles2_interface.h" |
20 #include "ui/gfx/gpu_memory_buffer.h" | 24 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h" |
21 | 25 |
22 namespace cc { | 26 namespace cc { |
23 namespace { | 27 namespace { |
24 | 28 |
25 class RasterBufferImpl : public RasterBuffer { | 29 class RasterBufferImpl : public RasterBuffer { |
26 public: | 30 public: |
27 RasterBufferImpl(OneCopyTileTaskWorkerPool* worker_pool, | 31 RasterBufferImpl(OneCopyTileTaskWorkerPool* worker_pool, |
28 ResourceProvider* resource_provider, | 32 ResourceProvider* resource_provider, |
29 ResourcePool* resource_pool, | |
30 ResourceFormat resource_format, | 33 ResourceFormat resource_format, |
31 const Resource* output_resource, | 34 const Resource* resource, |
32 uint64_t previous_content_id) | 35 uint64_t previous_content_id) |
33 : worker_pool_(worker_pool), | 36 : worker_pool_(worker_pool), |
34 resource_provider_(resource_provider), | 37 resource_(resource), |
35 resource_pool_(resource_pool), | 38 lock_(resource_provider, resource->id()), |
36 output_resource_(output_resource), | 39 previous_content_id_(previous_content_id) {} |
37 raster_content_id_(0), | |
38 sequence_(0) { | |
39 if (worker_pool->have_persistent_gpu_memory_buffers() && | |
40 previous_content_id) { | |
41 raster_resource_ = | |
42 resource_pool->TryAcquireResourceWithContentId(previous_content_id); | |
43 } | |
44 if (raster_resource_) { | |
45 raster_content_id_ = previous_content_id; | |
46 DCHECK_EQ(resource_format, raster_resource_->format()); | |
47 DCHECK_EQ(output_resource->size().ToString(), | |
48 raster_resource_->size().ToString()); | |
49 } else { | |
50 raster_resource_ = resource_pool->AcquireResource(output_resource->size(), | |
51 resource_format); | |
52 } | |
53 | 40 |
54 lock_.reset(new ResourceProvider::ScopedWriteLockGpuMemoryBuffer( | 41 ~RasterBufferImpl() override {} |
55 resource_provider_, raster_resource_->id())); | |
56 } | |
57 | |
58 ~RasterBufferImpl() override { | |
59 // Release write lock in case a copy was never scheduled. | |
60 lock_.reset(); | |
61 | |
62 // Make sure any scheduled copy operations are issued before we release the | |
63 // raster resource. | |
64 if (sequence_) | |
65 worker_pool_->AdvanceLastIssuedCopyTo(sequence_); | |
66 | |
67 // Return resources to pool so they can be used by another RasterBuffer | |
68 // instance. | |
69 resource_pool_->ReleaseResource(raster_resource_.Pass(), | |
70 raster_content_id_); | |
71 } | |
72 | 42 |
73 // Overridden from RasterBuffer: | 43 // Overridden from RasterBuffer: |
74 void Playback(const RasterSource* raster_source, | 44 void Playback(const RasterSource* raster_source, |
75 const gfx::Rect& raster_full_rect, | 45 const gfx::Rect& raster_full_rect, |
76 const gfx::Rect& raster_dirty_rect, | 46 const gfx::Rect& raster_dirty_rect, |
77 uint64_t new_content_id, | 47 uint64_t new_content_id, |
78 float scale) override { | 48 float scale) override { |
79 // If there's a raster_content_id_, we are reusing a resource with that | 49 worker_pool_->PlaybackAndCopyOnWorkerThread( |
80 // content id. | 50 resource_, &lock_, raster_source, raster_full_rect, raster_dirty_rect, |
81 bool reusing_raster_resource = raster_content_id_ != 0; | 51 scale, previous_content_id_, new_content_id); |
82 sequence_ = worker_pool_->PlaybackAndScheduleCopyOnWorkerThread( | |
83 reusing_raster_resource, lock_.Pass(), raster_resource_.get(), | |
84 output_resource_, raster_source, raster_full_rect, raster_dirty_rect, | |
85 scale); | |
86 // Store the content id of the resource to return to the pool. | |
87 raster_content_id_ = new_content_id; | |
88 } | 52 } |
89 | 53 |
90 private: | 54 private: |
91 OneCopyTileTaskWorkerPool* worker_pool_; | 55 OneCopyTileTaskWorkerPool* worker_pool_; |
92 ResourceProvider* resource_provider_; | 56 const Resource* resource_; |
93 ResourcePool* resource_pool_; | 57 ResourceProvider::ScopedWriteLockGL lock_; |
94 const Resource* output_resource_; | 58 uint64_t previous_content_id_; |
95 uint64_t raster_content_id_; | |
96 scoped_ptr<ScopedResource> raster_resource_; | |
97 scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> lock_; | |
98 CopySequenceNumber sequence_; | |
99 | 59 |
100 DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl); | 60 DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl); |
101 }; | 61 }; |
102 | 62 |
103 // Number of in-flight copy operations to allow. | 63 // Delay between checking for query result to be available. |
104 const int kMaxCopyOperations = 32; | 64 const int kCheckForQueryResultAvailableTickRateMs = 1; |
105 | 65 |
106 // Delay been checking for copy operations to complete. | 66 // Number of attempts to allow before we perform a check that will wait for |
107 const int kCheckForCompletedCopyOperationsTickRateMs = 1; | 67 // query to complete. |
108 | 68 const int kMaxCheckForQueryResultAvailableAttempts = 256; |
109 // Number of failed attempts to allow before we perform a check that will | |
110 // wait for copy operations to complete if needed. | |
111 const int kFailedAttemptsBeforeWaitIfNeeded = 256; | |
112 | 69 |
113 // 4MiB is the size of 4 512x512 tiles, which has proven to be a good | 70 // 4MiB is the size of 4 512x512 tiles, which has proven to be a good |
114 // default batch size for copy operations. | 71 // default batch size for copy operations. |
115 const int kMaxBytesPerCopyOperation = 1024 * 1024 * 4; | 72 const int kMaxBytesPerCopyOperation = 1024 * 1024 * 4; |
116 | 73 |
74 // Delay before a staging buffer might be released. | |
75 const int kStagingBufferExpirationDelayMs = 1000; | |
76 | |
77 bool CheckForQueryResult(gpu::gles2::GLES2Interface* gl, unsigned query_id) { | |
78 unsigned complete = 1; | |
79 gl->GetQueryObjectuivEXT(query_id, GL_QUERY_RESULT_AVAILABLE_EXT, &complete); | |
80 return !!complete; | |
81 } | |
82 | |
83 void WaitForQueryResult(gpu::gles2::GLES2Interface* gl, unsigned query_id) { | |
84 TRACE_EVENT0("cc", "WaitForQueryResult"); | |
85 | |
86 int attempts_left = kMaxCheckForQueryResultAvailableAttempts; | |
87 while (attempts_left--) { | |
88 if (CheckForQueryResult(gl, query_id)) | |
89 break; | |
90 | |
91 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( | |
92 kCheckForQueryResultAvailableTickRateMs)); | |
93 } | |
94 | |
95 unsigned result = 0; | |
96 gl->GetQueryObjectuivEXT(query_id, GL_QUERY_RESULT_EXT, &result); | |
97 } | |
98 | |
117 } // namespace | 99 } // namespace |
118 | 100 |
119 OneCopyTileTaskWorkerPool::CopyOperation::CopyOperation( | 101 OneCopyTileTaskWorkerPool::StagingBuffer::StagingBuffer(const gfx::Size& size) |
120 scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> src_write_lock, | 102 : size(size), texture_id(0), image_id(0), query_id(0), content_id(0) {} |
121 const Resource* src, | 103 |
122 const Resource* dst, | 104 OneCopyTileTaskWorkerPool::StagingBuffer::~StagingBuffer() { |
123 const gfx::Rect& rect) | 105 DCHECK_EQ(texture_id, 0u); |
124 : src_write_lock(src_write_lock.Pass()), src(src), dst(dst), rect(rect) { | 106 DCHECK_EQ(image_id, 0u); |
107 DCHECK_EQ(query_id, 0u); | |
125 } | 108 } |
126 | 109 |
127 OneCopyTileTaskWorkerPool::CopyOperation::~CopyOperation() { | 110 void OneCopyTileTaskWorkerPool::StagingBuffer::DestroyGLResources( |
111 gpu::gles2::GLES2Interface* gl) { | |
112 if (query_id) { | |
113 gl->DeleteQueriesEXT(1, &query_id); | |
114 query_id = 0; | |
115 } | |
116 if (image_id) { | |
117 gl->DestroyImageCHROMIUM(image_id); | |
118 image_id = 0; | |
119 } | |
120 if (texture_id) { | |
121 gl->DeleteTextures(1, &texture_id); | |
122 texture_id = 0; | |
123 } | |
124 } | |
125 | |
126 void OneCopyTileTaskWorkerPool::StagingBuffer::OnMemoryDump( | |
127 base::trace_event::ProcessMemoryDump* pmd, | |
128 ResourceFormat format, | |
129 bool in_free_list) const { | |
130 if (!gpu_memory_buffer) | |
131 return; | |
132 | |
133 gfx::GpuMemoryBufferId buffer_id = gpu_memory_buffer->GetId(); | |
134 std::string buffer_dump_name = | |
135 base::StringPrintf("cc/one_copy/staging_memory/buffer_%d", buffer_id); | |
136 base::trace_event::MemoryAllocatorDump* buffer_dump = | |
137 pmd->CreateAllocatorDump(buffer_dump_name); | |
138 | |
139 uint64_t buffer_size_in_bytes = | |
140 ResourceUtil::UncheckedSizeInBytes<uint64_t>(size, format); | |
141 buffer_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize, | |
142 base::trace_event::MemoryAllocatorDump::kUnitsBytes, | |
143 buffer_size_in_bytes); | |
144 buffer_dump->AddScalar("free_size", | |
145 base::trace_event::MemoryAllocatorDump::kUnitsBytes, | |
146 in_free_list ? buffer_size_in_bytes : 0); | |
147 | |
148 // Emit an ownership edge towards a global allocator dump node. | |
149 const uint64 tracing_process_id = | |
150 base::trace_event::MemoryDumpManager::GetInstance() | |
151 ->GetTracingProcessId(); | |
152 base::trace_event::MemoryAllocatorDumpGuid shared_buffer_guid = | |
153 gfx::GetGpuMemoryBufferGUIDForTracing(tracing_process_id, buffer_id); | |
154 pmd->CreateSharedGlobalAllocatorDump(shared_buffer_guid); | |
155 | |
156 // By creating an edge with a higher |importance| (w.r.t. browser-side dumps) | |
157 // the tracing UI will account the effective size of the buffer to the child. | |
158 const int kImportance = 2; | |
159 pmd->AddOwnershipEdge(buffer_dump->guid(), shared_buffer_guid, kImportance); | |
128 } | 160 } |
129 | 161 |
130 // static | 162 // static |
131 scoped_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create( | 163 scoped_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create( |
132 base::SequencedTaskRunner* task_runner, | 164 base::SequencedTaskRunner* task_runner, |
133 TaskGraphRunner* task_graph_runner, | 165 TaskGraphRunner* task_graph_runner, |
134 ContextProvider* context_provider, | 166 ContextProvider* context_provider, |
135 ResourceProvider* resource_provider, | 167 ResourceProvider* resource_provider, |
136 ResourcePool* resource_pool, | |
137 int max_copy_texture_chromium_size, | 168 int max_copy_texture_chromium_size, |
138 bool have_persistent_gpu_memory_buffers) { | 169 bool use_persistent_gpu_memory_buffers, |
170 unsigned image_target, | |
171 int max_staging_buffers) { | |
139 return make_scoped_ptr<TileTaskWorkerPool>(new OneCopyTileTaskWorkerPool( | 172 return make_scoped_ptr<TileTaskWorkerPool>(new OneCopyTileTaskWorkerPool( |
140 task_runner, task_graph_runner, context_provider, resource_provider, | 173 task_runner, task_graph_runner, resource_provider, |
141 resource_pool, max_copy_texture_chromium_size, | 174 max_copy_texture_chromium_size, use_persistent_gpu_memory_buffers, |
142 have_persistent_gpu_memory_buffers)); | 175 image_target, max_staging_buffers)); |
143 } | 176 } |
144 | 177 |
145 OneCopyTileTaskWorkerPool::OneCopyTileTaskWorkerPool( | 178 OneCopyTileTaskWorkerPool::OneCopyTileTaskWorkerPool( |
146 base::SequencedTaskRunner* task_runner, | 179 base::SequencedTaskRunner* task_runner, |
147 TaskGraphRunner* task_graph_runner, | 180 TaskGraphRunner* task_graph_runner, |
148 ContextProvider* context_provider, | |
149 ResourceProvider* resource_provider, | 181 ResourceProvider* resource_provider, |
150 ResourcePool* resource_pool, | |
151 int max_copy_texture_chromium_size, | 182 int max_copy_texture_chromium_size, |
152 bool have_persistent_gpu_memory_buffers) | 183 bool use_persistent_gpu_memory_buffers, |
184 unsigned image_target, | |
185 int max_staging_buffers) | |
153 : task_runner_(task_runner), | 186 : task_runner_(task_runner), |
154 task_graph_runner_(task_graph_runner), | 187 task_graph_runner_(task_graph_runner), |
155 namespace_token_(task_graph_runner->GetNamespaceToken()), | 188 namespace_token_(task_graph_runner->GetNamespaceToken()), |
156 context_provider_(context_provider), | |
157 resource_provider_(resource_provider), | 189 resource_provider_(resource_provider), |
158 resource_pool_(resource_pool), | |
159 max_bytes_per_copy_operation_( | 190 max_bytes_per_copy_operation_( |
160 max_copy_texture_chromium_size | 191 max_copy_texture_chromium_size |
161 ? std::min(kMaxBytesPerCopyOperation, | 192 ? std::min(kMaxBytesPerCopyOperation, |
162 max_copy_texture_chromium_size) | 193 max_copy_texture_chromium_size) |
163 : kMaxBytesPerCopyOperation), | 194 : kMaxBytesPerCopyOperation), |
164 have_persistent_gpu_memory_buffers_(have_persistent_gpu_memory_buffers), | 195 use_persistent_gpu_memory_buffers_(use_persistent_gpu_memory_buffers), |
165 last_issued_copy_operation_(0), | 196 image_target_(image_target), |
166 last_flushed_copy_operation_(0), | |
167 lock_(), | |
168 copy_operation_count_cv_(&lock_), | |
169 bytes_scheduled_since_last_flush_(0), | 197 bytes_scheduled_since_last_flush_(0), |
170 issued_copy_operation_count_(0), | 198 max_staging_buffers_(max_staging_buffers), |
171 next_copy_operation_sequence_(1), | 199 staging_buffer_expiration_delay_( |
172 check_for_completed_copy_operations_pending_(false), | 200 base::TimeDelta::FromMilliseconds(kStagingBufferExpirationDelayMs)), |
173 shutdown_(false), | 201 reduce_memory_usage_pending_(false), |
174 weak_ptr_factory_(this), | 202 weak_ptr_factory_(this), |
175 task_set_finished_weak_ptr_factory_(this) { | 203 task_set_finished_weak_ptr_factory_(this) { |
176 DCHECK(context_provider_); | 204 base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( |
205 this, base::ThreadTaskRunnerHandle::Get()); | |
206 reduce_memory_usage_callback_ = | |
207 base::Bind(&OneCopyTileTaskWorkerPool::ReduceMemoryUsage, | |
208 weak_ptr_factory_.GetWeakPtr()); | |
177 } | 209 } |
178 | 210 |
179 OneCopyTileTaskWorkerPool::~OneCopyTileTaskWorkerPool() { | 211 OneCopyTileTaskWorkerPool::~OneCopyTileTaskWorkerPool() { |
180 DCHECK_EQ(pending_copy_operations_.size(), 0u); | 212 base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider( |
213 this); | |
181 } | 214 } |
182 | 215 |
183 TileTaskRunner* OneCopyTileTaskWorkerPool::AsTileTaskRunner() { | 216 TileTaskRunner* OneCopyTileTaskWorkerPool::AsTileTaskRunner() { |
184 return this; | 217 return this; |
185 } | 218 } |
186 | 219 |
187 void OneCopyTileTaskWorkerPool::SetClient(TileTaskRunnerClient* client) { | 220 void OneCopyTileTaskWorkerPool::SetClient(TileTaskRunnerClient* client) { |
188 client_ = client; | 221 client_ = client; |
189 } | 222 } |
190 | 223 |
191 void OneCopyTileTaskWorkerPool::Shutdown() { | 224 void OneCopyTileTaskWorkerPool::Shutdown() { |
192 TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::Shutdown"); | 225 TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::Shutdown"); |
193 | 226 |
194 { | |
195 base::AutoLock lock(lock_); | |
196 | |
197 shutdown_ = true; | |
198 copy_operation_count_cv_.Signal(); | |
199 } | |
200 | |
201 TaskGraph empty; | 227 TaskGraph empty; |
202 task_graph_runner_->ScheduleTasks(namespace_token_, &empty); | 228 task_graph_runner_->ScheduleTasks(namespace_token_, &empty); |
203 task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_); | 229 task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_); |
230 | |
231 base::AutoLock lock(lock_); | |
232 | |
233 if (buffers_.empty()) | |
234 return; | |
235 | |
236 ReleaseBuffersNotUsedSince(base::TimeTicks() + base::TimeDelta::Max()); | |
204 } | 237 } |
205 | 238 |
206 void OneCopyTileTaskWorkerPool::ScheduleTasks(TileTaskQueue* queue) { | 239 void OneCopyTileTaskWorkerPool::ScheduleTasks(TileTaskQueue* queue) { |
207 TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::ScheduleTasks"); | 240 TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::ScheduleTasks"); |
208 | 241 |
209 #if DCHECK_IS_ON() | |
210 { | |
211 base::AutoLock lock(lock_); | |
212 DCHECK(!shutdown_); | |
213 } | |
214 #endif | |
215 | |
216 if (tasks_pending_.none()) | 242 if (tasks_pending_.none()) |
217 TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this); | 243 TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this); |
218 | 244 |
219 // Mark all task sets as pending. | 245 // Mark all task sets as pending. |
220 tasks_pending_.set(); | 246 tasks_pending_.set(); |
221 | 247 |
222 size_t priority = kTileTaskPriorityBase; | 248 size_t priority = kTileTaskPriorityBase; |
223 | 249 |
224 graph_.Reset(); | 250 graph_.Reset(); |
225 | 251 |
226 // Cancel existing OnTaskSetFinished callbacks. | 252 // Cancel existing OnTaskSetFinished callbacks. |
227 task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs(); | 253 task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs(); |
228 | 254 |
229 scoped_refptr<TileTask> new_task_set_finished_tasks[kNumberOfTaskSets]; | 255 scoped_refptr<TileTask> new_task_set_finished_tasks[kNumberOfTaskSets]; |
230 | 256 |
231 size_t task_count[kNumberOfTaskSets] = {0}; | 257 size_t task_count[kNumberOfTaskSets] = {0}; |
232 | 258 |
233 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) { | 259 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) { |
234 new_task_set_finished_tasks[task_set] = CreateTaskSetFinishedTask( | 260 new_task_set_finished_tasks[task_set] = CreateTaskSetFinishedTask( |
235 task_runner_.get(), | 261 task_runner_.get(), |
236 base::Bind(&OneCopyTileTaskWorkerPool::OnTaskSetFinished, | 262 base::Bind(&OneCopyTileTaskWorkerPool::OnTaskSetFinished, |
237 task_set_finished_weak_ptr_factory_.GetWeakPtr(), task_set)); | 263 task_set_finished_weak_ptr_factory_.GetWeakPtr(), task_set)); |
238 } | 264 } |
239 | 265 |
240 resource_pool_->CheckBusyResources(false); | |
241 | |
242 for (TileTaskQueue::Item::Vector::const_iterator it = queue->items.begin(); | 266 for (TileTaskQueue::Item::Vector::const_iterator it = queue->items.begin(); |
243 it != queue->items.end(); ++it) { | 267 it != queue->items.end(); ++it) { |
244 const TileTaskQueue::Item& item = *it; | 268 const TileTaskQueue::Item& item = *it; |
245 RasterTask* task = item.task; | 269 RasterTask* task = item.task; |
246 DCHECK(!task->HasCompleted()); | 270 DCHECK(!task->HasCompleted()); |
247 | 271 |
248 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) { | 272 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) { |
249 if (!item.task_sets[task_set]) | 273 if (!item.task_sets[task_set]) |
250 continue; | 274 continue; |
251 | 275 |
252 ++task_count[task_set]; | 276 ++task_count[task_set]; |
253 | 277 |
254 graph_.edges.push_back( | 278 graph_.edges.push_back( |
255 TaskGraph::Edge(task, new_task_set_finished_tasks[task_set].get())); | 279 TaskGraph::Edge(task, new_task_set_finished_tasks[task_set].get())); |
256 } | 280 } |
257 | 281 |
258 InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++); | 282 InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++); |
259 } | 283 } |
260 | 284 |
261 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) { | 285 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) { |
262 InsertNodeForTask(&graph_, new_task_set_finished_tasks[task_set].get(), | 286 InsertNodeForTask(&graph_, new_task_set_finished_tasks[task_set].get(), |
263 kTaskSetFinishedTaskPriorityBase + task_set, | 287 kTaskSetFinishedTaskPriorityBase + task_set, |
264 task_count[task_set]); | 288 task_count[task_set]); |
265 } | 289 } |
266 | 290 |
267 ScheduleTasksOnOriginThread(this, &graph_); | 291 ScheduleTasksOnOriginThread(this, &graph_); |
292 | |
293 // Barrier to sync any new resources to the worker context. | |
294 resource_provider_->output_surface() | |
295 ->context_provider() | |
296 ->ContextGL() | |
297 ->OrderingBarrierCHROMIUM(); | |
298 | |
268 task_graph_runner_->ScheduleTasks(namespace_token_, &graph_); | 299 task_graph_runner_->ScheduleTasks(namespace_token_, &graph_); |
269 | 300 |
270 std::copy(new_task_set_finished_tasks, | 301 std::copy(new_task_set_finished_tasks, |
271 new_task_set_finished_tasks + kNumberOfTaskSets, | 302 new_task_set_finished_tasks + kNumberOfTaskSets, |
272 task_set_finished_tasks_); | 303 task_set_finished_tasks_); |
273 | 304 |
274 resource_pool_->ReduceResourceUsage(); | |
275 | |
276 TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state", | 305 TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state", |
277 StateAsValue()); | 306 StateAsValue()); |
278 } | 307 } |
279 | 308 |
280 void OneCopyTileTaskWorkerPool::CheckForCompletedTasks() { | 309 void OneCopyTileTaskWorkerPool::CheckForCompletedTasks() { |
281 TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::CheckForCompletedTasks"); | 310 TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::CheckForCompletedTasks"); |
282 | 311 |
283 task_graph_runner_->CollectCompletedTasks(namespace_token_, | 312 task_graph_runner_->CollectCompletedTasks(namespace_token_, |
284 &completed_tasks_); | 313 &completed_tasks_); |
285 | 314 |
(...skipping 18 matching lines...) Expand all Loading... | |
304 return !PlatformColor::SameComponentOrder(GetResourceFormat()); | 333 return !PlatformColor::SameComponentOrder(GetResourceFormat()); |
305 } | 334 } |
306 | 335 |
307 scoped_ptr<RasterBuffer> OneCopyTileTaskWorkerPool::AcquireBufferForRaster( | 336 scoped_ptr<RasterBuffer> OneCopyTileTaskWorkerPool::AcquireBufferForRaster( |
308 const Resource* resource, | 337 const Resource* resource, |
309 uint64_t resource_content_id, | 338 uint64_t resource_content_id, |
310 uint64_t previous_content_id) { | 339 uint64_t previous_content_id) { |
311 // TODO(danakj): If resource_content_id != 0, we only need to copy/upload | 340 // TODO(danakj): If resource_content_id != 0, we only need to copy/upload |
312 // the dirty rect. | 341 // the dirty rect. |
313 DCHECK_EQ(resource->format(), resource_provider_->best_texture_format()); | 342 DCHECK_EQ(resource->format(), resource_provider_->best_texture_format()); |
314 return make_scoped_ptr<RasterBuffer>( | 343 return make_scoped_ptr<RasterBuffer>(new RasterBufferImpl( |
315 new RasterBufferImpl(this, resource_provider_, resource_pool_, | 344 this, resource_provider_, resource_provider_->best_texture_format(), |
316 resource_provider_->best_texture_format(), resource, | 345 resource, previous_content_id)); |
317 previous_content_id)); | |
318 } | 346 } |
319 | 347 |
320 void OneCopyTileTaskWorkerPool::ReleaseBufferForRaster( | 348 void OneCopyTileTaskWorkerPool::ReleaseBufferForRaster( |
321 scoped_ptr<RasterBuffer> buffer) { | 349 scoped_ptr<RasterBuffer> buffer) { |
322 // Nothing to do here. RasterBufferImpl destructor cleans up after itself. | 350 // Nothing to do here. RasterBufferImpl destructor cleans up after itself. |
323 } | 351 } |
324 | 352 |
325 CopySequenceNumber | 353 void OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread( |
326 OneCopyTileTaskWorkerPool::PlaybackAndScheduleCopyOnWorkerThread( | 354 const Resource* resource, |
327 bool reusing_raster_resource, | 355 const ResourceProvider::ScopedWriteLockGL* resource_lock, |
328 scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> | |
329 raster_resource_write_lock, | |
330 const Resource* raster_resource, | |
331 const Resource* output_resource, | |
332 const RasterSource* raster_source, | 356 const RasterSource* raster_source, |
333 const gfx::Rect& raster_full_rect, | 357 const gfx::Rect& raster_full_rect, |
334 const gfx::Rect& raster_dirty_rect, | 358 const gfx::Rect& raster_dirty_rect, |
335 float scale) { | 359 float scale, |
336 gfx::GpuMemoryBuffer* gpu_memory_buffer = | 360 uint64_t previous_content_id, |
337 raster_resource_write_lock->GetGpuMemoryBuffer(); | 361 uint64_t new_content_id) { |
338 if (gpu_memory_buffer) { | 362 base::AutoLock lock(lock_); |
339 void* data = NULL; | 363 |
340 bool rv = gpu_memory_buffer->Map(&data); | 364 scoped_ptr<StagingBuffer> staging_buffer = |
341 DCHECK(rv); | 365 AcquireStagingBuffer(resource, previous_content_id); |
342 int stride; | 366 DCHECK(staging_buffer); |
343 gpu_memory_buffer->GetStride(&stride); | 367 |
344 // TileTaskWorkerPool::PlaybackToMemory only supports unsigned strides. | 368 { |
345 DCHECK_GE(stride, 0); | 369 base::AutoUnlock unlock(lock_); |
370 | |
371 // Allocate GpuMemoryBuffer if necessary. | |
372 if (!staging_buffer->gpu_memory_buffer) { | |
373 staging_buffer->gpu_memory_buffer = | |
374 resource_provider_->gpu_memory_buffer_manager() | |
375 ->AllocateGpuMemoryBuffer( | |
376 staging_buffer->size, | |
377 GpuMemoryBufferFormat( | |
378 resource_provider_->best_texture_format()), | |
379 use_persistent_gpu_memory_buffers_ | |
380 ? gfx::GpuMemoryBuffer::PERSISTENT_MAP | |
381 : gfx::GpuMemoryBuffer::MAP); | |
382 } | |
346 | 383 |
347 gfx::Rect playback_rect = raster_full_rect; | 384 gfx::Rect playback_rect = raster_full_rect; |
348 if (reusing_raster_resource) { | 385 if (use_persistent_gpu_memory_buffers_ && previous_content_id) { |
349 playback_rect.Intersect(raster_dirty_rect); | 386 // Reduce playback rect to dirty region if the content id of the staging |
350 } | 387 // buffer matches the prevous content id. |
351 DCHECK(!playback_rect.IsEmpty()) | 388 if (previous_content_id == staging_buffer->content_id) |
352 << "Why are we rastering a tile that's not dirty?"; | 389 playback_rect.Intersect(raster_dirty_rect); |
353 TileTaskWorkerPool::PlaybackToMemory( | 390 } |
354 data, raster_resource->format(), raster_resource->size(), | 391 |
355 static_cast<size_t>(stride), raster_source, raster_full_rect, | 392 if (staging_buffer->gpu_memory_buffer) { |
356 playback_rect, scale); | 393 void* data = nullptr; |
357 gpu_memory_buffer->Unmap(); | 394 bool rv = staging_buffer->gpu_memory_buffer->Map(&data); |
358 } | 395 DCHECK(rv); |
359 | 396 int stride; |
397 staging_buffer->gpu_memory_buffer->GetStride(&stride); | |
398 // TileTaskWorkerPool::PlaybackToMemory only supports unsigned strides. | |
399 DCHECK_GE(stride, 0); | |
400 | |
401 DCHECK(!playback_rect.IsEmpty()) | |
402 << "Why are we rastering a tile that's not dirty?"; | |
403 TileTaskWorkerPool::PlaybackToMemory( | |
404 data, resource_provider_->best_texture_format(), staging_buffer->size, | |
405 static_cast<size_t>(stride), raster_source, raster_full_rect, | |
406 playback_rect, scale); | |
407 staging_buffer->gpu_memory_buffer->Unmap(); | |
408 staging_buffer->content_id = new_content_id; | |
409 } | |
410 } | |
411 | |
412 ContextProvider* context_provider = | |
413 resource_provider_->output_surface()->worker_context_provider(); | |
piman
2015/08/04 18:44:54
Mmh, we're accessing the ResourceProvider & Output
reveman
2015/08/04 21:56:41
This consistent with GpuTileTaskWorkerPool and saf
| |
414 DCHECK(context_provider); | |
415 | |
416 { | |
417 ContextProvider::ScopedContextLock scoped_context(context_provider); | |
418 | |
419 gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL(); | |
420 DCHECK(gl); | |
421 | |
422 if (!staging_buffer->texture_id) { | |
423 gl->GenTextures(1, &staging_buffer->texture_id); | |
424 gl->BindTexture(image_target_, staging_buffer->texture_id); | |
425 gl->TexParameteri(image_target_, GL_TEXTURE_MIN_FILTER, GL_NEAREST); | |
426 gl->TexParameteri(image_target_, GL_TEXTURE_MAG_FILTER, GL_NEAREST); | |
427 gl->TexParameteri(image_target_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); | |
428 gl->TexParameteri(image_target_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); | |
429 if (staging_buffer->gpu_memory_buffer) { | |
430 DCHECK(!staging_buffer->image_id); | |
431 staging_buffer->image_id = gl->CreateImageCHROMIUM( | |
432 staging_buffer->gpu_memory_buffer->AsClientBuffer(), | |
433 staging_buffer->size.width(), staging_buffer->size.height(), | |
434 GLInternalFormat(resource_provider_->best_texture_format())); | |
435 gl->BindTexImage2DCHROMIUM(image_target_, staging_buffer->image_id); | |
436 } else { | |
437 gl->BindTexture(image_target_, staging_buffer->texture_id); | |
438 gl->ReleaseTexImage2DCHROMIUM(image_target_, staging_buffer->image_id); | |
439 gl->BindTexImage2DCHROMIUM(image_target_, staging_buffer->image_id); | |
440 } | |
441 } | |
442 | |
443 if (resource_provider_->use_sync_query()) { | |
444 if (!staging_buffer->query_id) | |
445 gl->GenQueriesEXT(1, &staging_buffer->query_id); | |
446 | |
447 #if defined(OS_CHROMEOS) | |
448 // TODO(reveman): This avoids a performance problem on some ChromeOS | |
449 // devices. This needs to be removed to support native GpuMemoryBuffer | |
450 // implementations. crbug.com/436314 | |
451 gl->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM, staging_buffer->query_id); | |
452 #else | |
453 gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM, | |
454 staging_buffer->query_id); | |
455 #endif | |
456 } | |
457 | |
458 int bytes_per_row = | |
459 (BitsPerPixel(resource_provider_->best_texture_format()) * | |
460 resource->size().width()) / | |
461 8; | |
462 int chunk_size_in_rows = | |
463 std::max(1, max_bytes_per_copy_operation_ / bytes_per_row); | |
464 // Align chunk size to 4. Required to support compressed texture formats. | |
465 chunk_size_in_rows = MathUtil::RoundUp(chunk_size_in_rows, 4); | |
466 int y = 0; | |
467 int height = resource->size().height(); | |
468 while (y < height) { | |
469 // Copy at most |chunk_size_in_rows|. | |
470 int rows_to_copy = std::min(chunk_size_in_rows, height - y); | |
471 DCHECK_GT(rows_to_copy, 0); | |
472 | |
473 gl->CopySubTextureCHROMIUM(GL_TEXTURE_2D, staging_buffer->texture_id, | |
474 resource_lock->texture_id(), 0, y, 0, y, | |
475 resource->size().width(), rows_to_copy, false, | |
476 false, false); | |
477 y += rows_to_copy; | |
478 | |
479 // Increment |bytes_scheduled_since_last_flush_| by the amount of memory | |
480 // used for this copy operation. | |
481 bytes_scheduled_since_last_flush_ += rows_to_copy * bytes_per_row; | |
482 | |
483 if (bytes_scheduled_since_last_flush_ >= max_bytes_per_copy_operation_) { | |
484 gl->ShallowFlushCHROMIUM(); | |
485 bytes_scheduled_since_last_flush_ = 0; | |
486 } | |
487 } | |
488 | |
489 if (resource_provider_->use_sync_query()) { | |
490 #if defined(OS_CHROMEOS) | |
491 gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM); | |
492 #else | |
493 gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM); | |
494 #endif | |
495 } | |
496 | |
497 // Barrier to sync worker context output to cc context. | |
498 gl->OrderingBarrierCHROMIUM(); | |
499 } | |
500 | |
501 staging_buffer->last_usage = base::TimeTicks::Now(); | |
502 busy_buffers_.push_back(staging_buffer.Pass()); | |
503 | |
504 ScheduleReduceMemoryUsage(); | |
505 } | |
506 | |
507 bool OneCopyTileTaskWorkerPool::OnMemoryDump( | |
508 base::trace_event::ProcessMemoryDump* pmd) { | |
360 base::AutoLock lock(lock_); | 509 base::AutoLock lock(lock_); |
361 | 510 |
362 CopySequenceNumber sequence = 0; | 511 for (const auto& buffer : buffers_) { |
363 int bytes_per_row = (BitsPerPixel(raster_resource->format()) * | 512 buffer->OnMemoryDump(pmd, resource_provider_->best_texture_format(), |
364 raster_resource->size().width()) / | 513 std::find(free_buffers_.begin(), free_buffers_.end(), |
365 8; | 514 buffer) != free_buffers_.end()); |
366 int chunk_size_in_rows = | 515 } |
367 std::max(1, max_bytes_per_copy_operation_ / bytes_per_row); | 516 |
368 // Align chunk size to 4. Required to support compressed texture formats. | 517 return true; |
369 chunk_size_in_rows = MathUtil::RoundUp(chunk_size_in_rows, 4); | 518 } |
370 int y = 0; | 519 |
371 int height = raster_resource->size().height(); | 520 scoped_ptr<OneCopyTileTaskWorkerPool::StagingBuffer> |
372 while (y < height) { | 521 OneCopyTileTaskWorkerPool::AcquireStagingBuffer(const Resource* resource, |
373 int failed_attempts = 0; | 522 uint64_t previous_content_id) { |
374 while ((pending_copy_operations_.size() + issued_copy_operation_count_) >= | 523 lock_.AssertAcquired(); |
375 kMaxCopyOperations) { | 524 |
376 // Ignore limit when shutdown is set. | 525 scoped_ptr<StagingBuffer> staging_buffer; |
377 if (shutdown_) | 526 |
527 ContextProvider* context_provider = | |
528 resource_provider_->output_surface()->worker_context_provider(); | |
529 DCHECK(context_provider); | |
530 | |
531 ContextProvider::ScopedContextLock scoped_context(context_provider); | |
532 | |
533 gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL(); | |
534 DCHECK(gl); | |
535 | |
536 // Check if any busy buffers have become available. | |
537 if (resource_provider_->use_sync_query()) { | |
538 while (!busy_buffers_.empty()) { | |
539 if (!CheckForQueryResult(gl, busy_buffers_.front()->query_id)) | |
378 break; | 540 break; |
379 | 541 |
380 ++failed_attempts; | 542 free_buffers_.push_back(busy_buffers_.take_front()); |
381 | 543 } |
382 // Schedule a check that will also wait for operations to complete | 544 } |
383 // after too many failed attempts. | 545 |
384 bool wait_if_needed = failed_attempts > kFailedAttemptsBeforeWaitIfNeeded; | 546 // Wait for number of non-free buffers to become less than the limit. |
385 | 547 while ((buffers_.size() - free_buffers_.size()) >= max_staging_buffers_) { |
386 // Schedule a check for completed copy operations if too many operations | 548 // Stop when there are no more busy buffers to wait for. |
387 // are currently in-flight. | 549 if (busy_buffers_.empty()) |
388 ScheduleCheckForCompletedCopyOperationsWithLockAcquired(wait_if_needed); | 550 break; |
389 | 551 |
390 { | 552 if (resource_provider_->use_sync_query()) { |
391 TRACE_EVENT0("cc", "WaitingForCopyOperationsToComplete"); | 553 WaitForQueryResult(gl, busy_buffers_.front()->query_id); |
392 | 554 free_buffers_.push_back(busy_buffers_.take_front()); |
393 // Wait for in-flight copy operations to drop below limit. | 555 } else { |
394 copy_operation_count_cv_.Wait(); | 556 // Fall-back to glFinish if CHROMIUM_sync_query is not available. |
395 } | 557 gl->Finish(); |
396 } | 558 while (!busy_buffers_.empty()) |
397 | 559 free_buffers_.push_back(busy_buffers_.take_front()); |
398 // There may be more work available, so wake up another worker thread. | 560 } |
399 copy_operation_count_cv_.Signal(); | 561 } |
400 | 562 |
401 // Copy at most |chunk_size_in_rows|. | 563 // Find a staging buffer that allows us to perform partial raster when |
402 int rows_to_copy = std::min(chunk_size_in_rows, height - y); | 564 // using persistent GpuMemoryBuffers. |
403 DCHECK_GT(rows_to_copy, 0); | 565 if (use_persistent_gpu_memory_buffers_ && previous_content_id) { |
404 | 566 StagingBufferDeque::iterator it = |
405 // |raster_resource_write_lock| is passed to the first copy operation as it | 567 std::find_if(free_buffers_.begin(), free_buffers_.end(), |
406 // needs to be released before we can issue a copy. | 568 [previous_content_id](const StagingBuffer* buffer) { |
407 pending_copy_operations_.push_back(make_scoped_ptr(new CopyOperation( | 569 return buffer->content_id == previous_content_id; |
408 raster_resource_write_lock.Pass(), raster_resource, output_resource, | 570 }); |
409 gfx::Rect(0, y, raster_resource->size().width(), rows_to_copy)))); | 571 if (it != free_buffers_.end()) |
410 y += rows_to_copy; | 572 staging_buffer = free_buffers_.take(it); |
411 | 573 } |
412 // Acquire a sequence number for this copy operation. | 574 |
413 sequence = next_copy_operation_sequence_++; | 575 // Find staging buffer of correct size. |
414 | 576 if (!staging_buffer) { |
415 // Increment |bytes_scheduled_since_last_flush_| by the amount of memory | 577 StagingBufferDeque::iterator it = |
416 // used for this copy operation. | 578 std::find_if(free_buffers_.begin(), free_buffers_.end(), |
417 bytes_scheduled_since_last_flush_ += rows_to_copy * bytes_per_row; | 579 [resource](const StagingBuffer* buffer) { |
418 | 580 return buffer->size == resource->size(); |
419 // Post task that will advance last flushed copy operation to |sequence| | 581 }); |
420 // when |bytes_scheduled_since_last_flush_| has reached | 582 if (it != free_buffers_.end()) |
421 // |max_bytes_per_copy_operation_|. | 583 staging_buffer = free_buffers_.take(it); |
422 if (bytes_scheduled_since_last_flush_ >= max_bytes_per_copy_operation_) { | 584 } |
423 task_runner_->PostTask( | 585 |
424 FROM_HERE, | 586 // Create new staging buffer if necessary. |
425 base::Bind(&OneCopyTileTaskWorkerPool::AdvanceLastFlushedCopyTo, | 587 if (!staging_buffer) { |
426 weak_ptr_factory_.GetWeakPtr(), sequence)); | 588 staging_buffer = make_scoped_ptr(new StagingBuffer(resource->size())); |
427 bytes_scheduled_since_last_flush_ = 0; | 589 buffers_.insert(staging_buffer.get()); |
428 } | 590 } |
429 } | 591 |
430 | 592 // Release enough free buffers to stay within the limit. |
431 return sequence; | 593 while (buffers_.size() > max_staging_buffers_) { |
432 } | 594 if (free_buffers_.empty()) |
433 | 595 break; |
434 void OneCopyTileTaskWorkerPool::AdvanceLastIssuedCopyTo( | 596 |
435 CopySequenceNumber sequence) { | 597 free_buffers_.front()->DestroyGLResources(gl); |
436 if (last_issued_copy_operation_ >= sequence) | 598 buffers_.erase(free_buffers_.front()); |
599 free_buffers_.take_front(); | |
600 } | |
601 | |
602 return staging_buffer.Pass(); | |
603 } | |
604 | |
605 base::TimeTicks OneCopyTileTaskWorkerPool::GetUsageTimeForLRUBuffer() { | |
606 lock_.AssertAcquired(); | |
607 | |
608 if (!free_buffers_.empty()) | |
609 return free_buffers_.front()->last_usage; | |
610 | |
611 if (!busy_buffers_.empty()) | |
612 return busy_buffers_.front()->last_usage; | |
613 | |
614 return base::TimeTicks(); | |
615 } | |
616 | |
617 void OneCopyTileTaskWorkerPool::ScheduleReduceMemoryUsage() { | |
618 lock_.AssertAcquired(); | |
619 | |
620 if (reduce_memory_usage_pending_) | |
437 return; | 621 return; |
438 | 622 |
439 IssueCopyOperations(sequence - last_issued_copy_operation_); | 623 reduce_memory_usage_pending_ = true; |
440 last_issued_copy_operation_ = sequence; | 624 |
441 } | 625 // Schedule a call to ReduceMemoryUsage at the time when the LRU buffer |
442 | 626 // should be released. |
443 void OneCopyTileTaskWorkerPool::AdvanceLastFlushedCopyTo( | 627 base::TimeTicks reduce_memory_usage_time = |
444 CopySequenceNumber sequence) { | 628 GetUsageTimeForLRUBuffer() + staging_buffer_expiration_delay_; |
445 if (last_flushed_copy_operation_ >= sequence) | 629 task_runner_->PostDelayedTask( |
630 FROM_HERE, reduce_memory_usage_callback_, | |
631 reduce_memory_usage_time - base::TimeTicks::Now()); | |
632 } | |
633 | |
634 void OneCopyTileTaskWorkerPool::ReduceMemoryUsage() { | |
635 base::AutoLock lock(lock_); | |
636 | |
637 reduce_memory_usage_pending_ = false; | |
638 | |
639 if (free_buffers_.empty() && busy_buffers_.empty()) | |
446 return; | 640 return; |
447 | 641 |
448 AdvanceLastIssuedCopyTo(sequence); | 642 base::TimeTicks current_time = base::TimeTicks::Now(); |
449 | 643 ReleaseBuffersNotUsedSince(current_time - staging_buffer_expiration_delay_); |
450 // Flush all issued copy operations. | 644 |
451 context_provider_->ContextGL()->ShallowFlushCHROMIUM(); | 645 if (free_buffers_.empty() && busy_buffers_.empty()) |
452 last_flushed_copy_operation_ = last_issued_copy_operation_; | 646 return; |
647 | |
648 reduce_memory_usage_pending_ = true; | |
649 | |
650 // Schedule another call to ReduceMemoryUsage at the time when the next | |
651 // buffer should be released. | |
652 base::TimeTicks reduce_memory_usage_time = | |
653 GetUsageTimeForLRUBuffer() + staging_buffer_expiration_delay_; | |
654 task_runner_->PostDelayedTask(FROM_HERE, reduce_memory_usage_callback_, | |
655 reduce_memory_usage_time - current_time); | |
656 } | |
657 | |
658 void OneCopyTileTaskWorkerPool::ReleaseBuffersNotUsedSince( | |
659 base::TimeTicks time) { | |
660 lock_.AssertAcquired(); | |
661 | |
662 ContextProvider* context_provider = | |
663 resource_provider_->output_surface()->worker_context_provider(); | |
664 DCHECK(context_provider); | |
665 | |
666 { | |
667 ContextProvider::ScopedContextLock scoped_context(context_provider); | |
668 | |
669 gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL(); | |
670 DCHECK(gl); | |
671 | |
672 // Note: Front buffer is guaranteed to be LRU so we can stop releasing | |
673 // buffers as soon as we find a buffer that has been used since |time|. | |
674 while (!free_buffers_.empty()) { | |
675 if (free_buffers_.front()->last_usage > time) | |
676 return; | |
677 | |
678 free_buffers_.front()->DestroyGLResources(gl); | |
679 buffers_.erase(free_buffers_.front()); | |
680 free_buffers_.take_front(); | |
681 } | |
682 | |
683 while (!busy_buffers_.empty()) { | |
684 if (busy_buffers_.front()->last_usage > time) | |
685 return; | |
686 | |
687 busy_buffers_.front()->DestroyGLResources(gl); | |
688 buffers_.erase(busy_buffers_.front()); | |
689 busy_buffers_.take_front(); | |
690 } | |
691 } | |
453 } | 692 } |
454 | 693 |
455 void OneCopyTileTaskWorkerPool::OnTaskSetFinished(TaskSet task_set) { | 694 void OneCopyTileTaskWorkerPool::OnTaskSetFinished(TaskSet task_set) { |
456 TRACE_EVENT1("cc", "OneCopyTileTaskWorkerPool::OnTaskSetFinished", "task_set", | 695 TRACE_EVENT1("cc", "OneCopyTileTaskWorkerPool::OnTaskSetFinished", "task_set", |
457 task_set); | 696 task_set); |
458 | 697 |
459 DCHECK(tasks_pending_[task_set]); | 698 DCHECK(tasks_pending_[task_set]); |
460 tasks_pending_[task_set] = false; | 699 tasks_pending_[task_set] = false; |
461 if (tasks_pending_.any()) { | 700 if (tasks_pending_.any()) { |
462 TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", | 701 TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", |
463 "state", StateAsValue()); | 702 "state", StateAsValue()); |
464 } else { | 703 } else { |
465 TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this); | 704 TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this); |
466 } | 705 } |
467 client_->DidFinishRunningTileTasks(task_set); | 706 client_->DidFinishRunningTileTasks(task_set); |
468 } | 707 } |
469 | 708 |
470 void OneCopyTileTaskWorkerPool::IssueCopyOperations(int64 count) { | |
471 TRACE_EVENT1("cc", "OneCopyTileTaskWorkerPool::IssueCopyOperations", "count", | |
472 count); | |
473 | |
474 CopyOperation::Deque copy_operations; | |
475 | |
476 { | |
477 base::AutoLock lock(lock_); | |
478 | |
479 for (int64 i = 0; i < count; ++i) { | |
480 DCHECK(!pending_copy_operations_.empty()); | |
481 copy_operations.push_back(pending_copy_operations_.take_front()); | |
482 } | |
483 | |
484 // Increment |issued_copy_operation_count_| to reflect the transition of | |
485 // copy operations from "pending" to "issued" state. | |
486 issued_copy_operation_count_ += copy_operations.size(); | |
487 } | |
488 | |
489 while (!copy_operations.empty()) { | |
490 scoped_ptr<CopyOperation> copy_operation = copy_operations.take_front(); | |
491 | |
492 // Remove the write lock. | |
493 copy_operation->src_write_lock.reset(); | |
494 | |
495 // Copy contents of source resource to destination resource. | |
496 resource_provider_->CopyResource(copy_operation->src->id(), | |
497 copy_operation->dst->id(), | |
498 copy_operation->rect); | |
499 } | |
500 } | |
501 | |
502 void OneCopyTileTaskWorkerPool:: | |
503 ScheduleCheckForCompletedCopyOperationsWithLockAcquired( | |
504 bool wait_if_needed) { | |
505 lock_.AssertAcquired(); | |
506 | |
507 if (check_for_completed_copy_operations_pending_) | |
508 return; | |
509 | |
510 base::TimeTicks now = base::TimeTicks::Now(); | |
511 | |
512 // Schedule a check for completed copy operations as soon as possible but | |
513 // don't allow two consecutive checks to be scheduled to run less than the | |
514 // tick rate apart. | |
515 base::TimeTicks next_check_for_completed_copy_operations_time = | |
516 std::max(last_check_for_completed_copy_operations_time_ + | |
517 base::TimeDelta::FromMilliseconds( | |
518 kCheckForCompletedCopyOperationsTickRateMs), | |
519 now); | |
520 | |
521 task_runner_->PostDelayedTask( | |
522 FROM_HERE, | |
523 base::Bind(&OneCopyTileTaskWorkerPool::CheckForCompletedCopyOperations, | |
524 weak_ptr_factory_.GetWeakPtr(), wait_if_needed), | |
525 next_check_for_completed_copy_operations_time - now); | |
526 | |
527 last_check_for_completed_copy_operations_time_ = | |
528 next_check_for_completed_copy_operations_time; | |
529 check_for_completed_copy_operations_pending_ = true; | |
530 } | |
531 | |
532 void OneCopyTileTaskWorkerPool::CheckForCompletedCopyOperations( | |
533 bool wait_if_needed) { | |
534 TRACE_EVENT1("cc", | |
535 "OneCopyTileTaskWorkerPool::CheckForCompletedCopyOperations", | |
536 "wait_if_needed", wait_if_needed); | |
537 | |
538 resource_pool_->CheckBusyResources(wait_if_needed); | |
539 | |
540 { | |
541 base::AutoLock lock(lock_); | |
542 | |
543 DCHECK(check_for_completed_copy_operations_pending_); | |
544 check_for_completed_copy_operations_pending_ = false; | |
545 | |
546 // The number of busy resources in the pool reflects the number of issued | |
547 // copy operations that have not yet completed. | |
548 issued_copy_operation_count_ = resource_pool_->busy_resource_count(); | |
549 | |
550 // There may be work blocked on too many in-flight copy operations, so wake | |
551 // up a worker thread. | |
552 copy_operation_count_cv_.Signal(); | |
553 } | |
554 } | |
555 | |
556 scoped_refptr<base::trace_event::ConvertableToTraceFormat> | 709 scoped_refptr<base::trace_event::ConvertableToTraceFormat> |
557 OneCopyTileTaskWorkerPool::StateAsValue() const { | 710 OneCopyTileTaskWorkerPool::StateAsValue() const { |
558 scoped_refptr<base::trace_event::TracedValue> state = | 711 scoped_refptr<base::trace_event::TracedValue> state = |
559 new base::trace_event::TracedValue(); | 712 new base::trace_event::TracedValue(); |
560 | 713 |
561 state->BeginArray("tasks_pending"); | 714 state->BeginArray("tasks_pending"); |
562 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) | 715 for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) |
563 state->AppendBoolean(tasks_pending_[task_set]); | 716 state->AppendBoolean(tasks_pending_[task_set]); |
564 state->EndArray(); | 717 state->EndArray(); |
565 state->BeginDictionary("staging_state"); | 718 state->BeginDictionary("staging_state"); |
566 StagingStateAsValueInto(state.get()); | 719 StagingStateAsValueInto(state.get()); |
567 state->EndDictionary(); | 720 state->EndDictionary(); |
568 | 721 |
569 return state; | 722 return state; |
570 } | 723 } |
571 | 724 |
572 void OneCopyTileTaskWorkerPool::StagingStateAsValueInto( | 725 void OneCopyTileTaskWorkerPool::StagingStateAsValueInto( |
573 base::trace_event::TracedValue* staging_state) const { | 726 base::trace_event::TracedValue* staging_state) const { |
574 staging_state->SetInteger( | 727 base::AutoLock lock(lock_); |
575 "staging_resource_count", | 728 |
576 static_cast<int>(resource_pool_->total_resource_count())); | 729 staging_state->SetInteger("staging_buffer_count", |
577 staging_state->SetInteger( | 730 static_cast<int>(buffers_.size())); |
578 "bytes_used_for_staging_resources", | 731 staging_state->SetInteger("busy_count", |
579 static_cast<int>(resource_pool_->total_memory_usage_bytes())); | 732 static_cast<int>(busy_buffers_.size())); |
580 staging_state->SetInteger( | 733 staging_state->SetInteger("free_count", |
581 "pending_copy_count", | 734 static_cast<int>(free_buffers_.size())); |
582 static_cast<int>(resource_pool_->total_resource_count() - | |
583 resource_pool_->acquired_resource_count())); | |
584 staging_state->SetInteger( | |
585 "bytes_pending_copy", | |
586 static_cast<int>(resource_pool_->total_memory_usage_bytes() - | |
587 resource_pool_->acquired_memory_usage_bytes())); | |
588 } | 735 } |
589 | 736 |
590 } // namespace cc | 737 } // namespace cc |
OLD | NEW |