clang-format runtime/vm

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 34 matching lines @@
 
 
 class Profiler : public AllStatic {
  public:
   static void InitOnce();
   static void Shutdown();
 
   static void SetSampleDepth(intptr_t depth);
   static void SetSamplePeriod(intptr_t period);
 
-  static SampleBuffer* sample_buffer() {
-    return sample_buffer_;
-  }
+  static SampleBuffer* sample_buffer() { return sample_buffer_; }
 
   static void DumpStackTrace(bool native_stack_trace = true);
 
   static void SampleAllocation(Thread* thread, intptr_t cid);
 
   // 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);
+  static void SampleThread(Thread* thread, const InterruptedThreadState& state);
 
   static ProfilerCounters counters() {
     // Copies the counter values.
     return counters_;
   }
 
  private:
   // Does not walk the thread's stack.
   static void SampleThreadSingleFrame(Thread* thread, uintptr_t pc);
   static bool initialized_;
 
   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(Isolate* isolate) : isolate_(isolate), visited_(0) {}
   virtual ~SampleVisitor() {}
 
   virtual void VisitSample(Sample* sample) = 0;
 
-  intptr_t visited() const {
-    return visited_;
-  }
+  intptr_t visited() const { return visited_; }
 
-  void IncrementVisited() {
-    visited_++;
-  }
+  void IncrementVisited() { visited_++; }
 
-  Isolate* isolate() const {
-    return isolate_;
-  }
+  Isolate* isolate() const { return isolate_; }
 
  private:
   Isolate* isolate_;
   intptr_t visited_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SampleVisitor);
 };
 
 
 class SampleFilter : public ValueObject {
  public:
   SampleFilter(Isolate* isolate,
                intptr_t thread_task_mask,
                int64_t time_origin_micros,
                int64_t time_extent_micros)
       : isolate_(isolate),
         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() { }
+  virtual ~SampleFilter() {}
 
   // Override this function.
   // Return |true| if |sample| passes the filter.
-  virtual bool FilterSample(Sample* sample) {
-    return true;
-  }
+  virtual bool FilterSample(Sample* sample) { return true; }
 
-  Isolate* isolate() const {
-    return isolate_;
-  }
+  Isolate* isolate() const { return isolate_; }
 
   // 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_;
   intptr_t thread_task_mask_;
@@ skipping 14 matching lines @@
 class Sample {
  public:
   void Init(Isolate* isolate, int64_t timestamp, ThreadId tid) {
     Clear();
     timestamp_ = timestamp;
     tid_ = tid;
     isolate_ = isolate;
   }
 
   // Isolate sample was taken from.
-  Isolate* isolate() const {
-    return isolate_;
-  }
+  Isolate* isolate() const { return isolate_; }
 
   // Thread sample was taken on.
-  ThreadId tid() const {
-    return tid_;
-  }
+  ThreadId tid() const { return tid_; }
 
   void Clear() {
     isolate_ = NULL;
     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;
     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_;
-  }
+  int64_t timestamp() const { return timestamp_; }
 
   // Top most pc.
-  uword pc() const {
-    return At(0);
-  }
+  uword pc() const { return At(0); }
 
   // Get stack trace entry.
   uword At(intptr_t i) const {
     ASSERT(i >= 0);
     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 < pcs_length_);
     uword* pcs = GetPCArray();
     pcs[i] = pc;
   }
 
-  uword vm_tag() const {
-    return vm_tag_;
-  }
+  uword vm_tag() const { return vm_tag_; }
   void set_vm_tag(uword tag) {
     ASSERT(tag != VMTag::kInvalidTagId);
     vm_tag_ = tag;
   }
 
-  uword user_tag() const {
-    return user_tag_;
-  }
-  void set_user_tag(uword tag) {
-    user_tag_ = tag;
-  }
+  uword user_tag() const { return user_tag_; }
+  void set_user_tag(uword tag) { user_tag_ = tag; }
 
-  uword pc_marker() const {
-    return pc_marker_;
-  }
+  uword pc_marker() const { return pc_marker_; }
 
-  void set_pc_marker(uword pc_marker) {
-    pc_marker_ = pc_marker;
-  }
+  void set_pc_marker(uword pc_marker) { pc_marker_ = pc_marker; }
 
-  uword lr() const {
-    return lr_;
-  }
+  uword lr() const { return lr_; }
 
-  void set_lr(uword link_register) {
-    lr_ = link_register;
-  }
+  void set_lr(uword link_register) { lr_ = link_register; }
 
-  bool leaf_frame_is_dart() const {
-    return LeafFrameIsDart::decode(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_);
   }
 
-  bool ignore_sample() const {
-    return IgnoreBit::decode(state_);
-  }
+  bool ignore_sample() const { return IgnoreBit::decode(state_); }
 
   void set_ignore_sample(bool ignore_sample) {
     state_ = IgnoreBit::update(ignore_sample, state_);
   }
 
-  bool exit_frame_sample() const {
-    return ExitFrameBit::decode(state_);
-  }
+  bool exit_frame_sample() const { return ExitFrameBit::decode(state_); }
 
   void set_exit_frame_sample(bool exit_frame_sample) {
     state_ = ExitFrameBit::update(exit_frame_sample, state_);
   }
 
   bool missing_frame_inserted() const {
     return MissingFrameInsertedBit::decode(state_);
   }
 
   void set_missing_frame_inserted(bool missing_frame_inserted) {
     state_ = MissingFrameInsertedBit::update(missing_frame_inserted, state_);
   }
 
-  bool truncated_trace() const {
-    return TruncatedTraceBit::decode(state_);
-  }
+  bool truncated_trace() const { return TruncatedTraceBit::decode(state_); }
 
   void set_truncated_trace(bool truncated_trace) {
     state_ = TruncatedTraceBit::update(truncated_trace, state_);
   }
 
   bool is_allocation_sample() const {
     return ClassAllocationSampleBit::decode(state_);
   }
 
   void set_is_allocation_sample(bool allocation_sample) {
     state_ = ClassAllocationSampleBit::update(allocation_sample, state_);
   }
 
-  Thread::TaskKind thread_task() const {
-    return ThreadTaskBit::decode(state_);
-  }
+  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_);
   }
 
   void SetContinuationIndex(intptr_t index) {
@@ skipping 11 matching lines @@
 
   intptr_t allocation_cid() const {
     ASSERT(is_allocation_sample());
     return metadata_;
   }
 
   void set_head_sample(bool head_sample) {
     state_ = HeadSampleBit::update(head_sample, state_);
   }
 
-  bool head_sample() const {
-    return HeadSampleBit::decode(state_);
-  }
+  bool head_sample() const { return HeadSampleBit::decode(state_); }
 
-  void set_metadata(intptr_t metadata) {
-    metadata_ = metadata;
-  }
+  void set_metadata(intptr_t metadata) { metadata_ = metadata; }
 
   void SetAllocationCid(intptr_t cid) {
     set_is_allocation_sample(true);
     set_metadata(cid);
   }
 
   static void InitOnce();
 
-  static intptr_t instance_size() {
-    return instance_size_;
-  }
+  static intptr_t instance_size() { return instance_size_; }
 
   uword* GetPCArray() const;
 
   static const int kStackBufferSizeInWords = 2;
-  uword* GetStackBuffer() {
-    return &stack_buffer_[0];
-  }
+  uword* GetStackBuffer() { return &stack_buffer_[0]; }
 
  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.
     kNextFreeBit = 13,
   };
   class HeadSampleBit : public BitField<uword, bool, kHeadSampleBit, 1> {};
