Report precise number of incrementally marked bytes to gc tracer.

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"
@@ skipping 659 matching lines @@
   MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
   SLOW_ASSERT(Marking::IsGrey(mark_bit) ||
               (obj->IsFiller() && Marking::IsWhite(mark_bit)) ||
               (chunk->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR) &&
                Marking::IsBlack(mark_bit)));
 #endif
   MarkBlackOrKeepBlack(obj, mark_bit, size);
 }
 
 
-void IncrementalMarking::ProcessMarkingDeque(intptr_t bytes_to_process) {
+intptr_t IncrementalMarking::ProcessMarkingDeque(intptr_t bytes_to_process) {
+  intptr_t bytes_processed = 0;
   Map* filler_map = heap_->one_pointer_filler_map();
-  while (!marking_deque_.IsEmpty() && bytes_to_process > 0) {
+  while (!marking_deque_.IsEmpty() && bytes_processed < bytes_to_process) {
     HeapObject* obj = marking_deque_.Pop();
 
     // Explicitly skip one word fillers. Incremental markbit patterns are
     // correct only for objects that occupy at least two words.
     Map* map = obj->map();
     if (map == filler_map) continue;
 
     int size = obj->SizeFromMap(map);
     unscanned_bytes_of_large_object_ = 0;
     VisitObject(map, obj, size);
     int delta = (size - unscanned_bytes_of_large_object_);
     // TODO(jochen): remove after http://crbug.com/381820 is resolved.
     CHECK_LT(0, delta);
-    bytes_to_process -= delta;
+    bytes_processed += delta;
   }
+  return bytes_processed;
 }
 
 
 void IncrementalMarking::ProcessMarkingDeque() {
   Map* filler_map = heap_->one_pointer_filler_map();
   while (!marking_deque_.IsEmpty()) {
     HeapObject* obj = marking_deque_.Pop();
 
     // Explicitly skip one word fillers. Incremental markbit patterns are
     // correct only for objects that occupy at least two words.
@@ skipping 158 matching lines @@
     // on
     // allocation), so to reduce the lumpiness we don't use the write barriers
     // invoked since last step directly to determine the amount of work to do.
     intptr_t bytes_to_process =
         marking_speed_ *
         Max(allocated_, write_barriers_invoked_since_last_step_);
     allocated_ = 0;
     write_barriers_invoked_since_last_step_ = 0;
 
     bytes_scanned_ += bytes_to_process;
+    intptr_t bytes_processed = 0;
 
     if (state_ == SWEEPING) {
       if (heap_->mark_compact_collector()->sweeping_in_progress() &&
           heap_->mark_compact_collector()->IsSweepingCompleted()) {
         heap_->mark_compact_collector()->EnsureSweepingCompleted();
       }
       if (!heap_->mark_compact_collector()->sweeping_in_progress()) {
         bytes_scanned_ = 0;
         StartMarking(PREVENT_COMPACTION);
       }
     } else if (state_ == MARKING) {
-      ProcessMarkingDeque(bytes_to_process);
+      bytes_processed = ProcessMarkingDeque(bytes_to_process);
       if (marking_deque_.IsEmpty()) MarkingComplete(action);
     }
 
     steps_count_++;
 
     bool speed_up = false;
 
     if ((steps_count_ % kMarkingSpeedAccellerationInterval) == 0) {
       if (FLAG_trace_gc) {
         PrintPID("Speed up marking after %d steps\n",
@@ skipping 51 matching lines @@
         marking_speed_ = static_cast<int>(
             Min(kMaxMarkingSpeed, static_cast<intptr_t>(marking_speed_ * 1.3)));
         if (FLAG_trace_gc) {
           PrintPID("Marking speed increased to %d\n", marking_speed_);
         }
       }
     }
 
     double end = base::OS::TimeCurrentMillis();
     double duration = (end - start);
-    heap_->tracer()->AddIncrementalMarkingStep(duration, allocated_bytes);
+    // Note that we report zero bytes here when sweeping was in progress or
+    // when we just started incremental marking. In these cases we did not
+    // process the marking deque.
+    heap_->tracer()->AddIncrementalMarkingStep(duration, bytes_processed);
     heap_->AddMarkingTime(duration);
   }
 }
 
 
 void IncrementalMarking::ResetStepCounters() {
   steps_count_ = 0;
   old_generation_space_available_at_start_of_incremental_ =
       SpaceLeftInOldSpace();
   old_generation_space_used_at_start_of_incremental_ =
       heap_->PromotedTotalSize();
   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