Updated MallocHooks to collect stack traces when memory is allocated.

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"
@@ skipping 40 matching lines @@
 
   static void SetSampleDepth(intptr_t depth);
   static void SetSamplePeriod(intptr_t period);
 
   static SampleBuffer* sample_buffer() { return sample_buffer_; }
 
   static void DumpStackTrace(void* context);
   static void DumpStackTrace();
 
   static void SampleAllocation(Thread* thread, intptr_t cid);
+  static Sample* SampleNativeAllocation(intptr_t skip_count);
 
   // SampleThread is called from inside the signal handler and hence it is very
   // critical that the implementation of SampleThread does not do any of the
   // following:
   //   * Accessing TLS -- Because on Windows the callback will be running in a
   //                      different thread.
   //   * Allocating memory -- Because this takes locks which may already be
   //                          held, resulting in a dead lock.
   //   * Taking a lock -- See above.
   static void SampleThread(Thread* thread, const InterruptedThreadState& state);
@@ skipping 13 matching lines @@
   static SampleBuffer* sample_buffer_;
 
   static ProfilerCounters counters_;
 
   friend class Thread;
 };
 
 
 class SampleVisitor : public ValueObject {
  public:
-  explicit SampleVisitor(Isolate* isolate) : isolate_(isolate), visited_(0) {}
+  explicit SampleVisitor(Dart_Port port) : port_(port), visited_(0) {}
   virtual ~SampleVisitor() {}
 
   virtual void VisitSample(Sample* sample) = 0;
 
   intptr_t visited() const { return visited_; }
 
   void IncrementVisited() { visited_++; }
 
-  Isolate* isolate() const { return isolate_; }
+  Dart_Port port() const { return port_; }
 
  private:
-  Isolate* isolate_;
+  Dart_Port port_;
   intptr_t visited_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SampleVisitor);
 };
 
 
 class SampleFilter : public ValueObject {
  public:
-  SampleFilter(Isolate* isolate,
+  SampleFilter(Dart_Port port,
                intptr_t thread_task_mask,
                int64_t time_origin_micros,
                int64_t time_extent_micros)
-      : isolate_(isolate),
+      : port_(port),
         thread_task_mask_(thread_task_mask),
         time_origin_micros_(time_origin_micros),
         time_extent_micros_(time_extent_micros) {
     ASSERT(thread_task_mask != 0);
     ASSERT(time_origin_micros_ >= -1);
     ASSERT(time_extent_micros_ >= -1);
   }
   virtual ~SampleFilter() {}
 
   // Override this function.
   // Return |true| if |sample| passes the filter.
   virtual bool FilterSample(Sample* sample) { return true; }
 
-  Isolate* isolate() const { return isolate_; }
+  Dart_Port port() const { return port_; }
 
   // Returns |true| if |sample| passes the time filter.
   bool TimeFilterSample(Sample* sample);
 
   // Returns |true| if |sample| passes the thread task filter.
   bool TaskFilterSample(Sample* sample);
 
  private:
-  Isolate* isolate_;
+  Dart_Port port_;
   intptr_t thread_task_mask_;
   int64_t time_origin_micros_;
   int64_t time_extent_micros_;
 };
 
 
 class ClearProfileVisitor : public SampleVisitor {
  public:
   explicit ClearProfileVisitor(Isolate* isolate);
 
   virtual void VisitSample(Sample* sample);
 };
 
 
 // Each Sample holds a stack trace from an isolate.
 class Sample {
  public:
-  void Init(Isolate* isolate, int64_t timestamp, ThreadId tid) {
+  void Init(Dart_Port port, int64_t timestamp, ThreadId tid) {
     Clear();
     timestamp_ = timestamp;
     tid_ = tid;
-    isolate_ = isolate;
+    port_ = port;
   }
 
-  // Isolate sample was taken from.
-  Isolate* isolate() const { return isolate_; }
+  Dart_Port port() const { return port_; }
 
   // Thread sample was taken on.
   ThreadId tid() const { return tid_; }
 
   void Clear() {
-    isolate_ = NULL;
+    port_ = ILLEGAL_PORT;
     pc_marker_ = 0;
     for (intptr_t i = 0; i < kStackBufferSizeInWords; i++) {
       stack_buffer_[i] = 0;
     }
     vm_tag_ = VMTag::kInvalidTagId;
     user_tag_ = UserTags::kDefaultUserTag;
     lr_ = 0;
     metadata_ = 0;
     state_ = 0;
     continuation_index_ = -1;
@@ skipping 159 matching lines @@
       : 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> {};
 
   int64_t timestamp_;
   ThreadId tid_;
-  Isolate* isolate_;
+  Dart_Port port_;
   uword pc_marker_;
   uword stack_buffer_[kStackBufferSizeInWords];
   uword vm_tag_;
   uword user_tag_;
   uword metadata_;
   uword lr_;
   uword state_;
   intptr_t continuation_index_;
 
   /* There are a variable number of words that follow, the words hold the
@@ skipping 102 matching lines @@
     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;
       }
       if (sample->ignore_sample()) {
         // Bad sample.
         continue;
       }
-      if (sample->isolate() != visitor->isolate()) {
+      if ((sample->port() != visitor->port()) &&
+          sample->port() != ILLEGAL_PORT) {
         // Another isolate.
         continue;
       }
       if (sample->timestamp() == 0) {
         // Empty.
         continue;
       }
       if (sample->At(0) == 0) {
         // No frames.
         continue;
@@ skipping 121 matching lines @@
  private:
   ZoneGrowableArray<ProcessedSample*> samples_;
   CodeLookupTable* code_lookup_table_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessedSampleBuffer);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PROFILER_H_