[tracing] Ignore tracing allocations in heap profiler

base/trace_event/trace_buffer.cc

 // 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.
 
 #include "base/trace_event/trace_buffer.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
+#include "base/trace_event/malloc_dump_provider.h"
 #include "base/trace_event/trace_event_impl.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
 class TraceBufferRingBuffer : public TraceBuffer {
  public:
   TraceBufferRingBuffer(size_t max_chunks)
       : max_chunks_(max_chunks),
         recyclable_chunks_queue_(new size_t[queue_capacity()]),
         queue_head_(0),
         queue_tail_(max_chunks),
         current_iteration_index_(0),
         current_chunk_seq_(1) {
     chunks_.reserve(max_chunks);
     for (size_t i = 0; i < max_chunks; ++i)
       recyclable_chunks_queue_[i] = i;
   }
 
   std::unique_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
+    SCOPED_HEAP_PROFILER_IGNORE_MALLOC_EVENT;

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

I think you want to move this only to line 52 which does the new? Nothing else
here should do a malloc

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

There is a chunks_.resize call too. When we can capture this, why not.

[Primiano Tucci (use gerrit), 2016/04/21 19:47:31]

ahh right

     // Because the number of threads is much less than the number of chunks,
     // the queue should never be empty.
     DCHECK(!QueueIsEmpty());
 
     *index = recyclable_chunks_queue_[queue_head_];
     queue_head_ = NextQueueIndex(queue_head_);
     current_iteration_index_ = queue_head_;
 
     if (*index >= chunks_.size())
       chunks_.resize(*index + 1);
@@ skipping 106 matching lines @@
 
 class TraceBufferVector : public TraceBuffer {
  public:
   TraceBufferVector(size_t max_chunks)
       : in_flight_chunk_count_(0),
         current_iteration_index_(0),
         max_chunks_(max_chunks) {
     chunks_.reserve(max_chunks_);
   }
 
   std::unique_ptr<TraceBufferChunk> GetChunk(size_t* index) override {

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

I am sure that a ghost had removed this line from my CL!

[Primiano Tucci (use gerrit), 2016/04/21 19:47:31]

uh? right you need one here

     // This function may be called when adding normal events or indirectly from
     // AddMetadataEventsWhileLocked(). We can not DECHECK(!IsFull()) because we
     // have to add the metadata events and flush thread-local buffers even if
     // the buffer is full.
     *index = chunks_.size();
     chunks_.push_back(NULL);  // Put NULL in the slot of a in-flight chunk.
     ++in_flight_chunk_count_;
     // + 1 because zero chunk_seq is not allowed.
     return std::unique_ptr<TraceBufferChunk>(
         new TraceBufferChunk(static_cast<uint32_t>(*index) + 1));
@@ skipping 159 matching lines @@
 TraceBuffer* TraceBuffer::CreateTraceBufferRingBuffer(size_t max_chunks) {
   return new TraceBufferRingBuffer(max_chunks);
 }
 
 TraceBuffer* TraceBuffer::CreateTraceBufferVectorOfSize(size_t max_chunks) {
   return new TraceBufferVector(max_chunks);
 }
 
 }  // namespace trace_event
 }  // namespace base