Add OS::GetCurrentProcessId and prepend output from trace-gc with the current pid

src/heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 302 matching lines @@
     new_space_.CollectStatistics();
     new_space_.ReportStatistics();
     new_space_.ClearHistograms();
   }
 #endif  // DEBUG
 }
 
 
 void Heap::PrintShortHeapStatistics() {
   if (!FLAG_trace_gc_verbose) return;
-  PrintF("Memory allocator,   used: %6" V8_PTR_PREFIX "d KB"
-             ", available: %6" V8_PTR_PREFIX "d KB\n",
-         isolate_->memory_allocator()->Size() / KB,
-         isolate_->memory_allocator()->Available() / KB);
-  PrintF("New space,          used: %6" V8_PTR_PREFIX "d KB"
-             ", available: %6" V8_PTR_PREFIX "d KB"
-             ", committed: %6" V8_PTR_PREFIX "d KB\n",
-         new_space_.Size() / KB,
-         new_space_.Available() / KB,
-         new_space_.CommittedMemory() / KB);
-  PrintF("Old pointers,       used: %6" V8_PTR_PREFIX "d KB"
-             ", available: %6" V8_PTR_PREFIX "d KB"
-             ", committed: %6" V8_PTR_PREFIX "d KB\n",
-         old_pointer_space_->SizeOfObjects() / KB,
-         old_pointer_space_->Available() / KB,
-         old_pointer_space_->CommittedMemory() / KB);
-  PrintF("Old data space,     used: %6" V8_PTR_PREFIX "d KB"
-             ", available: %6" V8_PTR_PREFIX "d KB"
-             ", committed: %6" V8_PTR_PREFIX "d KB\n",
-         old_data_space_->SizeOfObjects() / KB,
-         old_data_space_->Available() / KB,
-         old_data_space_->CommittedMemory() / KB);
-  PrintF("Code space,         used: %6" V8_PTR_PREFIX "d KB"
-             ", available: %6" V8_PTR_PREFIX "d KB"
-             ", committed: %6" V8_PTR_PREFIX "d KB\n",
-         code_space_->SizeOfObjects() / KB,
-         code_space_->Available() / KB,
-         code_space_->CommittedMemory() / KB);
-  PrintF("Map space,          used: %6" V8_PTR_PREFIX "d KB"
-             ", available: %6" V8_PTR_PREFIX "d KB"
-             ", committed: %6" V8_PTR_PREFIX "d KB\n",
-         map_space_->SizeOfObjects() / KB,
-         map_space_->Available() / KB,
-         map_space_->CommittedMemory() / KB);
-  PrintF("Cell space,         used: %6" V8_PTR_PREFIX "d KB"
-             ", available: %6" V8_PTR_PREFIX "d KB"
-             ", committed: %6" V8_PTR_PREFIX "d KB\n",
-         cell_space_->SizeOfObjects() / KB,
-         cell_space_->Available() / KB,
-         cell_space_->CommittedMemory() / KB);
-  PrintF("Large object space, used: %6" V8_PTR_PREFIX "d KB"
-             ", available: %6" V8_PTR_PREFIX "d KB"
-             ", committed: %6" V8_PTR_PREFIX "d KB\n",
-         lo_space_->SizeOfObjects() / KB,
-         lo_space_->Available() / KB,
-         lo_space_->CommittedMemory() / KB);
+  PrintPID("Memory allocator,   used: %6" V8_PTR_PREFIX "d KB"
+               ", available: %6" V8_PTR_PREFIX "d KB\n",
+           isolate_->memory_allocator()->Size() / KB,
+           isolate_->memory_allocator()->Available() / KB);
+  PrintPID("New space,          used: %6" V8_PTR_PREFIX "d KB"
+               ", available: %6" V8_PTR_PREFIX "d KB"
+               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+           new_space_.Size() / KB,
+           new_space_.Available() / KB,
+           new_space_.CommittedMemory() / KB);
+  PrintPID("Old pointers,       used: %6" V8_PTR_PREFIX "d KB"
+               ", available: %6" V8_PTR_PREFIX "d KB"
+               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+           old_pointer_space_->SizeOfObjects() / KB,
+           old_pointer_space_->Available() / KB,
+           old_pointer_space_->CommittedMemory() / KB);
+  PrintPID("Old data space,     used: %6" V8_PTR_PREFIX "d KB"
+               ", available: %6" V8_PTR_PREFIX "d KB"
+               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+           old_data_space_->SizeOfObjects() / KB,
+           old_data_space_->Available() / KB,
+           old_data_space_->CommittedMemory() / KB);
+  PrintPID("Code space,         used: %6" V8_PTR_PREFIX "d KB"
+               ", available: %6" V8_PTR_PREFIX "d KB"
+               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+           code_space_->SizeOfObjects() / KB,
+           code_space_->Available() / KB,
+           code_space_->CommittedMemory() / KB);
+  PrintPID("Map space,          used: %6" V8_PTR_PREFIX "d KB"
+               ", available: %6" V8_PTR_PREFIX "d KB"
+               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+           map_space_->SizeOfObjects() / KB,
+           map_space_->Available() / KB,
+           map_space_->CommittedMemory() / KB);
+  PrintPID("Cell space,         used: %6" V8_PTR_PREFIX "d KB"
+               ", available: %6" V8_PTR_PREFIX "d KB"
+               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+           cell_space_->SizeOfObjects() / KB,
+           cell_space_->Available() / KB,
+           cell_space_->CommittedMemory() / KB);
+  PrintPID("Large object space, used: %6" V8_PTR_PREFIX "d KB"
+               ", available: %6" V8_PTR_PREFIX "d KB"
+               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+           lo_space_->SizeOfObjects() / KB,
+           lo_space_->Available() / KB,
+           lo_space_->CommittedMemory() / KB);
 }
 
 
 // TODO(1238405): Combine the infrastructure for --heap-stats and
 // --log-gc to avoid the complicated preprocessor and flag testing.
 void Heap::ReportStatisticsAfterGC() {
   // Similar to the before GC, we use some complicated logic to ensure that
   // NewSpace statistics are logged exactly once when --log-gc is turned on.
 #if defined(DEBUG)
   if (FLAG_heap_stats) {
@@ skipping 520 matching lines @@
   if (!new_space_high_promotion_mode_active_ &&
       new_space_.Capacity() == new_space_.MaximumCapacity() &&
       IsStableOrIncreasingSurvivalTrend() &&
       IsHighSurvivalRate()) {
     // Stable high survival rates even though young generation is at
     // maximum capacity indicates that most objects will be promoted.
     // To decrease scavenger pauses and final mark-sweep pauses, we
     // have to limit maximal capacity of the young generation.
     new_space_high_promotion_mode_active_ = true;
     if (FLAG_trace_gc) {
-      PrintF("Limited new space size due to high promotion rate: %d MB\n",
-             new_space_.InitialCapacity() / MB);
+      PrintPID("Limited new space size due to high promotion rate: %d MB\n",
+               new_space_.InitialCapacity() / MB);
     }
   } else if (new_space_high_promotion_mode_active_ &&
       IsStableOrDecreasingSurvivalTrend() &&
       IsLowSurvivalRate()) {
     // Decreasing low survival rates might indicate that the above high
     // promotion mode is over and we should allow the young generation
     // to grow again.
     new_space_high_promotion_mode_active_ = false;
     if (FLAG_trace_gc) {
-      PrintF("Unlimited new space size due to low promotion rate: %d MB\n",
-             new_space_.MaximumCapacity() / MB);
+      PrintPID("Unlimited new space size due to low promotion rate: %d MB\n",
+               new_space_.MaximumCapacity() / MB);
     }
   }
 
   if (new_space_high_promotion_mode_active_ &&
       new_space_.Capacity() > new_space_.InitialCapacity()) {
     new_space_.Shrink();
   }
 
   isolate_->counters()->objs_since_last_young()->Set(0);
 
@@ skipping 4867 matching lines @@
 
   if (FLAG_stress_compaction) {
     // This will cause more frequent GCs when stressing.
     max_semispace_size_ = Page::kPageSize;
   }
 
   if (max_semispace_size > 0) {
     if (max_semispace_size < Page::kPageSize) {
       max_semispace_size = Page::kPageSize;
       if (FLAG_trace_gc) {
-        PrintF("Max semispace size cannot be less than %dkbytes\n",
-               Page::kPageSize >> 10);
+        PrintPID("Max semispace size cannot be less than %dkbytes\n",
+                 Page::kPageSize >> 10);
       }
     }
     max_semispace_size_ = max_semispace_size;
   }
 
   if (Snapshot::IsEnabled()) {
     // If we are using a snapshot we always reserve the default amount
     // of memory for each semispace because code in the snapshot has
     // write-barrier code that relies on the size and alignment of new
     // space.  We therefore cannot use a larger max semispace size
     // than the default reserved semispace size.
     if (max_semispace_size_ > reserved_semispace_size_) {
       max_semispace_size_ = reserved_semispace_size_;
       if (FLAG_trace_gc) {
-        PrintF("Max semispace size cannot be more than %dkbytes\n",
-               reserved_semispace_size_ >> 10);
+        PrintPID("Max semispace size cannot be more than %dkbytes\n",
+                 reserved_semispace_size_ >> 10);
       }
     }
   } else {
     // If we are not using snapshots we reserve space for the actual
     // max semispace size.
     reserved_semispace_size_ = max_semispace_size_;
   }
 
   if (max_old_gen_size > 0) max_old_generation_size_ = max_old_gen_size;
   if (max_executable_size > 0) {
@@ skipping 1073 matching lines @@
   if (FLAG_print_cumulative_gc_stat) {
     heap_->max_gc_pause_ = Max(heap_->max_gc_pause_, time);
     heap_->max_alive_after_gc_ = Max(heap_->max_alive_after_gc_,
                                      heap_->alive_after_last_gc_);
     if (!first_gc) {
       heap_->min_in_mutator_ = Min(heap_->min_in_mutator_,
                                    static_cast<int>(spent_in_mutator_));
     }
   }
 
-  PrintF("%8.0f ms: ", heap_->isolate()->time_millis_since_init());
+  PrintPID("%8.0f ms: ", heap_->isolate()->time_millis_since_init());
 
   if (!FLAG_trace_gc_nvp) {
     int external_time = static_cast<int>(scopes_[Scope::EXTERNAL]);
 
     double end_memory_size_mb =
         static_cast<double>(heap_->isolate()->memory_allocator()->Size()) / MB;
 
     PrintF("%s %.1f (%.1f) -> %.1f (%.1f) MB, ",
            CollectorString(),
            static_cast<double>(start_object_size_) / MB,
@@ skipping 290 matching lines @@
   } else {
     p ^= 0x1d1ed & (Page::kPageSize - 1);  // I died.
   }
   remembered_unmapped_pages_[remembered_unmapped_pages_index_] =
       reinterpret_cast<Address>(p);
   remembered_unmapped_pages_index_++;
   remembered_unmapped_pages_index_ %= kRememberedUnmappedPages;
 }
 
 } }  // namespace v8::internal