OLD | NEW |
---|---|
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 1 // Copyright 2012 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_RESOURCES_TILE_MANAGER_H_ | 5 #ifndef CC_RESOURCES_TILE_MANAGER_H_ |
6 #define CC_RESOURCES_TILE_MANAGER_H_ | 6 #define CC_RESOURCES_TILE_MANAGER_H_ |
7 | 7 |
8 #include <deque> | 8 #include <deque> |
9 #include <queue> | 9 #include <queue> |
10 #include <set> | 10 #include <set> |
11 #include <utility> | 11 #include <utility> |
12 #include <vector> | 12 #include <vector> |
13 | 13 |
14 #include "base/containers/hash_tables.h" | 14 #include "base/containers/hash_tables.h" |
15 #include "base/memory/scoped_ptr.h" | 15 #include "base/memory/scoped_ptr.h" |
16 #include "base/values.h" | 16 #include "base/values.h" |
17 #include "cc/base/ref_counted_managed.h" | 17 #include "cc/base/ref_counted_managed.h" |
18 #include "cc/base/unique_notifier.h" | 18 #include "cc/base/unique_notifier.h" |
19 #include "cc/debug/rendering_stats_instrumentation.h" | 19 #include "cc/debug/rendering_stats_instrumentation.h" |
20 #include "cc/layers/picture_layer_impl.h" | 20 #include "cc/layers/picture_layer_impl.h" |
21 #include "cc/resources/managed_tile_state.h" | 21 #include "cc/resources/managed_tile_state.h" |
22 #include "cc/resources/memory_history.h" | 22 #include "cc/resources/memory_history.h" |
23 #include "cc/resources/picture_pile_impl.h" | 23 #include "cc/resources/picture_pile_impl.h" |
24 #include "cc/resources/prioritized_tile_set.h" | |
25 #include "cc/resources/rasterizer.h" | 24 #include "cc/resources/rasterizer.h" |
26 #include "cc/resources/resource_pool.h" | 25 #include "cc/resources/resource_pool.h" |
27 #include "cc/resources/tile.h" | 26 #include "cc/resources/tile.h" |
28 | 27 |
29 namespace cc { | 28 namespace cc { |
30 class ResourceProvider; | 29 class ResourceProvider; |
31 | 30 |
32 class CC_EXPORT TileManagerClient { | 31 class CC_EXPORT TileManagerClient { |
33 public: | 32 public: |
34 // Returns the set of layers that the tile manager should consider for raster. | 33 // Returns the set of layers that the tile manager should consider for raster. |
(...skipping 180 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
215 for (size_t i = 0; i < tiles.size(); ++i) { | 214 for (size_t i = 0; i < tiles.size(); ++i) { |
216 Tile* tile = tiles[i]; | 215 Tile* tile = tiles[i]; |
217 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { | 216 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { |
218 FreeResourceForTile(tile, static_cast<RasterMode>(mode)); | 217 FreeResourceForTile(tile, static_cast<RasterMode>(mode)); |
219 } | 218 } |
220 } | 219 } |
221 } | 220 } |
222 | 221 |
223 void SetGlobalStateForTesting( | 222 void SetGlobalStateForTesting( |
224 const GlobalStateThatImpactsTilePriority& state) { | 223 const GlobalStateThatImpactsTilePriority& state) { |
225 // Soft limit is used for resource pool such that | 224 global_state_ = state; |
226 // memory returns to soft limit after going over. | |
227 if (state != global_state_) { | |
228 global_state_ = state; | |
229 prioritized_tiles_dirty_ = true; | |
230 } | |
231 } | 225 } |
232 | 226 |
233 void SetRasterizerForTesting(Rasterizer* rasterizer); | 227 void SetRasterizerForTesting(Rasterizer* rasterizer); |
234 | 228 |
235 void CleanUpReleasedTilesForTesting() { CleanUpReleasedTiles(); } | 229 void CleanUpReleasedTilesForTesting() { CleanUpReleasedTiles(); } |
236 | 230 |
237 protected: | 231 protected: |
238 TileManager(TileManagerClient* client, | 232 TileManager(TileManagerClient* client, |
239 base::SequencedTaskRunner* task_runner, | 233 base::SequencedTaskRunner* task_runner, |
240 ResourcePool* resource_pool, | 234 ResourcePool* resource_pool, |
241 Rasterizer* rasterizer, | 235 Rasterizer* rasterizer, |
242 RenderingStatsInstrumentation* rendering_stats_instrumentation); | 236 RenderingStatsInstrumentation* rendering_stats_instrumentation); |
243 | 237 |
244 // Methods called by Tile | |
245 friend class Tile; | |
246 void DidChangeTilePriority(Tile* tile); | |
247 | |
248 void CleanUpReleasedTiles(); | 238 void CleanUpReleasedTiles(); |
249 | 239 |
250 // Overriden from RefCountedManager<Tile>: | 240 // Overriden from RefCountedManager<Tile>: |
241 friend class Tile; | |
251 virtual void Release(Tile* tile) OVERRIDE; | 242 virtual void Release(Tile* tile) OVERRIDE; |
252 | 243 |
253 // Overriden from RasterizerClient: | 244 // Overriden from RasterizerClient: |
254 virtual bool ShouldForceTasksRequiredForActivationToComplete() const OVERRIDE; | 245 virtual bool ShouldForceTasksRequiredForActivationToComplete() const OVERRIDE; |
255 virtual void DidFinishRunningTasks() OVERRIDE; | 246 virtual void DidFinishRunningTasks() OVERRIDE; |
256 virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE; | 247 virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE; |
257 | 248 |
258 typedef std::vector<Tile*> TileVector; | 249 typedef std::vector<Tile*> TileVector; |
259 typedef std::set<Tile*> TileSet; | 250 typedef std::set<Tile*> TileSet; |
260 | 251 |
261 // Virtual for test | 252 // Virtual for test |
262 virtual void ScheduleTasks( | 253 virtual void ScheduleTasks( |
263 const TileVector& tiles_that_need_to_be_rasterized); | 254 const TileVector& tiles_that_need_to_be_rasterized); |
264 | 255 |
265 void AssignGpuMemoryToTiles(PrioritizedTileSet* tiles, | 256 void AssignGpuMemoryToTiles(TileVector* tiles_that_need_to_be_rasterized); |
266 TileVector* tiles_that_need_to_be_rasterized); | |
267 void GetTilesWithAssignedBins(PrioritizedTileSet* tiles); | |
268 | 257 |
269 private: | 258 private: |
259 class MemoryUsage { | |
260 public: | |
261 MemoryUsage(); | |
262 MemoryUsage(int64 memory_bytes, int resource_count); | |
263 | |
264 static MemoryUsage FromConfig(const gfx::Size& size, ResourceFormat format); | |
265 static MemoryUsage FromTile(const Tile* tile); | |
266 | |
267 MemoryUsage& operator+=(const MemoryUsage& other); | |
268 MemoryUsage& operator-=(const MemoryUsage& other); | |
269 MemoryUsage operator-(const MemoryUsage& other); | |
270 | |
271 bool Exceeds(const MemoryUsage& limit) const; | |
272 | |
273 int64 memory_bytes() const { return memory_bytes_; } | |
274 | |
275 private: | |
276 int64 memory_bytes_; | |
277 int resource_count_; | |
278 }; | |
279 | |
270 void OnImageDecodeTaskCompleted(int layer_id, | 280 void OnImageDecodeTaskCompleted(int layer_id, |
271 SkPixelRef* pixel_ref, | 281 SkPixelRef* pixel_ref, |
272 bool was_canceled); | 282 bool was_canceled); |
273 void OnRasterTaskCompleted(Tile::Id tile, | 283 void OnRasterTaskCompleted(Tile::Id tile, |
274 scoped_ptr<ScopedResource> resource, | 284 scoped_ptr<ScopedResource> resource, |
275 RasterMode raster_mode, | 285 RasterMode raster_mode, |
276 const PicturePileImpl::Analysis& analysis, | 286 const PicturePileImpl::Analysis& analysis, |
277 bool was_canceled); | 287 bool was_canceled); |
278 | 288 |
279 inline size_t BytesConsumedIfAllocated(const Tile* tile) const { | 289 inline size_t BytesConsumedIfAllocated(const Tile* tile) const { |
reveman
2014/06/17 19:30:07
Current usage of this function that can't simply b
vmpstr
2014/06/17 21:34:06
Done.
| |
280 return Resource::MemorySizeBytes(tile->size(), | 290 return Resource::MemorySizeBytes(tile->size(), |
281 resource_pool_->resource_format()); | 291 resource_pool_->resource_format()); |
282 } | 292 } |
283 | 293 |
284 void FreeResourceForTile(Tile* tile, RasterMode mode); | 294 void FreeResourceForTile(Tile* tile, RasterMode mode); |
285 void FreeResourcesForTile(Tile* tile); | 295 void FreeResourcesForTile(Tile* tile); |
286 void FreeUnusedResourcesForTile(Tile* tile); | 296 void FreeUnusedResourcesForTile(Tile* tile); |
287 void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile); | 297 void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile); |
288 scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile, | 298 scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile, |
289 SkPixelRef* pixel_ref); | 299 SkPixelRef* pixel_ref); |
290 scoped_refptr<RasterTask> CreateRasterTask(Tile* tile); | 300 scoped_refptr<RasterTask> CreateRasterTask(Tile* tile); |
291 scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const; | 301 scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const; |
292 void UpdatePrioritizedTileSetIfNeeded(); | |
293 | 302 |
303 bool FreeTileResourcesUntilUsageIsWithinLimit( | |
304 EvictionTileIterator* eviction_iterator, | |
reveman
2014/06/17 19:30:07
nit: s/eviction_iterator/iterator/
vmpstr
2014/06/17 21:34:06
Done.
| |
305 const MemoryUsage& limit, | |
306 MemoryUsage* usage); | |
307 bool FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit( | |
308 EvictionTileIterator* eviction_iterator, | |
reveman
2014/06/17 19:30:07
nit: s/eviction_iterator/iterator/
vmpstr
2014/06/17 21:34:06
Done.
| |
309 const MemoryUsage& limit, | |
310 const TilePriority& max_priority, | |
311 MemoryUsage* usage); | |
312 bool TilePriorityViolatesMemoryPolicy(const TilePriority& priority); | |
294 bool IsReadyToActivate() const; | 313 bool IsReadyToActivate() const; |
295 void CheckIfReadyToActivate(); | 314 void CheckIfReadyToActivate(); |
296 | 315 |
297 TileManagerClient* client_; | 316 TileManagerClient* client_; |
298 scoped_refptr<base::SequencedTaskRunner> task_runner_; | 317 scoped_refptr<base::SequencedTaskRunner> task_runner_; |
299 ResourcePool* resource_pool_; | 318 ResourcePool* resource_pool_; |
300 Rasterizer* rasterizer_; | 319 Rasterizer* rasterizer_; |
301 GlobalStateThatImpactsTilePriority global_state_; | 320 GlobalStateThatImpactsTilePriority global_state_; |
302 | 321 |
303 typedef base::hash_map<Tile::Id, Tile*> TileMap; | 322 typedef base::hash_map<Tile::Id, Tile*> TileMap; |
304 TileMap tiles_; | 323 TileMap tiles_; |
305 | 324 |
306 PrioritizedTileSet prioritized_tiles_; | |
307 bool prioritized_tiles_dirty_; | |
308 | |
309 bool all_tiles_that_need_to_be_rasterized_have_memory_; | 325 bool all_tiles_that_need_to_be_rasterized_have_memory_; |
310 bool all_tiles_required_for_activation_have_memory_; | 326 bool all_tiles_required_for_activation_have_memory_; |
311 | 327 |
312 size_t memory_required_bytes_; | |
313 size_t memory_nice_to_have_bytes_; | |
314 | |
315 size_t bytes_releasable_; | 328 size_t bytes_releasable_; |
316 size_t resources_releasable_; | 329 size_t resources_releasable_; |
reveman
2014/06/17 19:30:07
Do we still need these? bytes/resources_releasable
vmpstr
2014/06/17 21:34:06
It's mostly used in DCHECKs as well as memory_stat
reveman
2014/06/17 22:26:07
As with computing bytes_required_but_not_allocated
| |
330 size_t bytes_required_but_not_allocated_; | |
317 | 331 |
318 bool ever_exceeded_memory_budget_; | 332 bool ever_exceeded_memory_budget_; |
319 MemoryHistory::Entry memory_stats_from_last_assign_; | 333 MemoryHistory::Entry memory_stats_from_last_assign_; |
320 | 334 |
321 RenderingStatsInstrumentation* rendering_stats_instrumentation_; | 335 RenderingStatsInstrumentation* rendering_stats_instrumentation_; |
322 | 336 |
323 bool did_initialize_visible_tile_; | 337 bool did_initialize_visible_tile_; |
324 bool did_check_for_completed_tasks_since_last_schedule_tasks_; | 338 bool did_check_for_completed_tasks_since_last_schedule_tasks_; |
325 | 339 |
326 typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask> > | 340 typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask> > |
(...skipping 16 matching lines...) Expand all Loading... | |
343 std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_; | 357 std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_; |
344 | 358 |
345 UniqueNotifier ready_to_activate_check_notifier_; | 359 UniqueNotifier ready_to_activate_check_notifier_; |
346 | 360 |
347 DISALLOW_COPY_AND_ASSIGN(TileManager); | 361 DISALLOW_COPY_AND_ASSIGN(TileManager); |
348 }; | 362 }; |
349 | 363 |
350 } // namespace cc | 364 } // namespace cc |
351 | 365 |
352 #endif // CC_RESOURCES_TILE_MANAGER_H_ | 366 #endif // CC_RESOURCES_TILE_MANAGER_H_ |
OLD | NEW |