Print promotion rate and semi-space copy rate in --trace-gc-nvp.

src/heap.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 "v8.h"
 
 #include "accessors.h"
 #include "api.h"
 #include "bootstrapper.h"
 #include "codegen.h"
@@ skipping 2038 matching lines @@
 
         if (object_contents == POINTER_OBJECT) {
           if (map->instance_type() == JS_FUNCTION_TYPE) {
             heap->promotion_queue()->insert(
                 target, JSFunction::kNonWeakFieldsEndOffset);
           } else {
             heap->promotion_queue()->insert(target, object_size);
           }
         }
 
-        heap->tracer()->increment_promoted_objects_size(object_size);
+        if (FLAG_trace_gc) {

[Michael Starzinger, 2014/05/16 11:30:37]

nit: This makes the code harder to read and I am not sure if it actually has
significant profit. Would you be willing to go back to increment unconditionally
here?

[Hannes Payer (out of office), 2014/05/20 09:29:14]

Done.

+          heap->tracer()->increment_promoted_objects_size(object_size);
+        }
         return;
       }
     }
     ASSERT(heap->AllowedToBeMigrated(object, NEW_SPACE));
     AllocationResult allocation =
         heap->new_space()->AllocateRaw(allocation_size);
     heap->promotion_queue()->SetNewLimit(heap->new_space()->top());
     HeapObject* target = HeapObject::cast(allocation.ToObjectChecked());
 
     if (alignment != kObjectAlignment) {
       target = EnsureDoubleAligned(heap, target, allocation_size);
     }
 
     // Order is important: slot might be inside of the target if target
     // was allocated over a dead object and slot comes from the store
     // buffer.
     *slot = target;
     MigrateObject(heap, object, target, object_size);
+    if (FLAG_trace_gc) {

[Michael Starzinger, 2014/05/16 11:30:37]

nit: Likewise.

[Hannes Payer (out of office), 2014/05/20 09:29:14]

Done.

+      heap->tracer()->increment_semi_space_copied_object_size(object_size);
+    }
     return;
   }
 
 
   static inline void EvacuateJSFunction(Map* map,
                                         HeapObject** slot,
                                         HeapObject* object) {
     ObjectEvacuationStrategy<POINTER_OBJECT>::
         template VisitSpecialized<JSFunction::kSize>(map, slot, object);
 
@@ skipping 3934 matching lines @@
                    const char* gc_reason,
                    const char* collector_reason)
     : start_time_(0.0),
       start_object_size_(0),
       start_memory_size_(0),
       gc_count_(0),
       full_gc_count_(0),
       allocated_since_last_gc_(0),
       spent_in_mutator_(0),
       promoted_objects_size_(0),
+      semi_space_copied_object_size_(0),
       nodes_died_in_new_space_(0),
       nodes_copied_in_new_space_(0),
       nodes_promoted_(0),
       heap_(heap),
       gc_reason_(gc_reason),
       collector_reason_(collector_reason) {
   if (!FLAG_trace_gc && !FLAG_print_cumulative_gc_stat) return;
   start_time_ = OS::TimeCurrentMillis();
   start_object_size_ = heap_->SizeOfObjects();
   start_memory_size_ = heap_->isolate()->memory_allocator()->Size();
@@ skipping 127 matching lines @@
         scopes_[Scope::MC_WEAKCOLLECTION_CLEAR]);
 
     PrintF("total_size_before=%" V8_PTR_PREFIX "d ", start_object_size_);
     PrintF("total_size_after=%" V8_PTR_PREFIX "d ", heap_->SizeOfObjects());
     PrintF("holes_size_before=%" V8_PTR_PREFIX "d ",
            in_free_list_or_wasted_before_gc_);
     PrintF("holes_size_after=%" V8_PTR_PREFIX "d ", CountTotalHolesSize(heap_));
 
     PrintF("allocated=%" V8_PTR_PREFIX "d ", allocated_since_last_gc_);
     PrintF("promoted=%" V8_PTR_PREFIX "d ", promoted_objects_size_);
+    PrintF("semi_space_copied=%" V8_PTR_PREFIX "d ",
+        semi_space_copied_object_size_);
     PrintF("nodes_died_in_new=%d ", nodes_died_in_new_space_);
     PrintF("nodes_copied_in_new=%d ", nodes_copied_in_new_space_);
     PrintF("nodes_promoted=%d ", nodes_promoted_);
-    PrintF("survived=%.1f%% ", heap_->survival_rate_);
+    PrintF("survival_rate=%.1f%% ", heap_->survival_rate_);
+    PrintF("promotion_rate=%.1f%% ",
+        (static_cast<double>(promoted_objects_size_) /
+            static_cast<double>(heap_->new_space()->Capacity())) * 100);
+    PrintF("semi_space_copy_rate=%.1f%% ",
+        (static_cast<double>(semi_space_copied_object_size_) /
+            static_cast<double>(heap_->new_space()->Capacity())) * 100);
 
     if (collector_ == SCAVENGER) {
       PrintF("stepscount=%d ", steps_count_since_last_gc_);
       PrintF("stepstook=%.1f ", steps_took_since_last_gc_);
     } else {
       PrintF("stepscount=%d ", steps_count_);
       PrintF("stepstook=%.1f ", steps_took_);
       PrintF("longeststep=%.1f ", longest_step_);
     }
 
@@ skipping 273 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   OS::MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   OS::MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal