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