Move node statistics from GCTracer to Heap.

src/heap.h

 // 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.
 
 #ifndef V8_HEAP_H_
 #define V8_HEAP_H_
 
 #include <cmath>
 
 #include "src/allocation.h"
@@ skipping 1164 matching lines @@
   inline void IncrementPromotedObjectsSize(int object_size) {
     ASSERT(object_size > 0);
     promoted_objects_size_ += object_size;
   }
 
   inline void IncrementSemiSpaceCopiedObjectSize(int object_size) {
     ASSERT(object_size > 0);
     semi_space_copied_object_size_ += object_size;
   }
 
+  inline void IncrementNodesDiedInNewSpace() {
+    nodes_died_in_new_space_++;
+  }
+
+  inline void IncrementNodesCopiedInNewSpace() {
+    nodes_copied_in_new_space_++;
+  }
+
+  inline void IncrementNodesPromoted() {
+    nodes_promoted_++;
+  }
+
   inline void IncrementYoungSurvivorsCounter(int survived) {
     ASSERT(survived >= 0);
     survived_since_last_expansion_ += survived;
   }
 
   inline bool NextGCIsLikelyToBeFull() {
     if (FLAG_gc_global) return true;
 
     if (FLAG_stress_compaction && (gc_count_ & 1) != 0) return true;
 
@@ skipping 824 matching lines @@
   static const int kYoungSurvivalRateHighThreshold = 90;
   static const int kYoungSurvivalRateAllowedDeviation = 15;
 
   static const int kOldSurvivalRateLowThreshold = 10;
 
   int high_survival_rate_period_length_;
   intptr_t promoted_objects_size_;
   double promotion_rate_;
   intptr_t semi_space_copied_object_size_;
   double semi_space_copied_rate_;
+  int nodes_died_in_new_space_;
+  int nodes_copied_in_new_space_;
+  int nodes_promoted_;
 
   // This is the pretenuring trigger for allocation sites that are in maybe
   // tenure state. When we switched to the maximum new space size we deoptimize
   // the code that belongs to the allocation site and derive the lifetime
   // of the allocation site.
   unsigned int maximum_size_scavenges_;
 
   // TODO(hpayer): Allocation site pretenuring may make this method obsolete.
   // Re-visit incremental marking heuristics.
   bool IsHighSurvivalRate() {
@@ skipping 523 matching lines @@
 
     DISALLOW_COPY_AND_ASSIGN(Scope);
   };
 
   explicit GCTracer(Heap* heap,
                     GarbageCollector collector,
                     const char* gc_reason,
                     const char* collector_reason);
   ~GCTracer();
 
-  void increment_nodes_died_in_new_space() {
-    nodes_died_in_new_space_++;
-  }
-
-  void increment_nodes_copied_in_new_space() {
-    nodes_copied_in_new_space_++;
-  }
-
-  void increment_nodes_promoted() {
-    nodes_promoted_++;
-  }
-
  private:
   // Returns a string matching the collector.
   const char* CollectorString() const;
 
   // Print one detailed trace line in name=value format.
   void PrintNVP() const;
 
   // Print one trace line.
   void Print() const;
 
@@ skipping 26 matching lines @@
   intptr_t in_free_list_or_wasted_before_gc_;
 
   // Difference between space used in the heap at the beginning of the current
   // collection and the end of the previous collection.
   intptr_t allocated_since_last_gc_;
 
   // Amount of time spent in mutator that is time elapsed between end of the
   // previous collection and the beginning of the current one.
   double spent_in_mutator_;
 
-  // Number of died nodes in the new space.
-  int nodes_died_in_new_space_;
-
-  // Number of copied nodes to the new space.
-  int nodes_copied_in_new_space_;
-
-  // Number of promoted nodes to the old space.
-  int nodes_promoted_;
-
   // Incremental marking steps counters.
   int steps_count_;
   double steps_took_;
   double longest_step_;
   int steps_count_since_last_gc_;
   double steps_took_since_last_gc_;
 
   Heap* heap_;
 
   const char* gc_reason_;
@@ skipping 138 matching lines @@
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_