Add a flag to specify the amount of total GPU memory available.

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>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
+#include "base/string_number_conversions.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/common/gpu/gpu_memory_allocation.h"
+#include "gpu/command_buffer/service/gpu_switches.h"
 
 namespace {
 
 const int kDelayedScheduleManageTimeoutMs = 67;
 
 bool IsInSameContextShareGroupAsAnyOf(
     const GpuCommandBufferStubBase* stub,
     const std::vector<GpuCommandBufferStubBase*>& stubs) {
   for (std::vector<GpuCommandBufferStubBase*>::const_iterator it =
       stubs.begin(); it != stubs.end(); ++it) {
     if (stub->IsInSameContextShareGroup(**it))
       return true;
   }
   return false;
 }
 
-#if defined(OS_ANDROID)
-size_t CalculateBonusMemoryAllocationBasedOnSize(gfx::Size size) {
-  const int viewportMultiplier = 16;
-  const unsigned int componentsPerPixel = 4; // GraphicsContext3D::RGBA
-  const unsigned int bytesPerComponent = 1; // sizeof(GC3Dubyte)
-
-  if (size.IsEmpty())
-    return 0;
-
-  size_t limit = viewportMultiplier * size.width() * size.height() *
-                     componentsPerPixel * bytesPerComponent;
-  if (limit < GpuMemoryManager::kMinimumAllocationForTab)
-    limit = GpuMemoryManager::kMinimumAllocationForTab;
-  else if (limit > GpuMemoryManager::kMaximumAllocationForTabs)
-    limit = GpuMemoryManager::kMaximumAllocationForTabs;
-  return limit - GpuMemoryManager::kMinimumAllocationForTab;
-}
-#endif
-
 void AssignMemoryAllocations(
     GpuMemoryManager::StubMemoryStatMap* stub_memory_stats,
     const std::vector<GpuCommandBufferStubBase*>& stubs,
     GpuMemoryAllocation allocation,
     bool visible) {
   for (std::vector<GpuCommandBufferStubBase*>::const_iterator it =
           stubs.begin();
       it != stubs.end();
       ++it) {
     (*it)->SetMemoryAllocation(allocation);
     (*stub_memory_stats)[*it].allocation = allocation;
     (*stub_memory_stats)[*it].visible = visible;
   }
 }
 
 }
 
+size_t GpuMemoryManager::CalculateBonusMemoryAllocationBasedOnSize(
+    gfx::Size size) const {
+  const int kViewportMultiplier = 16;
+  const unsigned int kComponentsPerPixel = 4; // GraphicsContext3D::RGBA
+  const unsigned int kBytesPerComponent = 1; // sizeof(GC3Dubyte)
+
+  if (size.IsEmpty())
+    return 0;
+
+  size_t limit = kViewportMultiplier * size.width() * size.height() *
+                 kComponentsPerPixel * kBytesPerComponent;
+  if (limit < GetMinimumTabAllocation())
+    limit = GetMinimumTabAllocation();
+  else if (limit > GetAvailableGpuMemory())
+    limit = GetAvailableGpuMemory();
+  return limit - GetMinimumTabAllocation();
+}
+
 GpuMemoryManager::GpuMemoryManager(GpuMemoryManagerClient* client,
         size_t max_surfaces_with_frontbuffer_soft_limit)
     : client_(client),
       manage_immediate_scheduled_(false),
       max_surfaces_with_frontbuffer_soft_limit_(
           max_surfaces_with_frontbuffer_soft_limit),
+      bytes_available_gpu_memory_(0),
       bytes_allocated_current_(0),
       bytes_allocated_historical_max_(0) {
+  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;
+  } else {
+#if defined(OS_ANDROID)
+    bytes_available_gpu_memory_ = 64 * 1024 * 1024;
+#else
+    bytes_available_gpu_memory_ = 448 * 1024 * 1024;
+#endif
+  }
 }
 
 GpuMemoryManager::~GpuMemoryManager() {
 }
 
 bool GpuMemoryManager::StubWithSurfaceComparator::operator()(
     GpuCommandBufferStubBase* lhs,
     GpuCommandBufferStubBase* rhs) {
   DCHECK(lhs->has_surface_state() && rhs->has_surface_state());
   const GpuCommandBufferStubBase::SurfaceState& lhs_ss = lhs->surface_state();
@@ skipping 19 matching lines @@
       return;
     delayed_manage_callback_.Reset(base::Bind(&GpuMemoryManager::Manage,
                                               AsWeakPtr()));
     MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       delayed_manage_callback_.callback(),
       base::TimeDelta::FromMilliseconds(kDelayedScheduleManageTimeoutMs));
   }
 }
 
