clang-format runtime/vm

runtime/vm/timeline_analysis.cc

 // Copyright (c) 2015, 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 "vm/timeline_analysis.h"
 
 #include "vm/flags.h"
 #include "vm/log.h"
 #include "vm/os_thread.h"
 
 namespace dart {
 
 #ifndef PRODUCT
 
 DECLARE_FLAG(bool, trace_timeline_analysis);
 DECLARE_FLAG(bool, timing);
 
-TimelineAnalysisThread::TimelineAnalysisThread(ThreadId id)
-    : id_(id) {
-}
+TimelineAnalysisThread::TimelineAnalysisThread(ThreadId id) : id_(id) {}
 
 
-TimelineAnalysisThread::~TimelineAnalysisThread() {
-}
+TimelineAnalysisThread::~TimelineAnalysisThread() {}
 
 
 void TimelineAnalysisThread::AddBlock(TimelineEventBlock* block) {
   blocks_.Add(block);
 }
 
 
 static int CompareBlocksLowerTimeBound(TimelineEventBlock* const* a,
                                        TimelineEventBlock* const* b) {
   ASSERT(a != NULL);
   ASSERT(*a != NULL);
   ASSERT(b != NULL);
   ASSERT(*b != NULL);
   return (*a)->LowerTimeBound() - (*b)->LowerTimeBound();
 }
 
 
 void TimelineAnalysisThread::Finalize() {
   blocks_.Sort(CompareBlocksLowerTimeBound);
   if (FLAG_trace_timeline_analysis) {
     THR_Print("Thread %" Px " has %" Pd " blocks\n",
-              OSThread::ThreadIdToIntPtr(id_),
-              blocks_.length());
+              OSThread::ThreadIdToIntPtr(id_), blocks_.length());
   }
 }
 
 
 TimelineAnalysisThreadEventIterator::TimelineAnalysisThreadEventIterator(
     TimelineAnalysisThread* thread) {
   Reset(thread);
 }
 
 
@@ skipping 55 matching lines @@
       isolate_(isolate),
       recorder_(recorder),
       has_error_(false),
       error_msg_(NULL) {
   ASSERT(zone_ != NULL);
   ASSERT(isolate_ != NULL);
   ASSERT(recorder_ != NULL);
 }
 
 
-TimelineAnalysis::~TimelineAnalysis() {
-}
+TimelineAnalysis::~TimelineAnalysis() {}
 
 
 void TimelineAnalysis::BuildThreads() {
   DiscoverThreads();
   FinalizeThreads();
 }
 
 
 TimelineAnalysisThread* TimelineAnalysis::GetThread(ThreadId tid) {
   // Linear lookup because we expect N (# of threads in an isolate) to be small.
@@ skipping 24 matching lines @@
   TimelineEventBlockIterator it(recorder_);
   while (it.HasNext()) {
     TimelineEventBlock* block = it.Next();
     ASSERT(block != NULL);
     if (block->IsEmpty()) {
       // Skip empty blocks.
       continue;
     }
     if (!block->CheckBlock()) {
       if (FLAG_trace_timeline_analysis) {
-        THR_Print("DiscoverThreads block %" Pd " "
-                  "violates invariants.\n", block->block_index());
+        THR_Print("DiscoverThreads block %" Pd
+                  " "
+                  "violates invariants.\n",
+                  block->block_index());
       }
-      SetError("Block %" Pd " violates invariants. See "
-               "TimelineEventBlock::CheckBlock", block->block_index());
+      SetError("Block %" Pd
+               " violates invariants. See "
+               "TimelineEventBlock::CheckBlock",
+               block->block_index());
       return;
     }
     TimelineAnalysisThread* thread = GetOrAddThread(block->thread_id());
     ASSERT(thread != NULL);
     thread->AddBlock(block);
   }
 }
 
 
 void TimelineAnalysis::FinalizeThreads() {
@@ skipping 77 matching lines @@
   }
   if (max_exclusive_micros_ < thread_pause_info->max_exclusive_micros_) {
     max_exclusive_micros_ = thread_pause_info->max_exclusive_micros_;
   }
 }
 
 
 TimelinePauses::TimelinePauses(Zone* zone,
                                Isolate* isolate,
                                TimelineEventRecorder* recorder)
