Delete memory manager dead code.

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 30 matching lines @@
 T RoundDown(T n, T mul) {
   return (n / mul) * mul;
 }
 
 }
 
 GpuMemoryManager::GpuMemoryManager(
     GpuChannelManager* channel_manager,
     uint64 max_surfaces_with_frontbuffer_soft_limit)
     : channel_manager_(channel_manager),
-      use_nonuniform_memory_policy_(true),
       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_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::kDisableNonuniformGpuMemPolicy))
-    use_nonuniform_memory_policy_ = false;
-
   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();
 }
 
 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_;
 }
 
-uint64 GpuMemoryManager::GetCurrentNonvisibleAvailableGpuMemory() const {
-  if (bytes_allocated_managed_visible_ < GetAvailableGpuMemory()) {
-    return std::min(bytes_nonvisible_available_gpu_memory_,
-                    GetAvailableGpuMemory() - bytes_allocated_managed_visible_);
-  }
-  return 0;
-}
-
 uint64 GpuMemoryManager::GetDefaultAvailableGpuMemory() const {
 #if defined(OS_ANDROID)
   return 32 * 1024 * 1024;
 #elif defined(OS_CHROMEOS)
   return 1024 * 1024 * 1024;
 #else
   return 256 * 1024 * 1024;
 #endif
 }
 
@@ skipping 76 matching lines @@
   // 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::UpdateNonvisibleAvailableGpuMemory() {
-  // Be conservative and disable saving nonvisible clients' textures on Android
-  // for the moment
-#if defined(OS_ANDROID)
-  bytes_nonvisible_available_gpu_memory_ = 0;
-#else
-  bytes_nonvisible_available_gpu_memory_ = GetAvailableGpuMemory() / 4;
-#endif
-}
-
 void GpuMemoryManager::ScheduleManage(
     ScheduleManageTime schedule_manage_time) {
   if (disable_schedule_manage_)
     return;
   if (manage_immediate_scheduled_)
     return;
   if (schedule_manage_time == kScheduleManageNow) {
     MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&GpuMemoryManager::Manage, AsWeakPtr()));
@@ skipping 120 matching lines @@
   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);
-    }
-  } else {
-    // If this allocation pushed our usage of nonvisible clients' memory over
-    // the limit, then schedule a drop of nonvisible memory.
-    if (bytes_allocated_managed_nonvisible_ >
-        GetCurrentNonvisibleAvailableGpuMemory())
-      ScheduleManage(kScheduleManageLater);
+  // 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);
   }
 }
 
 GpuMemoryTrackingGroup* GpuMemoryManager::CreateTrackingGroup(
     base::ProcessId pid, gpu::gles2::MemoryTracker* memory_tracker) {
   GpuMemoryTrackingGroup* tracking_group = new GpuMemoryTrackingGroup(
       pid, memory_tracker, this);
   DCHECK(!tracking_groups_.count(tracking_group->GetMemoryTracker()));
   tracking_groups_.insert(std::make_pair(tracking_group->GetMemoryTracker(),
                                          tracking_group));
@@ skipping 21 matching lines @@
   video_memory_usage_stats->process_map[
       base::GetCurrentProcId()].video_memory = GetCurrentUsage();
   video_memory_usage_stats->process_map[
       base::GetCurrentProcId()].has_duplicates = true;
 
   video_memory_usage_stats->bytes_allocated = GetCurrentUsage();
   video_memory_usage_stats->bytes_allocated_historical_max =
       bytes_allocated_historical_max_;
 }
 
-void GpuMemoryManager::SetWindowCount(uint32 window_count) {
-  bool should_schedule_manage = !window_count_has_been_received_ ||
-                                (window_count != window_count_);
-  window_count_has_been_received_ = true;
-  window_count_ = window_count;
-  if (should_schedule_manage)
-    ScheduleManage(kScheduleManageNow);
-}
-
-// The current Manage algorithm simply classifies contexts (clients) into
-// "foreground", "background", or "hibernated" categories.
-// For each of these three categories, there are predefined memory allocation
-// limits and front/backbuffer states.
-//
-// Users may or may not have a surfaces, and the rules are different for each.
-//
-// The rules for categorizing contexts with a surface are:
-//  1. Foreground: All visible surfaces.
-//                 * Must have both front and back buffer.
-//
-//  2. Background: Non visible surfaces, which have not surpassed the
-//                 max_surfaces_with_frontbuffer_soft_limit_ limit.
-//                 * Will have only a frontbuffer.
-//
-//  3. Hibernated: Non visible surfaces, which have surpassed the
-//                 max_surfaces_with_frontbuffer_soft_limit_ limit.
-//                 * Will not have either buffer.
-//
-// The considerations for categorizing contexts without a surface are:
-//  1. These contexts do not track {visibility,last_used_time}, so cannot
-//     sort them directly.
-//  2. These contexts may be used by, and thus affect, other contexts, and so
-//     cannot be less visible than any affected context.
-//  3. Contexts belong to share groups within which resources can be shared.
-//
-// 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 nonvisible available gpu memory because it depends on
-  // the available GPU memory.
-  UpdateNonvisibleAvailableGpuMemory();
-
   // Determine which clients are "hibernated" (which determines the
   // distribution of frontbuffers and memory among clients that don't have
   // surfaces).
   SetClientsHibernatedState();
 
   // Assign memory allocations to clients that have surfaces.
