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/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"
 
@@ skipping 252 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);

[reveman, 2015/07/24 21:16:36]

You'll need to provide a ThreadTaskRunnerHandle here.

[ericrk, 2015/07/28 21:02:32]

Done.

+
   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.
+    if (resource.second == resource.second->texture()->memory_tracking_ref_) {
+      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) {
+  uint32_t size = ref->texture()->estimated_size();
+
+  // Ignore unallocated texture IDs.
+  if (size == 0)
+    return;
+
+  uint64_t tracing_id = memory_tracker_->ClientTracingId();
+  std::string dump_name = base::StringPrintf(
+      "gl/process_%" PRIx64 "/textures/%d", tracing_id, ref->client_id());

[reveman, 2015/07/24 21:16:36]

s/%" PRIx64 "/%d/

nit: "gl/textures/client_%d/texture%d" as that would be more consistent with how
we report memory for gpu-memory-buffers

[ericrk, 2015/07/28 21:02:32]

Re-worked this to be consistent with gpu-memory-buffers.

+  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 GUID info for shared ownership with client process.
+  auto guid = base::trace_event::MemoryAllocatorDumpGuid(base::StringPrintf(
+      "gl-x-process/%" PRIx64 "/texture_%d", tracing_id, ref->client_id()));

[reveman, 2015/07/24 21:16:36]

Can you move this logic to where it can be shared between service and client?
Similar to what I did by adding GetGpuMemoryBufferGUIDForTracing to
ui/gfx/gpu_memory_buffer.h.

[ericrk, 2015/07/28 21:02:32]

Done.

+  pmd->CreateSharedGlobalAllocatorDump(guid);
+  pmd->AddOwnershipEdge(dump->guid(), guid);
+}
+
 }  // namespace gles2
 }  // namespace gpu