Add unit tests for nonuniform GPU memmgr policy

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 38 matching lines @@
     GpuChannelManager* channel_manager,
     uint64 max_surfaces_with_frontbuffer_soft_limit)
     : channel_manager_(channel_manager),
       use_nonuniform_memory_policy_(false),
       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_default_per_client_(0),
       bytes_nonvisible_available_gpu_memory_(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),
       window_count_has_been_received_(false),
       window_count_(0),
       disable_schedule_manage_(false)
 {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
+
+#if defined(OS_ANDROID)
+  bytes_default_per_client_ = 32 * 1024 * 1024;
+  bytes_minimum_per_client_ = 32 * 1024 * 1024;
+#else
+  bytes_default_per_client_ = 64 * 1024 * 1024;
+  bytes_minimum_per_client_ = 64 * 1024 * 1024;
+#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();
   UpdateNonvisibleAvailableGpuMemory();
 }
@@ skipping 47 matching lines @@
 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
   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
 }
 
-uint64 GpuMemoryManager::GetMinimumClientAllocation() 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
-}
-
 uint64 GpuMemoryManager::CalcAvailableFromViewportArea(int viewport_area) {
   // We can't query available GPU memory from the system on Android, but
   // 18X the viewport and 50% of the dalvik heap size give us a good
   // estimate of available GPU memory on a wide range of devices.
   const int kViewportMultiplier = 18;
   const unsigned int kComponentsPerPixel = 4; // GraphicsContext3D::RGBA
   const unsigned int kBytesPerComponent = 1; // sizeof(GC3Dubyte)
   uint64 viewport_limit = viewport_area * kViewportMultiplier *
                                           kComponentsPerPixel *
                                           kBytesPerComponent;
@@ skipping 219 matching lines @@
     GpuMemoryManagerClientState* client_state,
     const GpuManagedMemoryStats& 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;
+  }
+
   if (use_nonuniform_memory_policy_) {
     // If these statistics sit outside of the range that we used in our
     // computation of memory allocations then recompute the allocations.
     if (client_state->managed_memory_stats_.bytes_nice_to_have >
         client_state->bytes_nicetohave_limit_high_) {
       ScheduleManage(kScheduleManageNow);
     } else if (client_state->managed_memory_stats_.bytes_nice_to_have <
                client_state->bytes_nicetohave_limit_low_) {
       ScheduleManage(kScheduleManageLater);
     }
@@ skipping 152 matching lines @@
   return bytes_sum_limit / bytes_size;
 }
 
 uint64 GpuMemoryManager::ComputeClientAllocationWhenVisible(
     GpuMemoryManagerClientState* client_state,
     uint64 bytes_above_required_cap,
     uint64 bytes_above_minimum_cap,
     uint64 bytes_overall_cap) {
   GpuManagedMemoryStats* stats = &client_state->managed_memory_stats_;
 
+  if (!client_state->managed_memory_stats_received_)
+    return GetDefaultClientAllocation();
+
   uint64 bytes_required = 9 * stats->bytes_required / 8;
   bytes_required = std::min(bytes_required, GetMaximumClientAllocation());
   bytes_required = std::max(bytes_required, GetMinimumClientAllocation());
 
   uint64 bytes_nicetohave = 4 * stats->bytes_nice_to_have / 3;
   bytes_nicetohave = std::min(bytes_nicetohave, GetMaximumClientAllocation());
   bytes_nicetohave = std::max(bytes_nicetohave, GetMinimumClientAllocation());
   bytes_nicetohave = std::max(bytes_nicetohave, bytes_required);
 
   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;
+
   return 9 * client_state->managed_memory_stats_.bytes_required / 8;
 }
 
 void GpuMemoryManager::ComputeVisibleSurfacesAllocationsNonuniform() {
   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
@@ skipping 153 matching lines @@
         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_allocated_nonvisible) {
+        bytes_available_nonvisible) {
       client_state->bytes_allocation_when_nonvisible_ = 0;
     }
     bytes_allocated_nonvisible +=
         client_state->bytes_allocation_when_nonvisible_;
   }
 }
 
 void GpuMemoryManager::AssignSurfacesAllocationsNonuniform() {
   // Compute allocation when for all clients.
   ComputeVisibleSurfacesAllocationsNonuniform();
@@ skipping 249 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