Account for unmanaged (e.g, WebGL) use in memory manager

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"
 
 #if defined(ENABLE_GPU)
 
 #include <algorithm>
 
@@ skipping 10 matching lines @@
 #include "content/common/gpu/gpu_memory_tracking.h"
 #include "content/common/gpu/gpu_memory_uma_stats.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 
 namespace content {
 namespace {
 
 const int kDelayedScheduleManageTimeoutMs = 67;
 
+const size_t kBytesAllocatedUnmanagedStep = 16 * 1024 * 1024;
+
 void TrackValueChanged(size_t old_size, size_t new_size, size_t* total_size) {
   DCHECK(new_size > old_size || *total_size >= (old_size - new_size));
   *total_size += (new_size - old_size);
 }
 
+template<typename T>
+T RoundUp(T n, T mul) {
+  return ((n + mul - 1) / mul) * mul;
+}
+
+template<typename T>
+T RoundDown(T n, T mul) {
+  return (n / mul) * mul;
+}
+
 }
 
 GpuMemoryManager::GpuMemoryManager(
     GpuChannelManager* channel_manager,
     size_t 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_minimum_per_client_overridden_(false),
       bytes_backgrounded_available_gpu_memory_(0),
       bytes_allocated_managed_current_(0),
       bytes_allocated_managed_visible_(0),
       bytes_allocated_managed_backgrounded_(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),
       window_count_has_been_received_(false),
       window_count_(0),
       disable_schedule_manage_(false)
 {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kForceGpuMemAvailableMb)) {
     base::StringToSizeT(
       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();
   UpdateBackgroundedAvailableGpuMemory();
 }
 
 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_backgrounded_);
 }
 
 size_t GpuMemoryManager::GetAvailableGpuMemory() const {
-  return bytes_available_gpu_memory_;
+  // 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_;
 }
 
 size_t GpuMemoryManager::GetCurrentBackgroundedAvailableGpuMemory() const {
   if (bytes_allocated_managed_visible_ < GetAvailableGpuMemory()) {
     return std::min(bytes_backgrounded_available_gpu_memory_,
                     GetAvailableGpuMemory() - bytes_allocated_managed_visible_);
   }
   return 0;
 }
 
@@ skipping 20 matching lines @@
   return bytes_available_gpu_memory_;
 #else
   // This is to avoid allowing a single page on to use a full 256MB of memory
   // (the current total limit). Long-scroll pages will hit this limit,
   // resulting in instability on some platforms (e.g, issue 141377).
   return bytes_available_gpu_memory_ / 2;
 #endif
 }
 
 size_t GpuMemoryManager::GetMinimumTabAllocation() const {
+  if (bytes_minimum_per_client_overridden_)
+    return bytes_minimum_per_client_;
 #if defined(OS_ANDROID)
   return 32 * 1024 * 1024;
 #elif defined(OS_CHROMEOS)
   return 64 * 1024 * 1024;
 #else
   return 64 * 1024 * 1024;
 #endif
 }
 
 size_t GpuMemoryManager::CalcAvailableFromViewportArea(int viewport_area) {
@@ skipping 72 matching lines @@
   bytes_available_gpu_memory_ = CalcAvailableFromGpuTotal(bytes_min);
 #endif
 
   // Never go below the default allocation
   bytes_available_gpu_memory_ = std::max(bytes_available_gpu_memory_,
                                          GetDefaultAvailableGpuMemory());
 
   // Never go above the maximum.
   bytes_available_gpu_memory_ = std::min(bytes_available_gpu_memory_,
                                          GetMaximumTotalGpuMemory());
+}
 
-  // Update the backgrounded available gpu memory because it depends on
-  // the available GPU memory.
-  UpdateBackgroundedAvailableGpuMemory();
+void GpuMemoryManager::UpdateUnmanagedMemoryLimits() {
+  // Set the limit to be [current_, current_ + step_ / 4), with the endpoints
+  // of the intervals rounded down and up to the nearest step_, to avoid
+  // thrashing the interval.
+  bytes_allocated_unmanaged_high_ = RoundUp(
+      bytes_allocated_unmanaged_current_ + bytes_unmanaged_limit_step_ / 4,
+      bytes_unmanaged_limit_step_);
+  bytes_allocated_unmanaged_low_ = RoundDown(
+      bytes_allocated_unmanaged_current_,
+      bytes_unmanaged_limit_step_);
 }
 
 void GpuMemoryManager::UpdateBackgroundedAvailableGpuMemory() {
   // Be conservative and disable saving backgrounded tabs' textures on Android
   // for the moment
 #if defined(OS_ANDROID)
   bytes_backgrounded_available_gpu_memory_ = 0;
 #else
-  bytes_backgrounded_available_gpu_memory_ = bytes_available_gpu_memory_ / 4;
+  bytes_backgrounded_available_gpu_memory_ = GetAvailableGpuMemory() / 4;
 #endif
 }
 
 void GpuMemoryManager::ScheduleManage(bool immediate) {
   if (disable_schedule_manage_)
     return;
   if (manage_immediate_scheduled_)
     return;
   if (immediate) {
     MessageLoop::current()->PostTask(
@@ skipping 31 matching lines @@
       break;
     default:
       NOTREACHED();
       break;
   }
   if (new_size != old_size) {
     TRACE_COUNTER1("gpu",
                    "GpuMemoryUsage",
                    GetCurrentUsage());
   }
+
+  // If we've gone past our current limit on unmanaged memory, schedule a
+  // re-manage to take int account the unmanaged memory.
+  if (bytes_allocated_unmanaged_current_ >= bytes_allocated_unmanaged_high_)
+    ScheduleManage(true);
+  if (bytes_allocated_unmanaged_current_ < bytes_allocated_unmanaged_low_)
+    ScheduleManage(false);
+
   if (GetCurrentUsage() > bytes_allocated_historical_max_) {
       bytes_allocated_historical_max_ = GetCurrentUsage();
       // If we're blowing into new memory usage territory, spam the browser
       // process with the most up-to-date information about our memory usage.
       SendUmaStatsToBrowser();
   }
 }
 
 GpuMemoryManagerClientState* GpuMemoryManager::CreateClientState(
     GpuMemoryManagerClient* client,
@@ skipping 136 matching lines @@
 // As such, the rule for categorizing contexts without a surface is:
 //  1. Find the most visible context-with-a-surface within each
 //     context-without-a-surface's share group, and inherit its visibilty.
 void GpuMemoryManager::Manage() {
   manage_immediate_scheduled_ = false;
   delayed_manage_callback_.Cancel();
 
   // Update the amount of GPU memory available on the system.
   UpdateAvailableGpuMemory();
 
+  // Update the limit on unmanaged memory.
+  UpdateUnmanagedMemoryLimits();
+
+  // Update the backgrounded available gpu memory because it depends on
+  // the available GPU memory.
+  UpdateBackgroundedAvailableGpuMemory();
+
   // Determine which clients are "hibernated" (which determines the
   // distribution of frontbuffers and memory among clients that don't have
   // surfaces).
   SetClientsHibernatedState();
 
   // Determine how much memory to assign to give to visible and backgrounded
   // clients.
   size_t bytes_limit_when_visible = GetVisibleClientAllocation();
 
   // Experiment to determine if aggressively discarding tiles on OS X
@@ skipping 207 matching lines @@
     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
 
 #endif