Index: src/heap/heap.h |
diff --git a/src/heap/heap.h b/src/heap/heap.h |
index 549dfdd440501da2929cd7940538aa8084d12b60..4a8a9bb1f6ae03257ebe66c091fcc7658d1c183b 100644 |
--- a/src/heap/heap.h |
+++ b/src/heap/heap.h |
@@ -470,6 +470,7 @@ class GCTracer; |
class HeapObjectsFilter; |
class HeapStats; |
class HistogramTimer; |
+class InlineAllocationObserver; |
class Isolate; |
class MemoryReducer; |
class ObjectStats; |
@@ -2755,6 +2756,60 @@ class PathTracer : public ObjectVisitor { |
DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer); |
}; |
#endif // DEBUG |
+ |
+// ----------------------------------------------------------------------------- |
+// Allows observation of inline allocation in the new space. |
+class InlineAllocationObserver { |
+ public: |
+ explicit InlineAllocationObserver(intptr_t step_size) |
+ : step_size_(step_size), bytes_to_next_step_(step_size) { |
+ DCHECK(step_size >= kPointerSize); |
+ } |
+ virtual ~InlineAllocationObserver() {} |
+ |
+ // Called each time the new space does an inline allocation step. This may be |
+ // 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) { |
+ 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: |
+ intptr_t step_size() const { return step_size_; } |
+ intptr_t bytes_to_next_step() const { return bytes_to_next_step_; } |
+ |
+ // Pure virtual method provided by the subclasses that gets called when at |
+ // least step_size bytes have been allocated. soon_object is the address just |
+ // allocated (but not yet initialized.) size is the size of the object as |
+ // requested (i.e. w/o the alignment fillers). Some complexities to be aware |
+ // of: |
+ // 1) soon_object will be nullptr in cases where we end up observing an |
+ // allocation that happens to be a filler space (e.g. page boundaries.) |
+ // 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_; } |
+ |
+ intptr_t step_size_; |
+ intptr_t bytes_to_next_step_; |
+ |
+ private: |
+ friend class NewSpace; |
+ DISALLOW_COPY_AND_ASSIGN(InlineAllocationObserver); |
+}; |
+ |
} // namespace internal |
} // namespace v8 |