Begin transition to ProcessedSample in Profiler

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/bitfield.h"
 #include "vm/code_observers.h"
 #include "vm/globals.h"
+#include "vm/growable_array.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 SampleBuffer;
 
-
 class Profiler : public AllStatic {
  public:
   static void InitOnce();
   static void Shutdown();
 
   static void SetSampleDepth(intptr_t depth);
   static void SetSamplePeriod(intptr_t period);
 
   static void InitProfilingForIsolate(Isolate* isolate,
                                       bool shared_buffer = true);
@@ skipping 65 matching lines @@
   }
 
  private:
   Isolate* isolate_;
   intptr_t visited_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SampleVisitor);
 };
 
 
-class PreprocessVisitor : public SampleVisitor {
+class SampleFilter : public ValueObject {
  public:
-  explicit PreprocessVisitor(Isolate* isolate);
+  explicit SampleFilter(Isolate* isolate) : isolate_(isolate) { }
+  virtual ~SampleFilter() { }
 
-  virtual void VisitSample(Sample* sample);
+  // Override this function.
+  // Return |true| if |sample| passes the filter.
+  virtual bool FilterSample(Sample* sample) {
+    return true;
+  }
+
+  Isolate* isolate() const {
+    return isolate_;
+  }
 
  private:
-  void CheckForMissingDartFrame(const Code& code, Sample* sample) const;
-
-  bool ContainedInDartCodeHeaps(uword pc) const;
-
-  Isolate* vm_isolate() const {
-    return vm_isolate_;
-  }
-
-  RawCode* FindCodeForPC(uword pc) const;
-
-  Isolate* vm_isolate_;
+  Isolate* isolate_;
 };
 
 
 class ClearProfileVisitor : public SampleVisitor {
  public:
   explicit ClearProfileVisitor(Isolate* isolate);
 
   virtual void VisitSample(Sample* sample);
 };
 
@@ skipping 261 matching lines @@
       }
       if (sample->At(0) == 0) {
         // No frames.
         continue;
       }
       visitor->IncrementVisited();
       visitor->VisitSample(sample);
     }
   }
 
+  ProcessedSampleBuffer* BuildProcessedSampleBuffer(SampleFilter* filter);
+
  private:
+  ProcessedSample* BuildProcessedSample(Sample* sample);
+  Sample* Next(Sample* sample);
+
   Sample* samples_;
   intptr_t capacity_;
   uintptr_t cursor_;
 
   DISALLOW_COPY_AND_ASSIGN(SampleBuffer);
 };
 
 
+// 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);
+  }
+
+  // Insert |pc| at |index|.
+  void InsertAt(intptr_t index, uword pc) {
+    pcs_.InsertAt(index, pc);
+  }
+
+  // Number of pcs in stack trace.
+  intptr_t length() const { return pcs_.length(); }
+
+  // Get |pc| at |index|.
+  uword At(intptr_t index) const {
+    ASSERT(index >= 0);
+    ASSERT(index < length());
+    return pcs_[index];
+  }
+
+  // Timestamp sample was taken at.
+  int64_t timestamp() const { return timestamp_; }
+  void set_timestamp(int64_t timestamp) { timestamp_ = timestamp; }
+
+  // The VM tag.
+  uword vm_tag() const { return vm_tag_; }
+  void set_vm_tag(uword tag) { vm_tag_ = tag; }
+
+  // The user tag.
+  uword user_tag() const { return user_tag_; }
+  void set_user_tag(uword tag) { user_tag_ = tag; }
+
+  // The class id if this is an allocation profile sample. -1 otherwise.
+  intptr_t allocation_cid() const { return allocation_cid_; }
+  void set_allocation_cid(intptr_t cid) { allocation_cid_ = cid; }
+
+  // Was the stack trace truncated?
+  bool truncated() const { return truncated_; }
+  void set_truncated(bool truncated) { truncated_ = truncated; }
+
+  // Was the first frame in the stack trace executing?
+  bool first_frame_executing() const { return first_frame_executing_; }
+  void set_first_frame_executing(bool first_frame_executing) {
+    first_frame_executing_ = first_frame_executing;
+  }
+
+ private:
+  void FixupCaller(Isolate* isolate,
+                   Isolate* vm_isolate,
+                   uword pc_marker,
+                   uword* stack_buffer);
+
+  void CheckForMissingDartFrame(Isolate* isolate,
+                                Isolate* vm_isolate,
+                                const Code& code,
+                                uword pc_marker,
+                                uword* stack_buffer);
+
+  static RawCode* FindCodeForPC(Isolate* isolate,
+                                Isolate* vm_isolate,
+                                uword pc);
+
+  static bool ContainedInDartCodeHeaps(Isolate* isolate,
+                                       Isolate* vm_isolate,
+                                       uword pc);
+
+  ZoneGrowableArray<uword> pcs_;
+  int64_t timestamp_;
+  uword vm_tag_;
+  uword user_tag_;
+  intptr_t allocation_cid_;
+  bool truncated_;
+  bool first_frame_executing_;
+
+  friend class SampleBuffer;
+  DISALLOW_COPY_AND_ASSIGN(ProcessedSample);
+};
+
+
+// A collection of |ProcessedSample|s.
+class ProcessedSampleBuffer : public ZoneAllocated {
+ public:
+  ProcessedSampleBuffer();
+
+  void Add(ProcessedSample* sample) {
+    samples_.Add(sample);
+  }
+
+  intptr_t length() const {
+    return samples_.length();
+  }
+
+  ProcessedSample* At(intptr_t index) {
+    return samples_.At(index);
+  }
+
+ private:
+  ZoneGrowableArray<ProcessedSample*> samples_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProcessedSampleBuffer);
+};
+
 }  // namespace dart
 
 #endif  // VM_PROFILER_H_