cc/tiles/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_TILES_TILE_MANAGER_H_
   6 #define CC_TILES_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/unique_notifier.h"
  18 #include "cc/playback/raster_source.h"
  19 #include "cc/raster/tile_task_runner.h"
  20 #include "cc/resources/memory_history.h"
  21 #include "cc/resources/resource_pool.h"
  22 #include "cc/tiles/eviction_tile_priority_queue.h"
  23 #include "cc/tiles/raster_tile_priority_queue.h"
  24 #include "cc/tiles/tile.h"
  25 #include "cc/tiles/tile_draw_info.h"
  26
  27 namespace base {
  28 namespace trace_event {
  29 class ConvertableToTraceFormat;
  30 class TracedValue;
  31 }
  32 }
  33
  34 namespace cc {
  35 class PictureLayerImpl;
  36 class ResourceProvider;
  37
  38 class CC_EXPORT TileManagerClient {
  39  public:
  40   // Called when all tiles marked as required for activation are ready to draw.
  41   virtual void NotifyReadyToActivate() = 0;
  42
  43   // Called when all tiles marked as required for draw are ready to draw.
  44   virtual void NotifyReadyToDraw() = 0;
  45
  46   // Called when all tile tasks started by the most recent call to PrepareTiles
  47   // are completed.
  48   virtual void NotifyAllTileTasksCompleted() = 0;
  49
  50   // Called when the visible representation of a tile might have changed. Some
  51   // examples are:
  52   // - Tile version initialized.
  53   // - Tile resources freed.
  54   // - Tile marked for on-demand raster.
  55   virtual void NotifyTileStateChanged(const Tile* tile) = 0;
  56
  57   // Given an empty raster tile priority queue, this will build a priority queue
  58   // that will return tiles in order in which they should be rasterized.
  59   // Note if the queue was previous built, Reset must be called on it.
  60   virtual scoped_ptr<RasterTilePriorityQueue> BuildRasterQueue(
  61       TreePriority tree_priority,
  62       RasterTilePriorityQueue::Type type) = 0;
  63
  64   // Given an empty eviction tile priority queue, this will build a priority
  65   // queue that will return tiles in order in which they should be evicted.
  66   // Note if the queue was previous built, Reset must be called on it.
  67   virtual scoped_ptr<EvictionTilePriorityQueue> BuildEvictionQueue(
  68       TreePriority tree_priority) = 0;
  69
  70   // Informs the client that due to the currently rasterizing (or scheduled to
  71   // be rasterized) tiles, we will be in a position that will likely require a
  72   // draw. This can be used to preemptively start a frame.
  73   virtual void SetIsLikelyToRequireADraw(bool is_likely_to_require_a_draw) = 0;
  74
  75  protected:
  76   virtual ~TileManagerClient() {}
  77 };
  78
  79 struct RasterTaskCompletionStats {
  80   RasterTaskCompletionStats();
  81
  82   size_t completed_count;
  83   size_t canceled_count;
  84 };
  85 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
  86 RasterTaskCompletionStatsAsValue(const RasterTaskCompletionStats& stats);
  87
  88 // This class manages tiles, deciding which should get rasterized and which
  89 // should no longer have any memory assigned to them. Tile objects are "owned"
  90 // by layers; they automatically register with the manager when they are
  91 // created, and unregister from the manager when they are deleted.
  92 class CC_EXPORT TileManager : public TileTaskRunnerClient {
  93  public:
  94   enum NamedTaskSet {
  95     REQUIRED_FOR_ACTIVATION,
  96     REQUIRED_FOR_DRAW,
  97     // PixelBufferTileTaskWorkerPool depends on ALL being last.
  98     ALL
  99     // Adding additional values requires increasing kNumberOfTaskSets in
 100     // tile_task_runner.h
 101   };
 102
 103   static_assert(NamedTaskSet::ALL == (kNumberOfTaskSets - 1),
 104                 "NamedTaskSet::ALL should be equal to kNumberOfTaskSets"
 105                 "minus 1");
 106
 107   static scoped_ptr<TileManager> Create(TileManagerClient* client,
 108                                         base::SequencedTaskRunner* task_runner,
 109                                         size_t scheduled_raster_task_limit);
 110   ~TileManager() override;
 111
 112   // Assigns tile memory and schedules work to prepare tiles for drawing.
 113   // - Runs client_->NotifyReadyToActivate() when all tiles required for
 114   // activation are prepared, or failed to prepare due to OOM.
 115   // - Runs client_->NotifyReadyToDraw() when all tiles required draw are
 116   // prepared, or failed to prepare due to OOM.
 117   bool PrepareTiles(const GlobalStateThatImpactsTilePriority& state);
 118
 119   // Synchronously finish any in progress work, cancel the rest, and clean up as
 120   // much resources as possible. Also, prevents any future work until a
 121   // SetResources call.
 122   void FinishTasksAndCleanUp();
 123
 124   // Set the new given resource pool and tile task runner. Note that
 125   // FinishTasksAndCleanUp must be called in between consecutive calls to
 126   // SetResources.
 127   void SetResources(ResourcePool* resource_pool,
 128                     TileTaskRunner* tile_task_runner,
 129                     size_t scheduled_raster_task_limit);
 130
 131   // This causes any completed raster work to finalize, so that tiles get up to
 132   // date draw information.
 133   void Flush();
 134
 135   ScopedTilePtr CreateTile(const gfx::Size& desired_texture_size,
 136                            const gfx::Rect& content_rect,
 137                            float contents_scale,
 138                            int layer_id,
 139                            int source_frame_number,
 140                            int flags);
 141
 142   bool IsReadyToActivate() const;
 143   bool IsReadyToDraw() const;
 144
 145   scoped_refptr<base::trace_event::ConvertableToTraceFormat> BasicStateAsValue()
 146       const;
 147   void BasicStateAsValueInto(base::trace_event::TracedValue* dict) const;
 148   const MemoryHistory::Entry& memory_stats_from_last_assign() const {
 149     return memory_stats_from_last_assign_;
 150   }
 151
 152   // Public methods for testing.
 153   void InitializeTilesWithResourcesForTesting(const std::vector<Tile*>& tiles) {
 154     for (size_t i = 0; i < tiles.size(); ++i) {
 155       TileDrawInfo& draw_info = tiles[i]->draw_info();
 156       draw_info.resource_ = resource_pool_->AcquireResource(
 157           tiles[i]->desired_texture_size(),
 158           tile_task_runner_->GetResourceFormat());
 159     }
 160   }
 161
 162   void ReleaseTileResourcesForTesting(const std::vector<Tile*>& tiles) {
 163     for (size_t i = 0; i < tiles.size(); ++i) {
 164       Tile* tile = tiles[i];
 165       FreeResourcesForTile(tile);
 166     }
 167   }
 168
 169   void SetGlobalStateForTesting(
 170       const GlobalStateThatImpactsTilePriority& state) {
 171     global_state_ = state;
 172   }
 173
 174   void SetTileTaskRunnerForTesting(TileTaskRunner* tile_task_runner);
 175
 176   void FreeResourcesAndCleanUpReleasedTilesForTesting() {
 177     FreeResourcesForReleasedTiles();
 178     CleanUpReleasedTiles();
 179   }
 180
 181   std::vector<Tile*> AllTilesForTesting() const {
 182     std::vector<Tile*> tiles;
 183     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end();
 184          ++it) {
 185       tiles.push_back(it->second);
 186     }
 187     return tiles;
 188   }
 189
 190   void SetScheduledRasterTaskLimitForTesting(size_t limit) {
 191     scheduled_raster_task_limit_ = limit;
 192   }
 193
 194   void CheckIfMoreTilesNeedToBePreparedForTesting() {
 195     CheckIfMoreTilesNeedToBePrepared();
 196   }
 197
 198   void SetMoreTilesNeedToBeRasterizedForTesting() {
 199     all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
 200   }
 201
 202   bool HasScheduledTileTasksForTesting() const {
 203     return has_scheduled_tile_tasks_;
 204   }
 205
 206  protected:
 207   TileManager(TileManagerClient* client,
 208               const scoped_refptr<base::SequencedTaskRunner>& task_runner,
 209               size_t scheduled_raster_task_limit);
 210
 211   void FreeResourcesForReleasedTiles();
 212   void CleanUpReleasedTiles();
 213
 214   friend class Tile;
 215   // Virtual for testing.
 216   virtual void Release(Tile* tile);
 217
 218   // Overriden from TileTaskRunnerClient:
 219   void DidFinishRunningTileTasks(TaskSet task_set) override;
 220   TaskSetCollection TasksThatShouldBeForcedToComplete() const override;
 221
 222   typedef std::vector<PrioritizedTile> PrioritizedTileVector;
 223   typedef std::set<Tile*> TileSet;
 224
 225   // Virtual for test
 226   virtual void ScheduleTasks(
 227       const PrioritizedTileVector& tiles_that_need_to_be_rasterized);
 228
 229   void AssignGpuMemoryToTiles(
 230       RasterTilePriorityQueue* raster_priority_queue,
 231       size_t scheduled_raser_task_limit,
 232       PrioritizedTileVector* tiles_that_need_to_be_rasterized);
 233
 234  private:
 235   class MemoryUsage {
 236    public:
 237     MemoryUsage();
 238     MemoryUsage(size_t memory_bytes, size_t resource_count);
 239
 240     static MemoryUsage FromConfig(const gfx::Size& size, ResourceFormat format);
 241     static MemoryUsage FromTile(const Tile* tile);
 242
 243     MemoryUsage& operator+=(const MemoryUsage& other);
 244     MemoryUsage& operator-=(const MemoryUsage& other);
 245     MemoryUsage operator-(const MemoryUsage& other);
 246
 247     bool Exceeds(const MemoryUsage& limit) const;
 248     int64 memory_bytes() const { return memory_bytes_; }
 249
 250    private:
 251     int64 memory_bytes_;
 252     int resource_count_;
 253   };
 254
 255   void OnImageDecodeTaskCompleted(int layer_id,
 256                                   SkPixelRef* pixel_ref,
 257                                   bool was_canceled);
 258   void OnRasterTaskCompleted(Tile::Id tile,
 259                              scoped_ptr<ScopedResource> resource,
 260                              const RasterSource::SolidColorAnalysis& analysis,
 261                              bool was_canceled);
 262   void UpdateTileDrawInfo(Tile* tile,
 263                           scoped_ptr<ScopedResource> resource,
 264                           const RasterSource::SolidColorAnalysis& analysis);
 265
 266   void FreeResourcesForTile(Tile* tile);
 267   void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile);
 268   scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile,
 269                                                        SkPixelRef* pixel_ref);
 270   scoped_refptr<RasterTask> CreateRasterTask(
 271       const PrioritizedTile& prioritized_tile);
 272
 273   scoped_ptr<EvictionTilePriorityQueue>
 274   FreeTileResourcesUntilUsageIsWithinLimit(
 275       scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
 276       const MemoryUsage& limit,
 277       MemoryUsage* usage);
 278   scoped_ptr<EvictionTilePriorityQueue>
 279   FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
 280       scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
 281       const MemoryUsage& limit,
 282       const TilePriority& oother_priority,
 283       MemoryUsage* usage);
 284   bool TilePriorityViolatesMemoryPolicy(const TilePriority& priority);
 285   bool AreRequiredTilesReadyToDraw(RasterTilePriorityQueue::Type type) const;
 286   void CheckIfMoreTilesNeedToBePrepared();
 287   void CheckAndIssueSignals();
 288
 289   TileManagerClient* client_;
 290   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 291   ResourcePool* resource_pool_;
 292   TileTaskRunner* tile_task_runner_;
 293   GlobalStateThatImpactsTilePriority global_state_;
 294   size_t scheduled_raster_task_limit_;
 295
 296   typedef base::hash_map<Tile::Id, Tile*> TileMap;
 297   TileMap tiles_;
 298
 299   bool all_tiles_that_need_to_be_rasterized_are_scheduled_;
 300   MemoryHistory::Entry memory_stats_from_last_assign_;
 301
 302   bool did_check_for_completed_tasks_since_last_schedule_tasks_;
 303   bool did_oom_on_last_assign_;
 304
 305   typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask>>
 306       PixelRefTaskMap;
 307   typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
 308   LayerPixelRefTaskMap image_decode_tasks_;
 309
 310   typedef base::hash_map<int, int> LayerCountMap;
 311   LayerCountMap used_layer_counts_;
 312
 313   RasterTaskCompletionStats flush_stats_;
 314
 315   std::vector<Tile*> released_tiles_;
 316
 317   // Queue used when scheduling raster tasks.
 318   TileTaskQueue raster_queue_;
 319
 320   std::vector<scoped_refptr<RasterTask>> orphan_raster_tasks_;
 321
 322   UniqueNotifier more_tiles_need_prepare_check_notifier_;
 323
 324   struct Signals {
 325     Signals();
 326
 327     void reset();
 328
 329     bool ready_to_activate;
 330     bool did_notify_ready_to_activate;
 331     bool ready_to_draw;
 332     bool did_notify_ready_to_draw;
 333     bool all_tile_tasks_completed;
 334     bool did_notify_all_tile_tasks_completed;
 335   } signals_;
 336
 337   UniqueNotifier signals_check_notifier_;
 338
 339   bool has_scheduled_tile_tasks_;
 340
 341   uint64_t prepare_tiles_count_;
 342
 343   DISALLOW_COPY_AND_ASSIGN(TileManager);
 344 };
 345
 346 }  // namespace cc
 347
 348 #endif  // CC_TILES_TILE_MANAGER_H_