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