Revert "Track history of events in GCTracer."

src/incremental-marking.cc

 // Copyright 2012 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/incremental-marking.h"
 
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
 #include "src/conversions.h"
 #include "src/objects-visiting.h"
 #include "src/objects-visiting-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 IncrementalMarking::IncrementalMarking(Heap* heap)
     : heap_(heap),
       state_(STOPPED),
       marking_deque_memory_(NULL),
       marking_deque_memory_committed_(false),
       steps_count_(0),
+      steps_took_(0),
+      longest_step_(0.0),
       old_generation_space_available_at_start_of_incremental_(0),
       old_generation_space_used_at_start_of_incremental_(0),
+      steps_count_since_last_gc_(0),
+      steps_took_since_last_gc_(0),
       should_hurry_(false),
       marking_speed_(0),
       allocated_(0),
       no_marking_scope_depth_(0),
-      unscanned_bytes_of_large_object_(0) {
-}
+      unscanned_bytes_of_large_object_(0) {}
 
 
 void IncrementalMarking::TearDown() {
   delete marking_deque_memory_;
 }
 
 
 void IncrementalMarking::RecordWriteSlow(HeapObject* obj,
                                          Object** slot,
                                          Object* value) {
@@ skipping 605 matching lines @@
         MarkBit mark_bit = Marking::MarkBitFrom(obj);
         MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
         ASSERT(Marking::IsGrey(mark_bit) ||
                (obj->IsFiller() && Marking::IsWhite(mark_bit)) ||
                (chunk->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR) &&
                 Marking::IsBlack(mark_bit)));
 #endif
     }
   }
   marking_deque_.set_top(new_top);
+
+  steps_took_since_last_gc_ = 0;
+  steps_count_since_last_gc_ = 0;
 }
 
 
 void IncrementalMarking::VisitObject(Map* map, HeapObject* obj, int size) {
   MarkBit map_mark_bit = Marking::MarkBitFrom(map);
   if (Marking::IsWhite(map_mark_bit)) {
     WhiteToGreyAndPush(map, map_mark_bit);
   }
 
   IncrementalMarkingMarkingVisitor::IterateBody(map, obj);
@@ skipping 214 matching lines @@
     if (!heap_->mark_compact_collector()->sweeping_in_progress()) {
       bytes_scanned_ = 0;
       StartMarking(PREVENT_COMPACTION);
     }
   } else if (state_ == MARKING) {
     ProcessMarkingDeque(bytes_to_process);
     if (marking_deque_.IsEmpty()) MarkingComplete(action);
   }
 
   steps_count_++;
+  steps_count_since_last_gc_++;
 
   bool speed_up = false;
 
   if ((steps_count_ % kMarkingSpeedAccellerationInterval) == 0) {
     if (FLAG_trace_gc) {
       PrintPID("Speed up marking after %d steps\n",
                static_cast<int>(kMarkingSpeedAccellerationInterval));
     }
     speed_up = true;
   }
@@ skipping 48 matching lines @@
       if (FLAG_trace_gc) {
         PrintPID("Marking speed increased to %d\n", marking_speed_);
       }
     }
   }
 
   if (FLAG_trace_incremental_marking || FLAG_trace_gc ||
       FLAG_print_cumulative_gc_stat) {
     double end = base::OS::TimeCurrentMillis();
     double delta = (end - start);
-    heap_->tracer()->AddIncrementalMarkingStep(delta);
+    longest_step_ = Max(longest_step_, delta);
+    steps_took_ += delta;
+    steps_took_since_last_gc_ += delta;
     heap_->AddMarkingTime(delta);
   }
 }
 
 
 void IncrementalMarking::ResetStepCounters() {
   steps_count_ = 0;
+  steps_took_ = 0;
+  longest_step_ = 0.0;
   old_generation_space_available_at_start_of_incremental_ =
       SpaceLeftInOldSpace();
   old_generation_space_used_at_start_of_incremental_ =
       heap_->PromotedTotalSize();
+  steps_count_since_last_gc_ = 0;
+  steps_took_since_last_gc_ = 0;
   bytes_rescanned_ = 0;
   marking_speed_ = kInitialMarkingSpeed;
   bytes_scanned_ = 0;
   write_barriers_invoked_since_last_step_ = 0;
 }
 
 
 int64_t IncrementalMarking::SpaceLeftInOldSpace() {
   return heap_->MaxOldGenerationSize() - heap_->PromotedSpaceSizeOfObjects();
 }
 
 } }  // namespace v8::internal