Updated native memory allocation profiling to use its own sample buffer instead of sharing a sample…

runtime/vm/profiler.h

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_PROFILER_H_
 #define RUNTIME_VM_PROFILER_H_
 
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
 #include "vm/code_observers.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/malloc_hooks.h"
 #include "vm/native_symbol.h"
 #include "vm/object.h"
 #include "vm/tags.h"
 #include "vm/thread_interrupter.h"
 
 // Profiler sampling and stack walking support.
 // NOTE: For service related code, see profile_service.h.
 
 namespace dart {
 
 // Forward declarations.
 class ProcessedSample;
 class ProcessedSampleBuffer;
 
 class Sample;
+class AllocationSampleBuffer;
 class SampleBuffer;
 class ProfileTrieNode;
 
 struct ProfilerCounters {
   // Count of bail out reasons:
   int64_t bail_out_unknown_task;
   int64_t bail_out_jump_to_exception_handler;
   int64_t bail_out_check_isolate;
   // Count of single frame sampling reasons:
   int64_t single_frame_sample_deoptimizing;
   int64_t single_frame_sample_register_check;
   int64_t single_frame_sample_get_and_validate_stack_bounds;
   // Count of stack walkers used:
   int64_t stack_walker_native;
   int64_t stack_walker_dart_exit;
   int64_t stack_walker_dart;
   int64_t stack_walker_none;
   // Count of failed checks:
   int64_t failure_native_allocation_sample;
 };
 
 
 class Profiler : public AllStatic {
  public:
   static void InitOnce();
+  static void InitAllocationSampleBuffer();
   static void Shutdown();
 
   static void SetSampleDepth(intptr_t depth);
   static void SetSamplePeriod(intptr_t period);
 
   static SampleBuffer* sample_buffer() { return sample_buffer_; }
+  static AllocationSampleBuffer* allocation_sample_buffer() {
+    return allocation_sample_buffer_;
+  }
 
   static void DumpStackTrace(void* context);
   static void DumpStackTrace(bool for_crash = true);
 
   static void SampleAllocation(Thread* thread, intptr_t cid);
   static Sample* SampleNativeAllocation(intptr_t skip_count,
                                         uword address,
                                         uintptr_t allocation_size);
 
   // SampleThread is called from inside the signal handler and hence it is very
@@ skipping 12 matching lines @@
   }
 
  private:
   static void DumpStackTrace(uword sp, uword fp, uword pc, bool for_crash);
 
   // Does not walk the thread's stack.
   static void SampleThreadSingleFrame(Thread* thread, uintptr_t pc);
   static bool initialized_;
 
   static SampleBuffer* sample_buffer_;
+  static AllocationSampleBuffer* allocation_sample_buffer_;
 
   static ProfilerCounters counters_;
 
   friend class Thread;
 };
 
 
 class SampleVisitor : public ValueObject {
  public:
   explicit SampleVisitor(Dart_Port port) : port_(port), visited_(0) {}
@@ skipping 83 matching lines @@
       stack_buffer_[i] = 0;
     }
     vm_tag_ = VMTag::kInvalidTagId;
     user_tag_ = UserTags::kDefaultUserTag;
     lr_ = 0;
     metadata_ = 0;
     state_ = 0;
     native_allocation_address_ = 0;
     native_allocation_size_bytes_ = 0;
     continuation_index_ = -1;
+    next_free_ = NULL;
     uword* pcs = GetPCArray();
     for (intptr_t i = 0; i < pcs_length_; i++) {
       pcs[i] = 0;
     }
     set_head_sample(true);
   }
 
   // Timestamp sample was taken at.
   int64_t timestamp() const { return timestamp_; }
 
@@ skipping 81 matching lines @@
   }
 
   bool is_allocation_sample() const {
     return ClassAllocationSampleBit::decode(state_);
   }
 
   void set_is_allocation_sample(bool allocation_sample) {
     state_ = ClassAllocationSampleBit::update(allocation_sample, state_);
   }
 
-  bool is_native_allocation_sample() const {
-    return NativeAllocationSampleBit::decode(state_);
-  }
-
-  void set_is_native_allocation_sample(bool native_allocation_sample) {
-    state_ =
-        NativeAllocationSampleBit::update(native_allocation_sample, state_);
-  }
+  uword native_allocation_address() const { return native_allocation_address_; }
 
   void set_native_allocation_address(uword address) {
     native_allocation_address_ = address;
   }
 
