Record Chrome trace events in tcmalloc heap profiles

chrome/browser/chrome_browser_main_linux.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 "chrome/browser/chrome_browser_main_linux.h"
 
+#include "base/debug/trace_memory.h"
+
 #if !defined(OS_CHROMEOS)
 #include "chrome/browser/storage_monitor/storage_monitor_linux.h"
 #include "content/public/browser/browser_thread.h"
 #endif
 
 #if defined(USE_LINUX_BREAKPAD)
 #include <stdlib.h>
 
 #include "base/command_line.h"
 #include "base/linux_util.h"
@@ skipping 77 matching lines @@
       breakpad_enabled = getenv(env_vars::kHeadless) != NULL;
     if (!breakpad_enabled)
       breakpad_enabled = CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableCrashReporterForTesting);
   }
 
   return breakpad_enabled;
 }
 #endif  // defined(USE_LINUX_BREAKPAD)
 
+/*
+ * std::string my_str;
+    TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+      "cc::Picture", clone.get(), my_str);
+
+std::string* my_str;
+tcmalloc_dump(&my_str);
+MyStringOnwer : base::Debug::ConvdrtableToTraceLog // cc/debug/traced_picture.h for example
+scoped_ptr<MyStringOwner> mystr = ...;
+
+
+TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID("tcmalloc", "tcmalloc::Heap", 1, my_str);
+*/
+class MemoryDumpHolder : public base::debug::ConvertableToTraceFormat {
+ public:
+  // Takes ownership of dump, which must be allocated with malloc() and NULL
+  // terminated.
+  explicit MemoryDumpHolder(char* dump) : dump_(dump) {}
+  virtual ~MemoryDumpHolder() { free(dump_); }
+
+  // base::debug::ConvertableToTraceFormat overrides:
+  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
+    out->append("{\"heap_dump\": ");
+    //TODO - use JSON version
+    out->append(dump_);
+    LOG(ERROR) << "JAMESDEBUG1\n" << dump_;
+    out->append("\"}");
+  }
+
+ private:
+  char* dump_;
+
+  DISALLOW_COPY_AND_ASSIGN(MemoryDumpHolder);
+};
+
+void DumpMemoryProfile() {
+  // Check to see if tracing is enabled for the memory category.
+  bool enabled = TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("tcmalloc2");

[nduca, 2013/05/20 23:03:41]

static bool* enabled = ...
if (*enabled) {

}

[dsinclair, 2013/05/21 00:32:07]

bool enabled;
TRACE_EVENT_CATEGORY_GROUP_ENABLED("tcmalloc2", &enabled);
if (enabled) {
}
would also work.

+  if (enabled) {
+    // We take ownership of this string.
+    char* dump = base::TraceMemoryDumpAsString();
+//    LOG(ERROR) << "JAMESDEBUG2\n" << dump;
+    scoped_ptr<MemoryDumpHolder> dump_holder(new MemoryDumpHolder(dump));

[nduca, 2013/05/20 23:04:44]

maybe this needs to be scoped_ptr<base::debug::ConvertableToTraceFormat>
dump_holder()

[dsinclair, 2013/05/21 00:32:07]

Doesn't have to be, you can use PassAs below.

+//    const int kSnapshotId = 1;
+    TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
+        "tcmalloc2", "tcmalloc2::Heap", dump_holder.get(), dump_holder);

[nduca, 2013/05/20 23:03:41]

3rd arg should be 1

[dsinclair, 2013/05/21 00:32:07]

You don't want to do the .get() on dump_holder. That will return the
MemoryDumpHolder* which will get interpreted by trace event as the raw pointer
type and print the address.

You want to do: 

dump_holder.PassAs<base::debug::ConvertableToTraceFormat>()

which will provide a scoped_ptr<ConvertableToTraceFormat> to trace event and
call the AppendAsTraceFormat correctly.

Is there some way we could detect this in trace event? Figure out that the
pointer type you passed inherits from Convertable and print a warning?

+  }
+  MessageLoop::current()->PostDelayedTask(FROM_HERE,
+                                          base::Bind(&DumpMemoryProfile),
+                                          base::TimeDelta::FromSeconds(10));
+}
+
 }  // namespace
 
 ChromeBrowserMainPartsLinux::ChromeBrowserMainPartsLinux(
     const content::MainFunctionParams& parameters)
     : ChromeBrowserMainPartsPosix(parameters) {
 }
 
 ChromeBrowserMainPartsLinux::~ChromeBrowserMainPartsLinux() {
 }
 
@@ skipping 20 matching lines @@
 }
 
 void ChromeBrowserMainPartsLinux::PostProfileInit() {
 #if !defined(OS_CHROMEOS)
   storage_monitor_->Init();
 #endif
 
   ChromeBrowserMainPartsPosix::PostProfileInit();
 }
 
+void ChromeBrowserMainPartsLinux::PreMainMessageLoopRun() {
+  ChromeBrowserMainPartsPosix::PreMainMessageLoopRun();
+
+  // TODO(jamescook): This could be moved earlier in startup to capture more
+  // startup allocations.
+  base::TraceMemoryStart();
+
+  // Dump a heap profile every 10 seconds, forever.
+  MessageLoop::current()->PostDelayedTask(FROM_HERE,
+                                          base::Bind(&DumpMemoryProfile),
+                                          base::TimeDelta::FromSeconds(10));
+}
+
 void ChromeBrowserMainPartsLinux::PostMainMessageLoopRun() {
 #if !defined(OS_CHROMEOS)
   // Delete it now. Otherwise the FILE thread would be gone when we try to
   // release it in the dtor and Valgrind would report a leak on almost every
   // single browser_test.
   storage_monitor_.reset();
 #endif
 
+  base::TraceMemoryDump();
+  base::TraceMemoryStop();
+
   ChromeBrowserMainPartsPosix::PostMainMessageLoopRun();
 }