v8: GCTracer clean-up part 1.

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 1218 matching lines @@
   }
 
   void IncrementCodeGeneratedBytes(bool is_crankshafted, int size) {
     if (is_crankshafted) {
       crankshaft_codegen_bytes_generated_ += size;
     } else {
       full_codegen_bytes_generated_ += size;
     }
   }
 
+  // Update GC statistics that are tracked on the Heap.
+  void UpdateGCStatistics(double start_time,
+                          double end_time,
+                          double spent_in_mutator,
+                          double marking_time);
+
   // Returns maximum GC pause.
   double get_max_gc_pause() { return max_gc_pause_; }
 
   // Returns maximum size of objects alive after GC.
   intptr_t get_max_alive_after_gc() { return max_alive_after_gc_; }
 
   // Returns minimal interval between two subsequent collections.
   double get_min_in_mutator() { return min_in_mutator_; }
 
   // TODO(hpayer): remove, should be handled by GCTracer
@@ skipping 1279 matching lines @@
       MC_EVACUATE_PAGES,
       MC_UPDATE_NEW_TO_NEW_POINTERS,
       MC_UPDATE_ROOT_TO_NEW_POINTERS,
       MC_UPDATE_OLD_TO_NEW_POINTERS,
       MC_UPDATE_POINTERS_TO_EVACUATED,
       MC_UPDATE_POINTERS_BETWEEN_EVACUATED,
       MC_UPDATE_MISC_POINTERS,
       MC_WEAKCOLLECTION_PROCESS,
       MC_WEAKCOLLECTION_CLEAR,
       MC_FLUSH_CODE,
-      kNumberOfScopes
+      NUMBER_OF_SCOPES
     };
 
     Scope(GCTracer* tracer, ScopeId scope)
         : tracer_(tracer),
         scope_(scope) {
       start_time_ = base::OS::TimeCurrentMillis();
     }
 
     ~Scope() {
-      ASSERT(scope_ < kNumberOfScopes);  // scope_ is unsigned.
+      ASSERT(scope_ < NUMBER_OF_SCOPES);  // scope_ is unsigned.
       tracer_->scopes_[scope_] += base::OS::TimeCurrentMillis() - start_time_;
     }
 
    private:
     GCTracer* tracer_;
     ScopeId scope_;
     double start_time_;
+
+    DISALLOW_COPY_AND_ASSIGN(Scope);
   };
 
   explicit GCTracer(Heap* heap,
+                    GarbageCollector collector,
                     const char* gc_reason,
                     const char* collector_reason);
   ~GCTracer();
 
-  // Sets the collector.
-  void set_collector(GarbageCollector collector) { collector_ = collector; }
-
-  // Sets the GC count.
-  void set_gc_count(unsigned int count) { gc_count_ = count; }
-
-  // Sets the full GC count.
-  void set_full_gc_count(int count) { full_gc_count_ = count; }
-
   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 char* CollectorString() const;
 
-  // Returns size of object in heap (in MB).
-  inline double SizeOfHeapObjects();
+  // Print one detailed trace line in name=value format.
+  void PrintNVP() const;
+
+  // Print one trace line.
+  void Print() const;
 
   // Timestamp set in the constructor.
   double start_time_;
 
+  // Timestamp set in the destructor.
+  double end_time_;
+
   // Size of objects in heap set in constructor.
   intptr_t start_object_size_;
 
+  // Size of objects in heap set in destructor.
+  intptr_t end_object_size_;
+
   // Size of memory allocated from OS set in constructor.
   intptr_t start_memory_size_;
 
+  // Size of memory allocated from OS set in destructor.
+  intptr_t end_memory_size_;
+
   // Type of collector.
   GarbageCollector collector_;
 
-  // A count (including this one, e.g. the first collection is 1) of the
-  // number of garbage collections.
-  unsigned int gc_count_;
-
-  // A count (including this one) of the number of full garbage collections.
-  int full_gc_count_;
-
   // Amounts of time spent in different scopes during GC.
-  double scopes_[Scope::kNumberOfScopes];
+  double scopes_[Scope::NUMBER_OF_SCOPES];
 
   // Total amount of space either wasted or contained in one of free lists
   // before the current GC.
   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
@@ skipping 13 matching lines @@
   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_;
   const char* collector_reason_;
+
+  DISALLOW_COPY_AND_ASSIGN(GCTracer);
 };
 
 
 class RegExpResultsCache {
  public:
   enum ResultsCacheType { REGEXP_MULTIPLE_INDICES, STRING_SPLIT_SUBSTRINGS };
 
   // Attempt to retrieve a cached result.  On failure, 0 is returned as a Smi.
   // On success, the returned result is guaranteed to be a COW-array.
   static Object* Lookup(Heap* heap,
@@ skipping 125 matching lines @@
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_