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