Track managed memory usage in the command buffer.

gpu/command_buffer/service/texture_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 "gpu/command_buffer/service/texture_manager.h"
 #include "base/bits.h"
 #include "base/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
@@ skipping 64 matching lines @@
   have_context_ = have_context;
   texture_infos_.clear();
   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     default_textures_[ii] = NULL;
   }
 
   if (have_context) {
     glDeleteTextures(arraysize(black_texture_ids_), black_texture_ids_);
   }
 
-  DCHECK_EQ(0u, mem_represented_);
-  UpdateMemRepresented();
+  DCHECK_EQ(0u, memory_tracker_managed_->GetMemRepresented());
+  DCHECK_EQ(0u, memory_tracker_unmanaged_->GetMemRepresented());
+  memory_tracker_managed_->UpdateMemRepresented();
+  memory_tracker_unmanaged_->UpdateMemRepresented();
 }
 
 TextureManager::TextureInfo::TextureInfo(TextureManager* manager,
                                          GLuint service_id)
     : manager_(manager),
       service_id_(service_id),
       deleted_(false),
       cleared_(true),
       num_uncleared_mips_(0),
       target_(0),
       min_filter_(GL_NEAREST_MIPMAP_LINEAR),
       mag_filter_(GL_LINEAR),
       wrap_s_(GL_REPEAT),
       wrap_t_(GL_REPEAT),
       usage_(GL_NONE),
+      tracking_pool_(MemoryTracker::Unmanaged),
       max_level_set_(-1),
       texture_complete_(false),
       cube_complete_(false),
       npot_(false),
       has_been_bound_(false),
       framebuffer_attachment_count_(0),
       owned_(true),
       stream_texture_(false),
       immutable_(false),
       estimated_size_(0) {
@@ skipping 569 matching lines @@
     }
   }
   return 0;
 }
 
 TextureManager::TextureManager(
     MemoryTracker* memory_tracker,
     FeatureInfo* feature_info,
     GLint max_texture_size,
     GLint max_cube_map_texture_size)
-    : texture_memory_tracker_(new MemoryTypeTracker(memory_tracker)),
+    : memory_tracker_managed_(
+          new MemoryTypeTracker(memory_tracker, MemoryTracker::Managed)),
+      memory_tracker_unmanaged_(
+          new MemoryTypeTracker(memory_tracker, MemoryTracker::Unmanaged)),
       feature_info_(feature_info),
       max_texture_size_(max_texture_size),
       max_cube_map_texture_size_(max_cube_map_texture_size),
       max_levels_(ComputeMipMapCount(max_texture_size,
                                      max_texture_size,
                                      max_texture_size)),
       max_cube_map_levels_(ComputeMipMapCount(max_cube_map_texture_size,
                                               max_cube_map_texture_size,
                                               max_cube_map_texture_size)),
       num_unrenderable_textures_(0),
       num_unsafe_textures_(0),
       num_uncleared_mips_(0),
       texture_info_count_(0),
-      mem_represented_(0),
       have_context_(true) {
   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     black_texture_ids_[ii] = 0;
   }
 }
 
-void TextureManager::UpdateMemRepresented() {
-  texture_memory_tracker_->UpdateMemRepresented(mem_represented_);
-}
-
 bool TextureManager::Initialize() {
-  UpdateMemRepresented();
+  memory_tracker_managed_->UpdateMemRepresented();
+  memory_tracker_unmanaged_->UpdateMemRepresented();
 
   // TODO(gman): The default textures have to be real textures, not the 0
   // texture because we simulate non shared resources on top of shared
   // resources and all contexts that share resource share the same default
   // texture.
   default_textures_[kTexture2D] = CreateDefaultAndBlackTextures(
       GL_TEXTURE_2D, &black_texture_ids_[kTexture2D]);
   default_textures_[kCubeMap] = CreateDefaultAndBlackTextures(
       GL_TEXTURE_CUBE_MAP, &black_texture_ids_[kCubeMap]);
 
@@ skipping 171 matching lines @@
   if (!info->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
-  mem_represented_ -= info->estimated_size();
+
+  GetMemTracker(info->tracking_pool_)->TrackMemFree(info->estimated_size());
   info->SetLevelInfo(
       feature_info_, target, level, internal_format, width, height, depth,
       border, format, type, cleared);
-  mem_represented_ += info->estimated_size();
-  UpdateMemRepresented();
+  GetMemTracker(info->tracking_pool_)->TrackMemAlloc(info->estimated_size());
+  GetMemTracker(info->tracking_pool_)->UpdateMemRepresented();
 
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
 }
 
@@ skipping 131 matching lines @@
   if (!info->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
-  mem_represented_ -= info->estimated_size();
+  GetMemTracker(info->tracking_pool_)->TrackMemFree(info->estimated_size());
   bool result = info->MarkMipmapsGenerated(feature_info_);
-  mem_represented_ += info->estimated_size();
-  UpdateMemRepresented();
+  GetMemTracker(info->tracking_pool_)->TrackMemAlloc(info->estimated_size());
+  GetMemTracker(info->tracking_pool_)->UpdateMemRepresented();
 
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   return result;
 }
@@ skipping 39 matching lines @@
   if (!texture->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= texture->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
-  mem_represented_ -= texture->estimated_size();
-  UpdateMemRepresented();
+  GetMemTracker(texture->tracking_pool_)->TrackMemFree(
+      texture->estimated_size());
+  GetMemTracker(texture->tracking_pool_)->UpdateMemRepresented();
+}
+
+MemoryTypeTracker* TextureManager::GetMemTracker(
+    MemoryTracker::Pool tracking_pool) {
+  switch(tracking_pool) {
+  case MemoryTracker::Managed:

[greggman, 2012/12/12 07:17:47]

style: case is indented from switch

[ccameron, 2012/12/12 21:12:33]

Done.

+    return memory_tracker_managed_.get();
+    break;
+  case MemoryTracker::Unmanaged:
+    return memory_tracker_unmanaged_.get();
+    break;
+  default:
+    break;
+  }
+  NOTREACHED();
+  return NULL;
 }
 
 bool TextureManager::GetClientId(GLuint service_id, GLuint* client_id) const {
   // This doesn't need to be fast. It's only used during slow queries.
   for (TextureInfoMap::const_iterator it = texture_infos_.begin();
        it != texture_infos_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
       return true;
     }
@@ skipping 32 matching lines @@
 void TextureManager::AddToSignature(
     TextureInfo* info,
     GLenum target,
     GLint level,
     std::string* signature) const {
   info->AddToSignature(feature_info_.get(), target, level, signature);
 }
 
 }  // namespace gles2
 }  // namespace gpu