Make size of sample variable based on the profile depth flag

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 VM_PROFILER_H_
 #define VM_PROFILER_H_
 
 #include "vm/allocation.h"
 #include "vm/code_observers.h"
 #include "vm/globals.h"
@@ skipping 100 matching lines @@
     return isolate_;
   }
 
  private:
   Isolate* isolate_;
   intptr_t visited_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SampleVisitor);
 };
 
-// The maximum number of stack frames a sample can hold.
-#define kSampleFramesSize 256
-
 // Each Sample holds a stack trace from an isolate.
 class Sample {
  public:
   void Init(Isolate* isolate, int64_t timestamp, ThreadId tid) {
     timestamp_ = timestamp;
     tid_ = tid;
     isolate_ = isolate;
     pc_marker_ = 0;
     vm_tag_ = VMTag::kInvalidTagId;
     user_tag_ = UserTags::kDefaultUserTag;
     sp_ = 0;
     fp_ = 0;
     state_ = 0;
-    for (intptr_t i = 0; i < kSampleFramesSize; i++) {
-      pcs_[i] = 0;
+    uword* pcs = GetPCArray();
+    for (intptr_t i = 0; i < pcs_length_; i++) {
+      pcs[i] = 0;
     }
   }
 
   // Isolate sample was taken from.
   Isolate* isolate() const {
     return isolate_;
   }
 
   // Timestamp sample was taken at.
   int64_t timestamp() const {
     return timestamp_;
   }
 
   // Get stack trace entry.
   uword At(intptr_t i) const {
     ASSERT(i >= 0);
-    ASSERT(i < kSampleFramesSize);
-    return pcs_[i];
+    ASSERT(i < pcs_length_);
+    uword* pcs = GetPCArray();
+    return pcs[i];
   }
 
   // Set stack trace entry.
   void SetAt(intptr_t i, uword pc) {
     ASSERT(i >= 0);
-    ASSERT(i < kSampleFramesSize);
-    pcs_[i] = pc;
+    ASSERT(i < pcs_length_);
+    uword* pcs = GetPCArray();
+    pcs[i] = pc;
   }
 
   uword vm_tag() const {
     return vm_tag_;
   }
   void set_vm_tag(uword tag) {
     ASSERT(tag != VMTag::kInvalidTagId);
     vm_tag_ = tag;
   }
 
@@ skipping 22 matching lines @@
 
   uword fp() const {
     return fp_;
   }
 
   void set_fp(uword fp) {
     fp_ = fp;
   }
 
   void InsertCallerForTopFrame(uword pc) {
+    if (pcs_length_ == 1) {
+      // Only sampling top frame.
+      return;
+    }
+    uword* pcs = GetPCArray();
     // The caller for the top frame is store at index 1.
     // Shift all entries down by one.
-    for (intptr_t i = kSampleFramesSize - 1; i >= 2; i--) {
-      pcs_[i] = pcs_[i - 1];
+    for (intptr_t i = pcs_length_ - 1; i >= 2; i--) {
+      pcs[i] = pcs[i - 1];
     }
     // Insert caller for top frame.
-    pcs_[1] = pc;
+    pcs[1] = pc;
   }
 
   bool processed() const {
     return ProcessedBit::decode(state_);
   }
 
   void set_processed(bool processed) {
     state_ = ProcessedBit::update(processed, state_);
   }
 
   bool leaf_frame_is_dart() const {
     return LeafFrameIsDart::decode(state_);
   }
 
   void set_leaf_frame_is_dart(bool leaf_frame_is_dart) {
     state_ = LeafFrameIsDart::update(leaf_frame_is_dart, state_);
   }
 
+  static void InitOnce();
+
+  static intptr_t instance_size() {
+    return instance_size_;
+  }
+
+  uword* GetPCArray() const;
+
  private:
+  static intptr_t instance_size_;
+  static intptr_t pcs_length_;
   enum StateBits {
     kProcessedBit = 0,
     kLeafFrameIsDartBit = 1,
   };
   class ProcessedBit : public BitField<bool, kProcessedBit, 1> {};
   class LeafFrameIsDart : public BitField<bool, kLeafFrameIsDartBit, 1> {};
 
   int64_t timestamp_;
   ThreadId tid_;
   Isolate* isolate_;
   uword pc_marker_;
   uword vm_tag_;
   uword user_tag_;
   uword sp_;
   uword fp_;
   uword state_;
-  uword pcs_[kSampleFramesSize];
+
+  /* There are a variable number of words that follow, the words hold the
+   * sampled pc values. Access via GetPCArray() */
+
+  DISALLOW_COPY_AND_ASSIGN(Sample);
 };
 
 
 // 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) {
-    samples_ = reinterpret_cast<Sample*>(calloc(capacity, sizeof(*samples_)));
-    capacity_ = capacity;
-    cursor_ = 0;
-  }
+  explicit SampleBuffer(intptr_t capacity = kDefaultBufferCapacity);
 
   ~SampleBuffer() {
     if (samples_ != NULL) {
       free(samples_);
       samples_ = NULL;
       cursor_ = 0;
       capacity_ = 0;
     }
   }
 
   intptr_t capacity() const { return capacity_; }
 
+  Sample* At(intptr_t idx) const;
   Sample* ReserveSample();
 
-  Sample* At(intptr_t idx) const {
-    ASSERT(idx >= 0);
-    ASSERT(idx < capacity_);
-    return &samples_[idx];
-  }
-
   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->isolate() != visitor->isolate()) {
         // Another isolate.
         continue;
       }
       if (sample->timestamp() == 0) {
@@ skipping 14 matching lines @@
   intptr_t capacity_;
   uintptr_t cursor_;
 
   DISALLOW_COPY_AND_ASSIGN(SampleBuffer);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_PROFILER_H_