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

src/heap/spaces.h

 // Copyright 2011 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_SPACES_H_
 #define V8_HEAP_SPACES_H_
 
 #include "src/allocation.h"
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
@@ skipping 823 matching lines @@
   // Identity used in error reporting.
   AllocationSpace identity() { return id_; }
 
   // Returns allocated size.
   virtual intptr_t Size() = 0;
 
   // Returns size of objects. Can differ from the allocated size
   // (e.g. see LargeObjectSpace).
   virtual intptr_t SizeOfObjects() { return Size(); }
 
+  // Return the total amount of memory committed for new space.
+  virtual intptr_t CommittedMemory() = 0;
+
+  // Approximate amount of physical memory committed for this space.
+  virtual size_t CommittedPhysicalMemory() = 0;
+
+  // Return the available bytes without growing.
+  virtual intptr_t Available() = 0;
+
   virtual int RoundSizeDownToObjectAlignment(int size) {
     if (id_ == CODE_SPACE) {
       return RoundDown(size, kCodeAlignment);
     } else {
       return RoundDown(size, kPointerSize);
     }
   }
 
 #ifdef DEBUG
   virtual void Print() = 0;
@@ skipping 821 matching lines @@
   void RepairFreeListsAfterDeserialization();
 
   // Prepares for a mark-compact GC.
   void PrepareForMarkCompact();
 
   // Current capacity without growing (Size() + Available()).
   intptr_t Capacity() { return accounting_stats_.Capacity(); }
 
   // Total amount of memory committed for this space.  For paged
   // spaces this equals the capacity.
-  intptr_t CommittedMemory() { return Capacity(); }
+  intptr_t CommittedMemory() override { return Capacity(); }
 
   // The maximum amount of memory ever committed for this space.
   intptr_t MaximumCommittedMemory() { return accounting_stats_.MaxCapacity(); }
 
   // Approximate amount of physical memory committed for this space.
-  size_t CommittedPhysicalMemory();
+  size_t CommittedPhysicalMemory() override;
 
   struct SizeStats {
     intptr_t Total() {
       return small_size_ + medium_size_ + large_size_ + huge_size_;
     }
 
     intptr_t small_size_;
     intptr_t medium_size_;
     intptr_t large_size_;
     intptr_t huge_size_;
@@ skipping 14 matching lines @@
 
   // Increases the number of available bytes of that space.
   void AddToAccountingStats(intptr_t bytes) {
     accounting_stats_.DeallocateBytes(bytes);
   }
 
   // Available bytes without growing.  These are the bytes on the free list.
   // The bytes in the linear allocation area are not included in this total
   // because updating the stats would slow down allocation.  New pages are
   // immediately added to the free list so they show up here.
-  intptr_t Available() { return free_list_.available(); }
+  intptr_t Available() override { return free_list_.available(); }
 
   // Allocated bytes in this space.  Garbage bytes that were not found due to
   // concurrent sweeping are counted as being allocated!  The bytes in the
   // current linear allocation area (between top and limit) are also counted
   // here.
-  virtual intptr_t Size() { return accounting_stats_.Size(); }
+  intptr_t Size() override { return accounting_stats_.Size(); }
 
   // As size, but the bytes in lazily swept pages are estimated and the bytes
   // in the current linear allocation area are not included.
-  virtual intptr_t SizeOfObjects();
+  intptr_t SizeOfObjects() override;
 
   // Wasted bytes in this space.  These are just the bytes that were thrown away
   // due to being too small to use for allocation.  They do not include the
   // free bytes that were not found at all due to lazy sweeping.
   virtual intptr_t Waste() { return accounting_stats_.Waste(); }
 
   // Returns the allocation pointer in this space.
   Address top() { return allocation_info_.top(); }
   Address limit() { return allocation_info_.limit(); }
 
@@ skipping 54 matching lines @@
   // Verify integrity of this space.
   virtual void Verify(ObjectVisitor* visitor);
 
   // Overridden by subclasses to verify space-specific object
   // properties (e.g., only maps or free-list nodes are in map space).
   virtual void VerifyObject(HeapObject* obj) {}
 #endif
 
 #ifdef DEBUG
   // Print meta info and objects in this space.
-  virtual void Print();
+  void Print() override;
 
   // Reports statistics for the space
   void ReportStatistics();
 
   // Report code object related statistics
   void CollectCodeStatistics();
   static void ReportCodeStatistics(Isolate* isolate);
   static void ResetCodeStatistics(Isolate* isolate);
 #endif
 
@@ skipping 304 matching lines @@
            reinterpret_cast<uintptr_t>(start_);
   }
 
   // True if the object is a heap object in the address range of this
   // semispace (not necessarily below the allocation pointer).
   bool Contains(Object* o) {
     return (reinterpret_cast<uintptr_t>(o) & object_mask_) == object_expected_;
   }
 
   // If we don't have these here then SemiSpace will be abstract.  However
