[tracing] Ignore tracing allocations in heap profiler

base/trace_event/malloc_dump_provider.h

 // Copyright 2015 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_MALLOC_DUMP_PROVIDER_H_
 #define BASE_TRACE_EVENT_MALLOC_DUMP_PROVIDER_H_
 
 #include <istream>
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "build/build_config.h"
 
 #if defined(OS_LINUX) || defined(OS_ANDROID) || \
     (defined(OS_MACOSX) && !defined(OS_IOS))
 #define MALLOC_MEMORY_TRACING_SUPPORTED
 #endif
 
+#define SCOPED_HEAP_PROFILER_IGNORE_MALLOC_EVENT \

[Primiano Tucci (use gerrit), 2016/04/20 16:34:57]

HEAP_PROFILER_SCOPED_IGNORE should be enough as a name

More importantly I think you want here an if UNLIKELY(capture_enabled()) to
prevent initializing the TLS tracker when heap profiling is not used.
Which means that you should not increase the counter in the ctor, but I think
this needs to be

#define HEAP_PROFILER_SCOPED_IGNORE  \
  ScopedHeapProfilerIgnore INTERNAL_TRACE_EVENT_UID(heap_profiler_ignore)
  if (UNLIKELY(capture_enabled())
     heap_profiler_ignore.begin_ignore();

In essence, you need an empty ctor in ScopedHeapProfilerIgnore , and the dtor
should call the end_ignore() only if the begin was called.
This is really the same identical thing of ScopedTracer
    

[ssid, 2016/04/21 01:07:46]

Yes I have already prevented the initialization of tracker by checking enabled
inside the constuctor. Now moved it out so that constructor need not be called.

+  base::trace_event::MallocDumpProvider::ScopedHeapProfilerIgnoreMalloc event

[Primiano Tucci (use gerrit), 2016/04/20 16:34:57]

Ok I know I suggested malloc_dump_provider in the first place, but by looking at
your cl i just realized that this is really general and not malloc specific (and
should be such).
In other words, this scoped ignore will cause an ignore to ALL the dump
providers not just malloc.
It's ok, I think is just a matter of moving this macro and the scoped bject to a
better, more generic place.
Either let's put this (and the class gbelow) in
heap_profiler_allocation_context_tracker.h or let's create
heap_profiler_scoped_ignore.h (probably the latter is better, so can be used
without pulling in weird deps)

[ssid, 2016/04/21 01:07:46]

Yes, I was expecting this comment. I still let this be inside malloc since I was
planning to move invalidation of context also inside this file. But, I think it
is better to have it generic for all providers.

I had to add a new file because it causes weird deps.
I cannot use INTERNAL_TRACE_EVENT_UID in context_tracker.h because trace_event.h
already includes context_tracker.h.
The other option was to add this as TRACE_EVENT_API_HEAP_PROFILER_SCOPED_IGNORE.
I think this is better.

Maybe we should have a trace_event_heap_profiler_common file which defines new
trace events which are specific to heap profiler.
This way I can move the TRACE_EVENT_API_SCOPED_TASK_EXECUTION_EVENT,
HEAP_PROFILER_SCOPED_IGNORE and in future I would also need
TRACE_EVENT_API_ADD_NATIVE_STACK_EVENT or similar. I think this file
heap_profiler_scoped_ignore will be moved to that. I will discuss this change
later.

+
 namespace base {
 namespace trace_event {
 
 class AllocationRegister;
 
 // Dump provider which collects process-wide memory stats.
 class BASE_EXPORT MallocDumpProvider : public MemoryDumpProvider {
  public:
+  class ScopedHeapProfilerIgnoreMalloc {

[Primiano Tucci (use gerrit), 2016/04/20 16:34:57]

I think I'd drop Malloc from the name, for the reason explained above (this
works also for any other client).
ScopedHeapProfilerIgnore I think is ok

[ssid, 2016/04/21 01:07:46]

Done.

+   public:
+    ScopedHeapProfilerIgnoreMalloc();
+    ~ScopedHeapProfilerIgnoreMalloc();
+  };
+
   // Name of the allocated_objects dump. Use this to declare suballocator dumps
   // from other dump providers.
   static const char kAllocatedObjects[];
 
   static MallocDumpProvider* GetInstance();
 
   // MemoryDumpProvider implementation.
   bool OnMemoryDump(const MemoryDumpArgs& args,
                     ProcessMemoryDump* pmd) override;
 
@@ skipping 19 matching lines @@
   // generation is malloc/new-ing for its own bookeeping data structures.
   PlatformThreadId tid_dumping_heap_;
 
   DISALLOW_COPY_AND_ASSIGN(MallocDumpProvider);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MALLOC_DUMP_PROVIDER_H_