gpu: Add memory tracing for GrContext in GPU process.

Include memory dump from GrContext used for OOP raster in the GPU
process in traces.

R=bsalomon@chromium.org, ericrk@chromium.org, sadrul@chromium.org
TBR=bsalomon@google.com

Bug: 859419
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: Ie010e1c567626343d5698b02c45776d215640da0
Reviewed-on: https://chromium-review.googlesource.com/1123894
Commit-Queue: Khushal <khushalsagar@chromium.org>
Reviewed-by: Brian Salomon <bsalomon@google.com>
Reviewed-by: Eric Karl <ericrk@chromium.org>
Reviewed-by: Sadrul Chowdhury <sadrul@chromium.org>
Cr-Commit-Position: refs/heads/master@{#573479}

gpu/command_buffer/common/BUILD.gn

@@ -146,6 +146,8 @@ source_set("raster_sources") {
   deps = [
     ":gles2_utils",
     "//base",
+    "//skia",
+    "//ui/gl:gl",
   ]
   public_deps = [
     ":common",

gpu/command_buffer/common/DEPS

 include_rules = [
   "+components/viz/common/resources/resource_format.h",
   "+components/viz/common/resources/resource_format_utils.h",
+  "+third_party/skia/include",
 ]
 specific_include_rules = {
   "unittest_main\.cc": [

gpu/command_buffer/common/skia_utils.cc

@@ -5,10 +5,119 @@
 #include "gpu/command_buffer/common/skia_utils.h"
 
 #include "base/sys_info.h"
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/process_memory_dump.h"
 #include "build/build_config.h"
+#include "third_party/skia/include/core/SkTraceMemoryDump.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "ui/gl/trace_util.h"
 
 namespace gpu {
 namespace raster {
+namespace {
+
+// Derives from SkTraceMemoryDump and implements graphics specific memory
+// backing functionality.
+class SkiaGpuTraceMemoryDump : public SkTraceMemoryDump {
+ public:
+  // This should never outlive the provided ProcessMemoryDump, as it should
+  // always be scoped to a single OnMemoryDump funciton call.
+  SkiaGpuTraceMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                         base::Optional<uint64_t> share_group_tracing_guid)
+      : pmd_(pmd),
+        share_group_tracing_guid_(share_group_tracing_guid),
+        tracing_process_id_(base::trace_event::MemoryDumpManager::GetInstance()
+                                ->GetTracingProcessId()) {}
+
+  ~SkiaGpuTraceMemoryDump() override = default;
+
+  // Overridden from SkTraceMemoryDump:
+  void dumpNumericValue(const char* dump_name,
+                        const char* value_name,
+                        const char* units,
+                        uint64_t value) override {
+    auto* dump = GetOrCreateAllocatorDump(dump_name);
+    dump->AddScalar(value_name, units, value);
+  }
+
+  void setMemoryBacking(const char* dump_name,
+                        const char* backing_type,
+                        const char* backing_object_id) override {
+    // If we don't have a unique tracing guid, these resources are not
+    // referenced across processes and don't need ownership edges.
+    if (!share_group_tracing_guid_)
+      return;
+
+    // For uniformity, skia provides this value as a string. Convert back to a
+    // uint32_t.
+    uint32_t gl_id =
+        std::strtoul(backing_object_id, nullptr /* str_end */, 10 /* base */);
+
+    // Constants used by SkiaGpuTraceMemoryDump to identify different memory
+    // types.
+    const char* kGLTextureBackingType = "gl_texture";
+    const char* kGLBufferBackingType = "gl_buffer";
+    const char* kGLRenderbufferBackingType = "gl_renderbuffer";
+
+    // Populated in if statements below.
+    base::trace_event::MemoryAllocatorDumpGuid guid;
+
+    if (strcmp(backing_type, kGLTextureBackingType) == 0) {
+      guid = gl::GetGLTextureClientGUIDForTracing(*share_group_tracing_guid_,
+                                                  gl_id);
+    } else if (strcmp(backing_type, kGLBufferBackingType) == 0) {
+      guid = gl::GetGLBufferGUIDForTracing(tracing_process_id_, gl_id);
+    } else if (strcmp(backing_type, kGLRenderbufferBackingType) == 0) {
+      guid = gl::GetGLRenderbufferGUIDForTracing(tracing_process_id_, gl_id);
+    }
+
+    if (!guid.empty()) {
+      pmd_->CreateSharedGlobalAllocatorDump(guid);
+
+      auto* dump = GetOrCreateAllocatorDump(dump_name);
+
+      const int kImportance = 2;
+      pmd_->AddOwnershipEdge(dump->guid(), guid, kImportance);
+    }
+  }
+
+  void setDiscardableMemoryBacking(
+      const char* dump_name,
+      const SkDiscardableMemory& discardable_memory_object) override {
+    // We don't use this class for dumping discardable memory.
+    NOTREACHED();
+  }
+
+  LevelOfDetail getRequestedDetails() const override {
+    // TODO(ssid): Use MemoryDumpArgs to create light dumps when requested
+    // (crbug.com/499731).
+    return kObjectsBreakdowns_LevelOfDetail;
+  }
+
+  bool shouldDumpWrappedObjects() const override {
+    // Chrome already dumps objects it imports into Skia. Avoid duplicate dumps
+    // by asking Skia not to dump them.
+    return false;
+  }
+
+ private:
+  // Helper to create allocator dumps.
+  base::trace_event::MemoryAllocatorDump* GetOrCreateAllocatorDump(
+      const char* dump_name) {
+    auto* dump = pmd_->GetAllocatorDump(dump_name);
+    if (!dump)
+      dump = pmd_->CreateAllocatorDump(dump_name);
+    return dump;
+  }
+
+  base::trace_event::ProcessMemoryDump* pmd_;
+  base::Optional<uint64_t> share_group_tracing_guid_;
+  uint64_t tracing_process_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(SkiaGpuTraceMemoryDump);
+};
+
+}  // namespace
 
 void DetermineGrCacheLimitsFromAvailableMemory(
     size_t* max_resource_cache_bytes,
@@ -50,5 +159,12 @@ void DefaultGrCacheLimitsForTests(size_t* max_resource_cache_bytes,
   *max_glyph_cache_texture_bytes = kDefaultGlyphCacheTextureBytes;
 }
 
+void DumpGrMemoryStatistics(const GrContext* context,
+                            base::trace_event::ProcessMemoryDump* pmd,
+                            base::Optional<uint64_t> tracing_guid) {
+  SkiaGpuTraceMemoryDump trace_memory_dump(pmd, tracing_guid);
+  context->dumpMemoryStatistics(&trace_memory_dump);
+}
+
 }  // namespace raster
 }  // namespace gpu

gpu/command_buffer/common/skia_utils.h

@@ -6,8 +6,18 @@
 #define GPU_COMMAND_BUFFER_COMMON_SKIA_UTILS_H_
 
 #include <memory>
+
+#include "base/optional.h"
 #include "gpu/raster_export.h"
 
+class GrContext;
+
+namespace base {
+namespace trace_event {
+class ProcessMemoryDump;
+}
+}  // namespace base
+
 namespace gpu {
 namespace raster {
 
@@ -19,6 +29,13 @@ RASTER_EXPORT void DefaultGrCacheLimitsForTests(
     size_t* max_resource_cache_bytes,
     size_t* max_glyph_cache_texture_bytes);
 
+// Dumps memory usage from the |context| to |pmd|. A |tracing_guid| can be used
+// if these resources are referenced across processes for sharing across dumps.
+RASTER_EXPORT void DumpGrMemoryStatistics(
+    const GrContext* context,
+    base::trace_event::ProcessMemoryDump* pmd,
+    base::Optional<uint64_t> tracing_guid);
+
 }  // namespace raster
 }  // namespace gpu
 

gpu/command_buffer/service/raster_decoder_context_state.cc

@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/raster_decoder_context_state.h"
 
+#include "base/threading/thread_task_runner_handle.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "gpu/config/gpu_driver_bug_workarounds.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_share_group.h"
@@ -21,11 +23,18 @@ RasterDecoderContextState::RasterDecoderContextState(
     : share_group(std::move(share_group)),
       surface(std::move(surface)),
       context(std::move(context)),
-      use_virtualized_gl_contexts(use_virtualized_gl_contexts) {}
+      use_virtualized_gl_contexts(use_virtualized_gl_contexts) {
+  if (base::ThreadTaskRunnerHandle::IsSet()) {
+    base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+        this, "RasterDecoderContextState", base::ThreadTaskRunnerHandle::Get());
+  }
+}
 
 RasterDecoderContextState::~RasterDecoderContextState() {
   if (gr_context)
     gr_context->abandonContext();
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
 }
 
 void RasterDecoderContextState::InitializeGrContext(
@@ -62,5 +71,13 @@ void RasterDecoderContextState::InitializeGrContext(
   }
 }
 
+bool RasterDecoderContextState::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  if (gr_context)
+    DumpGrMemoryStatistics(gr_context.get(), pmd, base::nullopt);
+  return true;
+}
+
 }  // namespace raster
 }  // namespace gpu

gpu/command_buffer/service/raster_decoder_context_state.h

@@ -6,6 +6,7 @@
 #define GPU_COMMAND_BUFFER_SERVICE_RASTER_DECODER_CONTEXT_STATE_H_
 
 #include "base/memory/ref_counted.h"
+#include "base/trace_event/memory_dump_provider.h"
 #include "gpu/command_buffer/common/skia_utils.h"
 #include "gpu/gpu_gles2_export.h"
 #include "third_party/skia/include/gpu/GrContext.h"
@@ -22,7 +23,8 @@ class GpuDriverBugWorkarounds;
 namespace raster {
 
 struct GPU_GLES2_EXPORT RasterDecoderContextState
-    : public base::RefCounted<RasterDecoderContextState> {
+    : public base::RefCounted<RasterDecoderContextState>,
+      public base::trace_event::MemoryDumpProvider {
  public:
   RasterDecoderContextState(scoped_refptr<gl::GLShareGroup> share_group,
                             scoped_refptr<gl::GLSurface> surface,
@@ -44,9 +46,13 @@ struct GPU_GLES2_EXPORT RasterDecoderContextState
   // PermitsInconsistentContextState.
   bool need_context_state_reset = false;
 
+  // base::trace_event::MemoryDumpProvider implementation.
+  bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
+                    base::trace_event::ProcessMemoryDump* pmd) override;
+
  private:
   friend class base::RefCounted<RasterDecoderContextState>;
-  ~RasterDecoderContextState();
+  ~RasterDecoderContextState() override;
 };
 
 }  // namespace raster

services/ui/public/cpp/gpu/context_provider_command_buffer.cc

@@ -40,104 +40,6 @@
 
 class SkDiscardableMemory;
 
-namespace {
-
-// Derives from SkTraceMemoryDump and implements graphics specific memory
-// backing functionality.
-class SkiaGpuTraceMemoryDump : public SkTraceMemoryDump {
- public:
-  // This should never outlive the provided ProcessMemoryDump, as it should
-  // always be scoped to a single OnMemoryDump funciton call.
-  explicit SkiaGpuTraceMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
-                                  uint64_t share_group_tracing_guid)
-      : pmd_(pmd), share_group_tracing_guid_(share_group_tracing_guid) {}
-
-  // Overridden from SkTraceMemoryDump:
-  void dumpNumericValue(const char* dump_name,
-                        const char* value_name,
-                        const char* units,
-                        uint64_t value) override {
-    auto* dump = GetOrCreateAllocatorDump(dump_name);
-    dump->AddScalar(value_name, units, value);
-  }
-
-  void setMemoryBacking(const char* dump_name,
-                        const char* backing_type,
-                        const char* backing_object_id) override {
-    const uint64_t tracing_process_id =
-        base::trace_event::MemoryDumpManager::GetInstance()
-            ->GetTracingProcessId();
-
-    // For uniformity, skia provides this value as a string. Convert back to a
-    // uint32_t.
-    uint32_t gl_id =
-        std::strtoul(backing_object_id, nullptr /* str_end */, 10 /* base */);
-
-    // Constants used by SkiaGpuTraceMemoryDump to identify different memory
-    // types.
-    const char* kGLTextureBackingType = "gl_texture";
-    const char* kGLBufferBackingType = "gl_buffer";
-    const char* kGLRenderbufferBackingType = "gl_renderbuffer";
-
-    // Populated in if statements below.
-    base::trace_event::MemoryAllocatorDumpGuid guid;
-
-    if (strcmp(backing_type, kGLTextureBackingType) == 0) {
-      guid = gl::GetGLTextureClientGUIDForTracing(share_group_tracing_guid_,
-                                                  gl_id);
-    } else if (strcmp(backing_type, kGLBufferBackingType) == 0) {
-      guid = gl::GetGLBufferGUIDForTracing(tracing_process_id, gl_id);
-    } else if (strcmp(backing_type, kGLRenderbufferBackingType) == 0) {
-      guid = gl::GetGLRenderbufferGUIDForTracing(tracing_process_id, gl_id);
-    }
-
-    if (!guid.empty()) {
-      pmd_->CreateSharedGlobalAllocatorDump(guid);
-
-      auto* dump = GetOrCreateAllocatorDump(dump_name);
-
-      const int kImportance = 2;
-      pmd_->AddOwnershipEdge(dump->guid(), guid, kImportance);
-    }
-  }
-
-  void setDiscardableMemoryBacking(
-      const char* dump_name,
-      const SkDiscardableMemory& discardable_memory_object) override {
-    // We don't use this class for dumping discardable memory.
-    NOTREACHED();
-  }
-
-  LevelOfDetail getRequestedDetails() const override {
-    // TODO(ssid): Use MemoryDumpArgs to create light dumps when requested
-    // (crbug.com/499731).
-    return kObjectsBreakdowns_LevelOfDetail;
-  }
-
-  bool shouldDumpWrappedObjects() const override {
-    // Chrome already dumps objects it imports into Skia. Avoid duplicate dumps
-    // by asking Skia not to dump them.
-    return false;
-  }
-
- private:
-  // Helper to create allocator dumps.
-  base::trace_event::MemoryAllocatorDump* GetOrCreateAllocatorDump(
-      const char* dump_name) {
-    auto* dump = pmd_->GetAllocatorDump(dump_name);
-    if (!dump)
-      dump = pmd_->CreateAllocatorDump(dump_name);
-    return dump;
-  }
-
-  base::trace_event::ProcessMemoryDump* pmd_;
-  uint64_t share_group_tracing_guid_;
-
-  DISALLOW_COPY_AND_ASSIGN(SkiaGpuTraceMemoryDump);
-};
-
-}  // namespace
-
 namespace ui {
 
 ContextProviderCommandBuffer::ContextProviderCommandBuffer(
@@ -538,9 +440,8 @@ bool ContextProviderCommandBuffer::OnMemoryDump(
 
   if (gr_context_) {
     context_thread_checker_.DetachFromThread();
-    SkiaGpuTraceMemoryDump trace_memory_dump(
-        pmd, gles2_impl_->ShareGroupTracingGUID());
-    gr_context_->get()->dumpMemoryStatistics(&trace_memory_dump);
+    gpu::raster::DumpGrMemoryStatistics(gr_context_->get(), pmd,
+                                        gles2_impl_->ShareGroupTracingGUID());
     context_thread_checker_.DetachFromThread();
   }
   return true;