[tracing] Adding task information to heap profiler

base/trace_event/trace_event.h

 // 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.
 
 #ifndef BASE_TRACE_EVENT_TRACE_EVENT_H_
 #define BASE_TRACE_EVENT_TRACE_EVENT_H_
 
 // This header file defines implementation details of how the trace macros in
 // trace_event_common.h collect and store trace events. Anything not
 // implementation-specific should go in trace_event_common.h instead of here.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 
 #include "base/atomicops.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "base/trace_event/common/trace_event_common.h"
+#include "base/trace_event/heap_profiler_allocation_context_tracker.h"
 #include "base/trace_event/trace_event_system_stats_monitor.h"
 #include "base/trace_event/trace_log.h"
 #include "build/build_config.h"
 
 // By default, const char* argument values are assumed to have long-lived scope
 // and will not be copied. Use this macro to force a const char* to be copied.
 #define TRACE_STR_COPY(str) \
     trace_event_internal::TraceStringWithCopy(str)
 
 // By default, uint64_t ID argument values are not mangled with the Process ID
@@ skipping 344 matching lines @@
    private:                                                                \
     uint64_t cid_;                                                         \
     /* Local class friendly DISALLOW_COPY_AND_ASSIGN */                    \
     INTERNAL_TRACE_EVENT_UID(ScopedContext)                                \
     (const INTERNAL_TRACE_EVENT_UID(ScopedContext)&) {};                   \
     void operator=(const INTERNAL_TRACE_EVENT_UID(ScopedContext)&) {};     \
   };                                                                       \
   INTERNAL_TRACE_EVENT_UID(ScopedContext)                                  \
   INTERNAL_TRACE_EVENT_UID(scoped_context)(context.raw_id());
 
+// Special trace event macro to trace task execution with the location where it
+// was posted from.
+#define TRACE_TASK_EXECUTION(run_function, task)           \

[oystein (OOO til 10th of July), 2016/03/29 21:28:35]

I don't think this belongs in trace_event.h; typically that file should have
implementation code and pure macros should be in trace_event_common.h. I would
keep ScopedTaskExecutionEvent there and add a define for it (like
TRACE_EVENT_API_SCOPED_TASK_EXECUTION_EVENT) and move TRACE_TASK_EXECUTION to
trace_event_common.h. 

[ssid, 2016/03/29 23:04:19]

Thanks I was really confused about trace_event.h and trace_event_common.h.
I have added an INTERNAL macro instead of API since I am not planning to use
this api otherwise. Did I get it correct?

[oystein (OOO til 10th of July), 2016/03/29 23:44:52]

Almost! I mainly don't think trace_event.h should have the macro at all, for
consistency (trace_event.h should be as minimal as possible and not contain 
stuff like hardcoded categories).

I'd rather do, in trace_event.h (instead of the macro):
#define INTERNAL_TRACE_SCOPED_TASK_EXECUTION_EVENT
trace_event_internal::ScopedTaskExecutionEvent

and then the macro in trace_event_common.h would be something like this:
#define TRACE_TASK_EXECUTION(run_function, task)            \
  TRACE_EVENT2("toplevel", run_function, "src_file",                       \
               task.posted_from.file_name(), "src_func",                   \
               task.posted_from.function_name());                          \
  INTERNAL_TRACE_SCOPED_TASK_EXECUTION_EVENT INTERNAL_TRACE_EVENT_UID( \
       task_event)(task.posted_from.file_name());

+  TRACE_EVENT2("toplevel", (run_function), "src_file",     \

[oystein (OOO til 10th of July), 2016/03/29 21:28:35]

Why are the parameter usages all wrapped by ()? We don't do that elsewhere, but
maybe there's some reason I'm missing for it :).

[ssid, 2016/03/29 23:04:19]

Ah, it existed in the other file and I had copied it. It isn't required,
removed.

+               (task).posted_from.file_name(), "src_func", \
+               (task).posted_from.function_name());        \
+  trace_event_internal::ScopedTaskExecutionEvent event(    \

[oystein (OOO til 10th of July), 2016/03/29 21:28:35]

INTERNAL_TRACE_EVENT_UID(event) to avoid conflicts with 'event' vars in code
using this.

[ssid, 2016/03/29 23:04:19]

Done.

+      (task).posted_from.file_name());
+
 namespace trace_event_internal {
 
 // Specify these values when the corresponding argument of AddTraceEvent is not
 // used.
 const int kZeroNumArgs = 0;
 const std::nullptr_t kGlobalScope = nullptr;
 const unsigned long long kNoId = 0;
 
 // TraceID encapsulates an ID that can either be an integer or pointer. Pointers
 // are by default mangled with the Process ID so that they are unlikely to
@@ skipping 643 matching lines @@
     TRACE_EVENT_API_ATOMIC_STORE(
       g_trace_state[BucketNumber],
       reinterpret_cast<TRACE_EVENT_API_ATOMIC_WORD>(
         const_cast<char*>(category_and_name)));
   }
 
  private:
   const char* previous_state_;
 };
 
+// ScopedTaskExecutionEvent records the current task's context in the heap
+// profiler.
+class ScopedTaskExecutionEvent {
+ public:
+  ScopedTaskExecutionEvent(const char* task_context) : context_(task_context) {
+    if (UNLIKELY(
+            base::trace_event::AllocationContextTracker::capture_enabled())) {
+      base::trace_event::AllocationContextTracker::GetInstanceForCurrentThread()
+          ->PushCurrentTaskContext(context_);
+    }
+  }
+
+  ~ScopedTaskExecutionEvent() {
+    if (UNLIKELY(
+            base::trace_event::AllocationContextTracker::capture_enabled())) {
+      base::trace_event::AllocationContextTracker::GetInstanceForCurrentThread()
+          ->PopCurrentTaskContext(context_);
+    }
+  }
+
+ private:
+  const char* context_;
+};
+
 }  // namespace trace_event_internal
 
 namespace base {
 namespace trace_event {
 
 template<typename IDType> class TraceScopedTrackableObject {
  public:
   TraceScopedTrackableObject(const char* category_group, const char* name,
       IDType id)
     : category_group_(category_group),
@@ skipping 15 matching lines @@
   const char* name_;
   IDType id_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_H_