Adding api to get last gc object statistics for chrome://tracing.

src/heap/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_HEAP_H_
 #define V8_HEAP_HEAP_H_
 
 #include <cmath>
 #include <map>
 
@@ skipping 999 matching lines @@
   // Number of "runtime allocations" done so far.
   uint32_t allocations_count() { return allocations_count_; }
 
   // Returns deterministic "time" value in ms. Works only with
   // FLAG_verify_predictable.
   double synthetic_time() { return allocations_count_ / 2.0; }
 
   // Print short heap statistics.
   void PrintShortHeapStatistics();
 
+  size_t object_count_last_gc(size_t type) {
+    return object_counts_last_time_[type];

[picksi, 2015/05/05 14:01:55]

Should we DCHECK the array bounds here for safety? e.g. type>=0 and
type<object_types?

[ssid, 2015/05/05 14:48:01]

Done.

+  }
+  size_t object_size_last_gc(size_t type) {
+    return object_sizes_last_time_[type];
+  }
+
   // Write barrier support for address[offset] = o.
   INLINE(void RecordWrite(Address address, int offset));
 
   // Write barrier support for address[start : start + len[ = o.
   INLINE(void RecordWrites(Address address, int start, int len));
 
   enum HeapState { NOT_IN_GC, SCAVENGE, MARK_COMPACT };
   inline HeapState gc_state() { return gc_state_; }
 
   inline bool IsInGCPostProcessing() { return gc_post_processing_depth_ > 0; }
@@ skipping 408 matching lines @@
 
   void RecordFixedArraySubTypeStats(int array_sub_type, size_t size) {
     DCHECK(array_sub_type <= LAST_FIXED_ARRAY_SUB_TYPE);
     object_counts_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type]++;
     object_sizes_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type] += size;
   }
 
   void TraceObjectStats();
   void TraceObjectStat(const char* name, int count, int size, double time);
   void CheckpointObjectStats();
+  const char* GetObjectTypeName(size_t index);

[Primiano Tucci (use gerrit), 2015/05/05 14:17:53]

Should this be near the other ones you are adding?

[ssid, 2015/05/05 14:26:16]

the previous function does the same kind of operations. that is why this
function is added here. if the way in which the type index is handled changes,
then these functions change together.
Note: I am not sure if this function should be a part of Heap class. Maybe this
should be in objects.h . Waiting for owner's comment on that.

[ulan, 2015/05/06 12:46:02]

This place is correct. The "index" has meaning only in Heap because it is the
index in the object-stat table.

 
   // We don't use a LockGuard here since we want to lock the heap
   // only when FLAG_concurrent_recompilation is true.
   class RelocationLock {
    public:
     explicit RelocationLock(Heap* heap) : heap_(heap) {
       heap_->relocation_mutex_.Lock();
     }
 
 
@@ skipping 1150 matching lines @@
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 }
 }  // namespace v8::internal
 
 #endif  // V8_HEAP_HEAP_H_