-  // they should never be called.
-  virtual intptr_t Size() {
+  // they should never be called:
+
+  intptr_t Size() override {
     UNREACHABLE();
     return 0;
   }
 
+  intptr_t SizeOfObjects() override { return Size(); }
+
+  intptr_t CommittedMemory() override {
+    UNREACHABLE();
+    return 0;
+  }
+
+  intptr_t Available() override {
+    UNREACHABLE();
+    return 0;
+  }
+
+
   bool is_committed() { return committed_; }
   bool Commit();
   bool Uncommit();
 
   NewSpacePage* first_page() { return anchor_.next_page(); }
   NewSpacePage* current_page() { return current_page_; }
 
 #ifdef VERIFY_HEAP
   virtual void Verify();
 #endif
 
 #ifdef DEBUG
-  virtual void Print();
+  void Print() override;
   // Validate a range of of addresses in a SemiSpace.
   // The "from" address must be on a page prior to the "to" address,
   // in the linked page order, or it must be earlier on the same page.
   static void AssertValidRange(Address from, Address to);
 #else
   // Do nothing.
   inline static void AssertValidRange(Address from, Address to) {}
 #endif
 
   // Returns the current total capacity of the semispace.
   int TotalCapacity() { return total_capacity_; }
 
   // Returns the target for total capacity of the semispace.
   int TargetCapacity() { return target_capacity_; }
 
   // Returns the maximum total capacity of the semispace.
   int MaximumTotalCapacity() { return maximum_total_capacity_; }
 
   // Returns the initial capacity of the semispace.
   int InitialTotalCapacity() { return initial_total_capacity_; }
 
   SemiSpaceId id() { return id_; }
 
   static void Swap(SemiSpace* from, SemiSpace* to);
 
   // Returns the maximum amount of memory ever committed by the semi space.
   size_t MaximumCommittedMemory() { return maximum_committed_; }
 
   // Approximate amount of physical memory committed for this space.
-  size_t CommittedPhysicalMemory();
+  size_t CommittedPhysicalMemory() override;
 
  private:
   // Flips the semispace between being from-space and to-space.
   // Copies the flags into the masked positions on all pages in the space.
   void FlipPages(intptr_t flags, intptr_t flag_mask);
 
   // Updates Capacity and MaximumCommitted based on new capacity.
   void SetCapacity(int new_capacity);
 
   NewSpacePage* anchor() { return &anchor_; }
@@ skipping 158 matching lines @@
     return (reinterpret_cast<uintptr_t>(a) & address_mask_) ==
            reinterpret_cast<uintptr_t>(start_);
   }
 
   bool Contains(Object* o) {
     Address a = reinterpret_cast<Address>(o);
     return (reinterpret_cast<uintptr_t>(a) & object_mask_) == object_expected_;
   }
 
   // Return the allocated bytes in the active semispace.