-  if (use_nonuniform_memory_policy_)
-    AssignSurfacesAllocationsNonuniform();
-  else
-    AssignSurfacesAllocationsUniform();
+  AssignSurfacesAllocations();
 
   // Assign memory allocations to clients that don't have surfaces.
   AssignNonSurfacesAllocations();
 
   SendUmaStatsToBrowser();
 }
 
 // static
 uint64 GpuMemoryManager::ComputeCap(
     std::vector<uint64> bytes, uint64 bytes_sum_limit)
@@ skipping 67 matching lines @@
 
 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() {
+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
   uint64 bytes_nicetohave_visible = 0;
@@ skipping 100 matching lines @@
     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::ComputeNonvisibleSurfacesAllocationsNonuniform() {
+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.
@@ skipping 97 matching lines @@
        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() {
+void GpuMemoryManager::AssignSurfacesAllocations() {
   // Compute allocation when for all clients.
-  ComputeVisibleSurfacesAllocationsNonuniform();
-  ComputeNonvisibleSurfacesAllocationsNonuniform();
+  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 25 matching lines @@
 
     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);
   }
 }
 
-void GpuMemoryManager::AssignSurfacesAllocationsUniform() {
-  // Determine how much memory to assign to give to visible and nonvisible
-  // clients.
-  uint64 bytes_limit_when_visible = GetVisibleClientAllocation();
-
-  // Experiment to determine if aggressively discarding tiles on OS X
-  // results in greater stability.
-#if defined(OS_MACOSX)
-  GpuMemoryAllocationForRenderer::PriorityCutoff priority_cutoff_when_visible =
-      GpuMemoryAllocationForRenderer::kPriorityCutoffAllowNiceToHave;
-#else
-  GpuMemoryAllocationForRenderer::PriorityCutoff priority_cutoff_when_visible =
-      GpuMemoryAllocationForRenderer::kPriorityCutoffAllowEverything;
-#endif
-
-  // Assign memory allocations to visible clients.
-  for (ClientStateList::const_iterator it = clients_visible_mru_.begin();
-       it != clients_visible_mru_.end();
-       ++it) {
-    GpuMemoryManagerClientState* client_state = *it;
-    GpuMemoryAllocation allocation;
-
-    allocation.browser_allocation.suggest_have_frontbuffer = true;
-    allocation.renderer_allocation.bytes_limit_when_visible =
-        bytes_limit_when_visible;
-    allocation.renderer_allocation.priority_cutoff_when_visible =
-        priority_cutoff_when_visible;
-
-    // Allow this client to keep its textures when nonvisible if they
-    // aren't so expensive that they won't fit.
-    if (client_state->managed_memory_stats_.bytes_required <=
-        bytes_nonvisible_available_gpu_memory_) {
-      allocation.renderer_allocation.bytes_limit_when_not_visible =
-          GetCurrentNonvisibleAvailableGpuMemory();
-      allocation.renderer_allocation.priority_cutoff_when_not_visible =
-          GpuMemoryAllocationForRenderer::kPriorityCutoffAllowOnlyRequired;
-    } else {
-        allocation.renderer_allocation.bytes_limit_when_not_visible = 0;
-        allocation.renderer_allocation.priority_cutoff_when_not_visible =
-            GpuMemoryAllocationForRenderer::kPriorityCutoffAllowNothing;
-    }
-
-    client_state->client_->SetMemoryAllocation(allocation);
-  }
-
-  // Assign memory allocations to nonvisible clients.
-  uint64 bytes_allocated_nonvisible = 0;
-  for (ClientStateList::const_iterator it = clients_nonvisible_mru_.begin();
-       it != clients_nonvisible_mru_.end();
-       ++it) {
-    GpuMemoryManagerClientState* client_state = *it;
-    GpuMemoryAllocation allocation;
-
-    allocation.browser_allocation.suggest_have_frontbuffer =
-        !client_state->hibernated_;
-    allocation.renderer_allocation.bytes_limit_when_visible =
-        bytes_limit_when_visible;
-    allocation.renderer_allocation.priority_cutoff_when_visible =
-        priority_cutoff_when_visible;
-
-    if (client_state->managed_memory_stats_.bytes_required +
-        bytes_allocated_nonvisible <=
-        GetCurrentNonvisibleAvailableGpuMemory()) {
-      bytes_allocated_nonvisible +=
-          client_state->managed_memory_stats_.bytes_required;
-      allocation.renderer_allocation.bytes_limit_when_not_visible =
-          GetCurrentNonvisibleAvailableGpuMemory();
-      allocation.renderer_allocation.priority_cutoff_when_not_visible =
-          GpuMemoryAllocationForRenderer::kPriorityCutoffAllowOnlyRequired;
-    } else {
-      allocation.renderer_allocation.bytes_limit_when_not_visible = 0;
-      allocation.renderer_allocation.priority_cutoff_when_not_visible =
-          GpuMemoryAllocationForRenderer::kPriorityCutoffAllowNothing;
-    }
-
-    client_state->client_->SetMemoryAllocation(allocation);
-  }
-}
-
 void GpuMemoryManager::AssignNonSurfacesAllocations() {
   for (ClientStateList::const_iterator it = clients_nonsurface_.begin();
        it != clients_nonsurface_.end();
        ++it) {
     GpuMemoryManagerClientState* client_state = *it;
     GpuMemoryAllocation allocation;
 
     if (!client_state->hibernated_) {
       allocation.renderer_allocation.bytes_limit_when_visible =
           GetMinimumClientAllocation();
@@ skipping 40 matching lines @@
   // Clients that don't have surfaces are non-hibernated if they are
   // in a GL share group with a non-hibernated surface.
   for (ClientStateList::const_iterator it = clients_nonsurface_.begin();
        it != clients_nonsurface_.end();
        ++it) {
     GpuMemoryManagerClientState* client_state = *it;
     client_state->hibernated_ = client_state->tracking_group_->hibernated_;
   }
 }
 
-uint64 GpuMemoryManager::GetVisibleClientAllocation() const {
-  // Count how many clients will get allocations.
-  size_t clients_with_surface_visible_count = clients_visible_mru_.size();
-  size_t clients_without_surface_not_hibernated_count = 0;
-  for (ClientStateList::const_iterator it = clients_nonsurface_.begin();
-       it != clients_nonsurface_.end();
-       ++it) {
-    GpuMemoryManagerClientState* client_state = *it;
-    if (!client_state->hibernated_)
-      clients_without_surface_not_hibernated_count++;
-  }
-
-  // Calculate bonus allocation by splitting remainder of global limit equally
-  // after giving out the minimum to those that need it.
-  size_t num_clients_need_mem = clients_with_surface_visible_count +
-                                clients_without_surface_not_hibernated_count;
-  uint64 base_allocation_size = GetMinimumClientAllocation() *
-                                num_clients_need_mem;
-  uint64 bonus_allocation = 0;
-  if (base_allocation_size < GetAvailableGpuMemory() &&
-      clients_with_surface_visible_count)
-    bonus_allocation = (GetAvailableGpuMemory() - base_allocation_size) /
-                       clients_with_surface_visible_count;
-  uint64 clients_allocation_when_visible = GetMinimumClientAllocation() +
-                                           bonus_allocation;
-
-  // If we have received a window count message, then override the client-based
-  // scheme with a per-window scheme
-  if (window_count_has_been_received_) {
-    clients_allocation_when_visible = std::max(
-        clients_allocation_when_visible,
-        GetAvailableGpuMemory() / std::max(window_count_, 1u));
-  }
-
-  // Limit the memory per client to its maximum allowed level.
-  if (clients_allocation_when_visible >= GetMaximumClientAllocation())
-    clients_allocation_when_visible = GetMaximumClientAllocation();
-
-  return clients_allocation_when_visible;
-}
-
 void GpuMemoryManager::SendUmaStatsToBrowser() {
   if (!channel_manager_)
     return;
   GPUMemoryUmaStats params;
   params.bytes_allocated_current = GetCurrentUsage();
   params.bytes_allocated_max = bytes_allocated_historical_max_;
   params.bytes_limit = bytes_available_gpu_memory_;
   params.client_count = clients_visible_mru_.size() +
                         clients_nonvisible_mru_.size() +
                         clients_nonsurface_.size();
   params.context_group_count = tracking_groups_.size();
-  params.window_count = window_count_;
   channel_manager_->Send(new GpuHostMsg_GpuMemoryUmaStats(params));
 }
 
 GpuMemoryManager::ClientStateList* GpuMemoryManager::GetClientList(
     GpuMemoryManagerClientState* client_state) {
   if (client_state->has_surface_) {
     if (client_state->visible_)
       return &clients_visible_mru_;
     else
       return &clients_nonvisible_mru_;
@@ skipping 12 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