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 #ifndef CC_RASTER_ONE_COPY_TILE_TASK_WORKER_POOL_H_ | 5 #ifndef CC_RASTER_ONE_COPY_TILE_TASK_WORKER_POOL_H_ |
6 #define CC_RASTER_ONE_COPY_TILE_TASK_WORKER_POOL_H_ | 6 #define CC_RASTER_ONE_COPY_TILE_TASK_WORKER_POOL_H_ |
7 | 7 |
| 8 #include "base/memory/scoped_vector.h" |
8 #include "base/memory/weak_ptr.h" | 9 #include "base/memory/weak_ptr.h" |
9 #include "base/synchronization/lock.h" | 10 #include "base/synchronization/lock.h" |
10 #include "base/values.h" | 11 #include "base/values.h" |
11 #include "cc/base/scoped_ptr_deque.h" | 12 #include "cc/base/scoped_ptr_deque.h" |
12 #include "cc/output/context_provider.h" | 13 #include "cc/output/context_provider.h" |
13 #include "cc/raster/tile_task_runner.h" | 14 #include "cc/raster/tile_task_runner.h" |
14 #include "cc/raster/tile_task_worker_pool.h" | 15 #include "cc/raster/tile_task_worker_pool.h" |
15 #include "cc/resources/resource_provider.h" | 16 #include "cc/resources/resource_provider.h" |
16 | 17 |
17 namespace base { | 18 namespace base { |
18 namespace trace_event { | 19 namespace trace_event { |
19 class ConvertableToTraceFormat; | 20 class ConvertableToTraceFormat; |
20 class TracedValue; | 21 class TracedValue; |
21 } | 22 } |
22 } | 23 } |
23 | 24 |
| 25 namespace gpu { |
| 26 namespace gles2 { |
| 27 class GLES2Interface; |
| 28 } |
| 29 } |
| 30 |
24 namespace cc { | 31 namespace cc { |
25 class ResourcePool; | 32 class ResourcePool; |
26 class ScopedResource; | |
27 | |
28 typedef int64 CopySequenceNumber; | |
29 | 33 |
30 class CC_EXPORT OneCopyTileTaskWorkerPool : public TileTaskWorkerPool, | 34 class CC_EXPORT OneCopyTileTaskWorkerPool : public TileTaskWorkerPool, |
31 public TileTaskRunner, | 35 public TileTaskRunner, |
32 public TileTaskClient { | 36 public TileTaskClient { |
33 public: | 37 public: |
34 ~OneCopyTileTaskWorkerPool() override; | 38 ~OneCopyTileTaskWorkerPool() override; |
35 | 39 |
36 static scoped_ptr<TileTaskWorkerPool> Create( | 40 static scoped_ptr<TileTaskWorkerPool> Create( |
37 base::SequencedTaskRunner* task_runner, | 41 base::SequencedTaskRunner* task_runner, |
38 TaskGraphRunner* task_graph_runner, | 42 TaskGraphRunner* task_graph_runner, |
39 ContextProvider* context_provider, | 43 ContextProvider* context_provider, |
40 ResourceProvider* resource_provider, | 44 ResourceProvider* resource_provider, |
41 ResourcePool* resource_pool, | |
42 int max_copy_texture_chromium_size, | 45 int max_copy_texture_chromium_size, |
43 bool have_persistent_gpu_memory_buffers); | 46 bool use_persistent_gpu_memory_buffers, |
| 47 unsigned image_target); |
44 | 48 |
45 // Overridden from TileTaskWorkerPool: | 49 // Overridden from TileTaskWorkerPool: |
| 50 void ReleaseFreeMemory() override; |
46 TileTaskRunner* AsTileTaskRunner() override; | 51 TileTaskRunner* AsTileTaskRunner() override; |
47 | 52 |
48 // Overridden from TileTaskRunner: | 53 // Overridden from TileTaskRunner: |
49 void SetClient(TileTaskRunnerClient* client) override; | 54 void SetClient(TileTaskRunnerClient* client) override; |
50 void Shutdown() override; | 55 void Shutdown() override; |
51 void ScheduleTasks(TileTaskQueue* queue) override; | 56 void ScheduleTasks(TileTaskQueue* queue) override; |
52 void CheckForCompletedTasks() override; | 57 void CheckForCompletedTasks() override; |
53 ResourceFormat GetResourceFormat() const override; | 58 ResourceFormat GetResourceFormat() const override; |
54 bool GetResourceRequiresSwizzle() const override; | 59 bool GetResourceRequiresSwizzle() const override; |
55 | 60 |
56 // Overridden from TileTaskClient: | 61 // Overridden from TileTaskClient: |
57 scoped_ptr<RasterBuffer> AcquireBufferForRaster( | 62 scoped_ptr<RasterBuffer> AcquireBufferForRaster( |
58 const Resource* resource, | 63 const Resource* resource, |
59 uint64_t resource_content_id, | 64 uint64_t resource_content_id, |
60 uint64_t previous_content_id) override; | 65 uint64_t previous_content_id) override; |
61 void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override; | 66 void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override; |
62 | 67 |
63 // Playback raster source and schedule copy of |raster_resource| resource to | 68 // Playback raster source and schedule copy of |raster_resource| resource to |
64 // |output_resource|. Returns a non-zero sequence number for this copy | 69 // |output_resource|. Returns a non-zero sequence number for this copy |
65 // operation. | 70 // operation. |
66 CopySequenceNumber PlaybackAndScheduleCopyOnWorkerThread( | 71 void PlaybackAndScheduleCopyOnWorkerThread( |
67 bool reusing_raster_resource, | 72 const Resource* resource, |
68 scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> | 73 const ResourceProvider::ScopedWriteLockGL* resource_lock, |
69 raster_resource_write_lock, | |
70 const Resource* raster_resource, | |
71 const Resource* output_resource, | |
72 const RasterSource* raster_source, | 74 const RasterSource* raster_source, |
73 const gfx::Rect& raster_full_rect, | 75 const gfx::Rect& raster_full_rect, |
74 const gfx::Rect& raster_dirty_rect, | 76 const gfx::Rect& raster_dirty_rect, |
75 float scale); | 77 float scale, |
76 | 78 uint64_t resource_content_id, |
77 // Issues copy operations until |sequence| has been processed. This will | 79 uint64_t previous_content_id); |
78 // return immediately if |sequence| has already been processed. | |
79 void AdvanceLastIssuedCopyTo(CopySequenceNumber sequence); | |
80 | |
81 bool have_persistent_gpu_memory_buffers() const { | |
82 return have_persistent_gpu_memory_buffers_; | |
83 } | |
84 | 80 |
85 protected: | 81 protected: |
86 OneCopyTileTaskWorkerPool(base::SequencedTaskRunner* task_runner, | 82 OneCopyTileTaskWorkerPool(base::SequencedTaskRunner* task_runner, |
87 TaskGraphRunner* task_graph_runner, | 83 TaskGraphRunner* task_graph_runner, |
88 ContextProvider* context_provider, | |
89 ResourceProvider* resource_provider, | 84 ResourceProvider* resource_provider, |
90 ResourcePool* resource_pool, | |
91 int max_copy_texture_chromium_size, | 85 int max_copy_texture_chromium_size, |
92 bool have_persistent_gpu_memory_buffers); | 86 bool use_persistent_gpu_memory_buffers, |
| 87 unsigned image_target); |
93 | 88 |
94 private: | 89 private: |
95 struct CopyOperation { | 90 struct StagingBuffer { |
96 typedef ScopedPtrDeque<CopyOperation> Deque; | 91 StagingBuffer(scoped_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer, |
| 92 const gfx::Size& size); |
| 93 ~StagingBuffer(); |
97 | 94 |
98 CopyOperation(scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> | 95 void DestroyGLResources(gpu::gles2::GLES2Interface* gl); |
99 src_write_lock, | |
100 const Resource* src, | |
101 const Resource* dst, | |
102 const gfx::Rect& rect); | |
103 ~CopyOperation(); | |
104 | 96 |
105 scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> src_write_lock; | 97 scoped_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer; |
106 const Resource* src; | 98 const gfx::Size size; |
107 const Resource* dst; | 99 unsigned texture_id; |
108 const gfx::Rect rect; | 100 unsigned image_id; |
| 101 unsigned query_id; |
| 102 uint64_t content_id; |
| 103 unsigned sequence_id; |
109 }; | 104 }; |
110 | 105 |
111 void OnTaskSetFinished(TaskSet task_set); | 106 void OnTaskSetFinished(TaskSet task_set); |
112 void AdvanceLastFlushedCopyTo(CopySequenceNumber sequence); | |
113 void IssueCopyOperations(int64 count); | |
114 void ScheduleCheckForCompletedCopyOperationsWithLockAcquired( | |
115 bool wait_if_needed); | |
116 void CheckForCompletedCopyOperations(bool wait_if_needed); | |
117 scoped_refptr<base::trace_event::ConvertableToTraceFormat> StateAsValue() | 107 scoped_refptr<base::trace_event::ConvertableToTraceFormat> StateAsValue() |
118 const; | 108 const; |
119 void StagingStateAsValueInto( | 109 void StagingStateAsValueInto( |
120 base::trace_event::TracedValue* staging_state) const; | 110 base::trace_event::TracedValue* staging_state) const; |
121 | 111 |
122 scoped_refptr<base::SequencedTaskRunner> task_runner_; | 112 scoped_refptr<base::SequencedTaskRunner> task_runner_; |
123 TaskGraphRunner* task_graph_runner_; | 113 TaskGraphRunner* task_graph_runner_; |
124 const NamespaceToken namespace_token_; | 114 const NamespaceToken namespace_token_; |
125 TileTaskRunnerClient* client_; | 115 TileTaskRunnerClient* client_; |
126 ContextProvider* context_provider_; | 116 ResourceProvider* const resource_provider_; |
127 ResourceProvider* resource_provider_; | |
128 ResourcePool* resource_pool_; | |
129 const int max_bytes_per_copy_operation_; | 117 const int max_bytes_per_copy_operation_; |
130 const bool have_persistent_gpu_memory_buffers_; | 118 const bool use_persistent_gpu_memory_buffers_; |
| 119 const unsigned image_target_; |
131 TaskSetCollection tasks_pending_; | 120 TaskSetCollection tasks_pending_; |
132 scoped_refptr<TileTask> task_set_finished_tasks_[kNumberOfTaskSets]; | 121 scoped_refptr<TileTask> task_set_finished_tasks_[kNumberOfTaskSets]; |
133 CopySequenceNumber last_issued_copy_operation_; | |
134 CopySequenceNumber last_flushed_copy_operation_; | |
135 | 122 |
136 // Task graph used when scheduling tasks and vector used to gather | 123 // Task graph used when scheduling tasks and vector used to gather |
137 // completed tasks. | 124 // completed tasks. |
138 TaskGraph graph_; | 125 TaskGraph graph_; |
139 Task::Vector completed_tasks_; | 126 Task::Vector completed_tasks_; |
140 | 127 |
141 base::Lock lock_; | 128 mutable base::Lock lock_; |
142 // |lock_| must be acquired when accessing the following members. | 129 // |lock_| must be acquired when accessing the following members. |
143 base::ConditionVariable copy_operation_count_cv_; | 130 using StagingBufferVector = ScopedVector<StagingBuffer>; |
| 131 StagingBufferVector free_buffers_; |
| 132 using StagingBufferDeque = ScopedPtrDeque<StagingBuffer>; |
| 133 StagingBufferDeque busy_buffers_; |
| 134 unsigned next_sequence_id_; |
144 int bytes_scheduled_since_last_flush_; | 135 int bytes_scheduled_since_last_flush_; |
145 size_t issued_copy_operation_count_; | |
146 CopyOperation::Deque pending_copy_operations_; | |
147 CopySequenceNumber next_copy_operation_sequence_; | |
148 bool check_for_completed_copy_operations_pending_; | |
149 base::TimeTicks last_check_for_completed_copy_operations_time_; | |
150 bool shutdown_; | |
151 | 136 |
152 base::WeakPtrFactory<OneCopyTileTaskWorkerPool> weak_ptr_factory_; | 137 base::WeakPtrFactory<OneCopyTileTaskWorkerPool> weak_ptr_factory_; |
153 // "raster finished" tasks need their own factory as they need to be | 138 // "raster finished" tasks need their own factory as they need to be |
154 // canceled when ScheduleTasks() is called. | 139 // canceled when ScheduleTasks() is called. |
155 base::WeakPtrFactory<OneCopyTileTaskWorkerPool> | 140 base::WeakPtrFactory<OneCopyTileTaskWorkerPool> |
156 task_set_finished_weak_ptr_factory_; | 141 task_set_finished_weak_ptr_factory_; |
157 | 142 |
158 DISALLOW_COPY_AND_ASSIGN(OneCopyTileTaskWorkerPool); | 143 DISALLOW_COPY_AND_ASSIGN(OneCopyTileTaskWorkerPool); |
159 }; | 144 }; |
160 | 145 |
161 } // namespace cc | 146 } // namespace cc |
162 | 147 |
163 #endif // CC_RASTER_ONE_COPY_TILE_TASK_WORKER_POOL_H_ | 148 #endif // CC_RASTER_ONE_COPY_TILE_TASK_WORKER_POOL_H_ |
OLD | NEW |