-  class LeafFrameIsDart :
-      public BitField<uword, bool, kLeafFrameIsDartBit, 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 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> {};
 
   int64_t timestamp_;
   ThreadId tid_;
   Isolate* isolate_;
@@ skipping 17 matching lines @@
 class CodeDescriptor : public ZoneAllocated {
  public:
   explicit CodeDescriptor(const Code& code);
 
   uword Start() const;
 
   uword Size() const;
 
   int64_t CompileTimestamp() const;
 
-  RawCode* code() const {
-    return code_.raw();
-  }
+  RawCode* code() const { return code_.raw(); }
 
-  const char* Name() const {
-    return code_.Name();
-  }
+  const char* Name() const { return code_.Name(); }
 
   bool Contains(uword pc) const {
     uword end = Start() + Size();
     return (pc >= Start()) && (pc < end);
   }
 
-  static int Compare(CodeDescriptor* const* a,
-                     CodeDescriptor* const* b) {
+  static int Compare(CodeDescriptor* const* a, CodeDescriptor* const* b) {
     ASSERT(a != NULL);
     ASSERT(b != NULL);
 
     uword a_start = (*a)->Start();
     uword b_start = (*b)->Start();
 
     if (a_start < b_start) {
       return -1;
     } else if (a_start > b_start) {
       return 1;
     } else {
       return 0;
     }
   }
 
  private:
   const Code& code_;
 
   DISALLOW_COPY_AND_ASSIGN(CodeDescriptor);
 };
 
 
 // Fast lookup of Dart code objects.
 class CodeLookupTable : public ZoneAllocated {
  public:
   explicit CodeLookupTable(Thread* thread);
 
-  intptr_t length() const {
-    return code_objects_.length();
-  }
+  intptr_t length() const { return code_objects_.length(); }
 
   const CodeDescriptor* At(intptr_t index) const {
     return code_objects_.At(index);
   }
 
   const CodeDescriptor* FindCode(uword pc) const;
 
  private:
   void Build(Thread* thread);
 
@@ skipping 77 matching lines @@
 
 
 // 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);
-  }
+  void Add(uword pc) { pcs_.Add(pc); }
 
   // Insert |pc| at |index|.
-  void InsertAt(intptr_t index, uword pc) {
-    pcs_.InsertAt(index, pc);
-  }
+  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];
   }
@@ skipping 10 matching lines @@
   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; }
 
-  bool IsAllocationSample() const {
-    return allocation_cid_ > 0;
-  }
+  bool IsAllocationSample() const { return allocation_cid_ > 0; }
 
   // 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;
   }
@@ skipping 27 matching lines @@
   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);
-  }
+  void Add(ProcessedSample* sample) { samples_.Add(sample); }
 
-  intptr_t length() const {
-    return samples_.length();
-  }
+  intptr_t length() const { return samples_.length(); }
 
-  ProcessedSample* At(intptr_t index) {
-    return samples_.At(index);
-  }
+  ProcessedSample* At(intptr_t index) { return samples_.At(index); }
 
   const CodeLookupTable& code_lookup_table() const {
     return *code_lookup_table_;
   }
 
  private:
   ZoneGrowableArray<ProcessedSample*> samples_;
   CodeLookupTable* code_lookup_table_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessedSampleBuffer);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PROFILER_H_