[tracing] Adding task information to heap profiler

base/debug/task_annotator.h

 // Copyright 2014 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_DEBUG_TASK_ANNOTATOR_H_
 #define BASE_DEBUG_TASK_ANNOTATOR_H_
 
 #include <stdint.h>
 
 #include "base/base_export.h"
 #include "base/macros.h"
+#include "base/trace_event/heap_profiler_allocation_context_tracker.h"
 
 namespace base {
 struct PendingTask;
 namespace debug {
 
 // Implements common debug annotations for posted tasks. This includes data
 // such as task origins, queueing durations and memory usage.
 class BASE_EXPORT TaskAnnotator {
  public:
   TaskAnnotator();
@@ skipping 10 matching lines @@
 
  private:
   // Creates a process-wide unique ID to represent this task in trace events.
   // This will be mangled with a Process ID hash to reduce the likelyhood of
   // colliding with TaskAnnotator pointers on other processes.
   uint64_t GetTaskTraceID(const PendingTask& task) const;
 
   DISALLOW_COPY_AND_ASSIGN(TaskAnnotator);
 };
 
+class ScopedTaskExecutionEvent {
+ public:
+  ScopedTaskExecutionEvent(const char* file_name, const char* function_name)
+      : function_name_(function_name) {
+    if (base::trace_event::AllocationContextTracker::capture_enabled()) {

[Dmitry Skiba, 2016/03/15 19:38:31]

BTW, since this is inside base too, you can omit base:: from namespaces - this
will make lines shorter.

[ssid, 2016/03/17 00:11:46]

Done.

+      base::trace_event::AllocationContextTracker::SetCurrentTaskFileName(

[Primiano Tucci (use gerrit), 2016/03/15 16:44:33]

why are these inline? Is it for perf reasons?

Tasks are pretty coarse grained, not sure we need this level of perf obsession
here 

[ssid, 2016/03/17 00:11:46]

See TRACE_TASK_EXECUTION below.

TRACE_TASK_EXECUTION already adds a trace event. But the trace event has 2 extra
params as task posted file and function. With current infra only the main
function of the trace event is recorded and the arguments are ignored. So, it
will just show up as MessageLoop::RunLoop or similar.

By adding this manually here it actually shows the task file name and posting
function in the stack trace. I cannot add this inside the trace_event2 because
there are other use cases of trace_event2 which does not add task information.
So, TRACE_TASK_EXECUTION is a special macro that handles task execution tracing.

Is there another way to get this? Am I missing something?

+          file_name);
+      base::trace_event::AllocationContextTracker::PushPseudoStackFrame(

[Primiano Tucci (use gerrit), 2016/03/15 16:44:33]

Hmm I think that this will screw the pseudo-stack, right?
Right now everything starts with RunLoop -> RunTask -> bla bla.
With this change you are now making each task have a different root.
I don't think this PushPseudoStackFrame should happen at all

[ssid, 2016/03/17 00:11:47]

What I was imagining was, The function that posted the task is added in a stack
frame before the task is called. In some sense, the pseudo stack shows who
posted it instead of who called it. This happens inside RunLoop. But, this would
show up as if RunLoop called the posting function then the real function.

Now it will look like:
RunLoop -> RunTask -> posted_task_name -> actual_task_name -> bla bla.

Do you suggest to add this as a special field? How are we going to display this?

+          function_name_);
+    }
+  }
+
+  ~ScopedTaskExecutionEvent() {
+    if (base::trace_event::AllocationContextTracker::capture_enabled()) {
+      base::trace_event::AllocationContextTracker::PopPseudoStackFrame(
+          function_name_);
+      base::trace_event::AllocationContextTracker::SetCurrentTaskFileName(
+          nullptr);
+    }
+  }
+
+ private:
+  const char* function_name_;
+};
+
 #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());
+               (task).posted_from.function_name());        \
+  base::debug::ScopedTaskExecutionEvent scoped_task_event( \
+      (task).posted_from.file_name(), (task).posted_from.function_name());
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TASK_ANNOTATOR_H_