Allocation sampling for paged/lo spaces

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 452 matching lines @@
   V(UninitializedMap)                   \
   V(ArgumentsMarkerMap)                 \
   V(JSMessageObjectMap)                 \
   V(ForeignMap)                         \
   V(NeanderMap)                         \
   V(EmptyWeakCell)                      \
   V(empty_string)                       \
   PRIVATE_SYMBOL_LIST(V)
 
 // Forward declarations.
+class AllocationObserver;
 class ArrayBufferTracker;
 class GCIdleTimeAction;
 class GCIdleTimeHandler;
 class GCIdleTimeHeapState;
 class GCTracer;
 class HeapObjectsFilter;
 class HeapStats;
 class HistogramTimer;
-class InlineAllocationObserver;
 class Isolate;
 class MemoryReducer;
 class ObjectStats;
 class Scavenger;
 class ScavengeJob;
 class WeakObjectRetainer;
 
 
 // A queue of objects promoted during scavenge. Each object is accompanied
 // by it's size to avoid dereferencing a map pointer for scanning.
@@ skipping 1843 matching lines @@
   IncrementalMarking* incremental_marking_;
 
   GCIdleTimeHandler* gc_idle_time_handler_;
 
   MemoryReducer* memory_reducer_;
 
   ObjectStats* object_stats_;
 
   ScavengeJob* scavenge_job_;
 
-  InlineAllocationObserver* idle_scavenge_observer_;
+  AllocationObserver* idle_scavenge_observer_;
 
   // These two counters are monotomically increasing and never reset.
   size_t full_codegen_bytes_generated_;
   size_t crankshaft_codegen_bytes_generated_;
 
   // This counter is increased before each GC and never reset.
   // To account for the bytes allocated since the last GC, use the
   // NewSpaceAllocationCounter() function.
   size_t new_space_allocation_counter_;
 
@@ skipping 432 matching lines @@
   List<Object*> object_stack_;
 
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 
 // -----------------------------------------------------------------------------
-// Allows observation of inline allocation in the new space.
-class InlineAllocationObserver {
+// Allows observation of allocations.
+class AllocationObserver {
  public:
-  explicit InlineAllocationObserver(intptr_t step_size)
-      : step_size_(step_size), bytes_to_next_step_(step_size) {
+  explicit AllocationObserver(Heap* heap, intptr_t step_size)

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

'explicit' is only needed on single argument constructors.

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

Done.

+      : heap_(heap), step_size_(step_size), bytes_to_next_step_(step_size) {
     DCHECK(step_size >= kPointerSize);
   }
-  virtual ~InlineAllocationObserver() {}
+  virtual ~AllocationObserver() {}
 
   // Called each time the new space does an inline allocation step. This may be

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

Update comment since it applies to more than just new space now.

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

Done.

   // more frequently than the step_size we are monitoring (e.g. when there are
   // multiple observers, or when page or space boundary is encountered.)
-  void InlineAllocationStep(int bytes_allocated, Address soon_object,
-                            size_t size) {
+  void AllocationStep(int bytes_allocated, Address soon_object, size_t size) {
+    if (heap_->gc_state() != Heap::NOT_IN_GC) return;

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

It would be better to generalize the PauseInlineAllocationObserver concept. The
AllocationStep is supposed to cover >= 1 allocations, and checking the *current*
heap state sounds wrong when multiple allocations are being reported in
aggregate.

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

I've generalized it and pausing is unified across all spaces. It would be nice
to find a better way to isolate the locations where pause checks must be
performed. Right now, checks are made before each call to AllocationStep by
spaces other than new_space which seems analogous to what we had before.
@ofrobots, how do you envision these checks being performed to allow for
multiple allocations to aggregate?

[ofrobots, 2016/01/26 15:47:15]

Looking at the way this works, it seems like non-New spaces always call this on
single objects, so this will never be an aggregate for those spaces. If
PauseAlloctionObservers is working correctly, the check would not be necessary
(and could instead be assertions).

     bytes_to_next_step_ -= bytes_allocated;
     if (bytes_to_next_step_ <= 0) {
       Step(static_cast<int>(step_size_ - bytes_to_next_step_), soon_object,
            size);
       step_size_ = GetNextStepSize();
       bytes_to_next_step_ = step_size_;
     }
   }
 
  protected:
@@ skipping 10 matching lines @@
   // 2) size is the requested size at the time of allocation. Right-trimming
   //    may change the object size dynamically.
   // 3) soon_object may actually be the first object in an allocation-folding
   //    group. In such a case size is the size of the group rather than the
   //    first object.
   virtual void Step(int bytes_allocated, Address soon_object, size_t size) = 0;
 
   // Subclasses can override this method to make step size dynamic.
   virtual intptr_t GetNextStepSize() { return step_size_; }
 
+  Heap* heap_;
   intptr_t step_size_;
   intptr_t bytes_to_next_step_;
 
  private:
+  friend class LargeObjectSpace;
   friend class NewSpace;
-  DISALLOW_COPY_AND_ASSIGN(InlineAllocationObserver);
+  friend class PagedSpace;
+  DISALLOW_COPY_AND_ASSIGN(AllocationObserver);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_HEAP_H_