Adding V8 api to get memory statistics of spaces in V8::Heap.

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 5444 matching lines @@
 }
 
 
 HeapStatistics::HeapStatistics(): total_heap_size_(0),
                                   total_heap_size_executable_(0),
                                   total_physical_size_(0),
                                   used_heap_size_(0),
                                   heap_size_limit_(0) { }
 
 
+HeapSpaceStatistics::HeapSpaceStatistics(): space_name_(0),
+                                            space_size_(0),
+                                            space_used_size_(0),
+                                            space_avalable_size_(0),
+                                            physical_space_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 1517 matching lines @@
   i::Heap* heap = isolate->heap();
   heap_statistics->total_heap_size_ = heap->CommittedMemory();
   heap_statistics->total_heap_size_executable_ =
       heap->CommittedMemoryExecutable();
   heap_statistics->total_physical_size_ = heap->CommittedPhysicalMemory();
   heap_statistics->used_heap_size_ = heap->SizeOfObjects();
   heap_statistics->heap_size_limit_ = heap->MaxReserved();
 }
 
 
+int Isolate::NumberOfHeapSpaces() { return i::LAST_SPACE - i::FIRST_SPACE + 1; }

[rmcilroy, 2015/04/15 10:21:42]

nit - newline for body

[ssid, 2015/04/15 10:43:58]

Done.

+
+
+void Isolate::GetHeapSpaceStatistics(HeapSpaceStatistics* space_statistics,
+                                     int index) {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+  i::Heap* heap = isolate->heap();

[rmcilroy, 2015/04/15 10:21:42]

check for space_statistics being null.

[rmcilroy, 2015/04/15 10:21:42]

check for index out-of-bounds

[ssid, 2015/04/15 10:43:57]

Done.

+  if (index == i::NEW_SPACE) {
+    space_statistics->space_name_ = heap->GetSpaceName(i::NEW_SPACE);
+    space_statistics->space_size_ = heap->new_space()->CommittedMemory();
+    space_statistics->space_used_size_ = heap->new_space()->Size();

[rmcilroy, 2015/04/15 10:21:42]

SizeOfObjects

[ssid, 2015/04/15 10:29:20]

PrintShortHeapStatistics() uses Size() and not SizeOfObjects()
https://code.google.com/p/chromium/codesearch#chromium/src/v8/src/heap/heap.c...

[rmcilroy, 2015/04/15 12:17:40]

SizeOfObjects() calls Size() for the newspace, so let's keep them consistent.

+    space_statistics->space_avalable_size_ = heap->new_space()->Available();
+    space_statistics->physical_space_size_ =
+        heap->new_space()->CommittedPhysicalMemory();
+  } else if (index >= i::FIRST_PAGED_SPACE && index <= i::LAST_PAGED_SPACE) {
+    space_statistics->space_name_ = heap->GetSpaceName(index);
+    space_statistics->space_size_ = heap->paged_space(index)->CommittedMemory();
+    space_statistics->space_used_size_ =
+        heap->paged_space(index)->SizeOfObjects();
+    space_statistics->space_avalable_size_ =
+        heap->paged_space(index)->Available();
+    space_statistics->physical_space_size_ =
+        heap->paged_space(index)->CommittedPhysicalMemory();
+  } else if (index == i::LO_SPACE) {
+    space_statistics->space_name_ = heap->GetSpaceName(i::LO_SPACE);
+    space_statistics->space_size_ = heap->lo_space()->CommittedMemory();
+    space_statistics->space_used_size_ = heap->lo_space()->SizeOfObjects();
+    space_statistics->space_avalable_size_ = heap->lo_space()->Available();

[rmcilroy, 2015/04/15 10:21:42]

Does the Spaces superclass have these methods defined? If so you could pull out
the appropriate "Space" object and just do the code to fill in the
space_statistics object once. If the methods aren't there on the superclass it
might be worth doing this if all subclasses of the Space define the methods
anyway. 

[ssid, 2015/04/15 10:29:20]

The only line i can pull out of these three cases is GetSpaceName(x)
Other all functions are different for the three. These are defined in the
classes : PagedSpace, LargeObjectSpace and NewSpace.

[rmcilroy, 2015/04/15 12:17:40]

+hpayer

As mentioned, you could you make these functions virtual abstract in Space and
have the implementations in each of the spaces be overrides.

Hannes: Are you aware of any reason that these methods are defined in the
subclasses and aren't virtual abstract functions in Space which are overridden
by the specific subclass? Would it cause any issue to make this change for code
clarity?

[Hannes Payer (out of office), 2015/04/15 21:09:23]

Hmm, should be possible. I cannot think of any reason why that wouldn't work.
Would definitely cleaner in that case.  

+    space_statistics->physical_space_size_ =
+        heap->lo_space()->CommittedPhysicalMemory();
+  }
+}
+
+
 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