-  virtual intptr_t Size() {
+  intptr_t Size() override {
     return pages_used_ * NewSpacePage::kAreaSize +
            static_cast<int>(top() - to_space_.page_low());
   }
 
   // The same, but returning an int.  We have to have the one that returns
   // intptr_t because it is inherited, but if we know we are dealing with the
   // new space, which can't get as big as the other spaces then this is useful:
   int SizeAsInt() { return static_cast<int>(Size()); }
 
   // Return the allocatable capacity of a semispace.
   intptr_t Capacity() {
     SLOW_DCHECK(to_space_.TotalCapacity() == from_space_.TotalCapacity());
     return (to_space_.TotalCapacity() / Page::kPageSize) *
            NewSpacePage::kAreaSize;
   }
 
   // Return the current size of a semispace, allocatable and non-allocatable
   // memory.
   intptr_t TotalCapacity() {
     DCHECK(to_space_.TotalCapacity() == from_space_.TotalCapacity());
     return to_space_.TotalCapacity();
   }
 
   // Return the total amount of memory committed for new space.
-  intptr_t CommittedMemory() {
+  intptr_t CommittedMemory() override {
     if (from_space_.is_committed()) return 2 * Capacity();
     return TotalCapacity();
   }
 
   // Return the total amount of memory committed for new space.
   intptr_t MaximumCommittedMemory() {
     return to_space_.MaximumCommittedMemory() +
            from_space_.MaximumCommittedMemory();
   }
 
   // Approximate amount of physical memory committed for this space.
-  size_t CommittedPhysicalMemory();
+  size_t CommittedPhysicalMemory() override;
 
   // Return the available bytes without growing.
-  intptr_t Available() { return Capacity() - Size(); }
+  intptr_t Available() override { return Capacity() - Size(); }
 
   // Return the maximum capacity of a semispace.
   int MaximumCapacity() {
     DCHECK(to_space_.MaximumTotalCapacity() ==
            from_space_.MaximumTotalCapacity());
     return to_space_.MaximumTotalCapacity();
   }
 
   bool IsAtMaximumCapacity() { return TotalCapacity() == MaximumCapacity(); }
 
@@ skipping 96 matching lines @@
   // if successful.
   bool AddFreshPage();
 
 #ifdef VERIFY_HEAP
   // Verify the active semispace.
   virtual void Verify();
 #endif
 
 #ifdef DEBUG
   // Print the active semispace.
-  virtual void Print() { to_space_.Print(); }
+  void Print() override { to_space_.Print(); }
 #endif
 
   // Iterates the active semispace to collect statistics.
   void CollectStatistics();
   // Reports previously collected statistics of the active semispace.
   void ReportStatistics();
   // Clears previously collected statistics.
   void ClearHistograms();
 
   // Record the allocation or promotion of a heap object.  Note that we don't
@@ skipping 150 matching lines @@
   }
 
   // Shared implementation of AllocateRaw, AllocateRawCode and
   // AllocateRawFixedArray.
   MUST_USE_RESULT AllocationResult
       AllocateRaw(int object_size, Executability executable);
 
   bool CanAllocateSize(int size) { return Size() + size <= max_capacity_; }
 
   // Available bytes for objects in this space.
-  inline intptr_t Available();
+  inline intptr_t Available() override;
 
-  virtual intptr_t Size() { return size_; }
+  intptr_t Size() override { return size_; }
 
-  virtual intptr_t SizeOfObjects() { return objects_size_; }
+  intptr_t SizeOfObjects() override { return objects_size_; }
 
   intptr_t MaximumCommittedMemory() { return maximum_committed_; }
 
-  intptr_t CommittedMemory() { return Size(); }
+  intptr_t CommittedMemory() override { return Size(); }
 
   // Approximate amount of physical memory committed for this space.
-  size_t CommittedPhysicalMemory();
+  size_t CommittedPhysicalMemory() override;
 
   int PageCount() { return page_count_; }
 
   // Finds an object for a given address, returns a Smi if it is not found.
   // The function iterates through all objects in this space, may be slow.
   Object* FindObject(Address a);
 
   // Finds a large object page containing the given address, returns NULL
   // if such a page doesn't exist.
   LargePage* FindPage(Address a);
 
   // Frees unmarked objects.
   void FreeUnmarkedObjects();
 
   // Checks whether a heap object is in this space; O(1).
   bool Contains(HeapObject* obj);
 
   // Checks whether the space is empty.
   bool IsEmpty() { return first_page_ == NULL; }
 
   LargePage* first_page() { return first_page_; }
 
 #ifdef VERIFY_HEAP
   virtual void Verify();
 #endif
 
 #ifdef DEBUG
-  virtual void Print();
+  void Print() override;
   void ReportStatistics();
   void CollectCodeStatistics();
 #endif
   // Checks whether an address is in the object area in this space.  It
   // iterates all objects in the space. May be slow.
   bool SlowContains(Address addr) { return FindObject(addr)->IsHeapObject(); }
 
  private:
   intptr_t max_capacity_;
   intptr_t maximum_committed_;
@@ skipping 95 matching lines @@
     count = 0;
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 }
 }  // namespace v8::internal
 
 #endif  // V8_HEAP_SPACES_H_