summaryrefslogtreecommitdiff
path: root/deps/v8/src/mark-compact.h
diff options
context:
space:
mode:
Diffstat (limited to 'deps/v8/src/mark-compact.h')
-rw-r--r--deps/v8/src/mark-compact.h237
1 files changed, 80 insertions, 157 deletions
diff --git a/deps/v8/src/mark-compact.h b/deps/v8/src/mark-compact.h
index 179edba74..1b7e60022 100644
--- a/deps/v8/src/mark-compact.h
+++ b/deps/v8/src/mark-compact.h
@@ -28,8 +28,6 @@
#ifndef V8_MARK_COMPACT_H_
#define V8_MARK_COMPACT_H_
-#include "spaces.h"
-
namespace v8 {
namespace internal {
@@ -39,77 +37,23 @@ namespace internal {
typedef bool (*IsAliveFunction)(HeapObject* obj, int* size, int* offset);
// Forward declarations.
-class CodeFlusher;
-class GCTracer;
-class MarkingVisitor;
class RootMarkingVisitor;
-
-
-// ----------------------------------------------------------------------------
-// Marking stack for tracing live objects.
-
-class MarkingStack {
- public:
- MarkingStack() : low_(NULL), top_(NULL), high_(NULL), overflowed_(false) { }
-
- void Initialize(Address low, Address high) {
- top_ = low_ = reinterpret_cast<HeapObject**>(low);
- high_ = reinterpret_cast<HeapObject**>(high);
- overflowed_ = false;
- }
-
- bool is_full() const { return top_ >= high_; }
-
- bool is_empty() const { return top_ <= low_; }
-
- bool overflowed() const { return overflowed_; }
-
- void clear_overflowed() { overflowed_ = false; }
-
- // Push the (marked) object on the marking stack if there is room,
- // otherwise mark the object as overflowed and wait for a rescan of the
- // heap.
- void Push(HeapObject* object) {
- CHECK(object->IsHeapObject());
- if (is_full()) {
- object->SetOverflow();
- overflowed_ = true;
- } else {
- *(top_++) = object;
- }
- }
-
- HeapObject* Pop() {
- ASSERT(!is_empty());
- HeapObject* object = *(--top_);
- CHECK(object->IsHeapObject());
- return object;
- }
-
- private:
- HeapObject** low_;
- HeapObject** top_;
- HeapObject** high_;
- bool overflowed_;
-
- DISALLOW_COPY_AND_ASSIGN(MarkingStack);
-};
+class MarkingVisitor;
// -------------------------------------------------------------------------
// Mark-Compact collector
+//
+// All methods are static.
-class OverflowedObjectsScanner;
-
-class MarkCompactCollector {
+class MarkCompactCollector: public AllStatic {
public:
// Type of functions to compute forwarding addresses of objects in
// compacted spaces. Given an object and its size, return a (non-failure)
// Object* that will be the object after forwarding. There is a separate
// allocation function for each (compactable) space based on the location
// of the object before compaction.
- typedef MaybeObject* (*AllocationFunction)(Heap* heap,
- HeapObject* object,
+ typedef MaybeObject* (*AllocationFunction)(HeapObject* object,
int object_size);
// Type of functions to encode the forwarding address for an object.
@@ -120,21 +64,17 @@ class MarkCompactCollector {
// page as input, and is updated to contain the offset to be used for the
// next live object in the same page. For spaces using a different
// encoding (ie, contiguous spaces), the offset parameter is ignored.
- typedef void (*EncodingFunction)(Heap* heap,
- HeapObject* old_object,
+ typedef void (*EncodingFunction)(HeapObject* old_object,
int object_size,
Object* new_object,
int* offset);
// Type of functions to process non-live objects.
- typedef void (*ProcessNonLiveFunction)(HeapObject* object, Isolate* isolate);
-
- // Pointer to member function, used in IterateLiveObjects.
- typedef int (MarkCompactCollector::*LiveObjectCallback)(HeapObject* obj);
+ typedef void (*ProcessNonLiveFunction)(HeapObject* object);
// Set the global force_compaction flag, it must be called before Prepare
// to take effect.
- void SetForceCompaction(bool value) {
+ static void SetForceCompaction(bool value) {
force_compaction_ = value;
}
@@ -143,16 +83,16 @@ class MarkCompactCollector {
// Prepares for GC by resetting relocation info in old and map spaces and
// choosing spaces to compact.
- void Prepare(GCTracer* tracer);
+ static void Prepare(GCTracer* tracer);
// Performs a global garbage collection.
- void CollectGarbage();
+ static void CollectGarbage();
// True if the last full GC performed heap compaction.
- bool HasCompacted() { return compacting_collection_; }
+ static bool HasCompacted() { return compacting_collection_; }
// True after the Prepare phase if the compaction is taking place.
- bool IsCompacting() {
+ static bool IsCompacting() {
#ifdef DEBUG
// For the purposes of asserts we don't want this to keep returning true
// after the collection is completed.
@@ -164,20 +104,20 @@ class MarkCompactCollector {
// The count of the number of objects left marked at the end of the last
// completed full GC (expected to be zero).
- int previous_marked_count() { return previous_marked_count_; }
+ static int previous_marked_count() { return previous_marked_count_; }
// During a full GC, there is a stack-allocated GCTracer that is used for
// bookkeeping information. Return a pointer to that tracer.
- GCTracer* tracer() { return tracer_; }
+ static GCTracer* tracer() { return tracer_; }
#ifdef DEBUG
// Checks whether performing mark-compact collection.
- bool in_use() { return state_ > PREPARE_GC; }
- bool are_map_pointers_encoded() { return state_ == UPDATE_POINTERS; }
+ static bool in_use() { return state_ > PREPARE_GC; }
+ static bool are_map_pointers_encoded() { return state_ == UPDATE_POINTERS; }
#endif
// Determine type of object and emit deletion log event.
- static void ReportDeleteIfNeeded(HeapObject* obj, Isolate* isolate);
+ static void ReportDeleteIfNeeded(HeapObject* obj);
// Returns size of a possibly marked object.
static int SizeOfMarkedObject(HeapObject* obj);
@@ -187,16 +127,7 @@ class MarkCompactCollector {
static const uint32_t kSingleFreeEncoding = 0;
static const uint32_t kMultiFreeEncoding = 1;
- inline Heap* heap() const { return heap_; }
-
- CodeFlusher* code_flusher() { return code_flusher_; }
- inline bool is_code_flushing_enabled() const { return code_flusher_ != NULL; }
- void EnableCodeFlushing(bool enable);
-
private:
- MarkCompactCollector();
- ~MarkCompactCollector();
-
#ifdef DEBUG
enum CollectorState {
IDLE,
@@ -209,28 +140,28 @@ class MarkCompactCollector {
};
// The current stage of the collector.
- CollectorState state_;
+ static CollectorState state_;
#endif
// Global flag that forces a compaction.
- bool force_compaction_;
+ static bool force_compaction_;
// Global flag indicating whether spaces were compacted on the last GC.
- bool compacting_collection_;
+ static bool compacting_collection_;
// Global flag indicating whether spaces will be compacted on the next GC.
- bool compact_on_next_gc_;
+ static bool compact_on_next_gc_;
// The number of objects left marked at the end of the last completed full
// GC (expected to be zero).
- int previous_marked_count_;
+ static int previous_marked_count_;
// A pointer to the current stack-allocated GC tracer object during a full
// collection (NULL before and after).
- GCTracer* tracer_;
+ static GCTracer* tracer_;
// Finishes GC, performs heap verification if enabled.
- void Finish();
+ static void Finish();
// -----------------------------------------------------------------------
// Phase 1: Marking live objects.
@@ -248,86 +179,85 @@ class MarkCompactCollector {
friend class CodeMarkingVisitor;
friend class SharedFunctionInfoMarkingVisitor;
- void PrepareForCodeFlushing();
+ static void PrepareForCodeFlushing();
// Marking operations for objects reachable from roots.
- void MarkLiveObjects();
+ static void MarkLiveObjects();
- void MarkUnmarkedObject(HeapObject* obj);
+ static void MarkUnmarkedObject(HeapObject* obj);
- inline void MarkObject(HeapObject* obj) {
+ static inline void MarkObject(HeapObject* obj) {
if (!obj->IsMarked()) MarkUnmarkedObject(obj);
}
- inline void SetMark(HeapObject* obj);
+ static inline void SetMark(HeapObject* obj) {
+ tracer_->increment_marked_count();
+#ifdef DEBUG
+ UpdateLiveObjectCount(obj);
+#endif
+ obj->SetMark();
+ }
// Creates back pointers for all map transitions, stores them in
// the prototype field. The original prototype pointers are restored
// in ClearNonLiveTransitions(). All JSObject maps
// connected by map transitions have the same prototype object, which
// is why we can use this field temporarily for back pointers.
- void CreateBackPointers();
+ static void CreateBackPointers();
// Mark a Map and its DescriptorArray together, skipping transitions.
- void MarkMapContents(Map* map);
- void MarkDescriptorArray(DescriptorArray* descriptors);
+ static void MarkMapContents(Map* map);
+ static void MarkDescriptorArray(DescriptorArray* descriptors);
// Mark the heap roots and all objects reachable from them.
- void MarkRoots(RootMarkingVisitor* visitor);
+ static void MarkRoots(RootMarkingVisitor* visitor);
// Mark the symbol table specially. References to symbols from the
// symbol table are weak.
- void MarkSymbolTable();
+ static void MarkSymbolTable();
// Mark objects in object groups that have at least one object in the
// group marked.
- void MarkObjectGroups();
+ static void MarkObjectGroups();
- // Mark objects in implicit references groups if their parent object
- // is marked.
- void MarkImplicitRefGroups();
-
- // Mark all objects which are reachable due to host application
- // logic like object groups or implicit references' groups.
- void ProcessExternalMarking();
+ // Mark all objects in an object group with at least one marked
+ // object, then all objects reachable from marked objects in object
+ // groups, and repeat.
+ static void ProcessObjectGroups();
// Mark objects reachable (transitively) from objects in the marking stack
// or overflowed in the heap.
- void ProcessMarkingStack();
+ static void ProcessMarkingStack();
// Mark objects reachable (transitively) from objects in the marking
// stack. This function empties the marking stack, but may leave
// overflowed objects in the heap, in which case the marking stack's
// overflow flag will be set.
- void EmptyMarkingStack();
+ static void EmptyMarkingStack();
// Refill the marking stack with overflowed objects from the heap. This
// function either leaves the marking stack full or clears the overflow
// flag on the marking stack.
- void RefillMarkingStack();
-
- // After reachable maps have been marked process per context object
- // literal map caches removing unmarked entries.
- void ProcessMapCaches();
+ static void RefillMarkingStack();
// Callback function for telling whether the object *p is an unmarked
// heap object.
static bool IsUnmarkedHeapObject(Object** p);
#ifdef DEBUG
- void UpdateLiveObjectCount(HeapObject* obj);
+ static void UpdateLiveObjectCount(HeapObject* obj);
#endif
// We sweep the large object space in the same way whether we are
// compacting or not, because the large object space is never compacted.
- void SweepLargeObjectSpace();
+ static void SweepLargeObjectSpace();
// Test whether a (possibly marked) object is a Map.
static inline bool SafeIsMap(HeapObject* object);
// Map transitions from a live map to a dead map must be killed.
// We replace them with a null descriptor, with the same key.
- void ClearNonLiveTransitions();
+ static void ClearNonLiveTransitions();
// -----------------------------------------------------------------------
// Phase 2: Sweeping to clear mark bits and free non-live objects for
@@ -372,32 +302,32 @@ class MarkCompactCollector {
// Encodes forwarding addresses of objects in compactable parts of the
// heap.
- void EncodeForwardingAddresses();
+ static void EncodeForwardingAddresses();
// Encodes the forwarding addresses of objects in new space.
- void EncodeForwardingAddressesInNewSpace();
+ static void EncodeForwardingAddressesInNewSpace();
// Function template to encode the forwarding addresses of objects in
// paged spaces, parameterized by allocation and non-live processing
// functions.
template<AllocationFunction Alloc, ProcessNonLiveFunction ProcessNonLive>
- void EncodeForwardingAddressesInPagedSpace(PagedSpace* space);
+ static void EncodeForwardingAddressesInPagedSpace(PagedSpace* space);
// Iterates live objects in a space, passes live objects
// to a callback function which returns the heap size of the object.
// Returns the number of live objects iterated.
- int IterateLiveObjects(NewSpace* space, LiveObjectCallback size_f);
- int IterateLiveObjects(PagedSpace* space, LiveObjectCallback size_f);
+ static int IterateLiveObjects(NewSpace* space, HeapObjectCallback size_f);
+ static int IterateLiveObjects(PagedSpace* space, HeapObjectCallback size_f);
// Iterates the live objects between a range of addresses, returning the
// number of live objects.
- int IterateLiveObjectsInRange(Address start, Address end,
- LiveObjectCallback size_func);
+ static int IterateLiveObjectsInRange(Address start, Address end,
+ HeapObjectCallback size_func);
// If we are not compacting the heap, we simply sweep the spaces except
// for the large object space, clearing mark bits and adding unmarked
// regions to each space's free list.
- void SweepSpaces();
+ static void SweepSpaces();
// -----------------------------------------------------------------------
// Phase 3: Updating pointers in live objects.
@@ -411,15 +341,15 @@ class MarkCompactCollector {
friend class UpdatingVisitor; // helper for updating visited objects
// Updates pointers in all spaces.
- void UpdatePointers();
+ static void UpdatePointers();
// Updates pointers in an object in new space.
// Returns the heap size of the object.
- int UpdatePointersInNewObject(HeapObject* obj);
+ static int UpdatePointersInNewObject(HeapObject* obj);
// Updates pointers in an object in old spaces.
// Returns the heap size of the object.
- int UpdatePointersInOldObject(HeapObject* obj);
+ static int UpdatePointersInOldObject(HeapObject* obj);
// Calculates the forwarding address of an object in an old space.
static Address GetForwardingAddressInOldSpace(HeapObject* obj);
@@ -433,31 +363,31 @@ class MarkCompactCollector {
// After: Objects have been moved to their new addresses.
// Relocates objects in all spaces.
- void RelocateObjects();
+ static void RelocateObjects();
// Converts a code object's inline target to addresses, convention from
// address to target happens in the marking phase.
- int ConvertCodeICTargetToAddress(HeapObject* obj);
+ static int ConvertCodeICTargetToAddress(HeapObject* obj);
// Relocate a map object.
- int RelocateMapObject(HeapObject* obj);
+ static int RelocateMapObject(HeapObject* obj);
// Relocates an old object.
- int RelocateOldPointerObject(HeapObject* obj);
- int RelocateOldDataObject(HeapObject* obj);
+ static int RelocateOldPointerObject(HeapObject* obj);
+ static int RelocateOldDataObject(HeapObject* obj);
// Relocate a property cell object.
- int RelocateCellObject(HeapObject* obj);
+ static int RelocateCellObject(HeapObject* obj);
// Helper function.
- inline int RelocateOldNonCodeObject(HeapObject* obj,
- PagedSpace* space);
+ static inline int RelocateOldNonCodeObject(HeapObject* obj,
+ PagedSpace* space);
// Relocates an object in the code space.
- int RelocateCodeObject(HeapObject* obj);
+ static int RelocateCodeObject(HeapObject* obj);
// Copy a new object.
- int RelocateNewObject(HeapObject* obj);
+ static int RelocateNewObject(HeapObject* obj);
#ifdef DEBUG
// -----------------------------------------------------------------------
@@ -466,28 +396,28 @@ class MarkCompactCollector {
// mark-sweep collection.
// Size of live objects in Heap::to_space_.
- int live_young_objects_size_;
+ static int live_young_objects_size_;
// Size of live objects in Heap::old_pointer_space_.
- int live_old_pointer_objects_size_;
+ static int live_old_pointer_objects_size_;
// Size of live objects in Heap::old_data_space_.
- int live_old_data_objects_size_;
+ static int live_old_data_objects_size_;
// Size of live objects in Heap::code_space_.
- int live_code_objects_size_;
+ static int live_code_objects_size_;
// Size of live objects in Heap::map_space_.
- int live_map_objects_size_;
+ static int live_map_objects_size_;
// Size of live objects in Heap::cell_space_.
- int live_cell_objects_size_;
+ static int live_cell_objects_size_;
// Size of live objects in Heap::lo_space_.
- int live_lo_objects_size_;
+ static int live_lo_objects_size_;
// Number of live bytes in this collection.
- int live_bytes_;
+ static int live_bytes_;
friend class MarkObjectVisitor;
static void VisitObject(HeapObject* obj);
@@ -495,13 +425,6 @@ class MarkCompactCollector {
friend class UnmarkObjectVisitor;
static void UnmarkObject(HeapObject* obj);
#endif
-
- Heap* heap_;
- MarkingStack marking_stack_;
- CodeFlusher* code_flusher_;
-
- friend class Heap;
- friend class OverflowedObjectsScanner;
};