Add tracing for GL texture objects

cc/resources/resource_provider.cc

 // Copyright 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 "cc/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
+#include "base/format_macros.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_math.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/resources/platform_color.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/resources/shared_bitmap_manager.h"
 #include "cc/resources/transferable_resource.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "third_party/khronos/GLES2/gl2.h"
@@ skipping 371 matching lines @@
   scoped_ptr<ResourceProvider> resource_provider(new ResourceProvider(
       output_surface, shared_bitmap_manager, gpu_memory_buffer_manager,
       blocking_main_thread_task_runner, highp_threshold_min,
       use_rgba_4444_texture_format, id_allocation_chunk_size,
       use_persistent_map_for_gpu_memory_buffers));
   resource_provider->Initialize();
   return resource_provider;
 }
 
 ResourceProvider::~ResourceProvider() {
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
+
   while (!children_.empty())
     DestroyChildInternal(children_.begin(), FOR_SHUTDOWN);
   while (!resources_.empty())
     DeleteResourceInternal(resources_.begin(), FOR_SHUTDOWN);
 
   GLES2Interface* gl = ContextGL();
   if (default_resource_type_ != RESOURCE_TYPE_GL_TEXTURE) {
     // We are not in GL mode, but double check before returning.
     DCHECK(!gl);
     return;
@@ skipping 722 matching lines @@
   best_texture_format_ =
       PlatformColor::BestTextureFormat(use_texture_format_bgra_);
 
   best_render_buffer_format_ =
       PlatformColor::BestTextureFormat(caps.gpu.render_buffer_format_bgra8888);
 
   texture_id_allocator_.reset(
       new TextureIdAllocator(gl, id_allocation_chunk_size_));
   buffer_id_allocator_.reset(
       new BufferIdAllocator(gl, id_allocation_chunk_size_));
+
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this);

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

You'll need to provide a ThreadTaskRunnerHandle here to be sure that this is
called on the correct thread and there's no race at shutdown.

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

Done. Also moved this above (we were skipping registration in the GL case.

 }
 
 int ResourceProvider::CreateChild(const ReturnCallback& return_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Child child_info;
   child_info.return_callback = return_callback;
 
   int child = next_child_++;
   children_[child] = child_info;
@@ skipping 786 matching lines @@
   return context_provider ? context_provider->ContextGL() : NULL;
 }
 
 class GrContext* ResourceProvider::GrContext(bool worker_context) const {
   ContextProvider* context_provider =
       worker_context ? output_surface_->worker_context_provider()
                      : output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
+bool ResourceProvider::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // We currently only support memory dumping GL resources.

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

FYI, we should dump memory usage of shared bitmaps too and it's not very hard to
add as a browser side memory dump provider for that already exists.

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

Added this for Shared Bitmaps and for GPU Memory Buffers.

+  if (default_resource_type_ == RESOURCE_TYPE_GL_TEXTURE) {

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

is the resource.gl_id check below not enough? what if we have some resources
that were not created using the default type?

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

True - now that we log all types this no longer applies.

+    const uint64 tracing_process_id =
+        base::trace_event::MemoryDumpManager::GetInstance()
+            ->tracing_process_id();
+
+    for (const auto& resource_entry : resources_) {
+      const auto& resource = resource_entry.second;
+
+      // Only log memory if we find an internal GL resource with an allocated
+      // ID.
+      if (resource.gl_id && resource.allocated &&
+          resource.origin == Resource::INTERNAL) {
+        std::string dump_name =
+            base::StringPrintf("gl/CC/textures/%d", resource.gl_id);

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

I think the naming convention I used in my one-copy patch is better. That is to
use a dump name that describes the usage rather than the type of memory used.
Something like:

StringPrintf("cc/resource_memory/resource%d", resource_entry.first)

this way we can use the same name for gpu-memory-buffer and shared-bitmap backed
resources.

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

Makes sense.

+        base::trace_event::MemoryAllocatorDump* dump =
+            pmd->CreateAllocatorDump(dump_name);
+
+        // Calculate the size of the current resource.
+        // TODO(ericrk): Replace this with helper fn once crrev.org/1202843008
+        // goes in.
+        unsigned bytes_per_pixel = BitsPerPixel(resource.format) / 8;
+        uint32_t total_bytes =
+            resource.size.height() *
+            MathUtil::RoundUp(bytes_per_pixel * resource.size.width(), 4u);
+
+        dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                        base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                        static_cast<uint64_t>(total_bytes));
+
+        // Generate a global GUID used to share this allocation with the GPU
+        // process.
+        auto guid = base::trace_event::MemoryAllocatorDumpGuid(
+            base::StringPrintf("gl-x-process/%" PRIx64 "/texture_%d",
+                               tracing_process_id, resource.gl_id));

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

This is not going to be correct if the resource is backed by a GpuMemoryBuffer.
You need a gpumemorybuffer-x-process guid in that case.

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

Done.

+        const int kImportance = 2;
+        pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
+      }
+    }
+  }
+
+  return true;
+}
+
 }  // namespace cc