diff options
Diffstat (limited to 'deps/v8/src/mark-compact.h')
-rw-r--r-- | deps/v8/src/mark-compact.h | 237 |
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; }; |