cc/resources/tile_manager.h

   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
   3 // found in the LICENSE file.
   4
   5 #ifndef CC_RESOURCES_TILE_MANAGER_H_
   6 #define CC_RESOURCES_TILE_MANAGER_H_
   7
   8 #include <deque>
   9 #include <queue>
  10 #include <set>
  11 #include <utility>
  12 #include <vector>
  13
  14 #include "base/containers/hash_tables.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/values.h"
  17 #include "cc/base/ref_counted_managed.h"
  18 #include "cc/base/unique_notifier.h"
  19 #include "cc/debug/rendering_stats_instrumentation.h"
  20 #include "cc/layers/picture_layer_impl.h"
  21 #include "cc/resources/managed_tile_state.h"
  22 #include "cc/resources/memory_history.h"
  23 #include "cc/resources/picture_pile_impl.h"
  24 #include "cc/resources/prioritized_tile_set.h"
  25 #include "cc/resources/rasterizer.h"
  26 #include "cc/resources/resource_pool.h"
  27 #include "cc/resources/tile.h"
  28
  29 namespace cc {
  30 class ResourceProvider;
  31
  32 class CC_EXPORT TileManagerClient {
  33  public:
  34   // Called when all tiles marked as required for activation are ready to draw.
  35   virtual void NotifyReadyToActivate() = 0;
  36
  37   // Called when the visible representation of a tile might have changed. Some
  38   // examples are:
  39   // - Tile version initialized.
  40   // - Tile resources freed.
  41   // - Tile marked for on-demand raster.
  42   virtual void NotifyTileStateChanged(const Tile* tile) = 0;
  43
  44  protected:
  45   virtual ~TileManagerClient() {}
  46 };
  47
  48 struct RasterTaskCompletionStats {
  49   RasterTaskCompletionStats();
  50
  51   size_t completed_count;
  52   size_t canceled_count;
  53 };
  54 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
  55     const RasterTaskCompletionStats& stats);
  56
  57 // This class manages tiles, deciding which should get rasterized and which
  58 // should no longer have any memory assigned to them. Tile objects are "owned"
  59 // by layers; they automatically register with the manager when they are
  60 // created, and unregister from the manager when they are deleted.
  61 class CC_EXPORT TileManager : public RasterizerClient,
  62                               public RefCountedManager<Tile> {
  63  public:
  64   struct CC_EXPORT PairedPictureLayer {
  65     PairedPictureLayer();
  66     ~PairedPictureLayer();
  67
  68     PictureLayerImpl* active_layer;
  69     PictureLayerImpl* pending_layer;
  70   };
  71
  72   class CC_EXPORT RasterTileIterator {
  73    public:
  74     RasterTileIterator(TileManager* tile_manager, TreePriority tree_priority);
  75     ~RasterTileIterator();
  76
  77     RasterTileIterator& operator++();
  78     operator bool() const;
  79     Tile* operator*();
  80
  81    private:
  82     struct PairedPictureLayerIterator {
  83       PairedPictureLayerIterator();
  84       ~PairedPictureLayerIterator();
  85
  86       Tile* PeekTile(TreePriority tree_priority);
  87       void PopTile(TreePriority tree_priority);
  88
  89       std::pair<PictureLayerImpl::LayerRasterTileIterator*, WhichTree>
  90           NextTileIterator(TreePriority tree_priority);
  91
  92       PictureLayerImpl::LayerRasterTileIterator active_iterator;
  93       PictureLayerImpl::LayerRasterTileIterator pending_iterator;
  94
  95       std::vector<Tile*> returned_shared_tiles;
  96     };
  97
  98     class RasterOrderComparator {
  99      public:
 100       explicit RasterOrderComparator(TreePriority tree_priority);
 101
 102       bool operator()(PairedPictureLayerIterator* a,
 103                       PairedPictureLayerIterator* b) const;
 104
 105      private:
 106       TreePriority tree_priority_;
 107     };
 108
 109     std::vector<PairedPictureLayerIterator> paired_iterators_;
 110     std::vector<PairedPictureLayerIterator*> iterator_heap_;
 111     TreePriority tree_priority_;
 112     RasterOrderComparator comparator_;
 113
 114     DISALLOW_COPY_AND_ASSIGN(RasterTileIterator);
 115   };
 116
 117   struct CC_EXPORT EvictionTileIterator {
 118    public:
 119     EvictionTileIterator();
 120     EvictionTileIterator(TileManager* tile_manager, TreePriority tree_priority);
 121     ~EvictionTileIterator();
 122
 123     EvictionTileIterator& operator++();
 124     operator bool() const;
 125     Tile* operator*();
 126
 127    private:
 128     struct PairedPictureLayerIterator {
 129       PairedPictureLayerIterator();
 130       ~PairedPictureLayerIterator();
 131
 132       Tile* PeekTile(TreePriority tree_priority);
 133       void PopTile(TreePriority tree_priority);
 134
 135       PictureLayerImpl::LayerEvictionTileIterator* NextTileIterator(
 136           TreePriority tree_priority);
 137
 138       PictureLayerImpl::LayerEvictionTileIterator active_iterator;
 139       PictureLayerImpl::LayerEvictionTileIterator pending_iterator;
 140
 141       std::vector<Tile*> returned_shared_tiles;
 142     };
 143
 144     class EvictionOrderComparator {
 145      public:
 146       explicit EvictionOrderComparator(TreePriority tree_priority);
 147
 148       bool operator()(PairedPictureLayerIterator* a,
 149                       PairedPictureLayerIterator* b) const;
 150
 151      private:
 152       TreePriority tree_priority_;
 153     };
 154
 155     std::vector<PairedPictureLayerIterator> paired_iterators_;
 156     std::vector<PairedPictureLayerIterator*> iterator_heap_;
 157     TreePriority tree_priority_;
 158     EvictionOrderComparator comparator_;
 159
 160     DISALLOW_COPY_AND_ASSIGN(EvictionTileIterator);
 161   };
 162
 163   static scoped_ptr<TileManager> Create(
 164       TileManagerClient* client,
 165       base::SequencedTaskRunner* task_runner,
 166       ResourcePool* resource_pool,
 167       Rasterizer* rasterizer,
 168       RenderingStatsInstrumentation* rendering_stats_instrumentation);
 169   virtual ~TileManager();
 170
 171   void ManageTiles(const GlobalStateThatImpactsTilePriority& state);
 172
 173   // Returns true when visible tiles have been initialized.
 174   bool UpdateVisibleTiles();
 175
 176   scoped_refptr<Tile> CreateTile(PicturePileImpl* picture_pile,
 177                                  const gfx::Size& tile_size,
 178                                  const gfx::Rect& content_rect,
 179                                  const gfx::Rect& opaque_rect,
 180                                  float contents_scale,
 181                                  int layer_id,
 182                                  int source_frame_number,
 183                                  int flags);
 184
 185   void RegisterPictureLayerImpl(PictureLayerImpl* layer);
 186   void UnregisterPictureLayerImpl(PictureLayerImpl* layer);
 187
 188   scoped_ptr<base::Value> BasicStateAsValue() const;
 189   scoped_ptr<base::Value> AllTilesAsValue() const;
 190   void GetMemoryStats(size_t* memory_required_bytes,
 191                       size_t* memory_nice_to_have_bytes,
 192                       size_t* memory_allocated_bytes,
 193                       size_t* memory_used_bytes) const;
 194
 195   const MemoryHistory::Entry& memory_stats_from_last_assign() const {
 196     return memory_stats_from_last_assign_;
 197   }
 198
 199   void GetPairedPictureLayers(std::vector<PairedPictureLayer>* layers) const;
 200
 201   void InitializeTilesWithResourcesForTesting(const std::vector<Tile*>& tiles) {
 202     for (size_t i = 0; i < tiles.size(); ++i) {
 203       ManagedTileState& mts = tiles[i]->managed_state();
 204       ManagedTileState::TileVersion& tile_version =
 205           mts.tile_versions[HIGH_QUALITY_NO_LCD_RASTER_MODE];
 206
 207       tile_version.resource_ = resource_pool_->AcquireResource(gfx::Size(1, 1));
 208
 209       bytes_releasable_ += BytesConsumedIfAllocated(tiles[i]);
 210       ++resources_releasable_;
 211     }
 212   }
 213
 214   void ReleaseTileResourcesForTesting(const std::vector<Tile*>& tiles) {
 215     for (size_t i = 0; i < tiles.size(); ++i) {
 216       Tile* tile = tiles[i];
 217       for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
 218         FreeResourceForTile(tile, static_cast<RasterMode>(mode));
 219       }
 220     }
 221   }
 222
 223   void SetGlobalStateForTesting(
 224       const GlobalStateThatImpactsTilePriority& state) {
 225     // Soft limit is used for resource pool such that
 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   }
 232
 233   void SetRasterizerForTesting(Rasterizer* rasterizer);
 234
 235   void CleanUpReleasedTilesForTesting() { CleanUpReleasedTiles(); }
 236
 237  protected:
 238   TileManager(TileManagerClient* client,
 239               base::SequencedTaskRunner* task_runner,
 240               ResourcePool* resource_pool,
 241               Rasterizer* rasterizer,
 242               RenderingStatsInstrumentation* rendering_stats_instrumentation);
 243
 244   // Methods called by Tile
 245   friend class Tile;
 246   void DidChangeTilePriority(Tile* tile);
 247
 248   void CleanUpReleasedTiles();
 249
 250   // Overriden from RefCountedManager<Tile>:
 251   virtual void Release(Tile* tile) OVERRIDE;
 252
 253   // Overriden from RasterizerClient:
 254   virtual bool ShouldForceTasksRequiredForActivationToComplete() const OVERRIDE;
 255   virtual void DidFinishRunningTasks() OVERRIDE;
 256   virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE;
 257
 258   typedef std::vector<Tile*> TileVector;
 259   typedef std::set<Tile*> TileSet;
 260
 261   // Virtual for test
 262   virtual void ScheduleTasks(
 263       const TileVector& tiles_that_need_to_be_rasterized);
 264
 265   void AssignGpuMemoryToTiles(PrioritizedTileSet* tiles,
 266                               TileVector* tiles_that_need_to_be_rasterized);
 267   void GetTilesWithAssignedBins(PrioritizedTileSet* tiles);
 268
 269  private:
 270   void OnImageDecodeTaskCompleted(int layer_id,
 271                                   SkPixelRef* pixel_ref,
 272                                   bool was_canceled);
 273   void OnRasterTaskCompleted(Tile::Id tile,
 274                              scoped_ptr<ScopedResource> resource,
 275                              RasterMode raster_mode,
 276                              const PicturePileImpl::Analysis& analysis,
 277                              bool was_canceled);
 278
 279   inline size_t BytesConsumedIfAllocated(const Tile* tile) const {
 280     return Resource::MemorySizeBytes(tile->size(),
 281                                      resource_pool_->resource_format());
 282   }
 283
 284   void FreeResourceForTile(Tile* tile, RasterMode mode);
 285   void FreeResourcesForTile(Tile* tile);
 286   void FreeUnusedResourcesForTile(Tile* tile);
 287   void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile);
 288   scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile,
 289                                                        SkPixelRef* pixel_ref);
 290   scoped_refptr<RasterTask> CreateRasterTask(Tile* tile);
 291   scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const;
 292   void UpdatePrioritizedTileSetIfNeeded();
 293   void CleanUpLayers();
 294
 295   bool IsReadyToActivate() const;
 296   void CheckIfReadyToActivate();
 297
 298   TileManagerClient* client_;
 299   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 300   ResourcePool* resource_pool_;
 301   Rasterizer* rasterizer_;
 302   GlobalStateThatImpactsTilePriority global_state_;
 303
 304   typedef base::hash_map<Tile::Id, Tile*> TileMap;
 305   TileMap tiles_;
 306
 307   PrioritizedTileSet prioritized_tiles_;
 308   bool prioritized_tiles_dirty_;
 309
 310   bool all_tiles_that_need_to_be_rasterized_have_memory_;
 311   bool all_tiles_required_for_activation_have_memory_;
 312
 313   size_t memory_required_bytes_;
 314   size_t memory_nice_to_have_bytes_;
 315
 316   size_t bytes_releasable_;
 317   size_t resources_releasable_;
 318
 319   bool ever_exceeded_memory_budget_;
 320   MemoryHistory::Entry memory_stats_from_last_assign_;
 321
 322   RenderingStatsInstrumentation* rendering_stats_instrumentation_;
 323
 324   bool did_initialize_visible_tile_;
 325   bool did_check_for_completed_tasks_since_last_schedule_tasks_;
 326
 327   typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask> >
 328       PixelRefTaskMap;
 329   typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
 330   LayerPixelRefTaskMap image_decode_tasks_;
 331
 332   typedef base::hash_map<int, int> LayerCountMap;
 333   LayerCountMap used_layer_counts_;
 334
 335   RasterTaskCompletionStats update_visible_tiles_stats_;
 336
 337   std::vector<Tile*> released_tiles_;
 338
 339   ResourceFormat resource_format_;
 340
 341   // Queue used when scheduling raster tasks.
 342   RasterTaskQueue raster_queue_;
 343
 344   std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_;
 345
 346   std::vector<PictureLayerImpl*> layers_;
 347
 348   UniqueNotifier ready_to_activate_check_notifier_;
 349
 350   DISALLOW_COPY_AND_ASSIGN(TileManager);
 351 };
 352
 353 }  // namespace cc
 354
 355 #endif  // CC_RESOURCES_TILE_MANAGER_H_