Do not give GPU memory to backgrounded compositors.

content/common/gpu/gpu_memory_manager.cc

 // 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.
 
 #include "content/common/gpu/gpu_memory_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 41 matching lines @@
     uint64 max_surfaces_with_frontbuffer_soft_limit)
     : channel_manager_(channel_manager),
       manage_immediate_scheduled_(false),
       max_surfaces_with_frontbuffer_soft_limit_(
           max_surfaces_with_frontbuffer_soft_limit),
       bytes_available_gpu_memory_(0),
       bytes_available_gpu_memory_overridden_(false),
       bytes_minimum_per_client_(0),
       bytes_default_per_client_(0),
       bytes_allocated_managed_current_(0),
-      bytes_allocated_managed_visible_(0),
-      bytes_allocated_managed_nonvisible_(0),
       bytes_allocated_unmanaged_current_(0),
       bytes_allocated_historical_max_(0),
       bytes_allocated_unmanaged_high_(0),
       bytes_allocated_unmanaged_low_(0),
       bytes_unmanaged_limit_step_(kBytesAllocatedUnmanagedStep),
       disable_schedule_manage_(false)
 {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
 #if defined(OS_ANDROID)
   bytes_default_per_client_ = 8 * 1024 * 1024;
   bytes_minimum_per_client_ = 8 * 1024 * 1024;
 #elif defined(OS_CHROMEOS)
   bytes_default_per_client_ = 64 * 1024 * 1024;
   bytes_minimum_per_client_ = 4 * 1024 * 1024;
 #else
   bytes_default_per_client_ = 64 * 1024 * 1024;
   bytes_minimum_per_client_ = 64 * 1024 * 1024;
 #endif
 
-  // On Android, always discard everything that is nonvisible.
-  // On Linux and Mac, use as little memory as possible to avoid stability
-  // issues.
-  // http://crbug.com/145600 (Linux)
-  // http://crbug.com/141377 (Mac)
-#if defined(OS_ANDROID) || defined(OS_MACOSX) || \
-    (defined(OS_LINUX) && !defined(OS_CHROMEOS))
-  allow_nonvisible_memory_ = false;
-#else
-  allow_nonvisible_memory_ = true;
-#endif
-
   if (command_line->HasSwitch(switches::kForceGpuMemAvailableMb)) {
     base::StringToUint64(
         command_line->GetSwitchValueASCII(switches::kForceGpuMemAvailableMb),
         &bytes_available_gpu_memory_);
     bytes_available_gpu_memory_ *= 1024 * 1024;
     bytes_available_gpu_memory_overridden_ = true;
   } else
     bytes_available_gpu_memory_ = GetDefaultAvailableGpuMemory();
 }
 
 GpuMemoryManager::~GpuMemoryManager() {
   DCHECK(tracking_groups_.empty());
   DCHECK(clients_visible_mru_.empty());
   DCHECK(clients_nonvisible_mru_.empty());
   DCHECK(clients_nonsurface_.empty());
   DCHECK(!bytes_allocated_managed_current_);
   DCHECK(!bytes_allocated_unmanaged_current_);
-  DCHECK(!bytes_allocated_managed_visible_);
-  DCHECK(!bytes_allocated_managed_nonvisible_);
 }
 
 uint64 GpuMemoryManager::GetAvailableGpuMemory() const {
   // Allow unmanaged allocations to over-subscribe by at most (high_ - low_)
   // before restricting managed (compositor) memory based on unmanaged usage.
   if (bytes_allocated_unmanaged_low_ > bytes_available_gpu_memory_)
     return 0;
   return bytes_available_gpu_memory_ - bytes_allocated_unmanaged_low_;
 }
 
@@ skipping 166 matching lines @@
     GpuMemoryManagerClient* client,
     bool has_surface,
     bool visible) {
   TrackingGroupMap::iterator tracking_group_it =
       tracking_groups_.find(client->GetMemoryTracker());
   DCHECK(tracking_group_it != tracking_groups_.end());
   GpuMemoryTrackingGroup* tracking_group = tracking_group_it->second;
 
   GpuMemoryManagerClientState* client_state = new GpuMemoryManagerClientState(
       this, client, tracking_group, has_surface, visible);
-  TrackValueChanged(0, client_state->managed_memory_stats_.bytes_allocated,
-                    client_state->visible_ ?
-                        &bytes_allocated_managed_visible_ :
-                        &bytes_allocated_managed_nonvisible_);
   AddClientToList(client_state);
   ScheduleManage(kScheduleManageNow);
   return client_state;
 }
 
 void GpuMemoryManager::OnDestroyClientState(
     GpuMemoryManagerClientState* client_state) {
   RemoveClientFromList(client_state);
-  TrackValueChanged(client_state->managed_memory_stats_.bytes_allocated, 0,
-                    client_state->visible_ ?
-                        &bytes_allocated_managed_visible_ :
-                        &bytes_allocated_managed_nonvisible_);
   ScheduleManage(kScheduleManageLater);
 }
 
 void GpuMemoryManager::SetClientStateVisible(
     GpuMemoryManagerClientState* client_state, bool visible) {
   DCHECK(client_state->has_surface_);
   if (client_state->visible_ == visible)
     return;
 
   RemoveClientFromList(client_state);
   client_state->visible_ = visible;
   AddClientToList(client_state);
-
-  TrackValueChanged(client_state->managed_memory_stats_.bytes_allocated, 0,
-                    client_state->visible_ ?
-                        &bytes_allocated_managed_nonvisible_ :
-                        &bytes_allocated_managed_visible_);
-  TrackValueChanged(0, client_state->managed_memory_stats_.bytes_allocated,
-                    client_state->visible_ ?
-                        &bytes_allocated_managed_visible_ :
-                        &bytes_allocated_managed_nonvisible_);
   ScheduleManage(visible ? kScheduleManageNow : kScheduleManageLater);
 }
 
 void GpuMemoryManager::SetClientStateManagedMemoryStats(
     GpuMemoryManagerClientState* client_state,
     const ManagedMemoryStats& stats)
 {
-  TrackValueChanged(client_state->managed_memory_stats_.bytes_allocated,
-                    stats.bytes_allocated,
-                    client_state->visible_ ?
-                        &bytes_allocated_managed_visible_ :
-                        &bytes_allocated_managed_nonvisible_);
   client_state->managed_memory_stats_ = stats;
 
   // If this is the first time that stats have been received for this
   // client, use them immediately.
   if (!client_state->managed_memory_stats_received_) {
     client_state->managed_memory_stats_received_ = true;
     ScheduleManage(kScheduleManageNow);
     return;
   }
 
@@ skipping 134 matching lines @@
   uint64 allocation = GetMinimumClientAllocation();
   allocation += std::min(bytes_required - GetMinimumClientAllocation(),
                          bytes_above_minimum_cap);
   allocation += std::min(bytes_nicetohave - bytes_required,
                          bytes_above_required_cap);
   allocation = std::min(allocation,
                         bytes_overall_cap);
   return allocation;
 }
 
-uint64 GpuMemoryManager::ComputeClientAllocationWhenNonvisible(
-    GpuMemoryManagerClientState* client_state) {
-  if (!client_state->managed_memory_stats_received_)
-    return 0;
-
-  if (!allow_nonvisible_memory_)
-    return 0;
-
-  return 9 * client_state->managed_memory_stats_.bytes_required / 8;
-}
-
 void GpuMemoryManager::ComputeVisibleSurfacesAllocations() {
   uint64 bytes_available_total = GetAvailableGpuMemory();
   uint64 bytes_above_required_cap = std::numeric_limits<uint64>::max();
   uint64 bytes_above_minimum_cap = std::numeric_limits<uint64>::max();
   uint64 bytes_overall_cap_visible = GetMaximumClientAllocation();
 
   // Compute memory usage at three levels
   // - painting everything that is nicetohave for visible clients
   // - painting only what that is visible
   // - giving every client the minimum allocation
@@ skipping 78 matching lines @@
             bytes_above_required_cap,
             bytes_above_minimum_cap,
             bytes_overall_cap_visible);
     bytes_allocated_visible += client_state->bytes_allocation_when_visible_;
     bytes_allocated_max_client_allocation = std::max(
         bytes_allocated_max_client_allocation,
         client_state->bytes_allocation_when_visible_);
   }
 
   // Set the limit for nonvisible clients for when they become visible.
-  // Use the same formula, with a lowered overall cap to in case any of the
+  // Use the same formula, with a lowered overall cap in case any of the
   // currently-nonvisible clients are much more resource-intensive than any
   // of the existing clients.
   uint64 bytes_overall_cap_nonvisible = bytes_allocated_max_client_allocation;
   if (bytes_available_total > bytes_allocated_visible) {
     bytes_overall_cap_nonvisible +=
         bytes_available_total - bytes_allocated_visible;
   }
   bytes_overall_cap_nonvisible = std::min(bytes_overall_cap_nonvisible,
                                           GetMaximumClientAllocation());
   for (ClientStateList::const_iterator it = clients_nonvisible_mru_.begin();
        it != clients_nonvisible_mru_.end();
        ++it) {
     GpuMemoryManagerClientState* client_state = *it;
     client_state->bytes_allocation_when_visible_ =
         ComputeClientAllocationWhenVisible(
             client_state,
             bytes_above_required_cap,
             bytes_above_minimum_cap,
             bytes_overall_cap_nonvisible);
   }
 }
 
-void GpuMemoryManager::ComputeNonvisibleSurfacesAllocations() {
-  uint64 bytes_allocated_visible = 0;
-  for (ClientStateList::const_iterator it = clients_visible_mru_.begin();
-       it != clients_visible_mru_.end();
-       ++it) {
-    GpuMemoryManagerClientState* client_state = *it;
-    bytes_allocated_visible += client_state->bytes_allocation_when_visible_;
-  }
-
-  // Allow up to 1/4 of the memory that was available for visible clients to
-  // go to nonvisible clients.
-  uint64 bytes_available_total = GetAvailableGpuMemory();
-  uint64 bytes_available_nonvisible = 0;
-  uint64 bytes_allocated_nonvisible = 0;
-  if (bytes_available_total > bytes_allocated_visible) {
-    bytes_available_nonvisible = std::min(
-        bytes_available_total / 4,
-        bytes_available_total - bytes_allocated_visible);
-  }
-
-  // Determine which now-visible clients should keep their contents when
-  // they are made nonvisible.
-  for (ClientStateList::const_iterator it = clients_visible_mru_.begin();
-       it != clients_visible_mru_.end();
-       ++it) {
-    GpuMemoryManagerClientState* client_state = *it;
-
-    // Compute the amount of space available have for this renderer when it is
-    // nonvisible. Do not count this client's allocation while visible against
-    // the nonvisible clients' allocation total.
-    uint64 bytes_available_nonvisible_adjusted = std::min(
-        bytes_available_nonvisible +
-            client_state->bytes_allocation_when_visible_ / 4,
-        bytes_available_total / 4);
-
-    // Allow this client to keep its contents if they fit in the allocation.
-    client_state->bytes_allocation_when_nonvisible_ =
-        ComputeClientAllocationWhenNonvisible(client_state);
-    if (client_state->bytes_allocation_when_nonvisible_ >
-        bytes_available_nonvisible_adjusted)
-      client_state->bytes_allocation_when_nonvisible_ = 0;
-  }
-
-  // Compute which currently nonvisible clients should keep their contents.
-  for (ClientStateList::const_iterator it = clients_nonvisible_mru_.begin();
-       it != clients_nonvisible_mru_.end();
-       ++it) {
-    GpuMemoryManagerClientState* client_state = *it;
-
-    // If this client is nonvisible and has already had its contents discarded,
-    // don't re-generate the contents until the client becomes visible again.
-    if (!client_state->bytes_allocation_when_nonvisible_)
-      continue;
-
-    client_state->bytes_allocation_when_nonvisible_ =
-        ComputeClientAllocationWhenNonvisible(client_state);
-
-    // Take into account all more recently used nonvisible clients, and only if
-    // this client still fits, all it to keep its contents.
-    if (bytes_allocated_nonvisible +
-        client_state->bytes_allocation_when_nonvisible_ >
-        bytes_available_nonvisible) {
-      client_state->bytes_allocation_when_nonvisible_ = 0;
-    }
-    bytes_allocated_nonvisible +=
-        client_state->bytes_allocation_when_nonvisible_;
-  }
-}
-
 void GpuMemoryManager::DistributeRemainingMemoryToVisibleSurfaces() {
   uint64 bytes_available_total = GetAvailableGpuMemory();
   uint64 bytes_allocated_total = 0;
 
   for (ClientStateList::const_iterator it = clients_visible_mru_.begin();
        it != clients_visible_mru_.end();
        ++it) {
     GpuMemoryManagerClientState* client_state = *it;
     bytes_allocated_total += client_state->bytes_allocation_when_visible_;
   }
-  for (ClientStateList::const_iterator it = clients_nonvisible_mru_.begin();
-       it != clients_nonvisible_mru_.end();
-       ++it) {
-    GpuMemoryManagerClientState* client_state = *it;
-    bytes_allocated_total += client_state->bytes_allocation_when_nonvisible_;
-  }
 
   if (bytes_allocated_total >= bytes_available_total)
     return;
 
   std::vector<uint64> bytes_extra_requests;
   for (ClientStateList::const_iterator it = clients_visible_mru_.begin();
        it != clients_visible_mru_.end();
        ++it) {
     GpuMemoryManagerClientState* client_state = *it;
     CHECK(GetMaximumClientAllocation() >=
@@ skipping 11 matching lines @@
     uint64 bytes_extra = GetMaximumClientAllocation() -
                          client_state->bytes_allocation_when_visible_;
     client_state->bytes_allocation_when_visible_ += std::min(
         bytes_extra, bytes_extra_cap);
   }
 }
 
 void GpuMemoryManager::AssignSurfacesAllocations() {
   // Compute allocation when for all clients.
   ComputeVisibleSurfacesAllocations();
-  ComputeNonvisibleSurfacesAllocations();
 
   // Distribute the remaining memory to visible clients.
   DistributeRemainingMemoryToVisibleSurfaces();
 
   // Send that allocation to the clients.
   ClientStateList clients = clients_visible_mru_;
   clients.insert(clients.end(),
                  clients_nonvisible_mru_.begin(),
                  clients_nonvisible_mru_.end());
   for (ClientStateList::const_iterator it = clients.begin();
@@ skipping 17 matching lines @@
     // because the platform is unstable when under memory pressure.
     // http://crbug.com/145600 (Linux)
     // http://crbug.com/141377 (Mac)
     allocation.priority_cutoff_when_visible =
 #if defined(OS_MACOSX) || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
         MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 #else
         MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
 #endif
 
-    allocation.bytes_limit_when_not_visible =
-        client_state->bytes_allocation_when_nonvisible_;
-    allocation.priority_cutoff_when_not_visible =
-        MemoryAllocation::CUTOFF_ALLOW_REQUIRED_ONLY;
-
     client_state->client_->SetMemoryAllocation(allocation);
     client_state->client_->SuggestHaveFrontBuffer(!client_state->hibernated_);
   }
 }
 
 void GpuMemoryManager::AssignNonSurfacesAllocations() {
   for (ClientStateList::const_iterator it = clients_nonsurface_.begin();
        it != clients_nonsurface_.end();
        ++it) {
     GpuMemoryManagerClientState* client_state = *it;
@@ skipping 88 matching lines @@
 
 void GpuMemoryManager::RemoveClientFromList(
     GpuMemoryManagerClientState* client_state) {
   DCHECK(client_state->list_iterator_valid_);
   ClientStateList* client_list = GetClientList(client_state);
   client_list->erase(client_state->list_iterator_);
   client_state->list_iterator_valid_ = false;
 }
 
 }  // namespace content