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

src/api.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 "src/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 5330 matching lines @@
                                   heap_size_limit_(0) { }
 
 
 HeapSpaceStatistics::HeapSpaceStatistics(): space_name_(0),
                                             space_size_(0),
                                             space_used_size_(0),
                                             space_available_size_(0),
                                             physical_space_size_(0) { }
 
 
+HeapObjectStatistics::HeapObjectStatistics(): object_type_(nullptr),
+                                              object_count_(0),
+                                              object_size_(0) { }
+
 bool v8::V8::InitializeICU(const char* icu_data_file) {
   return i::InitializeICU(icu_data_file);
 }
 
 
 const char* v8::V8::GetVersion() {
   return i::Version::GetVersion();
 }
 
 
@@ skipping 1553 matching lines @@
 
   space_statistics->space_name_ = heap->GetSpaceName(static_cast<int>(index));
   space_statistics->space_size_ = space->CommittedMemory();
   space_statistics->space_used_size_ = space->SizeOfObjects();
   space_statistics->space_available_size_ = space->Available();
   space_statistics->physical_space_size_ = space->CommittedPhysicalMemory();
   return true;
 }
 
 
+size_t Isolate::NumberOfHeapObjectsTypes() {

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

primiano@ here is the definition.

+  return i::Heap::OBJECT_STATS_COUNT;
+}
+
+bool Isolate::GetLastGcObjectStatistics(HeapObjectStatistics* object_statistics,
+                                        size_t type_index) {
+  if (!object_statistics)
+    return false;
+  if (type_index >= i::Heap::OBJECT_STATS_COUNT)
+    return false;
+  if (!i::FLAG_track_gc_object_stats)
+    return false;
+
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+  i::Heap* heap = isolate->heap();
+  const char* object_type = heap->GetObjectTypeName(type_index);
+  size_t object_count = heap->object_count_last_gc(type_index);
+  size_t object_size = heap->object_size_last_gc(type_index);
+  if (object_type == nullptr) {

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

Is object type ever expected to be null? If so why does it imply that object
count should be 0? Maybe add a comment

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

The object type can be null in some cases, there are 241 object types defined in
multiple macros. but they are not continuous sequences.
DCHECK here is to check if no object type exists that is counted but not named.
will write a comment.

+    DCHECK_EQ(object_count, 0);
+    DCHECK_EQ(object_size, 0);
+    return false;
+  }
+
+  object_statistics->object_type_ = object_type;
+  object_statistics->object_count_ = object_count;
+  object_statistics->object_size_ = object_size;
+  return true;
+}
+
+
 void Isolate::GetStackSample(const RegisterState& state, void** frames,
                              size_t frames_limit, SampleInfo* sample_info) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
   i::TickSample::GetStackSample(isolate, state, i::TickSample::kSkipCEntryFrame,
                                 frames, frames_limit, sample_info);
 }
 
 
 void Isolate::SetEventLogger(LogEventCallback that) {
   // Do not overwrite the event logger if we want to log explicitly.
@@ skipping 1097 matching lines @@
   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 } }  // namespace v8::internal