Migrate logging infrastructure Isolate->Thread

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"
 
@@ skipping 21 matching lines @@
   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) {
-    ISL_Print("Thread %" Px " has %" Pd " blocks\n",
+    THR_Print("Thread %" Px " has %" Pd " blocks\n",
               OSThread::ThreadIdToIntPtr(id_),
               blocks_.length());
   }
 }
 
 
 TimelineAnalysisThreadEventIterator::TimelineAnalysisThreadEventIterator(
     TimelineAnalysisThread* thread) {
   Reset(thread);
 }
@@ skipping 103 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) {
-        ISL_Print("DiscoverThreads block %" Pd " "
+        THR_Print("DiscoverThreads block %" Pd " "
                   "violates invariants.\n", block->block_index());
       }
       SetError("Block %" Pd " violates invariants. See "
                "TimelineEventBlock::CheckBlock", block->block_index());
       return;
     }
     TimelineAnalysisThread* thread = GetOrAddThread(block->thread());
     ASSERT(thread != NULL);
     thread->AddBlock(block);
   }
@@ skipping 116 matching lines @@
 }
 
 
 void TimelinePauses::ProcessThread(TimelineAnalysisThread* thread) {
   ASSERT(thread != NULL);
   stack_.Clear();
   labels_.Clear();
 
   TimelineAnalysisThreadEventIterator it(thread);
   if (FLAG_trace_timeline_analysis) {
-    ISL_Print(">>> TimelinePauses::ProcessThread %" Px "\n",
+    THR_Print(">>> TimelinePauses::ProcessThread %" Px "\n",
               OSThread::ThreadIdToIntPtr(thread->id()));
   }
   intptr_t event_count = 0;
   while (it.HasNext()) {
     TimelineEvent* event = it.Next();
     if (!event->IsFinishedDuration()) {
       // We only care about finished duration events.
       continue;
     }
     int64_t start = event->TimeOrigin();
     PopFinished(start);
     if (!CheckStack(event)) {
       SetError("Duration check fail.");
       return;
     }
     event_count++;
     Push(event);
   }
   // Pop remaining stack.
   PopFinished(kMaxInt64);
   if (FLAG_trace_timeline_analysis) {
-    ISL_Print("<<< TimelinePauses::ProcessThread %" Px " had %" Pd " events\n",
+    THR_Print("<<< TimelinePauses::ProcessThread %" Px " had %" Pd " events\n",
               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->DurationContains(event)) {
       return false;
     }
   }
   return true;
 }
 
 
 void TimelinePauses::PopFinished(int64_t start) {
   while (stack_.length() > 0) {
     const StackItem& top = stack_.Last();
     if (top.event->DurationFinishedBefore(start)) {
       top.pause_info->OnPop(top.exclusive_micros);
       // Top of stack completes before |start|.
       stack_.RemoveLast();
       if (FLAG_trace_timeline_analysis) {
-        ISL_Print("Popping %s (%" Pd64 " <= %" Pd64 ")\n",
+        THR_Print("Popping %s (%" Pd64 " <= %" Pd64 ")\n",
                   top.event->label(),
                   top.event->TimeEnd(),
                   start);
       }
     } else {
       return;
     }
   }
 }
 
 
 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) {
-    ISL_Print("Pushing %s %" Pd64 " us\n",
+    THR_Print("Pushing %s %" Pd64 " us\n",
               pause_info->name(),
               event->TimeDuration());
   }
   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 35 matching lines @@
   if (pause_info != NULL) {
     return pause_info;
   }
   // New label.
   pause_info = new TimelineLabelPauseInfo(name);
   labels_.Add(pause_info);
   return pause_info;
 }
 
 }  // namespace dart