Distribute extra memory evenly among visible tabs

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 513 matching lines @@
   SendUmaStatsToBrowser();
 }
 
 // static
 uint64 GpuMemoryManager::ComputeCap(
     std::vector<uint64> bytes, uint64 bytes_sum_limit)
 {
   size_t bytes_size = bytes.size();
   uint64 bytes_sum = 0;
 
+  if (bytes_size == 0)
+    return std::numeric_limits<uint64>::max();
+
   // Sort and add up all entries
   std::sort(bytes.begin(), bytes.end());
   for (size_t i = 0; i < bytes_size; ++i)
     bytes_sum += bytes[i];
 
   // As we go through the below loop, let bytes_partial_sum be the
   // sum of bytes[0] + ... + bytes[bytes_size - i - 1]
   uint64 bytes_partial_sum = bytes_sum;
 
   // Try using each entry as a cap, and see where we get cut off.
@@ skipping 191 matching lines @@
   // 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);
   }
 
+  // On Android, always discard everything that is nonvisible.
+#if defined(OS_ANDROID)
+  bytes_available_nonvisible = 0;
+#endif
+
   // 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.
@@ skipping 29 matching lines @@
     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() >=
+          client_state->bytes_allocation_when_visible_);
+    uint64 bytes_extra = GetMaximumClientAllocation() -
+                         client_state->bytes_allocation_when_visible_;
+    bytes_extra_requests.push_back(bytes_extra);
+  }
+  uint64 bytes_extra_cap = ComputeCap(
+      bytes_extra_requests, bytes_available_total - bytes_allocated_total);
+  for (ClientStateList::const_iterator it = clients_visible_mru_.begin();
+       it != clients_visible_mru_.end();
+       ++it) {
+    GpuMemoryManagerClientState* client_state = *it;
+    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::AssignSurfacesAllocationsNonuniform() {
   // Compute allocation when for all clients.
   ComputeVisibleSurfacesAllocationsNonuniform();
   ComputeNonvisibleSurfacesAllocationsNonuniform();
 
+  // 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();
        it != clients.end();
        ++it) {
     GpuMemoryManagerClientState* client_state = *it;
 
     // Re-assign memory limits to this client when its "nice to have" bucket
     // grows or shrinks by 1/4.
     client_state->bytes_nicetohave_limit_high_ =
         5 * client_state->managed_memory_stats_.bytes_nice_to_have / 4;
     client_state->bytes_nicetohave_limit_low_ =
         3 * client_state->managed_memory_stats_.bytes_nice_to_have / 4;
 
     // Populate and send the allocation to the client
     GpuMemoryAllocation allocation;
 
     allocation.browser_allocation.suggest_have_frontbuffer =
         !client_state->hibernated_;
 
     allocation.renderer_allocation.bytes_limit_when_visible =
         client_state->bytes_allocation_when_visible_;
     allocation.renderer_allocation.priority_cutoff_when_visible =
-        GpuMemoryAllocationForRenderer::kPriorityCutoffAllowEverything;
+        GpuMemoryAllocationForRenderer::kPriorityCutoffAllowNiceToHave;

[nduca, 2013/02/11 22:11:52]

Why should we bother having an eventually bin, then? Can you grab me so that I
can understand this?

 
     allocation.renderer_allocation.bytes_limit_when_not_visible =
         client_state->bytes_allocation_when_nonvisible_;
     allocation.renderer_allocation.priority_cutoff_when_not_visible =
         GpuMemoryAllocationForRenderer::kPriorityCutoffAllowOnlyRequired;
 
     client_state->client_->SetMemoryAllocation(allocation);
   }
 }
 
@@ skipping 210 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