-  uword native_allocation_address() const { return native_allocation_address_; }
-
   uintptr_t native_allocation_size_bytes() const {
     return native_allocation_size_bytes_;
   }
 
   void set_native_allocation_size_bytes(uintptr_t size) {
     native_allocation_size_bytes_ = size;
   }
 
+  Sample* next_free() const { return next_free_; }
+  void set_next_free(Sample* next_free) { next_free_ = next_free; }
+
   Thread::TaskKind thread_task() const { return ThreadTaskBit::decode(state_); }
 
   void set_thread_task(Thread::TaskKind task) {
     state_ = ThreadTaskBit::update(task, state_);
   }
 
   bool is_continuation_sample() const {
     return ContinuationSampleBit::decode(state_);
   }
 
@@ skipping 21 matching lines @@
 
   bool head_sample() const { return HeadSampleBit::decode(state_); }
 
   void set_metadata(intptr_t metadata) { metadata_ = metadata; }
 
   void SetAllocationCid(intptr_t cid) {
     set_is_allocation_sample(true);
     set_metadata(cid);
   }
 
+

[zra, 2017/06/30 18:49:17]

rm extra newline

[bkonyi, 2017/07/05 18:20:52]

Done.

   static void InitOnce();
 
   static intptr_t instance_size() { return instance_size_; }
 
   uword* GetPCArray() const;
 
   static const int kStackBufferSizeInWords = 2;
   uword* GetStackBuffer() { return &stack_buffer_[0]; }
 
- private:
+ protected:

[zra, 2017/06/30 18:49:17]

I'm having trouble finding why this needs to be protected an not private. If it
needs to be protected for some reason, could you add a comment here about what
needs access.

[bkonyi, 2017/07/05 18:20:52]

This is just something I forgot to change back since I was going to inherit from
Sample at one point. Changed to private.

   static intptr_t instance_size_;
   static intptr_t pcs_length_;
   enum StateBits {
     kHeadSampleBit = 0,
     kLeafFrameIsDartBit = 1,
     kIgnoreBit = 2,
     kExitFrameBit = 3,
     kMissingFrameInsertedBit = 4,
     kTruncatedTraceBit = 5,
     kClassAllocationSampleBit = 6,
     kContinuationSampleBit = 7,
     kThreadTaskBit = 8,  // 5 bits.
-    kNativeAllocationSampleBit = 13,
-    kNextFreeBit = 14,
+    kNextFreeBit = 13,
   };
   class HeadSampleBit : public BitField<uword, bool, kHeadSampleBit, 1> {};
   class LeafFrameIsDart : public BitField<uword, bool, kLeafFrameIsDartBit, 1> {
   };
   class IgnoreBit : public BitField<uword, bool, kIgnoreBit, 1> {};
   class ExitFrameBit : public BitField<uword, bool, kExitFrameBit, 1> {};
   class MissingFrameInsertedBit
       : public BitField<uword, bool, kMissingFrameInsertedBit, 1> {};
   class TruncatedTraceBit
       : public BitField<uword, bool, kTruncatedTraceBit, 1> {};
   class ClassAllocationSampleBit
       : public BitField<uword, bool, kClassAllocationSampleBit, 1> {};
   class ContinuationSampleBit
       : public BitField<uword, bool, kContinuationSampleBit, 1> {};
   class ThreadTaskBit
       : public BitField<uword, Thread::TaskKind, kThreadTaskBit, 5> {};
-  class NativeAllocationSampleBit
-      : public BitField<uword, bool, kNativeAllocationSampleBit, 1> {};
 
   int64_t timestamp_;
   ThreadId tid_;
   Dart_Port port_;
   uword pc_marker_;
   uword stack_buffer_[kStackBufferSizeInWords];
   uword vm_tag_;
   uword user_tag_;
   uword metadata_;
   uword lr_;
   uword state_;
   uword native_allocation_address_;
   uintptr_t native_allocation_size_bytes_;
   intptr_t continuation_index_;
+  Sample* next_free_;
 
   /* There are a variable number of words that follow, the words hold the
    * sampled pc values. Access via GetPCArray() */
