Rework Sample class

runtime/vm/profiler.cc

 // 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.
 
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
 #include "vm/code_patcher.h"
 #include "vm/isolate.h"
@@ skipping 14 matching lines @@
   DEFINE_FLAG(bool, profile, false, "Enable Sampling Profiler");
 #else
   DEFINE_FLAG(bool, profile, true, "Enable Sampling Profiler");
 #endif
 DEFINE_FLAG(bool, trace_profiled_isolates, false, "Trace profiled isolates.");
 DEFINE_FLAG(charp, profile_dir, NULL,
             "Enable writing profile data into specified directory.");
 DEFINE_FLAG(int, profile_period, 1000,
             "Time between profiler samples in microseconds. Minimum 250.");
 DEFINE_FLAG(int, profile_depth, 8,
-            "Maximum number stack frames walked. Minimum 1. Maximum 128.");
+            "Maximum number stack frames walked. Minimum 1. Maximum 255.");
 
 bool Profiler::initialized_ = false;
 SampleBuffer* Profiler::sample_buffer_ = NULL;
 
 void Profiler::InitOnce() {
-  const int kMinimumProfilePeriod = 250;
-  const int kMinimumDepth = 1;
-  const int kMaximumDepth = 128;
   // Place some sane restrictions on user controlled flags.
-  if (FLAG_profile_period < kMinimumProfilePeriod) {
-    FLAG_profile_period = kMinimumProfilePeriod;
-  }
-  if (FLAG_profile_depth < kMinimumDepth) {
-    FLAG_profile_depth = kMinimumDepth;
-  } else if (FLAG_profile_depth > kMaximumDepth) {
-    FLAG_profile_depth = kMaximumDepth;
-  }
-  // We must always initialize the Sample, even when the profiler is disabled.
-  Sample::InitOnce();
+  SetSamplePeriod(FLAG_profile_period);
+  SetSampleDepth(FLAG_profile_depth);
   if (!FLAG_profile) {
     return;
   }
   ASSERT(!initialized_);
   sample_buffer_ = new SampleBuffer();
   NativeSymbolResolver::InitOnce();
   ThreadInterrupter::SetInterruptPeriod(FLAG_profile_period);
   ThreadInterrupter::Startup();
   initialized_ = true;
 }
 
 
 void Profiler::Shutdown() {
   if (!FLAG_profile) {
     return;
   }
   ASSERT(initialized_);
   ThreadInterrupter::Shutdown();
   NativeSymbolResolver::ShutdownOnce();
 }
 
 
