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/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/thread_task_runner_handle.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"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrTextureProvider.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/gpu_memory_buffer.h"
+#include "ui/gl/trace_util.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
 class IdAllocator {
  public:
   virtual ~IdAllocator() {}
 
   virtual GLuint NextId() = 0;
@@ skipping 354 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 693 matching lines @@
       use_sync_query_(false),
       use_persistent_map_for_gpu_memory_buffers_(
           use_persistent_map_for_gpu_memory_buffers) {
   DCHECK(output_surface_->HasClient());
   DCHECK(id_allocation_chunk_size_);
 }
 
 void ResourceProvider::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this, base::ThreadTaskRunnerHandle::Get());
+
   GLES2Interface* gl = ContextGL();
   if (!gl) {
     default_resource_type_ = RESOURCE_TYPE_BITMAP;
     // Pick an arbitrary limit here similar to what hardware might.
     max_texture_size_ = 16 * 1024;
     best_texture_format_ = RGBA_8888;
     return;
   }
 
   DCHECK(!texture_id_allocator_);
@@ skipping 821 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;
 }
 
+base::trace_event::MemoryAllocatorDump* ResourceProvider::DumpForResource(
+    base::trace_event::ProcessMemoryDump* pmd,
+    const ResourceId& id,
+    const Resource& resource) const {
+  std::string dump_name =
+      base::StringPrintf("CC/resource_memory/resource_%d", id);

[reveman, 2015/07/28 21:38:49]

nit: I'm using lower case "cc/..." in one-copy dump provider and having this be
consistent is useful when trying to determine the total amount of memory used by
cc/

[ericrk, 2015/07/29 18:46:45]

Done.

+  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.com/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));
+
+  return dump;
+}
+
+bool ResourceProvider::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  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 INTERNAL resources - other resources are owned by (and will be
+    // logged by) another ResourceProvider.
+    if (resource.origin != Resource::INTERNAL)
+      continue;
+
+    if (resource.gpu_memory_buffer) {
+      auto dump =
+          DumpForResource(pmd, resource_entry.first, resource_entry.second);
+
+      // Generate a global GUID used to share this allocation with the GPU
+      // process.

[reveman, 2015/07/28 21:38:49]

Not just the GPU process but also the browser process. Maybe say "...to share
this allocation with other processes."

[ericrk, 2015/07/29 18:46:46]

Done.

+      auto guid = gfx::GetSharedBitmapGUIDForTracing(

[reveman, 2015/07/28 21:38:49]

SharedBitmap? shouldn't this be gfx::GetGpuMemoryBufferGUIDForTracing?

[ssid, 2015/07/29 11:17:43]

+1

[ericrk, 2015/07/29 18:46:46]

my bad, did a re-name right at the end and replaced the wrong thing.

+          tracing_process_id, resource.gpu_memory_buffer->GetHandle().id);
+      const int kImportance = 2;

[petrcermak, 2015/07/29 16:13:34]

This constant is defined three times within this function. Could it be a global
constant within this file?

[ericrk, 2015/07/29 18:46:46]

refactored this section - should be a lot nicer now.

+      pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);

[petrcermak, 2015/07/29 16:13:34]

This call is also repeated three times withing this function. I'd factor it out
of the if-statement.

[ericrk, 2015/07/29 18:46:45]

refactored.

+    } else if (resource.shared_bitmap) {
+      auto dump =
+          DumpForResource(pmd, resource_entry.first, resource_entry.second);

[ssid, 2015/07/29 11:17:43]

This can be moved out of the if/else. It seems common. I also think the function
DumpForResource can be removed and the 2 lines moved in this method.
This might be easier to read the code, instead of moving between functions.

[ericrk, 2015/07/29 18:46:46]

Done.

+
+      // Generate a global GUID used to share this allocation with the GPU
+      // process.

[reveman, 2015/07/28 21:38:49]

Not the GPU process. Only the browser process in case of shared bitmaps.

[ericrk, 2015/07/29 18:46:46]

refactored.

+      auto guid =
+          GetSharedMemoryBufferGUIDForTracing(resource.shared_bitmap->id());

[reveman, 2015/07/28 21:38:49]

what's GetSharedMemoryBufferGUIDForTracing? is this not where we should be using
gfx::GetSharedBitmapGUIDForTracing?

[ssid, 2015/07/29 11:17:43]

I can't find this function?

[ericrk, 2015/07/29 18:46:45]

meant to replace this via rename, replaced the wrong thing.

+      const int kImportance = 2;
+      pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
+    } else if (resource.gl_id && resource.allocated) {
+      auto dump =
+          DumpForResource(pmd, resource_entry.first, resource_entry.second);
+
+      // Generate a global GUID used to share this allocation with the GPU
+      // process.
+      auto guid =
+          gfx::GetGLTextureGUIDForTracing(tracing_process_id, resource.gl_id);

[ssid, 2015/07/29 11:17:43]

Am i missing a dependent cl?

[ericrk, 2015/07/29 18:46:46]

added missing files.

+      const int kImportance = 2;
+      pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);

[ssid, 2015/07/29 11:17:43]

I think this memory is shared between processes. In that case just adding
ownership edge does not help, the dump with the guid must be actually created in
both the processes.
You need to add pmd->CreateSharedGlobalAllocatorDump(guid); for the ownership
edge to be valid.

[ericrk, 2015/07/29 18:46:45]

Interestingly, this was working - probably because we add the
SharedGlobalAllocatorDump for the same GUID in texture_manager.cc?

Added this.

+    }
+  }
+
+  return true;
+}
+
 }  // namespace cc