-size_t GpuMemoryManager::GetAvailableGpuMemory() const {
-  // TODO(mmocny): Implement this with real system figures.
-  return kMaximumAllocationForTabs;
-}
-
 void GpuMemoryManager::TrackMemoryAllocatedChange(size_t old_size,
                                                   size_t new_size)
 {
   if (new_size < old_size) {
     size_t delta = old_size - new_size;
     DCHECK(bytes_allocated_current_ >= delta);
     bytes_allocated_current_ -= delta;
-  }
-  else {
+  } else {
     size_t delta = new_size - old_size;
     bytes_allocated_current_ += delta;
     if (bytes_allocated_current_ > bytes_allocated_historical_max_) {
       bytes_allocated_historical_max_ = bytes_allocated_current_;
     }
   }
   if (new_size != old_size) {
     TRACE_COUNTER_ID1("GpuMemoryManager",
                       "GpuMemoryUsage",
                       this,
@@ skipping 95 matching lines @@
       stubs_without_surface_hibernated.push_back(stub);
   }
 
   size_t bonus_allocation = 0;
 #if !defined(OS_ANDROID)
   // Calculate bonus allocation by splitting remainder of global limit equally
   // after giving out the minimum to those that need it.
   size_t num_stubs_need_mem = stubs_with_surface_foreground.size() +
                               stubs_without_surface_foreground.size() +
                               stubs_without_surface_background.size();
-  size_t base_allocation_size = kMinimumAllocationForTab * num_stubs_need_mem;
-  if (base_allocation_size < kMaximumAllocationForTabs &&
+  size_t base_allocation_size = GetMinimumTabAllocation() * num_stubs_need_mem;
+  if (base_allocation_size < GetAvailableGpuMemory() &&
       !stubs_with_surface_foreground.empty())
-    bonus_allocation = (kMaximumAllocationForTabs - base_allocation_size) /
-                           stubs_with_surface_foreground.size();
+    bonus_allocation = (GetAvailableGpuMemory() - base_allocation_size) /
+                       stubs_with_surface_foreground.size();
 #else
   // On android, calculate bonus allocation based on surface size.
   if (!stubs_with_surface_foreground.empty())
     bonus_allocation = CalculateBonusMemoryAllocationBasedOnSize(
         stubs_with_surface_foreground[0]->GetSurfaceSize());
 #endif
 
   stub_memory_stats_for_last_manage_.clear();
 
   // Now give out allocations to everyone.
   AssignMemoryAllocations(
       &stub_memory_stats_for_last_manage_,
       stubs_with_surface_foreground,
-      GpuMemoryAllocation(kMinimumAllocationForTab + bonus_allocation,
+      GpuMemoryAllocation(GetMinimumTabAllocation() + bonus_allocation,
           GpuMemoryAllocation::kHasFrontbuffer |
           GpuMemoryAllocation::kHasBackbuffer),
       true);
 
   AssignMemoryAllocations(
       &stub_memory_stats_for_last_manage_,
       stubs_with_surface_background,
       GpuMemoryAllocation(0, GpuMemoryAllocation::kHasFrontbuffer),
       false);
 
   AssignMemoryAllocations(
       &stub_memory_stats_for_last_manage_,
       stubs_with_surface_hibernated,
       GpuMemoryAllocation(0, GpuMemoryAllocation::kHasNoBuffers),
       false);
 
   AssignMemoryAllocations(
       &stub_memory_stats_for_last_manage_,
       stubs_without_surface_foreground,
-      GpuMemoryAllocation(kMinimumAllocationForTab,
+      GpuMemoryAllocation(GetMinimumTabAllocation(),
           GpuMemoryAllocation::kHasNoBuffers),
       true);
 
   AssignMemoryAllocations(
       &stub_memory_stats_for_last_manage_,
       stubs_without_surface_background,
-      GpuMemoryAllocation(kMinimumAllocationForTab,
+      GpuMemoryAllocation(GetMinimumTabAllocation(),
           GpuMemoryAllocation::kHasNoBuffers),
       false);
 
   AssignMemoryAllocations(
       &stub_memory_stats_for_last_manage_,
       stubs_without_surface_hibernated,
       GpuMemoryAllocation(0, GpuMemoryAllocation::kHasNoBuffers),
       false);
-
-  size_t assigned_allocation_sum = 0;
-  for (StubMemoryStatMap::iterator it =
-          stub_memory_stats_for_last_manage_.begin();
-      it != stub_memory_stats_for_last_manage_.end();
-      ++it) {
-    assigned_allocation_sum += it->second.allocation.gpu_resource_size_in_bytes;
-  }
 }
 
 #endif