Allocation sampling for paged/lo spaces

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/atomic-utils.h"
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/base/platform/mutex.h"
 #include "src/flags.h"
 #include "src/hashmap.h"
 #include "src/list.h"
 #include "src/objects.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
+class AllocationObserver;
 class CompactionSpaceCollection;
-class InlineAllocationObserver;
 class Isolate;
 
 // -----------------------------------------------------------------------------
 // Heap structures:
 //
 // A JS heap consists of a young generation, an old generation, and a large
 // object space. The young generation is divided into two semispaces. A
 // scavenger implements Cheney's copying algorithm. The old generation is
 // separated into a map space and an old object space. The map space contains
 // all (and only) map objects, the rest of old objects go into the old space.
@@ skipping 2002 matching lines @@
   // Allocate the requested number of bytes in the space double aligned if
   // possible, return a failure object if not.
   MUST_USE_RESULT inline AllocationResult AllocateRawAligned(
       int size_in_bytes, AllocationAlignment alignment);
 
   // Allocate the requested number of bytes in the space and consider allocation
   // alignment if needed.
   MUST_USE_RESULT inline AllocationResult AllocateRaw(
       int size_in_bytes, AllocationAlignment alignment);
 
+  void AddAllocationObserver(AllocationObserver* observer) {
+    allocation_observers_.Add(observer);
+  }
+
+  void RemoveAllocationObserver(AllocationObserver* observer) {
+    bool removed = allocation_observers_.RemoveElement(observer);
+    static_cast<void>(removed);
+    DCHECK(removed);
+  }
+

[ofrobots, 2016/01/23 16:16:31]

Suggestion: These seem almost like a copy of the
Add/RemoveInlineAllocationObserver. Perhaps we could have a single set of
methods with a boolean flag? You may want to promote these methods and the
corresponding observer lists into the superclass (Space)?

[mattloring, 2016/01/26 00:42:48]

Done.

   // Give a block of memory to the space's free list.  It might be added to
   // the free list or accounted as waste.
   // If add_to_freelist is false then just accounting stats are updated and
   // no attempt to add area to free list is made.
   int Free(Address start, int size_in_bytes) {
     int wasted = free_list_.Free(start, size_in_bytes);
     accounting_stats_.DeallocateBytes(size_in_bytes);
     return size_in_bytes - wasted;
   }
 
@@ skipping 134 matching lines @@
 
   // Accounting information for this space.
   AllocationStats accounting_stats_;
 
   // The dummy page that anchors the double linked list of pages.
   Page anchor_;
 
   // The space's free list.
   FreeList free_list_;
 
+  // Allocation observers
+  List<AllocationObserver*> allocation_observers_;
+
   // Normal allocation information.
   AllocationInfo allocation_info_;
 
   // Mutex guarding any concurrent access to the space.
   base::Mutex space_mutex_;
 
   friend class MarkCompactCollector;
   friend class PageIterator;
 
   // Used in cctest.
@@ skipping 539 matching lines @@
 
   // Reset the allocation pointer to the beginning of the active semispace.
   void ResetAllocationInfo();
 
   void UpdateInlineAllocationLimit(int size_in_bytes);
 
   // Allows observation of inline allocation. The observer->Step() method gets
   // called after every step_size bytes have been allocated (approximately).
   // This works by adjusting the allocation limit to a lower value and adjusting
   // it after each step.
-  void AddInlineAllocationObserver(InlineAllocationObserver* observer);
+  void AddInlineAllocationObserver(AllocationObserver* observer);
 
   // Removes a previously installed observer.
-  void RemoveInlineAllocationObserver(InlineAllocationObserver* observer);
+  void RemoveInlineAllocationObserver(AllocationObserver* observer);
 
   void DisableInlineAllocationSteps() {
     top_on_previous_step_ = 0;
     UpdateInlineAllocationLimit(0);
   }
 
   // Get the extent of the inactive semispace (for use as a marking stack,
   // or to zap it). Notice: space-addresses are not necessarily on the
   // same page, so FromSpaceStart() might be above FromSpaceEnd().
   Address FromSpacePageLow() { return from_space_.page_low(); }
@@ skipping 86 matching lines @@
 
   // Allocation pointer and limit for normal allocation and allocation during
   // mark-compact collection.
   AllocationInfo allocation_info_;
 
   // When inline allocation stepping is active, either because of incremental
   // marking or because of idle scavenge, we 'interrupt' inline allocation every
   // once in a while. This is done by setting allocation_info_.limit to be lower
   // than the actual limit and and increasing it in steps to guarantee that the
   // observers are notified periodically.
-  List<InlineAllocationObserver*> inline_allocation_observers_;
+  List<AllocationObserver*> inline_allocation_observers_;
   Address top_on_previous_step_;
   bool inline_allocation_observers_paused_;
 
   HistogramInfo* allocated_histogram_;
   HistogramInfo* promoted_histogram_;
 
   bool EnsureAllocation(int size_in_bytes, AllocationAlignment alignment);
 
   // If we are doing inline allocation in steps, this method performs the 'step'
   // operation. top is the memory address of the bump pointer at the last
@@ skipping 173 matching lines @@
   static intptr_t ObjectSizeFor(intptr_t chunk_size) {
     if (chunk_size <= (Page::kPageSize + Page::kObjectStartOffset)) return 0;
     return chunk_size - Page::kPageSize - Page::kObjectStartOffset;
   }
 
   // Shared implementation of AllocateRaw, AllocateRawCode and
   // AllocateRawFixedArray.
   MUST_USE_RESULT AllocationResult
       AllocateRaw(int object_size, Executability executable);
 
+  void AddAllocationObserver(AllocationObserver* observer) {
+    allocation_observers_.Add(observer);
+  }
+
+  void RemoveAllocationObserver(AllocationObserver* observer) {
+    bool removed = allocation_observers_.RemoveElement(observer);
+    static_cast<void>(removed);
+    DCHECK(removed);
+  }
+
   // Available bytes for objects in this space.
   inline intptr_t Available() override;
 
   intptr_t Size() override { return size_; }
 
   intptr_t SizeOfObjects() override { return objects_size_; }
 
   // Approximate amount of physical memory committed for this space.
   size_t CommittedPhysicalMemory() override;
 
@@ skipping 37 matching lines @@
 
  private:
   // The head of the linked list of large object chunks.
   LargePage* first_page_;
   intptr_t size_;          // allocated bytes
   int page_count_;         // number of chunks
   intptr_t objects_size_;  // size of objects
   // Map MemoryChunk::kAlignment-aligned chunks to large pages covering them
   HashMap chunk_map_;
 
+  // Allocation observers
+  List<AllocationObserver*> allocation_observers_;
+
   friend class LargeObjectIterator;
 };
 
 
 class LargeObjectIterator : public ObjectIterator {
  public:
   explicit LargeObjectIterator(LargeObjectSpace* space);
 
   HeapObject* Next();
 
@@ skipping 34 matching lines @@
     count = 0;
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_H_