Track managed memory usage in the command buffer.

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 26 matching lines @@
 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_backgrounded_available_gpu_memory_(0),
-      bytes_allocated_current_(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),
       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_.empty());
-  DCHECK(!bytes_allocated_current_);
+  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_;
 }
 
 size_t GpuMemoryManager::GetCurrentBackgroundedAvailableGpuMemory() const {
   if (bytes_allocated_managed_visible_ < GetAvailableGpuMemory()) {
@@ skipping 170 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));
   }
 }
 
-void GpuMemoryManager::TrackMemoryAllocatedChange(size_t old_size,
-                                                  size_t new_size) {
-  TrackValueChanged(old_size, new_size, &bytes_allocated_current_);
+void GpuMemoryManager::TrackMemoryAllocatedChange(
+    size_t old_size,
+    size_t new_size,
+    gpu::gles2::MemoryTracker::Pool tracking_pool) {
+  switch (tracking_pool) {
+    case gpu::gles2::MemoryTracker::kManaged:
+      TrackValueChanged(old_size, new_size, &bytes_allocated_managed_current_);
+      break;
+    case gpu::gles2::MemoryTracker::kUnmanaged:
+      TrackValueChanged(old_size,
+                        new_size,
+                        &bytes_allocated_unmanaged_current_);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
   if (new_size != old_size) {
     TRACE_COUNTER1("gpu",
                    "GpuMemoryUsage",
-                   bytes_allocated_current_);
+                   GetCurrentUsage());
   }
-  if (bytes_allocated_current_ > bytes_allocated_historical_max_) {
-      bytes_allocated_historical_max_ = bytes_allocated_current_;
+  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();
   }
 }
 
 void GpuMemoryManager::AddClient(GpuMemoryManagerClient* client,
                                  bool has_surface,
                                  bool visible,
                                  base::TimeTicks last_used_time) {
@@ skipping 111 matching lines @@
   video_memory_usage_stats.process_map.clear();
   for (std::set<GpuMemoryTrackingGroup*>::const_iterator i =
        tracking_groups_.begin(); i != tracking_groups_.end(); ++i) {
     const GpuMemoryTrackingGroup* tracking_group = (*i);
     video_memory_usage_stats.process_map[
         tracking_group->GetPid()].video_memory += tracking_group->GetSize();
   }
 
   // Assign the total across all processes in the GPU process
   video_memory_usage_stats.process_map[
-      base::GetCurrentProcId()].video_memory = bytes_allocated_current_;
+      base::GetCurrentProcId()].video_memory = GetCurrentUsage();
   video_memory_usage_stats.process_map[
       base::GetCurrentProcId()].has_duplicates = true;
 }
 
 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)
@@ skipping 194 matching lines @@
   if (clients_allocation_when_visible >= GetMaximumTabAllocation())
     clients_allocation_when_visible = GetMaximumTabAllocation();
 
   return clients_allocation_when_visible;
 }
 
 void GpuMemoryManager::SendUmaStatsToBrowser() {
   if (!channel_manager_)
     return;
   GPUMemoryUmaStats params;
-  params.bytes_allocated_current = bytes_allocated_current_;
+  params.bytes_allocated_current = GetCurrentUsage();
   params.bytes_allocated_max = bytes_allocated_historical_max_;
   params.bytes_limit = bytes_available_gpu_memory_;
   params.window_count = window_count_;
   channel_manager_->Send(new GpuHostMsg_GpuMemoryUmaStats(params));
 }
 
 GpuMemoryManager::ClientState::ClientState(
     GpuMemoryManagerClient* client,
     bool has_surface,
     bool visible,
     base::TimeTicks last_used_time)
     : client(client),
       has_surface(has_surface),
       visible(visible),
       last_used_time(last_used_time),
       hibernated(false) {
 }
 
 }  // namespace content
 
 #endif