OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 "gpu/command_buffer/service/async_pixel_transfer_manager_idle.h" | 5 #include "gpu/command_buffer/service/async_pixel_transfer_manager_idle.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/debug/trace_event.h" | 8 #include "base/debug/trace_event.h" |
9 #include "base/debug/trace_event_synthetic_delay.h" | 9 #include "base/debug/trace_event_synthetic_delay.h" |
10 #include "base/lazy_instance.h" | 10 #include "base/lazy_instance.h" |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
100 const AsyncMemoryParams& mem_params, | 100 const AsyncMemoryParams& mem_params, |
101 const base::Closure& bind_callback) { | 101 const base::Closure& bind_callback) { |
102 TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage"); | 102 TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage"); |
103 DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target); | 103 DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target); |
104 DCHECK(mem_params.shared_memory); | 104 DCHECK(mem_params.shared_memory); |
105 DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size, | 105 DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size, |
106 mem_params.shm_size); | 106 mem_params.shm_size); |
107 | 107 |
108 shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task( | 108 shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task( |
109 id_, | 109 id_, |
| 110 this, |
110 base::Bind( | 111 base::Bind( |
111 &AsyncPixelTransferDelegateIdle::PerformAsyncTexImage2D, | 112 &AsyncPixelTransferDelegateIdle::PerformAsyncTexImage2D, |
112 AsWeakPtr(), | 113 AsWeakPtr(), |
113 tex_params, | 114 tex_params, |
114 mem_params, | 115 mem_params, |
115 bind_callback, | 116 bind_callback, |
116 base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(), | 117 base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(), |
117 mem_params.shared_memory, | 118 mem_params.shared_memory, |
118 mem_params.shm_size))))); | 119 mem_params.shm_size))))); |
119 | 120 |
120 transfer_in_progress_ = true; | 121 transfer_in_progress_ = true; |
121 } | 122 } |
122 | 123 |
123 void AsyncPixelTransferDelegateIdle::AsyncTexSubImage2D( | 124 void AsyncPixelTransferDelegateIdle::AsyncTexSubImage2D( |
124 const AsyncTexSubImage2DParams& tex_params, | 125 const AsyncTexSubImage2DParams& tex_params, |
125 const AsyncMemoryParams& mem_params) { | 126 const AsyncMemoryParams& mem_params) { |
126 TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage"); | 127 TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage"); |
127 DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target); | 128 DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target); |
128 DCHECK(mem_params.shared_memory); | 129 DCHECK(mem_params.shared_memory); |
129 DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size, | 130 DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size, |
130 mem_params.shm_size); | 131 mem_params.shm_size); |
131 | 132 |
132 shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task( | 133 shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task( |
133 id_, | 134 id_, |
| 135 this, |
134 base::Bind( | 136 base::Bind( |
135 &AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D, | 137 &AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D, |
136 AsWeakPtr(), | 138 AsWeakPtr(), |
137 tex_params, | 139 tex_params, |
138 mem_params, | 140 mem_params, |
139 base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(), | 141 base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(), |
140 mem_params.shared_memory, | 142 mem_params.shared_memory, |
141 mem_params.shm_size))))); | 143 mem_params.shm_size))))); |
142 | 144 |
143 transfer_in_progress_ = true; | 145 transfer_in_progress_ = true; |
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
248 } | 250 } |
249 | 251 |
250 TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage"); | 252 TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage"); |
251 transfer_in_progress_ = false; | 253 transfer_in_progress_ = false; |
252 shared_state_->texture_upload_count++; | 254 shared_state_->texture_upload_count++; |
253 shared_state_->total_texture_upload_time += | 255 shared_state_->total_texture_upload_time += |
254 base::TimeTicks::HighResNow() - begin_time; | 256 base::TimeTicks::HighResNow() - begin_time; |
255 } | 257 } |
256 | 258 |
257 AsyncPixelTransferManagerIdle::Task::Task( | 259 AsyncPixelTransferManagerIdle::Task::Task( |
258 uint64 transfer_id, const base::Closure& task) | 260 uint64 transfer_id, |
| 261 AsyncPixelTransferDelegate* delegate, |
| 262 const base::Closure& task) |
259 : transfer_id(transfer_id), | 263 : transfer_id(transfer_id), |
| 264 delegate(delegate), |
260 task(task) { | 265 task(task) { |
261 } | 266 } |
262 | 267 |
263 AsyncPixelTransferManagerIdle::Task::~Task() {} | 268 AsyncPixelTransferManagerIdle::Task::~Task() {} |
264 | 269 |
265 AsyncPixelTransferManagerIdle::SharedState::SharedState() | 270 AsyncPixelTransferManagerIdle::SharedState::SharedState() |
266 : texture_upload_count(0) {} | 271 : texture_upload_count(0) {} |
267 | 272 |
268 AsyncPixelTransferManagerIdle::SharedState::~SharedState() {} | 273 AsyncPixelTransferManagerIdle::SharedState::~SharedState() {} |
269 | 274 |
(...skipping 21 matching lines...) Expand all Loading... |
291 void AsyncPixelTransferManagerIdle::AsyncNotifyCompletion( | 296 void AsyncPixelTransferManagerIdle::AsyncNotifyCompletion( |
292 const AsyncMemoryParams& mem_params, | 297 const AsyncMemoryParams& mem_params, |
293 AsyncPixelTransferCompletionObserver* observer) { | 298 AsyncPixelTransferCompletionObserver* observer) { |
294 if (shared_state_.tasks.empty()) { | 299 if (shared_state_.tasks.empty()) { |
295 observer->DidComplete(mem_params); | 300 observer->DidComplete(mem_params); |
296 return; | 301 return; |
297 } | 302 } |
298 | 303 |
299 shared_state_.tasks.push_back( | 304 shared_state_.tasks.push_back( |
300 Task(0, // 0 transfer_id for notification tasks. | 305 Task(0, // 0 transfer_id for notification tasks. |
301 base::Bind( | 306 NULL, |
302 &PerformNotifyCompletion, | 307 base::Bind(&PerformNotifyCompletion, |
303 mem_params, | 308 mem_params, |
304 base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(), | 309 base::Owned( |
305 mem_params.shared_memory, | 310 new ScopedSafeSharedMemory(safe_shared_memory_pool(), |
306 mem_params.shm_size)), | 311 mem_params.shared_memory, |
307 make_scoped_refptr(observer)))); | 312 mem_params.shm_size)), |
| 313 make_scoped_refptr(observer)))); |
308 } | 314 } |
309 | 315 |
310 uint32 AsyncPixelTransferManagerIdle::GetTextureUploadCount() { | 316 uint32 AsyncPixelTransferManagerIdle::GetTextureUploadCount() { |
311 return shared_state_.texture_upload_count; | 317 return shared_state_.texture_upload_count; |
312 } | 318 } |
313 | 319 |
314 base::TimeDelta AsyncPixelTransferManagerIdle::GetTotalTextureUploadTime() { | 320 base::TimeDelta AsyncPixelTransferManagerIdle::GetTotalTextureUploadTime() { |
315 return shared_state_.total_texture_upload_time; | 321 return shared_state_.total_texture_upload_time; |
316 } | 322 } |
317 | 323 |
318 void AsyncPixelTransferManagerIdle::ProcessMorePendingTransfers() { | 324 void AsyncPixelTransferManagerIdle::ProcessMorePendingTransfers() { |
319 if (shared_state_.tasks.empty()) | 325 if (shared_state_.tasks.empty()) |
320 return; | 326 return; |
321 | 327 |
322 // First task should always be a pixel transfer task. | 328 // First task should always be a pixel transfer task. |
323 DCHECK(shared_state_.tasks.front().transfer_id); | 329 DCHECK(shared_state_.tasks.front().transfer_id); |
324 shared_state_.tasks.front().task.Run(); | 330 shared_state_.tasks.front().task.Run(); |
325 shared_state_.tasks.pop_front(); | 331 shared_state_.tasks.pop_front(); |
326 | 332 |
327 shared_state_.ProcessNotificationTasks(); | 333 shared_state_.ProcessNotificationTasks(); |
328 } | 334 } |
329 | 335 |
330 bool AsyncPixelTransferManagerIdle::NeedsProcessMorePendingTransfers() { | 336 bool AsyncPixelTransferManagerIdle::NeedsProcessMorePendingTransfers() { |
331 return !shared_state_.tasks.empty(); | 337 return !shared_state_.tasks.empty(); |
332 } | 338 } |
333 | 339 |
| 340 void AsyncPixelTransferManagerIdle::WaitAllAsyncTexImage2D() { |
| 341 if (shared_state_.tasks.empty()) |
| 342 return; |
| 343 |
| 344 const Task& task = shared_state_.tasks.back(); |
| 345 if (task.delegate) |
| 346 task.delegate->WaitForTransferCompletion(); |
| 347 } |
| 348 |
334 AsyncPixelTransferDelegate* | 349 AsyncPixelTransferDelegate* |
335 AsyncPixelTransferManagerIdle::CreatePixelTransferDelegateImpl( | 350 AsyncPixelTransferManagerIdle::CreatePixelTransferDelegateImpl( |
336 gles2::TextureRef* ref, | 351 gles2::TextureRef* ref, |
337 const AsyncTexImage2DParams& define_params) { | 352 const AsyncTexImage2DParams& define_params) { |
338 return new AsyncPixelTransferDelegateIdle(&shared_state_, | 353 return new AsyncPixelTransferDelegateIdle(&shared_state_, |
339 ref->service_id(), | 354 ref->service_id(), |
340 define_params); | 355 define_params); |
341 } | 356 } |
342 | 357 |
343 } // namespace gpu | 358 } // namespace gpu |
OLD | NEW |