src/content/common/gpu/gpu_memory_manager.h

   1 // Copyright (c) 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 CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_
   6 #define CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_
   7
   8 #include <list>
   9 #include <map>
  10
  11 #include "base/basictypes.h"
  12 #include "base/cancelable_callback.h"
  13 #include "base/containers/hash_tables.h"
  14 #include "base/gtest_prod_util.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "content/common/content_export.h"
  17 #include "content/public/common/gpu_memory_stats.h"
  18 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
  19 #include "gpu/command_buffer/service/memory_tracking.h"
  20
  21 namespace content {
  22
  23 class GpuChannelManager;
  24 class GpuMemoryManagerClient;
  25 class GpuMemoryManagerClientState;
  26 class GpuMemoryTrackingGroup;
  27
  28 class CONTENT_EXPORT GpuMemoryManager :
  29     public base::SupportsWeakPtr<GpuMemoryManager> {
  30  public:
  31 #if defined(OS_ANDROID) || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
  32   enum { kDefaultMaxSurfacesWithFrontbufferSoftLimit = 1 };
  33 #else
  34   enum { kDefaultMaxSurfacesWithFrontbufferSoftLimit = 8 };
  35 #endif
  36   enum ScheduleManageTime {
  37     // Add a call to Manage to the thread's message loop immediately.
  38     kScheduleManageNow,
  39     // Add a Manage call to the thread's message loop for execution 1/60th of
  40     // of a second from now.
  41     kScheduleManageLater,
  42   };
  43
  44   GpuMemoryManager(GpuChannelManager* channel_manager,
  45                    uint64 max_surfaces_with_frontbuffer_soft_limit);
  46   ~GpuMemoryManager();
  47
  48   // Schedule a Manage() call. If immediate is true, we PostTask without delay.
  49   // Otherwise PostDelayedTask using a CancelableClosure and allow multiple
  50   // delayed calls to "queue" up. This way, we do not spam clients in certain
  51   // lower priority situations. An immediate schedule manage will cancel any
  52   // queued delayed manage.
  53   void ScheduleManage(ScheduleManageTime schedule_manage_time);
  54
  55   // Retrieve GPU Resource consumption statistics for the task manager
  56   void GetVideoMemoryUsageStats(
  57       content::GPUVideoMemoryUsageStats* video_memory_usage_stats) const;
  58
  59   GpuMemoryManagerClientState* CreateClientState(
  60       GpuMemoryManagerClient* client, bool has_surface, bool visible);
  61
  62   GpuMemoryTrackingGroup* CreateTrackingGroup(
  63       base::ProcessId pid, gpu::gles2::MemoryTracker* memory_tracker);
  64
  65  private:
  66   friend class GpuMemoryManagerTest;
  67   friend class GpuMemoryTrackingGroup;
  68   friend class GpuMemoryManagerClientState;
  69
  70   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  71                            TestManageBasicFunctionality);
  72   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  73                            TestManageChangingVisibility);
  74   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  75                            TestManageManyVisibleStubs);
  76   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  77                            TestManageManyNotVisibleStubs);
  78   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  79                            TestManageChangingLastUsedTime);
  80   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  81                            TestManageChangingImportanceShareGroup);
  82   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  83                            TestForegroundStubsGetBonusAllocation);
  84   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  85                            TestUpdateAvailableGpuMemory);
  86   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  87                            GpuMemoryAllocationCompareTests);
  88   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  89                            StubMemoryStatsForLastManageTests);
  90   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  91                            TestManagedUsageTracking);
  92   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  93                            BackgroundMru);
  94   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  95                            AllowNonvisibleMemory);
  96   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  97                            BackgroundDiscardPersistent);
  98   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
  99                            UnmanagedTracking);
 100   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
 101                            DefaultAllocation);
 102
 103   typedef std::map<gpu::gles2::MemoryTracker*, GpuMemoryTrackingGroup*>
 104       TrackingGroupMap;
 105
 106   typedef std::list<GpuMemoryManagerClientState*> ClientStateList;
 107
 108   void Manage();
 109   void SetClientsHibernatedState() const;
 110   void AssignSurfacesAllocations();
 111   void AssignNonSurfacesAllocations();
 112
 113   // Math helper function to compute the maximum value of cap such that
 114   // sum_i min(bytes[i], cap) <= bytes_sum_limit
 115   static uint64 ComputeCap(std::vector<uint64> bytes, uint64 bytes_sum_limit);
 116
 117   // Compute the allocation for clients when visible and not visible.
 118   void ComputeVisibleSurfacesAllocations();
 119   void DistributeRemainingMemoryToVisibleSurfaces();
 120
 121   // Compute the budget for a client. Allow at most bytes_above_required_cap
 122   // bytes above client_state's required level. Allow at most
 123   // bytes_above_minimum_cap bytes above client_state's minimum level. Allow
 124   // at most bytes_overall_cap bytes total.
 125   uint64 ComputeClientAllocationWhenVisible(
 126       GpuMemoryManagerClientState* client_state,
 127       uint64 bytes_above_required_cap,
 128       uint64 bytes_above_minimum_cap,
 129       uint64 bytes_overall_cap);
 130
 131   // Update the amount of GPU memory we think we have in the system, based
 132   // on what the stubs' contexts report.
 133   void UpdateAvailableGpuMemory();
 134   void UpdateUnmanagedMemoryLimits();
 135
 136   // The amount of video memory which is available for allocation.
 137   uint64 GetAvailableGpuMemory() const;
 138
 139   // Minimum value of available GPU memory, no matter how little the GPU
 140   // reports. This is the default value.
 141   uint64 GetDefaultAvailableGpuMemory() const;
 142
 143   // Maximum cap on total GPU memory, no matter how much the GPU reports.
 144   uint64 GetMaximumTotalGpuMemory() const;
 145
 146   // The maximum and minimum amount of memory that a client may be assigned.
 147   uint64 GetMaximumClientAllocation() const;
 148   uint64 GetMinimumClientAllocation() const {
 149     return bytes_minimum_per_client_;
 150   }
 151   // The default amount of memory that a client is assigned, if it has not
 152   // reported any memory usage stats yet.
 153   uint64 GetDefaultClientAllocation() const {
 154     return bytes_default_per_client_;
 155   }
 156
 157   static uint64 CalcAvailableFromGpuTotal(uint64 total_gpu_memory);
 158
 159   // Send memory usage stats to the browser process.
 160   void SendUmaStatsToBrowser();
 161
 162   // Get the current number of bytes allocated.
 163   uint64 GetCurrentUsage() const {
 164     return bytes_allocated_managed_current_ +
 165         bytes_allocated_unmanaged_current_;
 166   }
 167
 168   // GpuMemoryTrackingGroup interface
 169   void TrackMemoryAllocatedChange(
 170       GpuMemoryTrackingGroup* tracking_group,
 171       uint64 old_size,
 172       uint64 new_size,
 173       gpu::gles2::MemoryTracker::Pool tracking_pool);
 174   void OnDestroyTrackingGroup(GpuMemoryTrackingGroup* tracking_group);
 175   bool EnsureGPUMemoryAvailable(uint64 size_needed);
 176
 177   // GpuMemoryManagerClientState interface
 178   void SetClientStateVisible(
 179       GpuMemoryManagerClientState* client_state, bool visible);
 180   void SetClientStateManagedMemoryStats(
 181       GpuMemoryManagerClientState* client_state,
 182       const gpu::ManagedMemoryStats& stats);
 183   void OnDestroyClientState(GpuMemoryManagerClientState* client);
 184
 185   // Add or remove a client from its clients list (visible, nonvisible, or
 186   // nonsurface). When adding the client, add it to the front of the list.
 187   void AddClientToList(GpuMemoryManagerClientState* client_state);
 188   void RemoveClientFromList(GpuMemoryManagerClientState* client_state);
 189   ClientStateList* GetClientList(GpuMemoryManagerClientState* client_state);
 190
 191   // Interfaces for testing
 192   void TestingDisableScheduleManage() { disable_schedule_manage_ = true; }
 193   void TestingSetAvailableGpuMemory(uint64 bytes) {
 194     bytes_available_gpu_memory_ = bytes;
 195     bytes_available_gpu_memory_overridden_ = true;
 196   }
 197
 198   void TestingSetMinimumClientAllocation(uint64 bytes) {
 199     bytes_minimum_per_client_ = bytes;
 200   }
 201
 202   void TestingSetDefaultClientAllocation(uint64 bytes) {
 203     bytes_default_per_client_ = bytes;
 204   }
 205
 206   void TestingSetUnmanagedLimitStep(uint64 bytes) {
 207     bytes_unmanaged_limit_step_ = bytes;
 208   }
 209
 210   GpuChannelManager* channel_manager_;
 211
 212   // A list of all visible and nonvisible clients, in most-recently-used
 213   // order (most recently used is first).
 214   ClientStateList clients_visible_mru_;
 215   ClientStateList clients_nonvisible_mru_;
 216
 217   // A list of all clients that don't have a surface.
 218   ClientStateList clients_nonsurface_;
 219
 220   // All context groups' tracking structures
 221   TrackingGroupMap tracking_groups_;
 222
 223   base::CancelableClosure delayed_manage_callback_;
 224   bool manage_immediate_scheduled_;
 225
 226   uint64 max_surfaces_with_frontbuffer_soft_limit_;
 227
 228   // The maximum amount of memory that may be allocated for GPU resources
 229   uint64 bytes_available_gpu_memory_;
 230   bool bytes_available_gpu_memory_overridden_;
 231
 232   // The minimum and default allocations for a single client.
 233   uint64 bytes_minimum_per_client_;
 234   uint64 bytes_default_per_client_;
 235
 236   // The current total memory usage, and historical maximum memory usage
 237   uint64 bytes_allocated_managed_current_;
 238   uint64 bytes_allocated_unmanaged_current_;
 239   uint64 bytes_allocated_historical_max_;
 240
 241   // If bytes_allocated_unmanaged_current_ leaves the interval [low_, high_),
 242   // then ScheduleManage to take the change into account.
 243   uint64 bytes_allocated_unmanaged_high_;
 244   uint64 bytes_allocated_unmanaged_low_;
 245
 246   // Update bytes_allocated_unmanaged_low/high_ in intervals of step_.
 247   uint64 bytes_unmanaged_limit_step_;
 248
 249   // Used to disable automatic changes to Manage() in testing.
 250   bool disable_schedule_manage_;
 251
 252   DISALLOW_COPY_AND_ASSIGN(GpuMemoryManager);
 253 };
 254
 255 }  // namespace content
 256
 257 #endif // CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_