-
+ private:
   DISALLOW_COPY_AND_ASSIGN(Sample);
 };
 
 
 class NativeAllocationSampleFilter : public SampleFilter {
  public:
   NativeAllocationSampleFilter(int64_t time_origin_micros,
                                int64_t time_extent_micros)
       : SampleFilter(ILLEGAL_PORT,
                      SampleFilter::kNoTaskFilter,
                      time_origin_micros,
                      time_extent_micros) {}
 
   bool FilterSample(Sample* sample) {
-    if (!sample->is_native_allocation_sample()) {
-      return false;
-    }
     // If the sample is an allocation sample, we need to check that the

[zra, 2017/06/30 18:49:17]

Maybe assert that the sample is an allocation sample.

[bkonyi, 2017/07/05 18:20:52]

I'll assert that the sample has a valid allocation address since I've removed
is_native_allocation_sample().

     // memory at the address hasn't been freed, and if the address associated
     // with the allocation has been freed and then reissued.
     void* alloc_address =
         reinterpret_cast<void*>(sample->native_allocation_address());
     Sample* recorded_sample = MallocHooks::GetSample(alloc_address);
     return (sample == recorded_sample);
   }
 };
 
 
@@ skipping 66 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(CodeLookupTable);
 };
 
 
 // Ring buffer of Samples that is (usually) shared by many isolates.
 class SampleBuffer {
  public:
   static const intptr_t kDefaultBufferCapacity = 120000;  // 2 minutes @ 1000hz.
 
   explicit SampleBuffer(intptr_t capacity = kDefaultBufferCapacity);
-  ~SampleBuffer();
+  virtual ~SampleBuffer();
 
   intptr_t capacity() const { return capacity_; }
 
   Sample* At(intptr_t idx) const;
-  intptr_t ReserveSampleSlot();
-  Sample* ReserveSample();
-  Sample* ReserveSampleAndLink(Sample* previous);
+  virtual intptr_t ReserveSampleSlot();
+  virtual Sample* ReserveSample();
+  virtual Sample* ReserveSampleAndLink(Sample* previous);
 
   void VisitSamples(SampleVisitor* visitor) {
     ASSERT(visitor != NULL);
     const intptr_t length = capacity();
     for (intptr_t i = 0; i < length; i++) {
       Sample* sample = At(i);
       if (!sample->head_sample()) {
         // An inner sample in a chain of samples.
         continue;
       }
@@ skipping 13 matching lines @@
         // No frames.
         continue;
       }
       visitor->IncrementVisited();
       visitor->VisitSample(sample);
     }
   }
 
   ProcessedSampleBuffer* BuildProcessedSampleBuffer(SampleFilter* filter);
 
- private:
+ protected:
   ProcessedSample* BuildProcessedSample(Sample* sample,
                                         const CodeLookupTable& clt);
   Sample* Next(Sample* sample);
 
   VirtualMemory* memory_;
   Sample* samples_;
   intptr_t capacity_;
   uintptr_t cursor_;
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(SampleBuffer);
 };
 
 
+class AllocationSampleBuffer : public SampleBuffer {
+ public:
+  explicit AllocationSampleBuffer(intptr_t capacity = kDefaultBufferCapacity);
+  virtual ~AllocationSampleBuffer();
+
+  virtual intptr_t ReserveSampleSlot();
+  virtual Sample* ReserveSample();
+  virtual Sample* ReserveSampleAndLink(Sample* previous);
+  void FreeAllocationSample(Sample* sample);
+
+ private:
+  Mutex* mutex_;
+  Sample* free_sample_list_;
+
+  DISALLOW_COPY_AND_ASSIGN(AllocationSampleBuffer);
+};
+
+
 // A |ProcessedSample| is a combination of 1 (or more) |Sample|(s) that have
 // been merged into a logical sample. The raw data may have been processed to
 // improve the quality of the stack trace.
 class ProcessedSample : public ZoneAllocated {
  public:
   ProcessedSample();
 
   // Add |pc| to stack trace.
   void Add(uword pc) { pcs_.Add(pc); }
 
@@ skipping 103 matching lines @@
  private:
   ZoneGrowableArray<ProcessedSample*> samples_;
   CodeLookupTable* code_lookup_table_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessedSampleBuffer);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PROFILER_H_