+void Profiler::SetSampleDepth(intptr_t depth) {
+  const int kMinimumDepth = 1;
+  const int kMaximumDepth = kSampleFramesSize - 1;
+  if (depth < kMinimumDepth) {
+    FLAG_profile_depth = kMinimumDepth;
+  } else if (depth > kMaximumDepth) {
+    FLAG_profile_depth = kMaximumDepth;
+  } else {
+    FLAG_profile_depth = depth;
+  }
+}
+
+
+void Profiler::SetSamplePeriod(intptr_t period) {
+  const int kMinimumProfilePeriod = 250;
+  if (period < kMinimumProfilePeriod) {
+    FLAG_profile_period = kMinimumProfilePeriod;
+  } else {
+    FLAG_profile_period = period;
+  }
+}
+
+
 void Profiler::InitProfilingForIsolate(Isolate* isolate, bool shared_buffer) {
   if (!FLAG_profile) {
     return;
   }
   ASSERT(isolate != NULL);
   ASSERT(sample_buffer_ != NULL);
   {
     MutexLocker profiler_data_lock(isolate->profiler_data_mutex());
     SampleBuffer* sample_buffer = sample_buffer_;
     if (!shared_buffer) {
@@ skipping 632 matching lines @@
 
 IsolateProfilerData::~IsolateProfilerData() {
   if (own_sample_buffer_) {
     delete sample_buffer_;
     sample_buffer_ = NULL;
     own_sample_buffer_ = false;
   }
 }
 
 
-intptr_t Sample::instance_size_ = 0;
-
-void Sample::InitOnce() {
-  ASSERT(FLAG_profile_depth >= 1);
-  instance_size_ =
-     sizeof(Sample) + (sizeof(intptr_t) * FLAG_profile_depth);  // NOLINT.
-}
-
-
-uword Sample::At(intptr_t i) const {
-  ASSERT(i >= 0);
-  ASSERT(i < FLAG_profile_depth);
-  return pcs_[i];
-}
-
-
-void Sample::SetAt(intptr_t i, uword pc) {
-  ASSERT(i >= 0);
-  ASSERT(i < FLAG_profile_depth);
-  pcs_[i] = pc;
-}
-
-
-void Sample::Init(SampleType type, Isolate* isolate, int64_t timestamp,
-                  ThreadId tid) {
-  timestamp_ = timestamp;
-  tid_ = tid;
-  isolate_ = isolate;
-  type_ = type;
-  for (int i = 0; i < FLAG_profile_depth; i++) {
-    pcs_[i] = 0;
-  }
-}
-
-
-void Sample::CopyInto(Sample* dst) const {
-  ASSERT(dst != NULL);
-  dst->timestamp_ = timestamp_;
-  dst->tid_ = tid_;
-  dst->isolate_ = isolate_;
-  dst->type_ = type_;
-  for (intptr_t i = 0; i < FLAG_profile_depth; i++) {
-    dst->pcs_[i] = pcs_[i];
-  }
-}
-
-
-Sample* Sample::Allocate() {
-  return reinterpret_cast<Sample*>(malloc(instance_size()));
-}
-
-
-SampleBuffer::SampleBuffer(intptr_t capacity) {
-  capacity_ = capacity;
-  samples_ = reinterpret_cast<Sample*>(
-      calloc(capacity, Sample::instance_size()));
-  cursor_ = 0;
-}
-
-
-SampleBuffer::~SampleBuffer() {
-  if (samples_ != NULL) {
-    free(samples_);
-    samples_ = NULL;
-    cursor_ = 0;
-    capacity_ = 0;
-  }
-}
-
-
 Sample* SampleBuffer::ReserveSample() {
   ASSERT(samples_ != NULL);
   uintptr_t cursor = AtomicOperations::FetchAndIncrement(&cursor_);
   // Map back into sample buffer range.
   cursor = cursor % capacity_;
   return At(cursor);
 }
 
-
-void SampleBuffer::CopySample(intptr_t i, Sample* sample) const {
-  At(i)->CopyInto(sample);
-}
-
-
-Sample* SampleBuffer::At(intptr_t idx) const {
-  ASSERT(idx >= 0);
-  ASSERT(idx < capacity_);
-  intptr_t offset = idx * Sample::instance_size();
-  uint8_t* samples = reinterpret_cast<uint8_t*>(samples_);
-  return reinterpret_cast<Sample*>(samples + offset);
-}
-
-
-void SampleBuffer::VisitSamples(SampleVisitor* visitor) {
-  ASSERT(visitor != NULL);
-  Sample* sample = Sample::Allocate();
-  const intptr_t length = capacity();
-  for (intptr_t i = 0; i < length; i++) {
-    CopySample(i, sample);
-    if (sample->isolate() != visitor->isolate()) {
-      // Another isolate.
-      continue;
-    }
-    if (sample->timestamp() == 0) {
-      // Empty.
-      continue;
-    }
-    if (sample->At(0) == 0) {
-      // No frames.
-      continue;
-    }
-    visitor->IncrementVisited();
-    visitor->VisitSample(sample);
-  }
-  free(sample);
-}
-
-
 // Notes on stack frame walking:
 //
 // The sampling profiler will collect up to Sample::kNumStackFrames stack frames
 // The stack frame walking code uses the frame pointer to traverse the stack.
 // If the VM is compiled without frame pointers (which is the default on
 // recent GCC versions with optimizing enabled) the stack walking code may
 // fail (sometimes leading to a crash).
 //
 class ProfilerSampleStackWalker : public ValueObject {
  public:
@@ skipping 99 matching lines @@
   }
   IsolateProfilerData* profiler_data = isolate->profiler_data();
   if (profiler_data == NULL) {
     return;
   }
   SampleBuffer* sample_buffer = profiler_data->sample_buffer();
   if (sample_buffer == NULL) {
     return;
   }
   Sample* sample = sample_buffer->ReserveSample();
-  sample->Init(Sample::kIsolateSample, isolate, OS::GetCurrentTimeMicros(),
-               state.tid);
+  sample->Init(isolate, OS::GetCurrentTimeMicros(), state.tid);
   uword stack_lower = 0;
   uword stack_upper = 0;
   isolate->GetStackBounds(&stack_lower, &stack_upper);
   if ((stack_lower == 0) || (stack_upper == 0)) {
     stack_lower = 0;
     stack_upper = 0;
   }
   ProfilerSampleStackWalker stackWalker(sample, stack_lower, stack_upper,
                                         state.pc, state.fp, state.sp);
   stackWalker.walk();
 }
 
 
 }  // namespace dart