Add tracing of all memory allocated in all contexts

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/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/common/gpu/gpu_memory_allocation.h"
 
 namespace {
 
 const int kDelayedScheduleManageTimeoutMs = 67;
 
 bool IsInSameContextShareGroupAsAnyOf(
     const GpuCommandBufferStubBase* stub,
@@ skipping 41 matching lines @@
 }
 
 }
 
 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),
-      peak_assigned_allocation_sum_(0) {
+      bytes_allocated_current_(0),
+      bytes_allocated_historical_max_(0) {
 }
 
 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 24 matching lines @@
       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 {
+    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,
+                      bytes_allocated_current_);
+  }
+}
+
 // The current Manage algorithm simply classifies contexts (stubs) into
 // "foreground", "background", or "hibernated" categories.
 // For each of these three categories, there are predefined memory allocation
 // limits and front/backbuffer states.
 //
 // Stubs 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.
@@ skipping 143 matching lines @@
       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;
   }
-
-  if (assigned_allocation_sum > peak_assigned_allocation_sum_)
-    peak_assigned_allocation_sum_ = assigned_allocation_sum;
 }
 
 #endif