-    : TimelineAnalysis(zone, isolate, recorder) {
-}
+    : TimelineAnalysis(zone, isolate, recorder) {}
 
 
 void TimelinePauses::Setup() {
   BuildThreads();
 }
 
 
 void TimelinePauses::CalculatePauseTimesForThread(ThreadId tid) {
   if (has_error()) {
     return;
@@ skipping 86 matching lines @@
         PopBegin(event->label(), event->TimeOrigin());
       }
     } else {
       // Skip other event kinds.
     }
   }
   // Pop remaining duration stack.
   PopFinishedDurations(kMaxInt64);
   if (FLAG_trace_timeline_analysis) {
     THR_Print("<<< TimelinePauses::ProcessThread %" Px " had %" Pd " events\n",
-              OSThread::ThreadIdToIntPtr(thread->id()),
-              event_count);
+              OSThread::ThreadIdToIntPtr(thread->id()), event_count);
   }
 }
 
 
 // Verify that |event| is contained within all parent events on the stack.
 bool TimelinePauses::CheckStack(TimelineEvent* event) {
   ASSERT(event != NULL);
   for (intptr_t i = 0; i < stack_.length(); i++) {
     const StackItem& slot = stack_.At(i);
     if (slot.event->IsDuration()) {
@@ skipping 12 matching lines @@
 
 
 void TimelinePauses::PopFinishedDurations(int64_t start) {
   while (stack_.length() > 0) {
     const StackItem& top = stack_.Last();
     if (top.event->IsDuration() && top.event->DurationFinishedBefore(start)) {
       top.pause_info->OnPop(top.exclusive_micros);
       // Top of stack completes before |start|.
       stack_.RemoveLast();
       if (FLAG_trace_timeline_analysis) {
-        THR_Print("Popping %s (%" Pd64 " <= %" Pd64 ")\n",
-                  top.event->label(),
-                  top.event->TimeEnd(),
-                  start);
+        THR_Print("Popping %s (%" Pd64 " <= %" Pd64 ")\n", top.event->label(),
+                  top.event->TimeEnd(), start);
       }
     } else {
       return;
     }
   }
 }
 
 
 void TimelinePauses::PopBegin(const char* label, int64_t end) {
   if (stack_.length() == 0) {
     SetError("PopBegin(%s, ...) called with empty stack.", label);
     return;
   }
   ASSERT(stack_.length() > 0);
   const StackItem& top = stack_.Last();
   const char* top_label = top.event->label();
   const bool top_is_begin = top.event->IsBegin();
   const int64_t start = top.event->TimeOrigin();
   if (start > end) {
     SetError("Bad time stamps for PopBegin(%s, ...) %" Pd64 " > %" Pd64 "",
              label, start, end);
     return;
   }
   const int64_t duration = end - start;
   // Sanity checks.
   if (strcmp(top_label, label) != 0) {
-    SetError("PopBegin(%s, ...) called with %s at the top of stack",
-             label, top.event->label());
+    SetError("PopBegin(%s, ...) called with %s at the top of stack", label,
+             top.event->label());
     return;
   }
   if (!top_is_begin) {
-    SetError("kEnd event not paired with kBegin event for label %s",
-             label);
+    SetError("kEnd event not paired with kBegin event for label %s", label);
     return;
   }
   // Pop this event.
   // Add duration to exclusive micros.
   if (FLAG_trace_timeline_analysis) {
-    THR_Print("Popping %s (%" Pd64 ")\n",
-              top.event->label(),
-              duration);
+    THR_Print("Popping %s (%" Pd64 ")\n", top.event->label(), duration);
   }
   const int64_t exclusive_micros = top.exclusive_micros + duration;
   stack_.RemoveLast();
-  top.pause_info->OnBeginPop(duration,
-                             exclusive_micros,
+  top.pause_info->OnBeginPop(duration, exclusive_micros,
                              IsLabelOnStack(top_label));
   if (StackDepth() > 0) {
     StackItem& top = GetStackTop();
     // |top| is under the popped |event|'s shadow, adjust the exclusive micros.
     top.exclusive_micros -= duration;
   }
 }
 
 
 void TimelinePauses::Push(TimelineEvent* event) {
   TimelineLabelPauseInfo* pause_info = GetOrAddLabelPauseInfo(event->label());
   ASSERT(pause_info != NULL);
   // |pause_info| will be running for |event->TimeDuration()|.
   if (FLAG_trace_timeline_analysis) {
-    THR_Print("Pushing %s %" Pd64 " us\n",
-              pause_info->name(),
+    THR_Print("Pushing %s %" Pd64 " us\n", pause_info->name(),
               event->TimeDuration());
   }
   if (event->IsDuration()) {
     pause_info->OnPush(event->TimeDuration(), IsLabelOnStack(event->label()));
     if (StackDepth() > 0) {
       StackItem& top = GetStackTop();
       // |top| is under |event|'s shadow, adjust the exclusive micros.
       top.exclusive_micros -= event->TimeDuration();
     }
     // Push onto the stack.
@@ skipping 45 matching lines @@
   if (pause_info != NULL) {
     return pause_info;
   }
   // New label.
   pause_info = new TimelineLabelPauseInfo(name);
   labels_.Add(pause_info);
   return pause_info;
 }
 
 
-TimelinePauseTrace::TimelinePauseTrace() {
-}
+TimelinePauseTrace::TimelinePauseTrace() {}
 
 
-TimelinePauseTrace::~TimelinePauseTrace() {
-}
+TimelinePauseTrace::~TimelinePauseTrace() {}
 
 
 void TimelinePauseTrace::Print() {
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   Zone* zone = thread->zone();
   ASSERT(zone != NULL);
   TimelineEventRecorder* recorder = Timeline::recorder();
   ASSERT(recorder != NULL);
   TimelinePauses pauses(zone, isolate, recorder);
   pauses.Setup();
 
-  THR_Print("Timing for isolate %s (from %" Pd " threads)\n",
-            isolate->name(),
+  THR_Print("Timing for isolate %s (from %" Pd " threads)\n", isolate->name(),
             pauses.NumThreads());
   THR_Print("\n");
   for (intptr_t t_idx = 0; t_idx < pauses.NumThreads(); t_idx++) {
     TimelineAnalysisThread* tat = pauses.At(t_idx);
     ASSERT(tat != NULL);
     pauses.CalculatePauseTimesForThread(tat->id());
-    THR_Print("Thread %" Pd " (%" Px "):\n",
-              t_idx,
+    THR_Print("Thread %" Pd " (%" Px "):\n", t_idx,
               OSThread::ThreadIdToIntPtr(tat->id()));
     for (intptr_t j = 0; j < pauses.NumPauseInfos(); j++) {
       const TimelineLabelPauseInfo* pause_info = pauses.PauseInfoAt(j);
       ASSERT(pause_info != NULL);
       Aggregate(pause_info);
       PrintPauseInfo(pause_info);
     }
     THR_Print("\n");
   }
   THR_Print("Totals:\n");
@@ skipping 43 matching lines @@
             MicrosecondsToMilliseconds(pause_info->exclusive_micros()));
   THR_Print("%.3f ms max on stack; ",
             MicrosecondsToMilliseconds(pause_info->max_inclusive_micros()));
   THR_Print("%.3f ms max executing.\n",
             MicrosecondsToMilliseconds(pause_info->max_exclusive_micros()));
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart