Add tracing for GL texture objects

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 <algorithm>
 #include <set>
 #include <utility>
 
 #include "base/bits.h"
 #include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/context_state.h"
 #include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "ui/gl/gl_implementation.h"
+#include "ui/gl/trace_util.h"
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 // This should contain everything to uniquely identify a Texture.
 const char TextureTag[] = "|Texture|";
 struct TextureSignature {
   GLenum target_;
@@ skipping 243 matching lines @@
   DCHECK(textures_.empty());
 
   // If this triggers, that means something is keeping a reference to
   // a Texture belonging to this.
   CHECK_EQ(texture_count_, 0u);
 
   DCHECK_EQ(0, num_unrenderable_textures_);
   DCHECK_EQ(0, num_unsafe_textures_);
   DCHECK_EQ(0, num_uncleared_mips_);
   DCHECK_EQ(0, num_images_);
+
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
 }
 
 void TextureManager::Destroy(bool have_context) {
   have_context_ = have_context;
   textures_.clear();
   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     default_textures_[ii] = NULL;
   }
 
   if (have_context) {
@@ skipping 1021 matching lines @@
                                FeatureInfo* feature_info,
                                GLint max_texture_size,
                                GLint max_cube_map_texture_size,
                                GLint max_rectangle_texture_size,
                                GLint max_3d_texture_size,
                                bool use_default_textures)
     : memory_tracker_managed_(
           new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
       memory_tracker_unmanaged_(
           new MemoryTypeTracker(memory_tracker, MemoryTracker::kUnmanaged)),
+      memory_tracker_(memory_tracker),
       feature_info_(feature_info),
       framebuffer_manager_(NULL),
       max_texture_size_(max_texture_size),
       max_cube_map_texture_size_(max_cube_map_texture_size),
       max_rectangle_texture_size_(max_rectangle_texture_size),
       max_3d_texture_size_(max_3d_texture_size),
       max_levels_(ComputeMipMapCount(GL_TEXTURE_2D,
                                      max_texture_size,
                                      max_texture_size,
                                      max_texture_size)),
@@ skipping 31 matching lines @@
   if (feature_info_->feature_flags().oes_egl_image_external) {
     default_textures_[kExternalOES] = CreateDefaultAndBlackTextures(
         GL_TEXTURE_EXTERNAL_OES, &black_texture_ids_[kExternalOES]);
   }
 
   if (feature_info_->feature_flags().arb_texture_rectangle) {
     default_textures_[kRectangleARB] = CreateDefaultAndBlackTextures(
         GL_TEXTURE_RECTANGLE_ARB, &black_texture_ids_[kRectangleARB]);
   }
 
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this, base::ThreadTaskRunnerHandle::Get());
+
   return true;
 }
 
 scoped_refptr<TextureRef>
     TextureManager::CreateDefaultAndBlackTextures(
         GLenum target,
         GLuint* black_texture) {
   static uint8 black[] = {0, 0, 0, 255};
 
   // Sampling a texture not associated with any EGLImage sibling will return
@@ skipping 632 matching lines @@
     : texture_state_(texture_state),
       begin_time_(base::TimeTicks::Now()) {
 }
 
 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
   texture_state_->texture_upload_count++;
   texture_state_->total_texture_upload_time +=
       base::TimeTicks::Now() - begin_time_;
 }
 
+bool TextureManager::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd) {
+  for (const auto& resource : textures_) {
+    // Only dump memory info for textures actually owned by this TextureManager.
+    DumpTextureRef(pmd, resource.second.get());
+  }
+
+  // Also dump TextureManager internal textures, if allocated.
+  for (int i = 0; i < kNumDefaultTextures; i++) {
+    if (default_textures_[i]) {
+      DumpTextureRef(pmd, default_textures_[i].get());
+    }
+  }
+
+  return true;
+}
+
+void TextureManager::DumpTextureRef(base::trace_event::ProcessMemoryDump* pmd,
+                                    TextureRef* ref) {
+  // TODO(ericrk): Trace image-backed textures. crbug.com/514914
+  if (ref->texture()->HasImages())
+    return;
+
+  uint32_t size = ref->texture()->estimated_size();
+
+  // Ignore unallocated texture IDs.
+  if (size == 0)
+    return;
+
+  std::string dump_name =
+      base::StringPrintf("gl/textures/client_%d/texture_%d",
+                         memory_tracker_->ClientId(), ref->client_id());
+  base::trace_event::MemoryAllocatorDump* dump =
+      pmd->CreateAllocatorDump(dump_name);
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                  static_cast<uint64_t>(size));
+
+  // Add the |client_guid| which expresses shared ownership with the client
+  // process.
+  auto client_guid = gfx::GetGLTextureGUIDForTracing(
+      memory_tracker_->ClientTracingId(), ref->client_id());
+  pmd->CreateSharedGlobalAllocatorDump(client_guid);
+  pmd->AddOwnershipEdge(dump->guid(), client_guid);
+
+  // Add a |service_guid| which expresses shared ownership between the various
+  // |client_guid|s.
+  auto service_guid =
+      gfx::GetGLTextureGUIDForTracing(0, ref->texture()->service_id());

[piman, 2015/08/03 21:36:21]

This is fine as a first pass. For Android WebView, we actually have separate
service-side share groups, so to get accurate data, you'll need to ensure
uniqueness using, maybe, the GLShareGroup. Also, on top of that we have a
sharing mechanism between these share groups which involves EGLImages (see the
code in MailboxManagerSync). Maybe add a TODO for that part?

[ericrk, 2015/08/03 22:11:04]

Done.

+  pmd->CreateSharedGlobalAllocatorDump(service_guid);
+
+  int importance = 0;  // Default importance.
+  // The link to the memory tracking |client_id| is given a higher importance
+  // than other refs.
+  if (ref == ref->texture()->memory_tracking_ref_)
+    importance = 2;
+
+  pmd->AddOwnershipEdge(client_guid, service_guid, importance);
+}
+
 }  // namespace gles2
 }  // namespace gpu