Revert 274326 "Lobotomize the GPU memory manager"

trunk/src/content/common/gpu/gpu_memory_manager.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_
 #define CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_
 
 #include <list>
 #include <map>
 
@@ skipping 45 matching lines @@
   void GetVideoMemoryUsageStats(
       content::GPUVideoMemoryUsageStats* video_memory_usage_stats) const;
 
   GpuMemoryManagerClientState* CreateClientState(
       GpuMemoryManagerClient* client, bool has_surface, bool visible);
 
   GpuMemoryTrackingGroup* CreateTrackingGroup(
       base::ProcessId pid, gpu::gles2::MemoryTracker* memory_tracker);
 
   uint64 GetClientMemoryUsage(const GpuMemoryManagerClient* client) const;
-  uint64 GetMaximumClientAllocation() const {
-    return client_hard_limit_bytes_;
+
+  // The maximum and minimum amount of memory that a client may be assigned.
+  uint64 GetMaximumClientAllocation() const;
+  uint64 GetMinimumClientAllocation() const {
+    return bytes_minimum_per_client_;
   }
 
  private:
   friend class GpuMemoryManagerTest;
   friend class GpuMemoryTrackingGroup;
   friend class GpuMemoryManagerClientState;
 
   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
                            TestManageBasicFunctionality);
   FRIEND_TEST_ALL_PREFIXES(GpuMemoryManagerTest,
@@ skipping 30 matching lines @@
   typedef std::map<gpu::gles2::MemoryTracker*, GpuMemoryTrackingGroup*>
       TrackingGroupMap;
 
   typedef std::list<GpuMemoryManagerClientState*> ClientStateList;
 
   void Manage();
   void SetClientsHibernatedState() const;
   void AssignSurfacesAllocations();
   void AssignNonSurfacesAllocations();
 
+  // Math helper function to compute the maximum value of cap such that
+  // sum_i min(bytes[i], cap) <= bytes_sum_limit
+  static uint64 ComputeCap(std::vector<uint64> bytes, uint64 bytes_sum_limit);
+
+  // Compute the allocation for clients when visible and not visible.
+  void ComputeVisibleSurfacesAllocations();
+  void DistributeRemainingMemoryToVisibleSurfaces();
+
+  // Compute the budget for a client. Allow at most bytes_above_required_cap
+  // bytes above client_state's required level. Allow at most
+  // bytes_above_minimum_cap bytes above client_state's minimum level. Allow
+  // at most bytes_overall_cap bytes total.
+  uint64 ComputeClientAllocationWhenVisible(
+      GpuMemoryManagerClientState* client_state,
+      uint64 bytes_above_required_cap,
+      uint64 bytes_above_minimum_cap,
+      uint64 bytes_overall_cap);
+
   // Update the amount of GPU memory we think we have in the system, based
   // on what the stubs' contexts report.
   void UpdateAvailableGpuMemory();
+  void UpdateUnmanagedMemoryLimits();
+
+  // The amount of video memory which is available for allocation.
+  uint64 GetAvailableGpuMemory() const;
+
+  // Minimum value of available GPU memory, no matter how little the GPU
+  // reports. This is the default value.
+  uint64 GetDefaultAvailableGpuMemory() const;
+
+  // Maximum cap on total GPU memory, no matter how much the GPU reports.
+  uint64 GetMaximumTotalGpuMemory() const;
+
+  // The default amount of memory that a client is assigned, if it has not
+  // reported any memory usage stats yet.
+  uint64 GetDefaultClientAllocation() const {
+    return bytes_default_per_client_;
+  }
+
+  static uint64 CalcAvailableFromGpuTotal(uint64 total_gpu_memory);
 
   // Send memory usage stats to the browser process.
   void SendUmaStatsToBrowser();
 
   // Get the current number of bytes allocated.
   uint64 GetCurrentUsage() const {
     return bytes_allocated_managed_current_ +
         bytes_allocated_unmanaged_current_;
   }
 
@@ skipping 15 matching lines @@
   void OnDestroyClientState(GpuMemoryManagerClientState* client);
 
   // Add or remove a client from its clients list (visible, nonvisible, or
   // nonsurface). When adding the client, add it to the front of the list.
   void AddClientToList(GpuMemoryManagerClientState* client_state);
   void RemoveClientFromList(GpuMemoryManagerClientState* client_state);
   ClientStateList* GetClientList(GpuMemoryManagerClientState* client_state);
 
   // Interfaces for testing
   void TestingDisableScheduleManage() { disable_schedule_manage_ = true; }
+  void TestingSetAvailableGpuMemory(uint64 bytes) {
+    bytes_available_gpu_memory_ = bytes;
+    bytes_available_gpu_memory_overridden_ = true;
+  }
+
+  void TestingSetMinimumClientAllocation(uint64 bytes) {
+    bytes_minimum_per_client_ = bytes;
+  }
+
+  void TestingSetDefaultClientAllocation(uint64 bytes) {
+    bytes_default_per_client_ = bytes;
+  }
+
+  void TestingSetUnmanagedLimitStep(uint64 bytes) {
+    bytes_unmanaged_limit_step_ = bytes;
+  }
 
   GpuChannelManager* channel_manager_;
 
   // A list of all visible and nonvisible clients, in most-recently-used
   // order (most recently used is first).
   ClientStateList clients_visible_mru_;
   ClientStateList clients_nonvisible_mru_;
 
   // A list of all clients that don't have a surface.
   ClientStateList clients_nonsurface_;
 
   // All context groups' tracking structures
   TrackingGroupMap tracking_groups_;
 
   base::CancelableClosure delayed_manage_callback_;
   bool manage_immediate_scheduled_;
-  bool disable_schedule_manage_;
 
   uint64 max_surfaces_with_frontbuffer_soft_limit_;
 
-  // The maximum amount of memory that may be allocated for a single client.
-  uint64 client_hard_limit_bytes_;
+  // The priority cutoff used for all renderers.
+  gpu::MemoryAllocation::PriorityCutoff priority_cutoff_;
+
+  // The maximum amount of memory that may be allocated for GPU resources
+  uint64 bytes_available_gpu_memory_;
+  bool bytes_available_gpu_memory_overridden_;
+
+  // The minimum and default allocations for a single client.
+  uint64 bytes_minimum_per_client_;
+  uint64 bytes_default_per_client_;
 
   // The current total memory usage, and historical maximum memory usage
   uint64 bytes_allocated_managed_current_;
   uint64 bytes_allocated_unmanaged_current_;
   uint64 bytes_allocated_historical_max_;
 
+  // If bytes_allocated_unmanaged_current_ leaves the interval [low_, high_),
+  // then ScheduleManage to take the change into account.
+  uint64 bytes_allocated_unmanaged_high_;
+  uint64 bytes_allocated_unmanaged_low_;
+
+  // Update bytes_allocated_unmanaged_low/high_ in intervals of step_.
+  uint64 bytes_unmanaged_limit_step_;
+
+  // Used to disable automatic changes to Manage() in testing.
+  bool disable_schedule_manage_;
+
   DISALLOW_COPY_AND_ASSIGN(GpuMemoryManager);
 };
 
 }  // namespace content
 
 #endif // CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_