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