Always trace garbage collection events in GCTracer.

src/gc-tracer.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/gc-tracer.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 60 matching lines @@
       incremental_marking_duration_(0.0),
       longest_incremental_marking_step_(0.0) {
   current_ = Event(Event::START, NULL, NULL);
   current_.end_time = base::OS::TimeCurrentMillis();
   previous_ = previous_mark_compactor_event_ = current_;
 }
 
 
 void GCTracer::Start(GarbageCollector collector, const char* gc_reason,
                      const char* collector_reason) {
-  if (!FLAG_trace_gc && !FLAG_print_cumulative_gc_stat) return;
-
   previous_ = current_;
   if (current_.type == Event::MARK_COMPACTOR)
     previous_mark_compactor_event_ = current_;
 
   if (collector == SCAVENGER) {
     current_ = Event(Event::SCAVENGER, gc_reason, collector_reason);
   } else {
     current_ = Event(Event::MARK_COMPACTOR, gc_reason, collector_reason);
   }
 
   current_.start_time = base::OS::TimeCurrentMillis();
   current_.start_object_size = heap_->SizeOfObjects();
   current_.start_memory_size = heap_->isolate()->memory_allocator()->Size();
   current_.start_holes_size = CountTotalHolesSize(heap_);
 
   current_.incremental_marking_steps = incremental_marking_steps_;
   current_.incremental_marking_duration = incremental_marking_duration_;
   current_.longest_incremental_marking_step = longest_incremental_marking_step_;
 
   for (int i = 0; i < Scope::NUMBER_OF_SCOPES; i++) {
     current_.scopes[i] = 0;
   }
 }
 
 
 void GCTracer::Stop() {
-  if (!FLAG_trace_gc && !FLAG_print_cumulative_gc_stat) return;
-
   current_.end_time = base::OS::TimeCurrentMillis();
   current_.end_object_size = heap_->SizeOfObjects();
   current_.end_memory_size = heap_->isolate()->memory_allocator()->Size();
   current_.end_holes_size = CountTotalHolesSize(heap_);
 
   if (current_.type == Event::SCAVENGER) {
     scavenger_events_.push_front(current_);
   } else {
     mark_compactor_events_.push_front(current_);
   }
 
   if (current_.type == Event::MARK_COMPACTOR)
     longest_incremental_marking_step_ = 0.0;
 
+  // TODO(ernstm): move the code below out of GCTracer.
+
+  if (!FLAG_trace_gc && !FLAG_print_cumulative_gc_stat) return;
+
   double duration = current_.end_time - current_.start_time;
   double spent_in_mutator = Max(current_.start_time - previous_.end_time, 0.0);
 
   heap_->UpdateCumulativeGCStatistics(duration, spent_in_mutator,
                                       current_.scopes[Scope::MC_MARK]);
 
   if (current_.type == Event::SCAVENGER && FLAG_trace_gc_ignore_scavenger)
     return;
 
   if (FLAG_trace_gc) {
@@ skipping 173 matching lines @@
 
 
 double GCTracer::MaxIncrementalMarkingDuration() const {
   if (mark_compactor_events_.empty()) return 0.0;
 
   EventBuffer::const_iterator last_mc = mark_compactor_events_.begin();
   return last_mc->longest_incremental_marking_step;
 }
 }
 }  // namespace v8::internal