v8::internal::MarkCompactCollector Class Reference

#include <mark-compact.h>

Collaboration diagram for v8::internal::MarkCompactCollector:

Classes
class	SweeperTask

Public Types
enum	CompactionMode { INCREMENTAL_COMPACTION , NON_INCREMENTAL_COMPACTION }
enum	SweeperType { PARALLEL_SWEEPING , CONCURRENT_SWEEPING , SEQUENTIAL_SWEEPING }
enum	SweepingParallelism { SWEEP_ON_MAIN_THREAD , SWEEP_IN_PARALLEL }

Public Member Functions
void	SetFlags (int flags)
void	SetUp ()
void	TearDown ()
void	CollectEvacuationCandidates (PagedSpace *space)
void	AddEvacuationCandidate (Page *p)
void	Prepare ()
void	CollectGarbage ()
bool	StartCompaction (CompactionMode mode)
void	AbortCompaction ()
Heap *	heap () const
Isolate *	isolate () const
CodeFlusher *	code_flusher ()
bool	is_code_flushing_enabled () const
void	EnableCodeFlushing (bool enable)
	INLINE (static bool ShouldSkipEvacuationSlotRecording(Object **anchor))
	INLINE (static bool ShouldSkipEvacuationSlotRecording(Object *host))
	INLINE (static bool IsOnEvacuationCandidate(Object *obj))
	INLINE (void EvictEvacuationCandidate(Page *page))
void	RecordRelocSlot (RelocInfo *rinfo, Object *target)
void	RecordCodeEntrySlot (Address slot, Code *target)
void	RecordCodeTargetPatch (Address pc, Code *target)
	INLINE (void RecordSlot(Object **anchor_slot, Object **slot, Object *object, SlotsBuffer::AdditionMode mode=SlotsBuffer::FAIL_ON_OVERFLOW))
void	MigrateObject (HeapObject *dst, HeapObject *src, int size, AllocationSpace to_old_space)
bool	TryPromoteObject (HeapObject *object, int object_size)
void	InvalidateCode (Code *code)
void	ClearMarkbits ()
bool	abort_incremental_marking () const
bool	is_compacting () const
MarkingParity	marking_parity ()
int	SweepInParallel (PagedSpace *space, int required_freed_bytes)
int	SweepInParallel (Page *page, PagedSpace *space)
void	EnsureSweepingCompleted ()
bool	IsSweepingCompleted ()
void	RefillFreeList (PagedSpace *space)
bool	AreSweeperThreadsActivated ()
bool	sweeping_in_progress ()
void	set_sequential_sweeping (bool sequential_sweeping)
bool	sequential_sweeping () const
void	MarkWeakObjectToCodeTable ()
void	MarkAllocationSite (AllocationSite *site)

Static Public Member Functions
static void	Initialize ()
static void	ReportDeleteIfNeeded (HeapObject *obj, Isolate *isolate)
static bool	IsMarked (Object *obj)

Static Public Attributes
static const uint32_t	kSingleFreeEncoding = 0
static const uint32_t	kMultiFreeEncoding = 1

Private Member Functions
	MarkCompactCollector (Heap *heap)
	~MarkCompactCollector ()
bool	MarkInvalidatedCode ()
bool	WillBeDeoptimized (Code *code)
void	RemoveDeadInvalidatedCode ()
void	ProcessInvalidatedCode (ObjectVisitor *visitor)
void	StartSweeperThreads ()
void	Finish ()
void	PrepareThreadForCodeFlushing (Isolate *isolate, ThreadLocalTop *top)
void	PrepareForCodeFlushing ()
void	MarkLiveObjects ()
void	AfterMarking ()
	INLINE (void MarkObject(HeapObject *obj, MarkBit mark_bit))
	INLINE (void SetMark(HeapObject *obj, MarkBit mark_bit))
void	MarkRoots (RootMarkingVisitor *visitor)
void	MarkStringTable (RootMarkingVisitor *visitor)
void	MarkImplicitRefGroups ()
void	ProcessMarkingDeque ()
void	ProcessEphemeralMarking (ObjectVisitor *visitor)
void	ProcessTopOptimizedFrame (ObjectVisitor *visitor)
void	EmptyMarkingDeque ()
void	RefillMarkingDeque ()
void	ProcessMapCaches ()
void	ClearNonLiveReferences ()
void	ClearNonLivePrototypeTransitions (Map *map)
void	ClearNonLiveMapTransitions (Map *map, MarkBit map_mark)
void	ClearMapTransitions (Map *map)
bool	ClearMapBackPointer (Map *map)
void	TrimDescriptorArray (Map *map, DescriptorArray *descriptors, int number_of_own_descriptors)
void	TrimEnumCache (Map *map, DescriptorArray *descriptors)
void	ClearDependentCode (DependentCode *dependent_code)
void	ClearDependentICList (Object *head)
void	ClearNonLiveDependentCode (DependentCode *dependent_code)
int	ClearNonLiveDependentCodeInGroup (DependentCode *dependent_code, int group, int start, int end, int new_start)
void	ProcessWeakCollections ()
void	ClearWeakCollections ()
void	AbortWeakCollections ()
void	SweepSpaces ()
int	DiscoverAndEvacuateBlackObjectsOnPage (NewSpace *new_space, NewSpacePage *p)
void	EvacuateNewSpace ()
void	EvacuateLiveObjectsFromPage (Page *p)
void	EvacuatePages ()
void	EvacuateNewSpaceAndCandidates ()
void	ReleaseEvacuationCandidates ()
void	MoveEvacuationCandidatesToEndOfPagesList ()
void	SweepSpace (PagedSpace *space, SweeperType sweeper)
void	ParallelSweepSpacesComplete ()
void	ParallelSweepSpaceComplete (PagedSpace *space)
void	RecordMigratedSlot (Object *value, Address slot)

Static Private Member Functions
static bool	IsUnmarkedHeapObject (Object **p)
static bool	IsUnmarkedHeapObjectWithHeap (Heap *heap, Object **p)

Private Attributes
bool	reduce_memory_footprint_
bool	abort_incremental_marking_
MarkingParity	marking_parity_
bool	compacting_
bool	was_marked_incrementally_
bool	sweeping_in_progress_
base::Semaphore	pending_sweeper_jobs_semaphore_
bool	sequential_sweeping_
SlotsBufferAllocator	slots_buffer_allocator_
SlotsBuffer *	migration_slots_buffer_
Heap *	heap_
MarkingDeque	marking_deque_
CodeFlusher *	code_flusher_
bool	have_code_to_deoptimize_
List< Page * >	evacuation_candidates_
List< Code * >	invalidated_code_
SmartPointer< FreeList >	free_list_old_data_space_
SmartPointer< FreeList >	free_list_old_pointer_space_

Friends
class	RootMarkingVisitor
class	MarkingVisitor
class	MarkCompactMarkingVisitor
class	CodeMarkingVisitor
class	SharedFunctionInfoMarkingVisitor
class	Heap

Detailed Description

Definition at line 498 of file mark-compact.h.

Member Enumeration Documentation

CompactionMode

enum v8::internal::MarkCompactCollector::CompactionMode

Enumerator
INCREMENTAL_COMPACTION
NON_INCREMENTAL_COMPACTION

Definition at line 520 of file mark-compact.h.

{ INCREMENTAL_COMPACTION, NON_INCREMENTAL_COMPACTION };

SweeperType

enum v8::internal::MarkCompactCollector::SweeperType

Enumerator
PARALLEL_SWEEPING
CONCURRENT_SWEEPING
SEQUENTIAL_SWEEPING

Definition at line 549 of file mark-compact.h.

                   {
    PARALLEL_SWEEPING,
    CONCURRENT_SWEEPING,
    SEQUENTIAL_SWEEPING
  };

SweepingParallelism

enum v8::internal::MarkCompactCollector::SweepingParallelism

Enumerator
SWEEP_ON_MAIN_THREAD
SWEEP_IN_PARALLEL

Definition at line 555 of file mark-compact.h.

{ SWEEP_ON_MAIN_THREAD, SWEEP_IN_PARALLEL };

Constructor & Destructor Documentation

MarkCompactCollector()

v8::internal::MarkCompactCollector::MarkCompactCollector ( Heap *  heap )

explicitprivate

Definition at line 39 of file mark-compact.cc.

    :  // NOLINT
#ifdef DEBUG
      state_(IDLE),
#endif
      reduce_memory_footprint_(false),
      abort_incremental_marking_(false),
      marking_parity_(ODD_MARKING_PARITY),
      compacting_(false),
      was_marked_incrementally_(false),
      sweeping_in_progress_(false),
      pending_sweeper_jobs_semaphore_(0),
      sequential_sweeping_(false),
      migration_slots_buffer_(NULL),
      heap_(heap),
      code_flusher_(NULL),
      have_code_to_deoptimize_(false) {
}

~MarkCompactCollector()

v8::internal::MarkCompactCollector::~MarkCompactCollector ( )

private

Definition at line 1309 of file mark-compact.cc.

                                            {
  if (code_flusher_ != NULL) {
    delete code_flusher_;
    code_flusher_ = NULL;
  }
}

References code_flusher_, and NULL.

Member Function Documentation

abort_incremental_marking()

bool v8::internal::MarkCompactCollector::abort_incremental_marking ( ) const

inline

Definition at line 618 of file mark-compact.h.

{ return abort_incremental_marking_; }

References abort_incremental_marking_.

AbortCompaction()

void v8::internal::MarkCompactCollector::AbortCompaction

(

)

Definition at line 918 of file mark-compact.cc.

                                           {
  if (compacting_) {
    int npages = evacuation_candidates_.length();
    for (int i = 0; i < npages; i++) {
      Page* p = evacuation_candidates_[i];
      slots_buffer_allocator_.DeallocateChain(p->slots_buffer_address());
      p->ClearEvacuationCandidate();
      p->ClearFlag(MemoryChunk::RESCAN_ON_EVACUATION);
    }
    compacting_ = false;
    evacuation_candidates_.Rewind(0);
    invalidated_code_.Rewind(0);
  }
  DCHECK_EQ(0, evacuation_candidates_.length());
}

References v8::internal::MemoryChunk::ClearEvacuationCandidate(), v8::internal::MemoryChunk::ClearFlag(), compacting_, DCHECK_EQ, v8::internal::SlotsBufferAllocator::DeallocateChain(), evacuation_candidates_, invalidated_code_, v8::internal::MemoryChunk::RESCAN_ON_EVACUATION, v8::internal::MemoryChunk::slots_buffer_address(), and slots_buffer_allocator_.

Referenced by Prepare(), and TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

AbortWeakCollections()

void v8::internal::MarkCompactCollector::AbortWeakCollections ( )

private

Definition at line 2846 of file mark-compact.cc.

                                                {
  GCTracer::Scope gc_scope(heap()->tracer(),
                           GCTracer::Scope::MC_WEAKCOLLECTION_ABORT);
  Object* weak_collection_obj = heap()->encountered_weak_collections();
  while (weak_collection_obj != Smi::FromInt(0)) {
    JSWeakCollection* weak_collection =
        reinterpret_cast<JSWeakCollection*>(weak_collection_obj);
    weak_collection_obj = weak_collection->next();
    weak_collection->set_next(heap()->undefined_value());
  }
  heap()->set_encountered_weak_collections(Smi::FromInt(0));
}

References v8::internal::Heap::encountered_weak_collections(), v8::internal::Smi::FromInt(), heap(), v8::internal::GCTracer::Scope::MC_WEAKCOLLECTION_ABORT, and v8::internal::Heap::set_encountered_weak_collections().

Referenced by Prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

AddEvacuationCandidate()

void v8::internal::MarkCompactCollector::AddEvacuationCandidate

(

Page *

p

)

Definition at line 337 of file mark-compact.cc.

                                                         {
  p->MarkEvacuationCandidate();
  evacuation_candidates_.Add(p);
}

References evacuation_candidates_, and v8::internal::MemoryChunk::MarkEvacuationCandidate().

Referenced by CollectEvacuationCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

AfterMarking()

void v8::internal::MarkCompactCollector::AfterMarking ( )

private

Definition at line 2351 of file mark-compact.cc.

                                        {
  // Object literal map caches reference strings (cache keys) and maps
  // (cache values). At this point still useful maps have already been
  // marked. Mark the keys for the alive values before we process the
  // string table.
  ProcessMapCaches();
 
  // Prune the string table removing all strings only pointed to by the
  // string table.  Cannot use string_table() here because the string
  // table is marked.
  StringTable* string_table = heap()->string_table();
  InternalizedStringTableCleaner internalized_visitor(heap());
  string_table->IterateElements(&internalized_visitor);
  string_table->ElementsRemoved(internalized_visitor.PointersRemoved());
 
  ExternalStringTableCleaner external_visitor(heap());
  heap()->external_string_table_.Iterate(&external_visitor);
  heap()->external_string_table_.CleanUp();
 
  // Process the weak references.
  MarkCompactWeakObjectRetainer mark_compact_object_retainer;
  heap()->ProcessWeakReferences(&mark_compact_object_retainer);
 
  // Remove object groups after marking phase.
  heap()->isolate()->global_handles()->RemoveObjectGroups();
  heap()->isolate()->global_handles()->RemoveImplicitRefGroups();
 
  // Flush code from collected candidates.
  if (is_code_flushing_enabled()) {
    code_flusher_->ProcessCandidates();
    // If incremental marker does not support code flushing, we need to
    // disable it before incremental marking steps for next cycle.
    if (FLAG_flush_code && !FLAG_flush_code_incrementally) {
      EnableCodeFlushing(false);
    }
  }
 
  if (FLAG_track_gc_object_stats) {
    heap()->CheckpointObjectStats();
  }
}

References v8::internal::Heap::CheckpointObjectStats(), v8::internal::ExternalStringTable::CleanUp(), code_flusher_, v8::internal::HashTable< Derived, Shape, Key >::ElementsRemoved(), EnableCodeFlushing(), v8::internal::Heap::external_string_table_, v8::internal::Isolate::global_handles(), heap(), is_code_flushing_enabled(), v8::internal::Heap::isolate(), v8::internal::ExternalStringTable::Iterate(), v8::internal::HashTable< Derived, Shape, Key >::IterateElements(), v8::internal::StringTableCleaner< finalize_external_strings >::PointersRemoved(), v8::internal::CodeFlusher::ProcessCandidates(), ProcessMapCaches(), v8::internal::Heap::ProcessWeakReferences(), v8::internal::GlobalHandles::RemoveImplicitRefGroups(), and v8::internal::GlobalHandles::RemoveObjectGroups().

Referenced by MarkLiveObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

AreSweeperThreadsActivated()

bool v8::internal::MarkCompactCollector::AreSweeperThreadsActivated

(

)

Definition at line 646 of file mark-compact.cc.

                                                      {
  return isolate()->sweeper_threads() != NULL || FLAG_job_based_sweeping;
}

References isolate(), NULL, and v8::internal::Isolate::sweeper_threads().

Referenced by EnsureSweepingCompleted().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearDependentCode()

void v8::internal::MarkCompactCollector::ClearDependentCode ( DependentCode *  dependent_code )

private

Definition at line 2706 of file mark-compact.cc.

                                                                    {
  DisallowHeapAllocation no_allocation;
  DependentCode::GroupStartIndexes starts(entries);
  int number_of_entries = starts.number_of_entries();
  if (number_of_entries == 0) return;
  int g = DependentCode::kWeakICGroup;
  if (starts.at(g) != starts.at(g + 1)) {
    int i = starts.at(g);
    DCHECK(i + 1 == starts.at(g + 1));
    Object* head = entries->object_at(i);
    ClearDependentICList(head);
  }
  g = DependentCode::kWeakCodeGroup;
  for (int i = starts.at(g); i < starts.at(g + 1); i++) {
    // If the entry is compilation info then the map must be alive,
    // and ClearDependentCode shouldn't be called.
    DCHECK(entries->is_code_at(i));
    Code* code = entries->code_at(i);
    if (IsMarked(code) && !code->marked_for_deoptimization()) {
      DependentCode::SetMarkedForDeoptimization(
          code, static_cast<DependentCode::DependencyGroup>(g));
      code->InvalidateEmbeddedObjects();
      have_code_to_deoptimize_ = true;
    }
  }
  for (int i = 0; i < number_of_entries; i++) {
    entries->clear_at(i);
  }
}

References v8::internal::DependentCode::GroupStartIndexes::at(), v8::internal::DependentCode::clear_at(), ClearDependentICList(), v8::internal::DependentCode::code_at(), DCHECK, have_code_to_deoptimize_, v8::internal::Code::InvalidateEmbeddedObjects(), v8::internal::DependentCode::is_code_at(), IsMarked(), v8::internal::DependentCode::kWeakCodeGroup, v8::internal::DependentCode::kWeakICGroup, v8::internal::Code::marked_for_deoptimization(), v8::internal::DependentCode::GroupStartIndexes::number_of_entries(), v8::internal::DependentCode::object_at(), and v8::internal::DependentCode::SetMarkedForDeoptimization().

Referenced by ClearNonLiveReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearDependentICList()

void v8::internal::MarkCompactCollector::ClearDependentICList ( Object *  head )

private

Definition at line 2691 of file mark-compact.cc.

                                                            {
  Object* current = head;
  Object* undefined = heap()->undefined_value();
  while (current != undefined) {
    Code* code = Code::cast(current);
    if (IsMarked(code)) {
      DCHECK(code->is_weak_stub());
      IC::InvalidateMaps(code);
    }
    current = code->next_code_link();
    code->set_next_code_link(undefined);
  }
}

References DCHECK, heap(), v8::internal::IC::InvalidateMaps(), v8::internal::Code::is_weak_stub(), and IsMarked().

Referenced by ClearDependentCode().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearMapBackPointer()

bool v8::internal::MarkCompactCollector::ClearMapBackPointer ( Map *  map )

private

Definition at line 2583 of file mark-compact.cc.

                                                          {
  if (Marking::MarkBitFrom(target).Get()) return false;
  target->SetBackPointer(heap_->undefined_value(), SKIP_WRITE_BARRIER);
  return true;
}

References heap_, v8::internal::Map::SetBackPointer(), and v8::internal::SKIP_WRITE_BARRIER.

Referenced by ClearMapTransitions().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearMapTransitions()

void v8::internal::MarkCompactCollector::ClearMapTransitions ( Map *  map )

private

Definition at line 2590 of file mark-compact.cc.

                                                       {
  // If there are no transitions to be cleared, return.
  // TODO(verwaest) Should be an assert, otherwise back pointers are not
  // properly cleared.
  if (!map->HasTransitionArray()) return;
 
  TransitionArray* t = map->transitions();
 
  int transition_index = 0;
 
  DescriptorArray* descriptors = map->instance_descriptors();
  bool descriptors_owner_died = false;
 
  // Compact all live descriptors to the left.
  for (int i = 0; i < t->number_of_transitions(); ++i) {
    Map* target = t->GetTarget(i);
    if (ClearMapBackPointer(target)) {
      if (target->instance_descriptors() == descriptors) {
        descriptors_owner_died = true;
      }
    } else {
      if (i != transition_index) {
        Name* key = t->GetKey(i);
        t->SetKey(transition_index, key);
        Object** key_slot = t->GetKeySlot(transition_index);
        RecordSlot(key_slot, key_slot, key);
        // Target slots do not need to be recorded since maps are not compacted.
        t->SetTarget(transition_index, t->GetTarget(i));
      }
      transition_index++;
    }
  }
 
  // If there are no transitions to be cleared, return.
  // TODO(verwaest) Should be an assert, otherwise back pointers are not
  // properly cleared.
  if (transition_index == t->number_of_transitions()) return;
 
  int number_of_own_descriptors = map->NumberOfOwnDescriptors();
 
  if (descriptors_owner_died) {
    if (number_of_own_descriptors > 0) {
      TrimDescriptorArray(map, descriptors, number_of_own_descriptors);
      DCHECK(descriptors->number_of_descriptors() == number_of_own_descriptors);
      map->set_owns_descriptors(true);
    } else {
      DCHECK(descriptors == heap_->empty_descriptor_array());
    }
  }
 
  // Note that we never eliminate a transition array, though we might right-trim
  // such that number_of_transitions() == 0. If this assumption changes,
  // TransitionArray::CopyInsert() will need to deal with the case that a
  // transition array disappeared during GC.
  int trim = t->number_of_transitions() - transition_index;
  if (trim > 0) {
    heap_->RightTrimFixedArray<Heap::FROM_GC>(
        t, t->IsSimpleTransition() ? trim
                                   : trim * TransitionArray::kTransitionSize);
  }
  DCHECK(map->HasTransitionArray());
}

References ClearMapBackPointer(), DCHECK, v8::internal::Heap::FROM_GC, v8::internal::TransitionArray::GetKey(), v8::internal::TransitionArray::GetKeySlot(), v8::internal::TransitionArray::GetTarget(), heap_, v8::internal::TransitionArray::IsSimpleTransition(), v8::internal::TransitionArray::kTransitionSize, map, v8::internal::DescriptorArray::number_of_descriptors(), v8::internal::TransitionArray::number_of_transitions(), v8::internal::Heap::RightTrimFixedArray(), v8::internal::TransitionArray::SetKey(), v8::internal::TransitionArray::SetTarget(), and TrimDescriptorArray().

Referenced by ClearNonLiveMapTransitions().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearMarkbits()

void v8::internal::MarkCompactCollector::ClearMarkbits

(

)

Definition at line 516 of file mark-compact.cc.

                                         {
  ClearMarkbitsInPagedSpace(heap_->code_space());
  ClearMarkbitsInPagedSpace(heap_->map_space());
  ClearMarkbitsInPagedSpace(heap_->old_pointer_space());
  ClearMarkbitsInPagedSpace(heap_->old_data_space());
  ClearMarkbitsInPagedSpace(heap_->cell_space());
  ClearMarkbitsInPagedSpace(heap_->property_cell_space());
  ClearMarkbitsInNewSpace(heap_->new_space());
 
  LargeObjectIterator it(heap_->lo_space());
  for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
    MarkBit mark_bit = Marking::MarkBitFrom(obj);
    mark_bit.Clear();
    mark_bit.Next().Clear();
    Page::FromAddress(obj->address())->ResetProgressBar();
    Page::FromAddress(obj->address())->ResetLiveBytes();
  }
}

References v8::internal::Heap::cell_space(), v8::internal::MarkBit::Clear(), v8::internal::ClearMarkbitsInNewSpace(), v8::internal::ClearMarkbitsInPagedSpace(), v8::internal::Heap::code_space(), v8::internal::MemoryChunk::FromAddress(), heap_, v8::internal::Heap::lo_space(), v8::internal::Heap::map_space(), v8::internal::Heap::new_space(), v8::internal::MarkBit::Next(), v8::internal::LargeObjectIterator::Next(), NULL, v8::internal::Heap::old_data_space(), v8::internal::Heap::old_pointer_space(), v8::internal::Heap::property_cell_space(), v8::internal::MemoryChunk::ResetLiveBytes(), and v8::internal::MemoryChunk::ResetProgressBar().

Referenced by Prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearNonLiveDependentCode()

void v8::internal::MarkCompactCollector::ClearNonLiveDependentCode ( DependentCode *  dependent_code )

private

Definition at line 2776 of file mark-compact.cc.

                                                                           {
  DisallowHeapAllocation no_allocation;
  DependentCode::GroupStartIndexes starts(entries);
  int number_of_entries = starts.number_of_entries();
  if (number_of_entries == 0) return;
  int new_number_of_entries = 0;
  // Go through all groups, remove dead codes and compact.
  for (int g = 0; g < DependentCode::kGroupCount; g++) {
    int survived = ClearNonLiveDependentCodeInGroup(
        entries, g, starts.at(g), starts.at(g + 1), new_number_of_entries);
    new_number_of_entries += survived;
  }
  for (int i = new_number_of_entries; i < number_of_entries; i++) {
    entries->clear_at(i);
  }
}

References v8::internal::DependentCode::GroupStartIndexes::at(), v8::internal::DependentCode::clear_at(), ClearNonLiveDependentCodeInGroup(), v8::internal::DependentCode::kGroupCount, and v8::internal::DependentCode::GroupStartIndexes::number_of_entries().

Referenced by ClearNonLiveReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearNonLiveDependentCodeInGroup()

int v8::internal::MarkCompactCollector::ClearNonLiveDependentCodeInGroup ( DependentCode *  dependent_code, int  group, int  start, int  end, int  new_start  )

private

Definition at line 2737 of file mark-compact.cc.

                                                                          {
  int survived = 0;
  if (group == DependentCode::kWeakICGroup) {
    // Dependent weak IC stubs form a linked list and only the head is stored
    // in the dependent code array.
    if (start != end) {
      DCHECK(start + 1 == end);
      Object* old_head = entries->object_at(start);
      MarkCompactWeakObjectRetainer retainer;
      Object* head = VisitWeakList<Code>(heap(), old_head, &retainer);
      entries->set_object_at(new_start, head);
      Object** slot = entries->slot_at(new_start);
      RecordSlot(slot, slot, head);
      // We do not compact this group even if the head is undefined,
      // more dependent ICs are likely to be added later.
      survived = 1;
    }
  } else {
    for (int i = start; i < end; i++) {
      Object* obj = entries->object_at(i);
      DCHECK(obj->IsCode() || IsMarked(obj));
      if (IsMarked(obj) &&
          (!obj->IsCode() || !WillBeDeoptimized(Code::cast(obj)))) {
        if (new_start + survived != i) {
          entries->set_object_at(new_start + survived, obj);
        }
        Object** slot = entries->slot_at(new_start + survived);
        RecordSlot(slot, slot, obj);
        survived++;
      }
    }
  }
  entries->set_number_of_entries(
      static_cast<DependentCode::DependencyGroup>(group), survived);
  return survived;
}

References DCHECK, heap(), IsMarked(), v8::internal::DependentCode::kWeakICGroup, v8::internal::DependentCode::object_at(), v8::internal::DependentCode::set_number_of_entries(), v8::internal::DependentCode::set_object_at(), v8::internal::DependentCode::slot_at(), v8::internal::VisitWeakList< Code >(), and WillBeDeoptimized().

Referenced by ClearNonLiveDependentCode().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearNonLiveMapTransitions()

void v8::internal::MarkCompactCollector::ClearNonLiveMapTransitions ( Map *  map, MarkBit  map_mark  )

private

Definition at line 2565 of file mark-compact.cc.

                                                                        {
  Object* potential_parent = map->GetBackPointer();
  if (!potential_parent->IsMap()) return;
  Map* parent = Map::cast(potential_parent);
 
  // Follow back pointer, check whether we are dealing with a map transition
  // from a live map to a dead path and in case clear transitions of parent.
  bool current_is_alive = map_mark.Get();
  bool parent_is_alive = Marking::MarkBitFrom(parent).Get();
  if (!current_is_alive && parent_is_alive) {
    ClearMapTransitions(parent);
  }
}

References ClearMapTransitions(), v8::internal::MarkBit::Get(), and map.

Referenced by ClearNonLiveReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearNonLivePrototypeTransitions()

void v8::internal::MarkCompactCollector::ClearNonLivePrototypeTransitions ( Map *  map )

private

Definition at line 2526 of file mark-compact.cc.

                                                                    {
  int number_of_transitions = map->NumberOfProtoTransitions();
  FixedArray* prototype_transitions = map->GetPrototypeTransitions();
 
  int new_number_of_transitions = 0;
  const int header = Map::kProtoTransitionHeaderSize;
  const int proto_offset = header + Map::kProtoTransitionPrototypeOffset;
  const int map_offset = header + Map::kProtoTransitionMapOffset;
  const int step = Map::kProtoTransitionElementsPerEntry;
  for (int i = 0; i < number_of_transitions; i++) {
    Object* prototype = prototype_transitions->get(proto_offset + i * step);
    Object* cached_map = prototype_transitions->get(map_offset + i * step);
    if (IsMarked(prototype) && IsMarked(cached_map)) {
      DCHECK(!prototype->IsUndefined());
      int proto_index = proto_offset + new_number_of_transitions * step;
      int map_index = map_offset + new_number_of_transitions * step;
      if (new_number_of_transitions != i) {
        prototype_transitions->set(proto_index, prototype,
                                   UPDATE_WRITE_BARRIER);
        prototype_transitions->set(map_index, cached_map, SKIP_WRITE_BARRIER);
      }
      Object** slot = prototype_transitions->RawFieldOfElementAt(proto_index);
      RecordSlot(slot, slot, prototype);
      new_number_of_transitions++;
    }
  }
 
  if (new_number_of_transitions != number_of_transitions) {
    map->SetNumberOfProtoTransitions(new_number_of_transitions);
  }
 
  // Fill slots that became free with undefined value.
  for (int i = new_number_of_transitions * step;
       i < number_of_transitions * step; i++) {
    prototype_transitions->set_undefined(header + i);
  }
}

References DCHECK, v8::internal::FixedArray::get(), IsMarked(), v8::internal::Map::kProtoTransitionElementsPerEntry, v8::internal::Map::kProtoTransitionHeaderSize, v8::internal::Map::kProtoTransitionMapOffset, v8::internal::Map::kProtoTransitionPrototypeOffset, map, v8::internal::FixedArray::RawFieldOfElementAt(), v8::internal::FixedArray::set(), v8::internal::FixedArray::set_undefined(), v8::internal::SKIP_WRITE_BARRIER, and v8::internal::UPDATE_WRITE_BARRIER.

Referenced by ClearNonLiveReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearNonLiveReferences()

void v8::internal::MarkCompactCollector::ClearNonLiveReferences ( )

private

Definition at line 2445 of file mark-compact.cc.

                                                  {
  // Iterate over the map space, setting map transitions that go from
  // a marked map to an unmarked map to null transitions.  This action
  // is carried out only on maps of JSObjects and related subtypes.
  HeapObjectIterator map_iterator(heap()->map_space());
  for (HeapObject* obj = map_iterator.Next(); obj != NULL;
       obj = map_iterator.Next()) {
    Map* map = Map::cast(obj);
 
    if (!map->CanTransition()) continue;
 
    MarkBit map_mark = Marking::MarkBitFrom(map);
    ClearNonLivePrototypeTransitions(map);
    ClearNonLiveMapTransitions(map, map_mark);
 
    if (map_mark.Get()) {
      ClearNonLiveDependentCode(map->dependent_code());
    } else {
      ClearDependentCode(map->dependent_code());
      map->set_dependent_code(DependentCode::cast(heap()->empty_fixed_array()));
    }
  }
 
  // Iterate over property cell space, removing dependent code that is not
  // otherwise kept alive by strong references.
  HeapObjectIterator cell_iterator(heap_->property_cell_space());
  for (HeapObject* cell = cell_iterator.Next(); cell != NULL;
       cell = cell_iterator.Next()) {
    if (IsMarked(cell)) {
      ClearNonLiveDependentCode(PropertyCell::cast(cell)->dependent_code());
    }
  }
 
  // Iterate over allocation sites, removing dependent code that is not
  // otherwise kept alive by strong references.
  Object* undefined = heap()->undefined_value();
  for (Object* site = heap()->allocation_sites_list(); site != undefined;
       site = AllocationSite::cast(site)->weak_next()) {
    if (IsMarked(site)) {
      ClearNonLiveDependentCode(AllocationSite::cast(site)->dependent_code());
    }
  }
 
  if (heap_->weak_object_to_code_table()->IsHashTable()) {
    WeakHashTable* table =
        WeakHashTable::cast(heap_->weak_object_to_code_table());
    uint32_t capacity = table->Capacity();
    for (uint32_t i = 0; i < capacity; i++) {
      uint32_t key_index = table->EntryToIndex(i);
      Object* key = table->get(key_index);
      if (!table->IsKey(key)) continue;
      uint32_t value_index = table->EntryToValueIndex(i);
      Object* value = table->get(value_index);
      if (key->IsCell() && !IsMarked(key)) {
        Cell* cell = Cell::cast(key);
        Object* object = cell->value();
        if (IsMarked(object)) {
          MarkBit mark = Marking::MarkBitFrom(cell);
          SetMark(cell, mark);
          Object** value_slot = HeapObject::RawField(cell, Cell::kValueOffset);
          RecordSlot(value_slot, value_slot, *value_slot);
        }
      }
      if (IsMarked(key)) {
        if (!IsMarked(value)) {
          HeapObject* obj = HeapObject::cast(value);
          MarkBit mark = Marking::MarkBitFrom(obj);
          SetMark(obj, mark);
        }
        ClearNonLiveDependentCode(DependentCode::cast(value));
      } else {
        ClearDependentCode(DependentCode::cast(value));
        table->set(key_index, heap_->the_hole_value());
        table->set(value_index, heap_->the_hole_value());
        table->ElementRemoved();
      }
    }
  }
}

References v8::internal::HashTable< Derived, Shape, Key >::Capacity(), ClearDependentCode(), ClearNonLiveDependentCode(), ClearNonLiveMapTransitions(), ClearNonLivePrototypeTransitions(), v8::internal::dependent_code, v8::internal::HashTable< Derived, Shape, Key >::ElementRemoved(), v8::internal::HashTable< Derived, Shape, Key >::EntryToIndex(), v8::internal::WeakHashTable::EntryToValueIndex(), v8::internal::MarkBit::Get(), v8::internal::FixedArray::get(), heap(), heap_, v8::internal::HashTable< Derived, Shape, Key >::IsKey(), IsMarked(), v8::internal::Cell::kValueOffset, map, v8::internal::HeapObjectIterator::Next(), NULL, v8::internal::Heap::property_cell_space(), v8::internal::HeapObject::RawField(), v8::internal::FixedArray::set(), and v8::internal::Heap::weak_object_to_code_table().

Referenced by CollectGarbage().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearWeakCollections()

void v8::internal::MarkCompactCollector::ClearWeakCollections ( )

private

Definition at line 2822 of file mark-compact.cc.

                                                {
  GCTracer::Scope gc_scope(heap()->tracer(),
                           GCTracer::Scope::MC_WEAKCOLLECTION_CLEAR);
  Object* weak_collection_obj = heap()->encountered_weak_collections();
  while (weak_collection_obj != Smi::FromInt(0)) {
    JSWeakCollection* weak_collection =
        reinterpret_cast<JSWeakCollection*>(weak_collection_obj);
    DCHECK(MarkCompactCollector::IsMarked(weak_collection));
    if (weak_collection->table()->IsHashTable()) {
      ObjectHashTable* table = ObjectHashTable::cast(weak_collection->table());
      for (int i = 0; i < table->Capacity(); i++) {
        HeapObject* key = HeapObject::cast(table->KeyAt(i));
        if (!MarkCompactCollector::IsMarked(key)) {
          table->RemoveEntry(i);
        }
      }
    }
    weak_collection_obj = weak_collection->next();
    weak_collection->set_next(heap()->undefined_value());
  }
  heap()->set_encountered_weak_collections(Smi::FromInt(0));
}

References v8::internal::HashTable< Derived, Shape, Key >::Capacity(), DCHECK, v8::internal::Heap::encountered_weak_collections(), v8::internal::Smi::FromInt(), heap(), IsMarked(), v8::internal::HashTable< Derived, Shape, Key >::KeyAt(), v8::internal::GCTracer::Scope::MC_WEAKCOLLECTION_CLEAR, v8::internal::ObjectHashTable::RemoveEntry(), and v8::internal::Heap::set_encountered_weak_collections().

Referenced by CollectGarbage().

Here is the call graph for this function:

Here is the caller graph for this function:

code_flusher()

CodeFlusher* v8::internal::MarkCompactCollector::code_flusher ( )

inline

Definition at line 545 of file mark-compact.h.

{ return code_flusher_; }

References code_flusher_.

Referenced by v8::internal::Context::AddOptimizedFunction(), v8::internal::SharedFunctionInfo::ClearOptimizedCodeMap(), v8::internal::SharedFunctionInfo::ReplaceCode(), and v8::internal::Heap::Scavenge().

Here is the caller graph for this function:

CollectEvacuationCandidates()

void v8::internal::MarkCompactCollector::CollectEvacuationCandidates

(

PagedSpace *

space

)

Definition at line 768 of file mark-compact.cc.

                                                                        {
  DCHECK(space->identity() == OLD_POINTER_SPACE ||
         space->identity() == OLD_DATA_SPACE ||
         space->identity() == CODE_SPACE);
 
  static const int kMaxMaxEvacuationCandidates = 1000;
  int number_of_pages = space->CountTotalPages();
  int max_evacuation_candidates =
      static_cast<int>(std::sqrt(number_of_pages / 2.0) + 1);
 
  if (FLAG_stress_compaction || FLAG_always_compact) {
    max_evacuation_candidates = kMaxMaxEvacuationCandidates;
  }
 
  class Candidate {
   public:
    Candidate() : fragmentation_(0), page_(NULL) {}
    Candidate(int f, Page* p) : fragmentation_(f), page_(p) {}
 
    int fragmentation() { return fragmentation_; }
    Page* page() { return page_; }
 
   private:
    int fragmentation_;
    Page* page_;
  };
 
  enum CompactionMode { COMPACT_FREE_LISTS, REDUCE_MEMORY_FOOTPRINT };
 
  CompactionMode mode = COMPACT_FREE_LISTS;
 
  intptr_t reserved = number_of_pages * space->AreaSize();
  intptr_t over_reserved = reserved - space->SizeOfObjects();
  static const intptr_t kFreenessThreshold = 50;
 
  if (reduce_memory_footprint_ && over_reserved >= space->AreaSize()) {
    // If reduction of memory footprint was requested, we are aggressive
    // about choosing pages to free.  We expect that half-empty pages
    // are easier to compact so slightly bump the limit.
    mode = REDUCE_MEMORY_FOOTPRINT;
    max_evacuation_candidates += 2;
  }
 
 
  if (over_reserved > reserved / 3 && over_reserved >= 2 * space->AreaSize()) {
    // If over-usage is very high (more than a third of the space), we
    // try to free all mostly empty pages.  We expect that almost empty
    // pages are even easier to compact so bump the limit even more.
    mode = REDUCE_MEMORY_FOOTPRINT;
    max_evacuation_candidates *= 2;
  }
 
  if (FLAG_trace_fragmentation && mode == REDUCE_MEMORY_FOOTPRINT) {
    PrintF(
        "Estimated over reserved memory: %.1f / %.1f MB (threshold %d), "
        "evacuation candidate limit: %d\n",
        static_cast<double>(over_reserved) / MB,
        static_cast<double>(reserved) / MB,
        static_cast<int>(kFreenessThreshold), max_evacuation_candidates);
  }
 
  intptr_t estimated_release = 0;
 
  Candidate candidates[kMaxMaxEvacuationCandidates];
 
  max_evacuation_candidates =
      Min(kMaxMaxEvacuationCandidates, max_evacuation_candidates);
 
  int count = 0;
  int fragmentation = 0;
  Candidate* least = NULL;
 
  PageIterator it(space);
  if (it.has_next()) it.next();  // Never compact the first page.
 
  while (it.has_next()) {
    Page* p = it.next();
    p->ClearEvacuationCandidate();
 
    if (FLAG_stress_compaction) {
      unsigned int counter = space->heap()->ms_count();
      uintptr_t page_number = reinterpret_cast<uintptr_t>(p) >> kPageSizeBits;
      if ((counter & 1) == (page_number & 1)) fragmentation = 1;
    } else if (mode == REDUCE_MEMORY_FOOTPRINT) {
      // Don't try to release too many pages.
      if (estimated_release >= over_reserved) {
        continue;
      }
 
      intptr_t free_bytes = 0;
 
      if (!p->WasSwept()) {
        free_bytes = (p->area_size() - p->LiveBytes());
      } else {
        PagedSpace::SizeStats sizes;
        space->ObtainFreeListStatistics(p, &sizes);
        free_bytes = sizes.Total();
      }
 
      int free_pct = static_cast<int>(free_bytes * 100) / p->area_size();
 
      if (free_pct >= kFreenessThreshold) {
        estimated_release += free_bytes;
        fragmentation = free_pct;
      } else {
        fragmentation = 0;
      }
 
      if (FLAG_trace_fragmentation) {
        PrintF("%p [%s]: %d (%.2f%%) free %s\n", reinterpret_cast<void*>(p),
               AllocationSpaceName(space->identity()),
               static_cast<int>(free_bytes),
               static_cast<double>(free_bytes * 100) / p->area_size(),
               (fragmentation > 0) ? "[fragmented]" : "");
      }
    } else {
      fragmentation = FreeListFragmentation(space, p);
    }
 
    if (fragmentation != 0) {
      if (count < max_evacuation_candidates) {
        candidates[count++] = Candidate(fragmentation, p);
      } else {
        if (least == NULL) {
          for (int i = 0; i < max_evacuation_candidates; i++) {
            if (least == NULL ||
                candidates[i].fragmentation() < least->fragmentation()) {
              least = candidates + i;
            }
          }
        }
        if (least->fragmentation() < fragmentation) {
          *least = Candidate(fragmentation, p);
          least = NULL;
        }
      }
    }
  }
 
  for (int i = 0; i < count; i++) {
    AddEvacuationCandidate(candidates[i].page());
  }
 
  if (count > 0 && FLAG_trace_fragmentation) {
    PrintF("Collected %d evacuation candidates for space %s\n", count,
           AllocationSpaceName(space->identity()));
  }
}

References AddEvacuationCandidate(), v8::internal::AllocationSpaceName(), v8::internal::MemoryChunk::area_size(), v8::internal::MemoryChunk::ClearEvacuationCandidate(), v8::internal::CODE_SPACE, DCHECK, v8::internal::FreeListFragmentation(), kPageSizeBits, v8::internal::MemoryChunk::LiveBytes(), v8::internal::MB, v8::internal::Min(), mode(), NULL, v8::internal::OLD_DATA_SPACE, v8::internal::OLD_POINTER_SPACE, v8::internal::PrintF(), reduce_memory_footprint_, space(), v8::internal::PagedSpace::SizeStats::Total(), and v8::internal::Page::WasSwept().

Referenced by StartCompaction().

Here is the call graph for this function:

Here is the caller graph for this function:

CollectGarbage()

void v8::internal::MarkCompactCollector::CollectGarbage

(

)

Definition at line 389 of file mark-compact.cc.

                                          {
  // Make sure that Prepare() has been called. The individual steps below will
  // update the state as they proceed.
  DCHECK(state_ == PREPARE_GC);
 
  MarkLiveObjects();
  DCHECK(heap_->incremental_marking()->IsStopped());
 
  if (FLAG_collect_maps) ClearNonLiveReferences();
 
  ClearWeakCollections();
 
#ifdef VERIFY_HEAP
  if (FLAG_verify_heap) {
    VerifyMarking(heap_);
  }
#endif
 
  SweepSpaces();
 
#ifdef DEBUG
  if (FLAG_verify_native_context_separation) {
    VerifyNativeContextSeparation(heap_);
  }
#endif
 
#ifdef VERIFY_HEAP
  if (heap()->weak_embedded_objects_verification_enabled()) {
    VerifyWeakEmbeddedObjectsInCode();
  }
  if (FLAG_collect_maps && FLAG_omit_map_checks_for_leaf_maps) {
    VerifyOmittedMapChecks();
  }
#endif
 
  Finish();
 
  if (marking_parity_ == EVEN_MARKING_PARITY) {
    marking_parity_ = ODD_MARKING_PARITY;
  } else {
    DCHECK(marking_parity_ == ODD_MARKING_PARITY);
    marking_parity_ = EVEN_MARKING_PARITY;
  }
}

References ClearNonLiveReferences(), ClearWeakCollections(), DCHECK, v8::internal::EVEN_MARKING_PARITY, Finish(), heap(), heap_, v8::internal::Heap::incremental_marking(), v8::internal::IncrementalMarking::IsStopped(), marking_parity_, MarkLiveObjects(), v8::internal::ODD_MARKING_PARITY, and SweepSpaces().

Referenced by v8::internal::Heap::MarkCompact().

Here is the call graph for this function:

Here is the caller graph for this function:

DiscoverAndEvacuateBlackObjectsOnPage()

int v8::internal::MarkCompactCollector::DiscoverAndEvacuateBlackObjectsOnPage ( NewSpace *  new_space, NewSpacePage *  p  )

private

Definition at line 1947 of file mark-compact.cc.

                                          {
  DCHECK(strcmp(Marking::kWhiteBitPattern, "00") == 0);
  DCHECK(strcmp(Marking::kBlackBitPattern, "10") == 0);
  DCHECK(strcmp(Marking::kGreyBitPattern, "11") == 0);
  DCHECK(strcmp(Marking::kImpossibleBitPattern, "01") == 0);
 
  MarkBit::CellType* cells = p->markbits()->cells();
  int survivors_size = 0;
 
  for (MarkBitCellIterator it(p); !it.Done(); it.Advance()) {
    Address cell_base = it.CurrentCellBase();
    MarkBit::CellType* cell = it.CurrentCell();
 
    MarkBit::CellType current_cell = *cell;
    if (current_cell == 0) continue;
 
    int offset = 0;
    while (current_cell != 0) {
      int trailing_zeros = base::bits::CountTrailingZeros32(current_cell);
      current_cell >>= trailing_zeros;
      offset += trailing_zeros;
      Address address = cell_base + offset * kPointerSize;
      HeapObject* object = HeapObject::FromAddress(address);
 
      int size = object->Size();
      survivors_size += size;
 
      Heap::UpdateAllocationSiteFeedback(object, Heap::RECORD_SCRATCHPAD_SLOT);
 
      offset++;
      current_cell >>= 1;
 
      // TODO(hpayer): Refactor EvacuateObject and call this function instead.
      if (heap()->ShouldBePromoted(object->address(), size) &&
          TryPromoteObject(object, size)) {
        continue;
      }
 
      AllocationResult allocation = new_space->AllocateRaw(size);
      if (allocation.IsRetry()) {
        if (!new_space->AddFreshPage()) {
          // Shouldn't happen. We are sweeping linearly, and to-space
          // has the same number of pages as from-space, so there is
          // always room.
          UNREACHABLE();
        }
        allocation = new_space->AllocateRaw(size);
        DCHECK(!allocation.IsRetry());
      }
      Object* target = allocation.ToObjectChecked();
 
      MigrateObject(HeapObject::cast(target), object, size, NEW_SPACE);
      heap()->IncrementSemiSpaceCopiedObjectSize(size);
    }
    *cells = 0;
  }
  return survivors_size;
}

References v8::internal::NewSpace::AddFreshPage(), v8::internal::HeapObject::address(), v8::base::bits::CountTrailingZeros32(), DCHECK, v8::internal::HeapObject::FromAddress(), heap(), v8::internal::Heap::IncrementSemiSpaceCopiedObjectSize(), v8::internal::AllocationResult::IsRetry(), v8::internal::Marking::kBlackBitPattern, v8::internal::Marking::kGreyBitPattern, v8::internal::Marking::kImpossibleBitPattern, v8::internal::kPointerSize, v8::internal::Marking::kWhiteBitPattern, v8::internal::MemoryChunk::markbits(), MigrateObject(), v8::internal::NEW_SPACE, v8::internal::Heap::RECORD_SCRATCHPAD_SLOT, size, v8::internal::AllocationResult::ToObjectChecked(), TryPromoteObject(), UNREACHABLE, and v8::internal::Heap::UpdateAllocationSiteFeedback().

Referenced by EvacuateNewSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

EmptyMarkingDeque()

void v8::internal::MarkCompactCollector::EmptyMarkingDeque ( )

private

Definition at line 2134 of file mark-compact.cc.

                                             {
  while (!marking_deque_.IsEmpty()) {
    HeapObject* object = marking_deque_.Pop();
    DCHECK(object->IsHeapObject());
    DCHECK(heap()->Contains(object));
    DCHECK(Marking::IsBlack(Marking::MarkBitFrom(object)));
 
    Map* map = object->map();
    MarkBit map_mark = Marking::MarkBitFrom(map);
    MarkObject(map, map_mark);
 
    MarkCompactMarkingVisitor::IterateBody(map, object);
  }
}

References DCHECK, heap(), v8::internal::MarkingDeque::IsEmpty(), map, and marking_deque_.

Referenced by MarkLiveObjects(), v8::internal::RootMarkingVisitor::MarkObjectByPointer(), MarkRoots(), and ProcessMarkingDeque().

Here is the call graph for this function:

Here is the caller graph for this function:

EnableCodeFlushing()

void v8::internal::MarkCompactCollector::EnableCodeFlushing

(

bool

enable

)

Definition at line 4356 of file mark-compact.cc.

                                                         {
  if (isolate()->debug()->is_loaded() ||
      isolate()->debug()->has_break_points()) {
    enable = false;
  }
 
  if (enable) {
    if (code_flusher_ != NULL) return;
    code_flusher_ = new CodeFlusher(isolate());
  } else {
    if (code_flusher_ == NULL) return;
    code_flusher_->EvictAllCandidates();
    delete code_flusher_;
    code_flusher_ = NULL;
  }
 
  if (FLAG_trace_code_flushing) {
    PrintF("[code-flushing is now %s]\n", enable ? "on" : "off");
  }
}

References code_flusher_, v8::internal::CodeFlusher::EvictAllCandidates(), isolate(), NULL, and v8::internal::PrintF().

Referenced by AfterMarking(), v8::internal::Heap::GarbageCollectionPrologue(), and PrepareForCodeFlushing().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureSweepingCompleted()

void v8::internal::MarkCompactCollector::EnsureSweepingCompleted

(

)

Definition at line 574 of file mark-compact.cc.

                                                   {
  DCHECK(sweeping_in_progress_ == true);
 
  // If sweeping is not completed, we try to complete it here. If we do not
  // have sweeper threads we have to complete since we do not have a good
  // indicator for a swept space in that case.
  if (!AreSweeperThreadsActivated() || !IsSweepingCompleted()) {
    SweepInParallel(heap()->paged_space(OLD_DATA_SPACE), 0);
    SweepInParallel(heap()->paged_space(OLD_POINTER_SPACE), 0);
  }
 
  for (int i = 0; i < isolate()->num_sweeper_threads(); i++) {
    isolate()->sweeper_threads()[i]->WaitForSweeperThread();
  }
  if (FLAG_job_based_sweeping) {
    // Wait twice for both jobs.
    pending_sweeper_jobs_semaphore_.Wait();
    pending_sweeper_jobs_semaphore_.Wait();
  }
  ParallelSweepSpacesComplete();
  sweeping_in_progress_ = false;
  RefillFreeList(heap()->paged_space(OLD_DATA_SPACE));
  RefillFreeList(heap()->paged_space(OLD_POINTER_SPACE));
  heap()->paged_space(OLD_DATA_SPACE)->ResetUnsweptFreeBytes();
  heap()->paged_space(OLD_POINTER_SPACE)->ResetUnsweptFreeBytes();
 
#ifdef VERIFY_HEAP
  if (FLAG_verify_heap) {
    VerifyEvacuation(heap_);
  }
#endif
}

References AreSweeperThreadsActivated(), DCHECK, heap(), heap_, isolate(), IsSweepingCompleted(), v8::internal::Isolate::num_sweeper_threads(), v8::internal::OLD_DATA_SPACE, v8::internal::OLD_POINTER_SPACE, v8::internal::Heap::paged_space(), ParallelSweepSpacesComplete(), pending_sweeper_jobs_semaphore_, RefillFreeList(), v8::internal::PagedSpace::ResetUnsweptFreeBytes(), v8::internal::Isolate::sweeper_threads(), sweeping_in_progress_, SweepInParallel(), and v8::internal::SweeperThread::WaitForSweeperThread().

Referenced by v8::internal::Isolate::Deinit(), v8::internal::Heap::IdleNotification(), v8::internal::StoreBuffer::IteratePointersToNewSpace(), v8::internal::Heap::MakeHeapIterable(), Prepare(), v8::internal::IncrementalMarking::Step(), SweepSpaces(), and v8::internal::PagedSpace::WaitForSweeperThreadsAndRetryAllocation().

Here is the call graph for this function:

Here is the caller graph for this function:

EvacuateLiveObjectsFromPage()

void v8::internal::MarkCompactCollector::EvacuateLiveObjectsFromPage ( Page *  p )

private

Definition at line 3122 of file mark-compact.cc.

                                                              {
  AlwaysAllocateScope always_allocate(isolate());
  PagedSpace* space = static_cast<PagedSpace*>(p->owner());
  DCHECK(p->IsEvacuationCandidate() && !p->WasSwept());
  p->SetWasSwept();
 
  int offsets[16];
 
  for (MarkBitCellIterator it(p); !it.Done(); it.Advance()) {
    Address cell_base = it.CurrentCellBase();
    MarkBit::CellType* cell = it.CurrentCell();
 
    if (*cell == 0) continue;
 
    int live_objects = MarkWordToObjectStarts(*cell, offsets);
    for (int i = 0; i < live_objects; i++) {
      Address object_addr = cell_base + offsets[i] * kPointerSize;
      HeapObject* object = HeapObject::FromAddress(object_addr);
      DCHECK(Marking::IsBlack(Marking::MarkBitFrom(object)));
 
      int size = object->Size();
 
      HeapObject* target_object;
      AllocationResult allocation = space->AllocateRaw(size);
      if (!allocation.To(&target_object)) {
        // If allocation failed, use emergency memory and re-try allocation.
        CHECK(space->HasEmergencyMemory());
        space->UseEmergencyMemory();
        allocation = space->AllocateRaw(size);
      }
      if (!allocation.To(&target_object)) {
        // OS refused to give us memory.
        V8::FatalProcessOutOfMemory("Evacuation");
        return;
      }
 
      MigrateObject(target_object, object, size, space->identity());
      DCHECK(object->map_word().IsForwardingAddress());
    }
 
    // Clear marking bits for current cell.
    *cell = 0;
  }
  p->ResetLiveBytes();
}

References CHECK, DCHECK, v8::internal::V8::FatalProcessOutOfMemory(), v8::internal::HeapObject::FromAddress(), v8::internal::MemoryChunk::IsEvacuationCandidate(), isolate(), v8::internal::kPointerSize, v8::internal::HeapObject::map_word(), v8::internal::MarkWordToObjectStarts(), MigrateObject(), v8::internal::MemoryChunk::owner(), v8::internal::MemoryChunk::ResetLiveBytes(), v8::internal::Page::SetWasSwept(), size, space(), v8::internal::AllocationResult::To(), and v8::internal::Page::WasSwept().

Referenced by EvacuatePages().

Here is the call graph for this function:

Here is the caller graph for this function:

EvacuateNewSpace()

void v8::internal::MarkCompactCollector::EvacuateNewSpace ( )

private

Definition at line 3088 of file mark-compact.cc.

                                            {
  // There are soft limits in the allocation code, designed trigger a mark
  // sweep collection by failing allocations.  But since we are already in
  // a mark-sweep allocation, there is no sense in trying to trigger one.
  AlwaysAllocateScope scope(isolate());
 
  NewSpace* new_space = heap()->new_space();
 
  // Store allocation range before flipping semispaces.
  Address from_bottom = new_space->bottom();
  Address from_top = new_space->top();
 
  // Flip the semispaces.  After flipping, to space is empty, from space has
  // live objects.
  new_space->Flip();
  new_space->ResetAllocationInfo();
 
  int survivors_size = 0;
 
  // First pass: traverse all objects in inactive semispace, remove marks,
  // migrate live objects and write forwarding addresses.  This stage puts
  // new entries in the store buffer and may cause some pages to be marked
  // scan-on-scavenge.
  NewSpacePageIterator it(from_bottom, from_top);
  while (it.has_next()) {
    NewSpacePage* p = it.next();
    survivors_size += DiscoverAndEvacuateBlackObjectsOnPage(new_space, p);
  }
 
  heap_->IncrementYoungSurvivorsCounter(survivors_size);
  new_space->set_age_mark(new_space->top());
}

References v8::internal::NewSpace::bottom(), DiscoverAndEvacuateBlackObjectsOnPage(), v8::internal::NewSpace::Flip(), heap(), heap_, v8::internal::Heap::IncrementYoungSurvivorsCounter(), isolate(), v8::internal::Heap::new_space(), v8::internal::NewSpace::ResetAllocationInfo(), v8::internal::NewSpace::set_age_mark(), and v8::internal::NewSpace::top().

Referenced by EvacuateNewSpaceAndCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

EvacuateNewSpaceAndCandidates()

void v8::internal::MarkCompactCollector::EvacuateNewSpaceAndCandidates ( )

private

Definition at line 3508 of file mark-compact.cc.

                                                         {
  Heap::RelocationLock relocation_lock(heap());
 
  bool code_slots_filtering_required;
  {
    GCTracer::Scope gc_scope(heap()->tracer(),
                             GCTracer::Scope::MC_SWEEP_NEWSPACE);
    code_slots_filtering_required = MarkInvalidatedCode();
    EvacuateNewSpace();
  }
 
  {
    GCTracer::Scope gc_scope(heap()->tracer(),
                             GCTracer::Scope::MC_EVACUATE_PAGES);
    EvacuatePages();
  }
 
  // Second pass: find pointers to new space and update them.
  PointersUpdatingVisitor updating_visitor(heap());
 
  {
    GCTracer::Scope gc_scope(heap()->tracer(),
                             GCTracer::Scope::MC_UPDATE_NEW_TO_NEW_POINTERS);
    // Update pointers in to space.
    SemiSpaceIterator to_it(heap()->new_space()->bottom(),
                            heap()->new_space()->top());
    for (HeapObject* object = to_it.Next(); object != NULL;
         object = to_it.Next()) {
      Map* map = object->map();
      object->IterateBody(map->instance_type(), object->SizeFromMap(map),
                          &updating_visitor);
    }
  }
 
  {
    GCTracer::Scope gc_scope(heap()->tracer(),
                             GCTracer::Scope::MC_UPDATE_ROOT_TO_NEW_POINTERS);
    // Update roots.
    heap_->IterateRoots(&updating_visitor, VISIT_ALL_IN_SWEEP_NEWSPACE);
  }
 
  {
    GCTracer::Scope gc_scope(heap()->tracer(),
                             GCTracer::Scope::MC_UPDATE_OLD_TO_NEW_POINTERS);
    StoreBufferRebuildScope scope(heap_, heap_->store_buffer(),
                                  &Heap::ScavengeStoreBufferCallback);
    heap_->store_buffer()->IteratePointersToNewSpaceAndClearMaps(
        &UpdatePointer);
  }
 
  {
    GCTracer::Scope gc_scope(heap()->tracer(),
                             GCTracer::Scope::MC_UPDATE_POINTERS_TO_EVACUATED);
    SlotsBuffer::UpdateSlotsRecordedIn(heap_, migration_slots_buffer_,
                                       code_slots_filtering_required);
    if (FLAG_trace_fragmentation) {
      PrintF("  migration slots buffer: %d\n",
             SlotsBuffer::SizeOfChain(migration_slots_buffer_));
    }
 
    if (compacting_ && was_marked_incrementally_) {
      // It's difficult to filter out slots recorded for large objects.
      LargeObjectIterator it(heap_->lo_space());
      for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
        // LargeObjectSpace is not swept yet thus we have to skip
        // dead objects explicitly.
        if (!IsMarked(obj)) continue;
 
        Page* p = Page::FromAddress(obj->address());
        if (p->IsFlagSet(Page::RESCAN_ON_EVACUATION)) {
          obj->Iterate(&updating_visitor);
          p->ClearFlag(Page::RESCAN_ON_EVACUATION);
        }
      }
    }
  }
 
  int npages = evacuation_candidates_.length();
  {
    GCTracer::Scope gc_scope(
        heap()->tracer(),
        GCTracer::Scope::MC_UPDATE_POINTERS_BETWEEN_EVACUATED);
    for (int i = 0; i < npages; i++) {
      Page* p = evacuation_candidates_[i];
      DCHECK(p->IsEvacuationCandidate() ||
             p->IsFlagSet(Page::RESCAN_ON_EVACUATION));
 
      if (p->IsEvacuationCandidate()) {
        SlotsBuffer::UpdateSlotsRecordedIn(heap_, p->slots_buffer(),
                                           code_slots_filtering_required);
        if (FLAG_trace_fragmentation) {
          PrintF("  page %p slots buffer: %d\n", reinterpret_cast<void*>(p),
                 SlotsBuffer::SizeOfChain(p->slots_buffer()));
        }
 
        // Important: skip list should be cleared only after roots were updated
        // because root iteration traverses the stack and might have to find
        // code objects from non-updated pc pointing into evacuation candidate.
        SkipList* list = p->skip_list();
        if (list != NULL) list->Clear();
      } else {
        if (FLAG_gc_verbose) {
          PrintF("Sweeping 0x%" V8PRIxPTR " during evacuation.\n",
                 reinterpret_cast<intptr_t>(p));
        }
        PagedSpace* space = static_cast<PagedSpace*>(p->owner());
        p->ClearFlag(MemoryChunk::RESCAN_ON_EVACUATION);
 
        switch (space->identity()) {
          case OLD_DATA_SPACE:
            Sweep<SWEEP_AND_VISIT_LIVE_OBJECTS, SWEEP_ON_MAIN_THREAD,
                  IGNORE_SKIP_LIST, IGNORE_FREE_SPACE>(space, NULL, p,
                                                       &updating_visitor);
            break;
          case OLD_POINTER_SPACE:
            Sweep<SWEEP_AND_VISIT_LIVE_OBJECTS, SWEEP_ON_MAIN_THREAD,
                  IGNORE_SKIP_LIST, IGNORE_FREE_SPACE>(space, NULL, p,
                                                       &updating_visitor);
            break;
          case CODE_SPACE:
            if (FLAG_zap_code_space) {
              Sweep<SWEEP_AND_VISIT_LIVE_OBJECTS, SWEEP_ON_MAIN_THREAD,
                    REBUILD_SKIP_LIST, ZAP_FREE_SPACE>(space, NULL, p,
                                                       &updating_visitor);
            } else {
              Sweep<SWEEP_AND_VISIT_LIVE_OBJECTS, SWEEP_ON_MAIN_THREAD,
                    REBUILD_SKIP_LIST, IGNORE_FREE_SPACE>(space, NULL, p,
                                                          &updating_visitor);
            }
            break;
          default:
            UNREACHABLE();
            break;
        }
      }
    }
  }
 
  GCTracer::Scope gc_scope(heap()->tracer(),
                           GCTracer::Scope::MC_UPDATE_MISC_POINTERS);
 
  // Update pointers from cells.
  HeapObjectIterator cell_iterator(heap_->cell_space());
  for (HeapObject* cell = cell_iterator.Next(); cell != NULL;
       cell = cell_iterator.Next()) {
    if (cell->IsCell()) {
      Cell::BodyDescriptor::IterateBody(cell, &updating_visitor);
    }
  }
 
  HeapObjectIterator js_global_property_cell_iterator(
      heap_->property_cell_space());
  for (HeapObject* cell = js_global_property_cell_iterator.Next(); cell != NULL;
       cell = js_global_property_cell_iterator.Next()) {
    if (cell->IsPropertyCell()) {
      PropertyCell::BodyDescriptor::IterateBody(cell, &updating_visitor);
    }
  }
 
  heap_->string_table()->Iterate(&updating_visitor);
  updating_visitor.VisitPointer(heap_->weak_object_to_code_table_address());
  if (heap_->weak_object_to_code_table()->IsHashTable()) {
    WeakHashTable* table =
        WeakHashTable::cast(heap_->weak_object_to_code_table());
    table->Iterate(&updating_visitor);
    table->Rehash(heap_->isolate()->factory()->undefined_value());
  }
 
  // Update pointers from external string table.
  heap_->UpdateReferencesInExternalStringTable(
      &UpdateReferenceInExternalStringTableEntry);
 
  EvacuationWeakObjectRetainer evacuation_object_retainer;
  heap()->ProcessWeakReferences(&evacuation_object_retainer);
 
  // Visit invalidated code (we ignored all slots on it) and clear mark-bits
  // under it.
  ProcessInvalidatedCode(&updating_visitor);
 
  heap_->isolate()->inner_pointer_to_code_cache()->Flush();
 
  slots_buffer_allocator_.DeallocateChain(&migration_slots_buffer_);
  DCHECK(migration_slots_buffer_ == NULL);
}

References v8::internal::HeapObject::address(), v8::internal::Heap::cell_space(), v8::internal::SkipList::Clear(), v8::internal::MemoryChunk::ClearFlag(), v8::internal::CODE_SPACE, compacting_, DCHECK, v8::internal::SlotsBufferAllocator::DeallocateChain(), EvacuateNewSpace(), EvacuatePages(), evacuation_candidates_, v8::internal::Isolate::factory(), v8::internal::InnerPointerToCodeCache::Flush(), v8::internal::MemoryChunk::FromAddress(), heap(), heap_, v8::internal::IGNORE_FREE_SPACE, v8::internal::IGNORE_SKIP_LIST, v8::internal::Isolate::inner_pointer_to_code_cache(), v8::internal::MemoryChunk::IsEvacuationCandidate(), v8::internal::MemoryChunk::IsFlagSet(), IsMarked(), v8::internal::Heap::isolate(), v8::internal::HeapObject::Iterate(), v8::internal::FixedBodyDescriptor< start_offset, end_offset, size >::IterateBody(), v8::internal::StoreBuffer::IteratePointersToNewSpaceAndClearMaps(), v8::internal::Heap::IterateRoots(), v8::internal::Heap::lo_space(), map, MarkInvalidatedCode(), v8::internal::GCTracer::Scope::MC_EVACUATE_PAGES, v8::internal::GCTracer::Scope::MC_SWEEP_NEWSPACE, v8::internal::GCTracer::Scope::MC_UPDATE_MISC_POINTERS, v8::internal::GCTracer::Scope::MC_UPDATE_NEW_TO_NEW_POINTERS, v8::internal::GCTracer::Scope::MC_UPDATE_OLD_TO_NEW_POINTERS, v8::internal::GCTracer::Scope::MC_UPDATE_POINTERS_BETWEEN_EVACUATED, v8::internal::GCTracer::Scope::MC_UPDATE_POINTERS_TO_EVACUATED, v8::internal::GCTracer::Scope::MC_UPDATE_ROOT_TO_NEW_POINTERS, migration_slots_buffer_, v8::internal::HeapObjectIterator::Next(), v8::internal::SemiSpaceIterator::Next(), v8::internal::LargeObjectIterator::Next(), NULL, v8::internal::OLD_DATA_SPACE, v8::internal::OLD_POINTER_SPACE, v8::internal::MemoryChunk::owner(), v8::internal::PrintF(), ProcessInvalidatedCode(), v8::internal::Heap::ProcessWeakReferences(), v8::internal::Heap::property_cell_space(), v8::internal::REBUILD_SKIP_LIST, v8::internal::HashTable< Derived, Shape, Key >::Rehash(), v8::internal::MemoryChunk::RESCAN_ON_EVACUATION, v8::internal::Heap::ScavengeStoreBufferCallback(), v8::internal::SlotsBuffer::SizeOfChain(), v8::internal::MemoryChunk::skip_list(), v8::internal::MemoryChunk::slots_buffer(), slots_buffer_allocator_, space(), v8::internal::Heap::store_buffer(), v8::internal::Sweep(), v8::internal::SWEEP_AND_VISIT_LIVE_OBJECTS, SWEEP_ON_MAIN_THREAD, UNREACHABLE, v8::internal::UpdatePointer(), v8::internal::UpdateReferenceInExternalStringTableEntry(), v8::internal::Heap::UpdateReferencesInExternalStringTable(), v8::internal::SlotsBuffer::UpdateSlotsRecordedIn(), V8PRIxPTR, v8::internal::VISIT_ALL_IN_SWEEP_NEWSPACE, v8::internal::PointersUpdatingVisitor::VisitPointer(), was_marked_incrementally_, v8::internal::Heap::weak_object_to_code_table(), v8::internal::Heap::weak_object_to_code_table_address(), and v8::internal::ZAP_FREE_SPACE.

Referenced by SweepSpaces().

Here is the call graph for this function:

Here is the caller graph for this function:

EvacuatePages()

void v8::internal::MarkCompactCollector::EvacuatePages ( )

private

Definition at line 3169 of file mark-compact.cc.

                                         {
  int npages = evacuation_candidates_.length();
  for (int i = 0; i < npages; i++) {
    Page* p = evacuation_candidates_[i];
    DCHECK(p->IsEvacuationCandidate() ||
           p->IsFlagSet(Page::RESCAN_ON_EVACUATION));
    DCHECK(static_cast<int>(p->parallel_sweeping()) ==
           MemoryChunk::SWEEPING_DONE);
    PagedSpace* space = static_cast<PagedSpace*>(p->owner());
    // Allocate emergency memory for the case when compaction fails due to out
    // of memory.
    if (!space->HasEmergencyMemory()) {
      space->CreateEmergencyMemory();
    }
    if (p->IsEvacuationCandidate()) {
      // During compaction we might have to request a new page. Check that we
      // have an emergency page and the space still has room for that.
      if (space->HasEmergencyMemory() && space->CanExpand()) {
        EvacuateLiveObjectsFromPage(p);
      } else {
        // Without room for expansion evacuation is not guaranteed to succeed.
        // Pessimistically abandon unevacuated pages.
        for (int j = i; j < npages; j++) {
          Page* page = evacuation_candidates_[j];
          slots_buffer_allocator_.DeallocateChain(page->slots_buffer_address());
          page->ClearEvacuationCandidate();
          page->SetFlag(Page::RESCAN_ON_EVACUATION);
        }
        break;
      }
    }
  }
  if (npages > 0) {
    // Release emergency memory.
    PagedSpaces spaces(heap());
    for (PagedSpace* space = spaces.next(); space != NULL;
         space = spaces.next()) {
      if (space->HasEmergencyMemory()) {
        space->FreeEmergencyMemory();
      }
    }
  }
}

References v8::internal::MemoryChunk::ClearEvacuationCandidate(), DCHECK, v8::internal::SlotsBufferAllocator::DeallocateChain(), EvacuateLiveObjectsFromPage(), evacuation_candidates_, heap(), v8::internal::MemoryChunk::IsEvacuationCandidate(), v8::internal::MemoryChunk::IsFlagSet(), NULL, v8::internal::MemoryChunk::owner(), v8::internal::MemoryChunk::parallel_sweeping(), v8::internal::MemoryChunk::RESCAN_ON_EVACUATION, v8::internal::MemoryChunk::SetFlag(), v8::internal::MemoryChunk::slots_buffer_address(), slots_buffer_allocator_, space(), and v8::internal::MemoryChunk::SWEEPING_DONE.

Referenced by EvacuateNewSpaceAndCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

Finish()

void v8::internal::MarkCompactCollector::Finish ( )

private

Definition at line 979 of file mark-compact.cc.

                                  {
#ifdef DEBUG
  DCHECK(state_ == SWEEP_SPACES || state_ == RELOCATE_OBJECTS);
  state_ = IDLE;
#endif
  // The stub cache is not traversed during GC; clear the cache to
  // force lazy re-initialization of it. This must be done after the
  // GC, because it relies on the new address of certain old space
  // objects (empty string, illegal builtin).
  isolate()->stub_cache()->Clear();
 
  if (have_code_to_deoptimize_) {
    // Some code objects were marked for deoptimization during the GC.
    Deoptimizer::DeoptimizeMarkedCode(isolate());
    have_code_to_deoptimize_ = false;
  }
}

References v8::internal::StubCache::Clear(), DCHECK, v8::internal::Deoptimizer::DeoptimizeMarkedCode(), have_code_to_deoptimize_, v8::internal::IDLE, isolate(), and v8::internal::Isolate::stub_cache().

Referenced by CollectGarbage().

Here is the call graph for this function:

Here is the caller graph for this function:

heap()

Heap* v8::internal::MarkCompactCollector::heap ( ) const

inline

Definition at line 542 of file mark-compact.h.

{ return heap_; }

References heap_.

Referenced by AbortWeakCollections(), AfterMarking(), ClearDependentICList(), ClearNonLiveDependentCodeInGroup(), ClearNonLiveReferences(), ClearWeakCollections(), CollectGarbage(), DiscoverAndEvacuateBlackObjectsOnPage(), EmptyMarkingDeque(), EnsureSweepingCompleted(), EvacuateNewSpace(), EvacuateNewSpaceAndCandidates(), EvacuatePages(), v8::internal::MarkCompactMarkingVisitor::INLINE(), MarkLiveObjects(), MarkRoots(), MarkStringTable(), MarkWeakObjectToCodeTable(), MigrateObject(), ParallelSweepSpacesComplete(), Prepare(), PrepareForCodeFlushing(), PrepareThreadForCodeFlushing(), ProcessMapCaches(), ProcessWeakCollections(), RecordCodeTargetPatch(), RefillFreeList(), RefillMarkingDeque(), ReleaseEvacuationCandidates(), StartCompaction(), StartSweeperThreads(), SweepInParallel(), SweepSpace(), SweepSpaces(), and TryPromoteObject().

Here is the caller graph for this function:

Initialize()

void v8::internal::MarkCompactCollector::Initialize ( )

static

Definition at line 4392 of file mark-compact.cc.

                                      {
  MarkCompactMarkingVisitor::Initialize();
  IncrementalMarking::Initialize();
}

References v8::internal::IncrementalMarking::Initialize(), and v8::internal::MarkCompactMarkingVisitor::Initialize().

Referenced by v8::internal::InitializeGCOnce().

Here is the call graph for this function:

Here is the caller graph for this function:

INLINE() [1/7]

v8::internal::MarkCompactCollector::INLINE ( static bool   IsOnEvacuationCandidateObject *obj )

inline

Definition at line 575 of file mark-compact.h.

                                                           {
    return Page::FromAddress(reinterpret_cast<Address>(obj))
        ->IsEvacuationCandidate();
  }

References v8::internal::MemoryChunk::FromAddress(), and v8::internal::MemoryChunk::IsEvacuationCandidate().

Here is the call graph for this function:

INLINE() [2/7]

v8::internal::MarkCompactCollector::INLINE ( static bool   ShouldSkipEvacuationSlotRecordingObject **anchor )

inline

Definition at line 565 of file mark-compact.h.

                                                                         {
    return Page::FromAddress(reinterpret_cast<Address>(anchor))
        ->ShouldSkipEvacuationSlotRecording();
  }

References v8::internal::MemoryChunk::FromAddress(), and v8::internal::MemoryChunk::ShouldSkipEvacuationSlotRecording().

Here is the call graph for this function:

INLINE() [3/7]

v8::internal::MarkCompactCollector::INLINE ( static bool   ShouldSkipEvacuationSlotRecordingObject *host )

inline

Definition at line 570 of file mark-compact.h.

                                                                      {
    return Page::FromAddress(reinterpret_cast<Address>(host))
        ->ShouldSkipEvacuationSlotRecording();
  }

References v8::internal::MemoryChunk::FromAddress(), and v8::internal::MemoryChunk::ShouldSkipEvacuationSlotRecording().

Here is the call graph for this function:

INLINE() [4/7]

v8::internal::MarkCompactCollector::INLINE ( void   EvictEvacuationCandidatePage *page )

inline

Definition at line 580 of file mark-compact.h.

                                                    {
    if (FLAG_trace_fragmentation) {
      PrintF("Page %p is too popular. Disabling evacuation.\n",
             reinterpret_cast<void*>(page));
    }
 
    // TODO(gc) If all evacuation candidates are too popular we
    // should stop slots recording entirely.
    page->ClearEvacuationCandidate();
 
    // We were not collecting slots on this page that point
    // to other evacuation candidates thus we have to
    // rescan the page after evacuation to discover and update all
    // pointers to evacuated objects.
    if (page->owner()->identity() == OLD_DATA_SPACE) {
      evacuation_candidates_.RemoveElement(page);
    } else {
      page->SetFlag(Page::RESCAN_ON_EVACUATION);
    }
  }

References v8::internal::MemoryChunk::ClearEvacuationCandidate(), evacuation_candidates_, v8::internal::Space::identity(), v8::internal::OLD_DATA_SPACE, v8::internal::MemoryChunk::owner(), v8::internal::PrintF(), v8::internal::MemoryChunk::RESCAN_ON_EVACUATION, and v8::internal::MemoryChunk::SetFlag().

Here is the call graph for this function:

INLINE() [5/7]

v8::internal::MarkCompactCollector::INLINE ( void   MarkObjectHeapObject *obj, MarkBit mark_bit )

private

INLINE() [6/7]

v8::internal::MarkCompactCollector::INLINE

(

void

RecordSlotObject **anchor_slot, Object **slot, Object *object, SlotsBuffer::AdditionMode mode=SlotsBuffer::FAIL_ON_OVERFLOW

)

INLINE() [7/7]

v8::internal::MarkCompactCollector::INLINE ( void   SetMarkHeapObject *obj, MarkBit mark_bit )

private

InvalidateCode()

void v8::internal::MarkCompactCollector::InvalidateCode

(

Code *

code

)

Definition at line 3451 of file mark-compact.cc.

                                                    {
  if (heap_->incremental_marking()->IsCompacting() &&
      !ShouldSkipEvacuationSlotRecording(code)) {
    DCHECK(compacting_);
 
    // If the object is white than no slots were recorded on it yet.
    MarkBit mark_bit = Marking::MarkBitFrom(code);
    if (Marking::IsWhite(mark_bit)) return;
 
    invalidated_code_.Add(code);
  }
}

References compacting_, DCHECK, heap_, v8::internal::Heap::incremental_marking(), invalidated_code_, and v8::internal::IncrementalMarking::IsCompacting().

Referenced by v8::internal::Deoptimizer::DeoptimizeMarkedCodeForContext().

Here is the call graph for this function:

Here is the caller graph for this function:

is_code_flushing_enabled()

bool v8::internal::MarkCompactCollector::is_code_flushing_enabled ( ) const

inline

Definition at line 546 of file mark-compact.h.

{ return code_flusher_ != NULL; }

References code_flusher_, and NULL.

Referenced by AfterMarking(), PrepareForCodeFlushing(), v8::internal::Heap::Scavenge(), and v8::internal::MarkCompactMarkingVisitor::VisitRegExpAndFlushCode().

Here is the caller graph for this function:

is_compacting()

bool v8::internal::MarkCompactCollector::is_compacting ( ) const

inline

Definition at line 620 of file mark-compact.h.

{ return compacting_; }

References compacting_.

Referenced by v8::internal::MustRecordSlots(), and RecordCodeTargetPatch().

Here is the caller graph for this function:

IsMarked()

bool v8::internal::MarkCompactCollector::IsMarked ( Object *  obj )

inlinestatic

Definition at line 50 of file mark-compact-inl.h.

                                               {
  DCHECK(obj->IsHeapObject());
  HeapObject* heap_object = HeapObject::cast(obj);
  return Marking::MarkBitFrom(heap_object).Get();
}

References DCHECK.

Referenced by ClearDependentCode(), ClearDependentICList(), ClearNonLiveDependentCodeInGroup(), ClearNonLivePrototypeTransitions(), ClearNonLiveReferences(), ClearWeakCollections(), EvacuateNewSpaceAndCandidates(), v8::internal::MarkCompactMarkingVisitor::INLINE(), MarkImplicitRefGroups(), MarkLiveObjects(), MarkWeakObjectToCodeTable(), ProcessMapCaches(), ProcessWeakCollections(), and RemoveDeadInvalidatedCode().

Here is the caller graph for this function:

isolate()

Isolate * v8::internal::MarkCompactCollector::isolate ( ) const

inline

Definition at line 4389 of file mark-compact.cc.

{ return heap_->isolate(); }

References heap_, and v8::internal::Heap::isolate().

Referenced by AreSweeperThreadsActivated(), EnableCodeFlushing(), EnsureSweepingCompleted(), EvacuateLiveObjectsFromPage(), EvacuateNewSpace(), Finish(), IsSweepingCompleted(), MarkImplicitRefGroups(), MarkLiveObjects(), MigrateObject(), PrepareForCodeFlushing(), PrepareThreadForCodeFlushing(), ProcessEphemeralMarking(), ProcessTopOptimizedFrame(), RecordCodeTargetPatch(), ReportDeleteIfNeeded(), and StartSweeperThreads().

Here is the call graph for this function:

Here is the caller graph for this function:

IsSweepingCompleted()

bool v8::internal::MarkCompactCollector::IsSweepingCompleted

(

)

Definition at line 608 of file mark-compact.cc.

                                               {
  for (int i = 0; i < isolate()->num_sweeper_threads(); i++) {
    if (!isolate()->sweeper_threads()[i]->SweepingCompleted()) {
      return false;
    }
  }
 
  if (FLAG_job_based_sweeping) {
    if (!pending_sweeper_jobs_semaphore_.WaitFor(
            base::TimeDelta::FromSeconds(0))) {
      return false;
    }
    pending_sweeper_jobs_semaphore_.Signal();
  }
 
  return true;
}

References isolate(), v8::internal::Isolate::num_sweeper_threads(), pending_sweeper_jobs_semaphore_, v8::internal::Isolate::sweeper_threads(), and v8::internal::SweeperThread::SweepingCompleted().

Referenced by EnsureSweepingCompleted(), and v8::internal::IncrementalMarking::Step().

Here is the call graph for this function:

Here is the caller graph for this function:

IsUnmarkedHeapObject()

bool v8::internal::MarkCompactCollector::IsUnmarkedHeapObject ( Object **  p )

staticprivate

Definition at line 2031 of file mark-compact.cc.

                                                          {
  Object* o = *p;
  if (!o->IsHeapObject()) return false;
  HeapObject* heap_object = HeapObject::cast(o);
  MarkBit mark = Marking::MarkBitFrom(heap_object);
  return !mark.Get();
}

References v8::internal::MarkBit::Get().

Referenced by MarkLiveObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

IsUnmarkedHeapObjectWithHeap()

bool v8::internal::MarkCompactCollector::IsUnmarkedHeapObjectWithHeap ( Heap *  heap, Object **  p  )

staticprivate

Definition at line 2040 of file mark-compact.cc.

                                                                    {
  Object* o = *p;
  DCHECK(o->IsHeapObject());
  HeapObject* heap_object = HeapObject::cast(o);
  MarkBit mark = Marking::MarkBitFrom(heap_object);
  return !mark.Get();
}

References DCHECK, and v8::internal::MarkBit::Get().

Referenced by ProcessEphemeralMarking().

Here is the call graph for this function:

Here is the caller graph for this function:

MarkAllocationSite()

void v8::internal::MarkCompactCollector::MarkAllocationSite

(

AllocationSite *

site

)

Definition at line 2064 of file mark-compact.cc.

                                                                  {
  MarkBit mark_bit = Marking::MarkBitFrom(site);
  SetMark(site, mark_bit);
}

Referenced by v8::internal::MarkCompactWeakObjectRetainer::RetainAs().

Here is the caller graph for this function:

MarkImplicitRefGroups()

void v8::internal::MarkCompactCollector::MarkImplicitRefGroups ( )

private

Definition at line 2088 of file mark-compact.cc.

                                                 {
  List<ImplicitRefGroup*>* ref_groups =
      isolate()->global_handles()->implicit_ref_groups();
 
  int last = 0;
  for (int i = 0; i < ref_groups->length(); i++) {
    ImplicitRefGroup* entry = ref_groups->at(i);
    DCHECK(entry != NULL);
 
    if (!IsMarked(*entry->parent)) {
      (*ref_groups)[last++] = entry;
      continue;
    }
 
    Object*** children = entry->children;
    // A parent object is marked, so mark all child heap objects.
    for (size_t j = 0; j < entry->length; ++j) {
      if ((*children[j])->IsHeapObject()) {
        HeapObject* child = HeapObject::cast(*children[j]);
        MarkBit mark = Marking::MarkBitFrom(child);
        MarkObject(child, mark);
      }
    }
 
    // Once the entire group has been marked, dispose it because it's
    // not needed anymore.
    delete entry;
  }
  ref_groups->Rewind(last);
}

References v8::internal::List< T, AllocationPolicy >::at(), v8::internal::ImplicitRefGroup::children, DCHECK, v8::internal::Isolate::global_handles(), v8::internal::GlobalHandles::implicit_ref_groups(), IsMarked(), isolate(), v8::internal::ImplicitRefGroup::length, NULL, and v8::internal::ImplicitRefGroup::parent.

Referenced by ProcessEphemeralMarking().

Here is the call graph for this function:

Here is the caller graph for this function:

marking_parity()

MarkingParity v8::internal::MarkCompactCollector::marking_parity ( )

inline

Definition at line 622 of file mark-compact.h.

{ return marking_parity_; }

References marking_parity_.

MarkInvalidatedCode()

bool v8::internal::MarkCompactCollector::MarkInvalidatedCode ( )

private

Definition at line 3471 of file mark-compact.cc.

                                               {
  bool code_marked = false;
 
  int length = invalidated_code_.length();
  for (int i = 0; i < length; i++) {
    Code* code = invalidated_code_[i];
 
    if (SetMarkBitsUnderInvalidatedCode(code, true)) {
      code_marked = true;
    }
  }
 
  return code_marked;
}

References invalidated_code_, and v8::internal::SetMarkBitsUnderInvalidatedCode().

Referenced by EvacuateNewSpaceAndCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

MarkLiveObjects()

void v8::internal::MarkCompactCollector::MarkLiveObjects ( )

private

Definition at line 2236 of file mark-compact.cc.

                                           {
  GCTracer::Scope gc_scope(heap()->tracer(), GCTracer::Scope::MC_MARK);
  double start_time = 0.0;
  if (FLAG_print_cumulative_gc_stat) {
    start_time = base::OS::TimeCurrentMillis();
  }
  // The recursive GC marker detects when it is nearing stack overflow,
  // and switches to a different marking system.  JS interrupts interfere
  // with the C stack limit check.
  PostponeInterruptsScope postpone(isolate());
 
  bool incremental_marking_overflowed = false;
  IncrementalMarking* incremental_marking = heap_->incremental_marking();
  if (was_marked_incrementally_) {
    // Finalize the incremental marking and check whether we had an overflow.
    // Both markers use grey color to mark overflowed objects so
    // non-incremental marker can deal with them as if overflow
    // occured during normal marking.
    // But incremental marker uses a separate marking deque
    // so we have to explicitly copy its overflow state.
    incremental_marking->Finalize();
    incremental_marking_overflowed =
        incremental_marking->marking_deque()->overflowed();
    incremental_marking->marking_deque()->ClearOverflowed();
  } else {
    // Abort any pending incremental activities e.g. incremental sweeping.
    incremental_marking->Abort();
  }
 
#ifdef DEBUG
  DCHECK(state_ == PREPARE_GC);
  state_ = MARK_LIVE_OBJECTS;
#endif
  // The to space contains live objects, a page in from space is used as a
  // marking stack.
  Address marking_deque_start = heap()->new_space()->FromSpacePageLow();
  Address marking_deque_end = heap()->new_space()->FromSpacePageHigh();
  if (FLAG_force_marking_deque_overflows) {
    marking_deque_end = marking_deque_start + 64 * kPointerSize;
  }
  marking_deque_.Initialize(marking_deque_start, marking_deque_end);
  DCHECK(!marking_deque_.overflowed());
 
  if (incremental_marking_overflowed) {
    // There are overflowed objects left in the heap after incremental marking.
    marking_deque_.SetOverflowed();
  }
 
  PrepareForCodeFlushing();
 
  if (was_marked_incrementally_) {
    // There is no write barrier on cells so we have to scan them now at the end
    // of the incremental marking.
    {
      HeapObjectIterator cell_iterator(heap()->cell_space());
      HeapObject* cell;
      while ((cell = cell_iterator.Next()) != NULL) {
        DCHECK(cell->IsCell());
        if (IsMarked(cell)) {
          int offset = Cell::kValueOffset;
          MarkCompactMarkingVisitor::VisitPointer(
              heap(), reinterpret_cast<Object**>(cell->address() + offset));
        }
      }
    }
    {
      HeapObjectIterator js_global_property_cell_iterator(
          heap()->property_cell_space());
      HeapObject* cell;
      while ((cell = js_global_property_cell_iterator.Next()) != NULL) {
        DCHECK(cell->IsPropertyCell());
        if (IsMarked(cell)) {
          MarkCompactMarkingVisitor::VisitPropertyCell(cell->map(), cell);
        }
      }
    }
  }
 
  RootMarkingVisitor root_visitor(heap());
  MarkRoots(&root_visitor);
 
  ProcessTopOptimizedFrame(&root_visitor);
 
  // The objects reachable from the roots are marked, yet unreachable
  // objects are unmarked.  Mark objects reachable due to host
  // application specific logic or through Harmony weak maps.
  ProcessEphemeralMarking(&root_visitor);
 
  // The objects reachable from the roots, weak maps or object groups
  // are marked, yet unreachable objects are unmarked.  Mark objects
  // reachable only from weak global handles.
  //
  // First we identify nonlive weak handles and mark them as pending
  // destruction.
  heap()->isolate()->global_handles()->IdentifyWeakHandles(
      &IsUnmarkedHeapObject);
  // Then we mark the objects and process the transitive closure.
  heap()->isolate()->global_handles()->IterateWeakRoots(&root_visitor);
  while (marking_deque_.overflowed()) {
    RefillMarkingDeque();
    EmptyMarkingDeque();
  }
 
  // Repeat host application specific and Harmony weak maps marking to
  // mark unmarked objects reachable from the weak roots.
  ProcessEphemeralMarking(&root_visitor);
 
  AfterMarking();
 
  if (FLAG_print_cumulative_gc_stat) {
    heap_->tracer()->AddMarkingTime(base::OS::TimeCurrentMillis() - start_time);
  }
}

References v8::internal::IncrementalMarking::Abort(), v8::internal::GCTracer::AddMarkingTime(), v8::internal::HeapObject::address(), AfterMarking(), v8::internal::MarkingDeque::ClearOverflowed(), DCHECK, EmptyMarkingDeque(), v8::internal::IncrementalMarking::Finalize(), v8::internal::NewSpace::FromSpacePageHigh(), v8::internal::NewSpace::FromSpacePageLow(), v8::internal::Isolate::global_handles(), heap(), heap_, v8::internal::GlobalHandles::IdentifyWeakHandles(), v8::internal::Heap::incremental_marking(), v8::internal::MarkingDeque::Initialize(), IsMarked(), v8::internal::Heap::isolate(), isolate(), IsUnmarkedHeapObject(), v8::internal::GlobalHandles::IterateWeakRoots(), v8::internal::kPointerSize, v8::internal::Cell::kValueOffset, v8::internal::HeapObject::map(), v8::internal::IncrementalMarking::marking_deque(), marking_deque_, MarkRoots(), v8::internal::GCTracer::Scope::MC_MARK, v8::internal::Heap::new_space(), v8::internal::HeapObjectIterator::Next(), NULL, v8::internal::MarkingDeque::overflowed(), PrepareForCodeFlushing(), ProcessEphemeralMarking(), ProcessTopOptimizedFrame(), RefillMarkingDeque(), v8::internal::MarkingDeque::SetOverflowed(), v8::base::OS::TimeCurrentMillis(), v8::internal::Heap::tracer(), and was_marked_incrementally_.

Referenced by CollectGarbage().

Here is the call graph for this function:

Here is the caller graph for this function:

MarkRoots()

void v8::internal::MarkCompactCollector::MarkRoots ( RootMarkingVisitor *  visitor )

private

Definition at line 2070 of file mark-compact.cc.

                                                                {
  // Mark the heap roots including global variables, stack variables,
  // etc., and all objects reachable from them.
  heap()->IterateStrongRoots(visitor, VISIT_ONLY_STRONG);
 
  // Handle the string table specially.
  MarkStringTable(visitor);
 
  MarkWeakObjectToCodeTable();
 
  // There may be overflowed objects in the heap.  Visit them now.
  while (marking_deque_.overflowed()) {
    RefillMarkingDeque();
    EmptyMarkingDeque();
  }
}

References EmptyMarkingDeque(), heap(), v8::internal::Heap::IterateStrongRoots(), marking_deque_, MarkStringTable(), MarkWeakObjectToCodeTable(), v8::internal::MarkingDeque::overflowed(), RefillMarkingDeque(), and v8::internal::VISIT_ONLY_STRONG.

Referenced by MarkLiveObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

MarkStringTable()

void v8::internal::MarkCompactCollector::MarkStringTable ( RootMarkingVisitor *  visitor )

private

Definition at line 2050 of file mark-compact.cc.

                                                                      {
  StringTable* string_table = heap()->string_table();
  // Mark the string table itself.
  MarkBit string_table_mark = Marking::MarkBitFrom(string_table);
  if (!string_table_mark.Get()) {
    // String table could have already been marked by visiting the handles list.
    SetMark(string_table, string_table_mark);
  }
  // Explicitly mark the prefix.
  string_table->IteratePrefix(visitor);
  ProcessMarkingDeque();
}

References v8::internal::MarkBit::Get(), heap(), v8::internal::HashTable< Derived, Shape, Key >::IteratePrefix(), and ProcessMarkingDeque().

Referenced by MarkRoots().

Here is the call graph for this function:

Here is the caller graph for this function:

MarkWeakObjectToCodeTable()

void v8::internal::MarkCompactCollector::MarkWeakObjectToCodeTable

(

)

Definition at line 2120 of file mark-compact.cc.

                                                     {
  HeapObject* weak_object_to_code_table =
      HeapObject::cast(heap()->weak_object_to_code_table());
  if (!IsMarked(weak_object_to_code_table)) {
    MarkBit mark = Marking::MarkBitFrom(weak_object_to_code_table);
    SetMark(weak_object_to_code_table, mark);
  }
}

References heap(), and IsMarked().

Referenced by MarkRoots(), and v8::internal::IncrementalMarking::StartMarking().

Here is the call graph for this function:

Here is the caller graph for this function:

MigrateObject()

void v8::internal::MarkCompactCollector::MigrateObject	(	HeapObject *	dst,
		HeapObject *	src,
		int	size,
		AllocationSpace	to_old_space
	)

Definition at line 2885 of file mark-compact.cc.

                                                                         {
  Address dst_addr = dst->address();
  Address src_addr = src->address();
  DCHECK(heap()->AllowedToBeMigrated(src, dest));
  DCHECK(dest != LO_SPACE && size <= Page::kMaxRegularHeapObjectSize);
  if (dest == OLD_POINTER_SPACE) {
    Address src_slot = src_addr;
    Address dst_slot = dst_addr;
    DCHECK(IsAligned(size, kPointerSize));
 
    for (int remaining = size / kPointerSize; remaining > 0; remaining--) {
      Object* value = Memory::Object_at(src_slot);
 
      Memory::Object_at(dst_slot) = value;
 
      if (!src->MayContainRawValues()) {
        RecordMigratedSlot(value, dst_slot);
      }
 
      src_slot += kPointerSize;
      dst_slot += kPointerSize;
    }
 
    if (compacting_ && dst->IsJSFunction()) {
      Address code_entry_slot = dst_addr + JSFunction::kCodeEntryOffset;
      Address code_entry = Memory::Address_at(code_entry_slot);
 
      if (Page::FromAddress(code_entry)->IsEvacuationCandidate()) {
        SlotsBuffer::AddTo(&slots_buffer_allocator_, &migration_slots_buffer_,
                           SlotsBuffer::CODE_ENTRY_SLOT, code_entry_slot,
                           SlotsBuffer::IGNORE_OVERFLOW);
      }
    } else if (dst->IsConstantPoolArray()) {
      // We special case ConstantPoolArrays since they could contain integers
      // value entries which look like tagged pointers.
      // TODO(mstarzinger): restructure this code to avoid this special-casing.
      ConstantPoolArray* array = ConstantPoolArray::cast(dst);
      ConstantPoolArray::Iterator code_iter(array, ConstantPoolArray::CODE_PTR);
      while (!code_iter.is_finished()) {
        Address code_entry_slot =
            dst_addr + array->OffsetOfElementAt(code_iter.next_index());
        Address code_entry = Memory::Address_at(code_entry_slot);
 
        if (Page::FromAddress(code_entry)->IsEvacuationCandidate()) {
          SlotsBuffer::AddTo(&slots_buffer_allocator_, &migration_slots_buffer_,
                             SlotsBuffer::CODE_ENTRY_SLOT, code_entry_slot,
                             SlotsBuffer::IGNORE_OVERFLOW);
        }
      }
      ConstantPoolArray::Iterator heap_iter(array, ConstantPoolArray::HEAP_PTR);
      while (!heap_iter.is_finished()) {
        Address heap_slot =
            dst_addr + array->OffsetOfElementAt(heap_iter.next_index());
        Object* value = Memory::Object_at(heap_slot);
        RecordMigratedSlot(value, heap_slot);
      }
    }
  } else if (dest == CODE_SPACE) {
    PROFILE(isolate(), CodeMoveEvent(src_addr, dst_addr));
    heap()->MoveBlock(dst_addr, src_addr, size);
    SlotsBuffer::AddTo(&slots_buffer_allocator_, &migration_slots_buffer_,
                       SlotsBuffer::RELOCATED_CODE_OBJECT, dst_addr,
                       SlotsBuffer::IGNORE_OVERFLOW);
    Code::cast(dst)->Relocate(dst_addr - src_addr);
  } else {
    DCHECK(dest == OLD_DATA_SPACE || dest == NEW_SPACE);
    heap()->MoveBlock(dst_addr, src_addr, size);
  }
  heap()->OnMoveEvent(dst, src, size);
  Memory::Address_at(src_addr) = dst_addr;
}

References v8::internal::HeapObject::address(), v8::internal::Memory::Address_at(), v8::internal::SlotsBuffer::AddTo(), v8::internal::SlotsBuffer::CODE_ENTRY_SLOT, v8::internal::ConstantPoolArray::CODE_PTR, v8::internal::CODE_SPACE, compacting_, DCHECK, v8::internal::MemoryChunk::FromAddress(), heap(), v8::internal::ConstantPoolArray::HEAP_PTR, v8::internal::SlotsBuffer::IGNORE_OVERFLOW, v8::internal::IsAligned(), isolate(), v8::internal::JSFunction::kCodeEntryOffset, v8::internal::Page::kMaxRegularHeapObjectSize, v8::internal::kPointerSize, v8::internal::LO_SPACE, v8::internal::HeapObject::MayContainRawValues(), migration_slots_buffer_, v8::internal::Heap::MoveBlock(), v8::internal::NEW_SPACE, v8::internal::Memory::Object_at(), v8::internal::ConstantPoolArray::OffsetOfElementAt(), v8::internal::OLD_DATA_SPACE, v8::internal::OLD_POINTER_SPACE, v8::internal::Heap::OnMoveEvent(), PROFILE, RecordMigratedSlot(), v8::internal::SlotsBuffer::RELOCATED_CODE_OBJECT, size, and slots_buffer_allocator_.

Referenced by DiscoverAndEvacuateBlackObjectsOnPage(), EvacuateLiveObjectsFromPage(), and TryPromoteObject().

Here is the call graph for this function:

Here is the caller graph for this function:

MoveEvacuationCandidatesToEndOfPagesList()

void v8::internal::MarkCompactCollector::MoveEvacuationCandidatesToEndOfPagesList ( )

private

Definition at line 3694 of file mark-compact.cc.

                                                                    {
  int npages = evacuation_candidates_.length();
  for (int i = 0; i < npages; i++) {
    Page* p = evacuation_candidates_[i];
    if (!p->IsEvacuationCandidate()) continue;
    p->Unlink();
    PagedSpace* space = static_cast<PagedSpace*>(p->owner());
    p->InsertAfter(space->LastPage());
  }
}

References evacuation_candidates_, v8::internal::MemoryChunk::InsertAfter(), v8::internal::MemoryChunk::IsEvacuationCandidate(), v8::internal::MemoryChunk::owner(), space(), and v8::internal::MemoryChunk::Unlink().

Referenced by SweepSpaces().

Here is the call graph for this function:

Here is the caller graph for this function:

ParallelSweepSpaceComplete()

void v8::internal::MarkCompactCollector::ParallelSweepSpaceComplete ( PagedSpace *  space )

private

Definition at line 4337 of file mark-compact.cc.

                                                                       {
  PageIterator it(space);
  while (it.has_next()) {
    Page* p = it.next();
    if (p->parallel_sweeping() == MemoryChunk::SWEEPING_FINALIZE) {
      p->set_parallel_sweeping(MemoryChunk::SWEEPING_DONE);
      p->SetWasSwept();
    }
    DCHECK(p->parallel_sweeping() == MemoryChunk::SWEEPING_DONE);
  }
}

References DCHECK, v8::internal::MemoryChunk::parallel_sweeping(), v8::internal::MemoryChunk::set_parallel_sweeping(), v8::internal::Page::SetWasSwept(), space(), v8::internal::MemoryChunk::SWEEPING_DONE, and v8::internal::MemoryChunk::SWEEPING_FINALIZE.

Referenced by ParallelSweepSpacesComplete().

Here is the call graph for this function:

Here is the caller graph for this function:

ParallelSweepSpacesComplete()

void v8::internal::MarkCompactCollector::ParallelSweepSpacesComplete ( )

private

Definition at line 4350 of file mark-compact.cc.

                                                       {
  ParallelSweepSpaceComplete(heap()->old_pointer_space());
  ParallelSweepSpaceComplete(heap()->old_data_space());
}

References heap(), and ParallelSweepSpaceComplete().

Referenced by EnsureSweepingCompleted().

Here is the call graph for this function:

Here is the caller graph for this function:

Prepare()

void v8::internal::MarkCompactCollector::Prepare

(

)

Definition at line 935 of file mark-compact.cc.

                                   {
  was_marked_incrementally_ = heap()->incremental_marking()->IsMarking();
 
#ifdef DEBUG
  DCHECK(state_ == IDLE);
  state_ = PREPARE_GC;
#endif
 
  DCHECK(!FLAG_never_compact || !FLAG_always_compact);
 
  if (sweeping_in_progress()) {
    // Instead of waiting we could also abort the sweeper threads here.
    EnsureSweepingCompleted();
  }
 
  // Clear marking bits if incremental marking is aborted.
  if (was_marked_incrementally_ && abort_incremental_marking_) {
    heap()->incremental_marking()->Abort();
    ClearMarkbits();
    AbortWeakCollections();
    AbortCompaction();
    was_marked_incrementally_ = false;
  }
 
  // Don't start compaction if we are in the middle of incremental
  // marking cycle. We did not collect any slots.
  if (!FLAG_never_compact && !was_marked_incrementally_) {
    StartCompaction(NON_INCREMENTAL_COMPACTION);
  }
 
  PagedSpaces spaces(heap());
  for (PagedSpace* space = spaces.next(); space != NULL;
       space = spaces.next()) {
    space->PrepareForMarkCompact();
  }
 
#ifdef VERIFY_HEAP
  if (!was_marked_incrementally_ && FLAG_verify_heap) {
    VerifyMarkbitsAreClean();
  }
#endif
}

References v8::internal::IncrementalMarking::Abort(), abort_incremental_marking_, AbortCompaction(), AbortWeakCollections(), ClearMarkbits(), DCHECK, EnsureSweepingCompleted(), heap(), v8::internal::IDLE, v8::internal::Heap::incremental_marking(), NON_INCREMENTAL_COMPACTION, NULL, space(), StartCompaction(), sweeping_in_progress(), and was_marked_incrementally_.

Referenced by v8::internal::Heap::MarkCompact().

Here is the call graph for this function:

Here is the caller graph for this function:

PrepareForCodeFlushing()

void v8::internal::MarkCompactCollector::PrepareForCodeFlushing ( )

private

Definition at line 1736 of file mark-compact.cc.

                                                  {
  // Enable code flushing for non-incremental cycles.
  if (FLAG_flush_code && !FLAG_flush_code_incrementally) {
    EnableCodeFlushing(!was_marked_incrementally_);
  }
 
  // If code flushing is disabled, there is no need to prepare for it.
  if (!is_code_flushing_enabled()) return;
 
  // Ensure that empty descriptor array is marked. Method MarkDescriptorArray
  // relies on it being marked before any other descriptor array.
  HeapObject* descriptor_array = heap()->empty_descriptor_array();
  MarkBit descriptor_array_mark = Marking::MarkBitFrom(descriptor_array);
  MarkObject(descriptor_array, descriptor_array_mark);
 
  // Make sure we are not referencing the code from the stack.
  DCHECK(this == heap()->mark_compact_collector());
  PrepareThreadForCodeFlushing(heap()->isolate(),
                               heap()->isolate()->thread_local_top());
 
  // Iterate the archived stacks in all threads to check if
  // the code is referenced.
  CodeMarkingVisitor code_marking_visitor(this);
  heap()->isolate()->thread_manager()->IterateArchivedThreads(
      &code_marking_visitor);
 
  SharedFunctionInfoMarkingVisitor visitor(this);
  heap()->isolate()->compilation_cache()->IterateFunctions(&visitor);
  heap()->isolate()->handle_scope_implementer()->Iterate(&visitor);
 
  ProcessMarkingDeque();
}

References v8::internal::Isolate::compilation_cache(), DCHECK, EnableCodeFlushing(), v8::internal::Isolate::handle_scope_implementer(), heap(), is_code_flushing_enabled(), v8::internal::Heap::isolate(), isolate(), v8::internal::HandleScopeImplementer::Iterate(), v8::internal::ThreadManager::IterateArchivedThreads(), v8::internal::CompilationCache::IterateFunctions(), PrepareThreadForCodeFlushing(), ProcessMarkingDeque(), v8::internal::Isolate::thread_manager(), and was_marked_incrementally_.

Referenced by MarkLiveObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

PrepareThreadForCodeFlushing()

void v8::internal::MarkCompactCollector::PrepareThreadForCodeFlushing ( Isolate *  isolate, ThreadLocalTop *  top  )

private

Definition at line 1717 of file mark-compact.cc.

                                                                             {
  for (StackFrameIterator it(isolate, top); !it.done(); it.Advance()) {
    // Note: for the frame that has a pending lazy deoptimization
    // StackFrame::unchecked_code will return a non-optimized code object for
    // the outermost function and StackFrame::LookupCode will return
    // actual optimized code object.
    StackFrame* frame = it.frame();
    Code* code = frame->unchecked_code();
    MarkBit code_mark = Marking::MarkBitFrom(code);
    MarkObject(code, code_mark);
    if (frame->is_optimized()) {
      MarkCompactMarkingVisitor::MarkInlinedFunctionsCode(heap(),
                                                          frame->LookupCode());
    }
  }
}

References v8::internal::StackFrameIterator::Advance(), heap(), isolate(), and v8::internal::StaticMarkingVisitor< MarkCompactMarkingVisitor >::MarkInlinedFunctionsCode().

Referenced by PrepareForCodeFlushing(), and v8::internal::CodeMarkingVisitor::VisitThread().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessEphemeralMarking()

void v8::internal::MarkCompactCollector::ProcessEphemeralMarking ( ObjectVisitor *  visitor )

private

Definition at line 2204 of file mark-compact.cc.

                                                                         {
  bool work_to_do = true;
  DCHECK(marking_deque_.IsEmpty());
  while (work_to_do) {
    isolate()->global_handles()->IterateObjectGroups(
        visitor, &IsUnmarkedHeapObjectWithHeap);
    MarkImplicitRefGroups();
    ProcessWeakCollections();
    work_to_do = !marking_deque_.IsEmpty();
    ProcessMarkingDeque();
  }
}

References DCHECK, v8::internal::Isolate::global_handles(), v8::internal::MarkingDeque::IsEmpty(), isolate(), IsUnmarkedHeapObjectWithHeap(), v8::internal::GlobalHandles::IterateObjectGroups(), MarkImplicitRefGroups(), marking_deque_, ProcessMarkingDeque(), and ProcessWeakCollections().

Referenced by MarkLiveObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessInvalidatedCode()

void v8::internal::MarkCompactCollector::ProcessInvalidatedCode ( ObjectVisitor *  visitor )

private

Definition at line 3495 of file mark-compact.cc.

                                                                        {
  int length = invalidated_code_.length();
  for (int i = 0; i < length; i++) {
    Code* code = invalidated_code_[i];
    if (code != NULL) {
      code->Iterate(visitor);
      SetMarkBitsUnderInvalidatedCode(code, false);
    }
  }
  invalidated_code_.Rewind(0);
}

References invalidated_code_, v8::internal::HeapObject::Iterate(), NULL, and v8::internal::SetMarkBitsUnderInvalidatedCode().

Referenced by EvacuateNewSpaceAndCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessMapCaches()

void v8::internal::MarkCompactCollector::ProcessMapCaches ( )

private

Definition at line 2394 of file mark-compact.cc.

                                            {
  Object* raw_context = heap()->native_contexts_list();
  while (raw_context != heap()->undefined_value()) {
    Context* context = reinterpret_cast<Context*>(raw_context);
    if (IsMarked(context)) {
      HeapObject* raw_map_cache =
          HeapObject::cast(context->get(Context::MAP_CACHE_INDEX));
      // A map cache may be reachable from the stack. In this case
      // it's already transitively marked and it's too late to clean
      // up its parts.
      if (!IsMarked(raw_map_cache) &&
          raw_map_cache != heap()->undefined_value()) {
        MapCache* map_cache = reinterpret_cast<MapCache*>(raw_map_cache);
        int existing_elements = map_cache->NumberOfElements();
        int used_elements = 0;
        for (int i = MapCache::kElementsStartIndex; i < map_cache->length();
             i += MapCache::kEntrySize) {
          Object* raw_key = map_cache->get(i);
          if (raw_key == heap()->undefined_value() ||
              raw_key == heap()->the_hole_value())
            continue;
          STATIC_ASSERT(MapCache::kEntrySize == 2);
          Object* raw_map = map_cache->get(i + 1);
          if (raw_map->IsHeapObject() && IsMarked(raw_map)) {
            ++used_elements;
          } else {
            // Delete useless entries with unmarked maps.
            DCHECK(raw_map->IsMap());
            map_cache->set_the_hole(i);
            map_cache->set_the_hole(i + 1);
          }
        }
        if (used_elements == 0) {
          context->set(Context::MAP_CACHE_INDEX, heap()->undefined_value());
        } else {
          // Note: we don't actually shrink the cache here to avoid
          // extra complexity during GC. We rely on subsequent cache
          // usages (EnsureCapacity) to do this.
          map_cache->ElementsRemoved(existing_elements - used_elements);
          MarkBit map_cache_markbit = Marking::MarkBitFrom(map_cache);
          MarkObject(map_cache, map_cache_markbit);
        }
      }
    }
    // Move to next element in the list.
    raw_context = context->get(Context::NEXT_CONTEXT_LINK);
  }
  ProcessMarkingDeque();
}

References DCHECK, v8::internal::HashTable< Derived, Shape, Key >::ElementsRemoved(), v8::internal::FixedArray::get(), heap(), IsMarked(), v8::internal::HashTable< MapCache, MapCacheShape, HashTableKey * >::kElementsStartIndex, v8::internal::HashTable< MapCache, MapCacheShape, HashTableKey * >::kEntrySize, v8::internal::FixedArrayBase::length(), v8::internal::Context::MAP_CACHE_INDEX, v8::internal::Heap::native_contexts_list(), v8::internal::Context::NEXT_CONTEXT_LINK, v8::internal::HashTable< Derived, Shape, Key >::NumberOfElements(), ProcessMarkingDeque(), v8::internal::FixedArray::set(), v8::internal::FixedArray::set_the_hole(), and v8::internal::STATIC_ASSERT().

Referenced by AfterMarking().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessMarkingDeque()

void v8::internal::MarkCompactCollector::ProcessMarkingDeque ( )

private

Definition at line 2193 of file mark-compact.cc.

                                               {
  EmptyMarkingDeque();
  while (marking_deque_.overflowed()) {
    RefillMarkingDeque();
    EmptyMarkingDeque();
  }
}

References EmptyMarkingDeque(), marking_deque_, v8::internal::MarkingDeque::overflowed(), and RefillMarkingDeque().

Referenced by MarkStringTable(), PrepareForCodeFlushing(), ProcessEphemeralMarking(), ProcessMapCaches(), and ProcessTopOptimizedFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessTopOptimizedFrame()

void v8::internal::MarkCompactCollector::ProcessTopOptimizedFrame ( ObjectVisitor *  visitor )

private

Definition at line 2218 of file mark-compact.cc.

                                                                          {
  for (StackFrameIterator it(isolate(), isolate()->thread_local_top());
       !it.done(); it.Advance()) {
    if (it.frame()->type() == StackFrame::JAVA_SCRIPT) {
      return;
    }
    if (it.frame()->type() == StackFrame::OPTIMIZED) {
      Code* code = it.frame()->LookupCode();
      if (!code->CanDeoptAt(it.frame()->pc())) {
        code->CodeIterateBody(visitor);
      }
      ProcessMarkingDeque();
      return;
    }
  }
}

References v8::internal::StackFrameIterator::Advance(), v8::internal::Code::CanDeoptAt(), v8::internal::Code::CodeIterateBody(), isolate(), and ProcessMarkingDeque().

Referenced by MarkLiveObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessWeakCollections()

void v8::internal::MarkCompactCollector::ProcessWeakCollections ( )

private

Definition at line 2794 of file mark-compact.cc.

                                                  {
  GCTracer::Scope gc_scope(heap()->tracer(),
                           GCTracer::Scope::MC_WEAKCOLLECTION_PROCESS);
  Object* weak_collection_obj = heap()->encountered_weak_collections();
  while (weak_collection_obj != Smi::FromInt(0)) {
    JSWeakCollection* weak_collection =
        reinterpret_cast<JSWeakCollection*>(weak_collection_obj);
    DCHECK(MarkCompactCollector::IsMarked(weak_collection));
    if (weak_collection->table()->IsHashTable()) {
      ObjectHashTable* table = ObjectHashTable::cast(weak_collection->table());
      Object** anchor = reinterpret_cast<Object**>(table->address());
      for (int i = 0; i < table->Capacity(); i++) {
        if (MarkCompactCollector::IsMarked(HeapObject::cast(table->KeyAt(i)))) {
          Object** key_slot =
              table->RawFieldOfElementAt(ObjectHashTable::EntryToIndex(i));
          RecordSlot(anchor, key_slot, *key_slot);
          Object** value_slot =
              table->RawFieldOfElementAt(ObjectHashTable::EntryToValueIndex(i));
          MarkCompactMarkingVisitor::MarkObjectByPointer(this, anchor,
                                                         value_slot);
        }
      }
    }
    weak_collection_obj = weak_collection->next();
  }
}

References v8::internal::HeapObject::address(), v8::internal::HashTable< Derived, Shape, Key >::Capacity(), DCHECK, v8::internal::Heap::encountered_weak_collections(), v8::internal::HashTable< ObjectHashTable, ObjectHashTableShape, Handle< Object > >::EntryToIndex(), v8::internal::ObjectHashTable::EntryToValueIndex(), v8::internal::Smi::FromInt(), heap(), IsMarked(), v8::internal::HashTable< Derived, Shape, Key >::KeyAt(), v8::internal::GCTracer::Scope::MC_WEAKCOLLECTION_PROCESS, and v8::internal::FixedArray::RawFieldOfElementAt().

Referenced by ProcessEphemeralMarking().

Here is the call graph for this function:

Here is the caller graph for this function:

RecordCodeEntrySlot()

void v8::internal::MarkCompactCollector::RecordCodeEntrySlot	(	Address	slot,
		Code *	target
	)

Definition at line 4468 of file mark-compact.cc.

                                                                         {
  Page* target_page = Page::FromAddress(reinterpret_cast<Address>(target));
  if (target_page->IsEvacuationCandidate() &&
      !ShouldSkipEvacuationSlotRecording(reinterpret_cast<Object**>(slot))) {
    if (!SlotsBuffer::AddTo(&slots_buffer_allocator_,
                            target_page->slots_buffer_address(),
                            SlotsBuffer::CODE_ENTRY_SLOT, slot,
                            SlotsBuffer::FAIL_ON_OVERFLOW)) {
      EvictEvacuationCandidate(target_page);
    }
  }
}

References v8::internal::SlotsBuffer::AddTo(), v8::internal::SlotsBuffer::CODE_ENTRY_SLOT, v8::internal::SlotsBuffer::FAIL_ON_OVERFLOW, v8::internal::MemoryChunk::FromAddress(), v8::internal::MemoryChunk::IsEvacuationCandidate(), v8::internal::MemoryChunk::slots_buffer_address(), and slots_buffer_allocator_.

Referenced by v8::internal::CodeFlusher::ProcessJSFunctionCandidates(), and v8::internal::IncrementalMarking::RecordWriteOfCodeEntrySlow().

Here is the call graph for this function:

Here is the caller graph for this function:

RecordCodeTargetPatch()

void v8::internal::MarkCompactCollector::RecordCodeTargetPatch	(	Address	pc,
		Code *	target
	)

Definition at line 4482 of file mark-compact.cc.

                                                                         {
  DCHECK(heap()->gc_state() == Heap::MARK_COMPACT);
  if (is_compacting()) {
    Code* host =
        isolate()->inner_pointer_to_code_cache()->GcSafeFindCodeForInnerPointer(
            pc);
    MarkBit mark_bit = Marking::MarkBitFrom(host);
    if (Marking::IsBlack(mark_bit)) {
      RelocInfo rinfo(pc, RelocInfo::CODE_TARGET, 0, host);
      RecordRelocSlot(&rinfo, target);
    }
  }
}

References v8::internal::RelocInfo::CODE_TARGET, DCHECK, v8::internal::InnerPointerToCodeCache::GcSafeFindCodeForInnerPointer(), heap(), v8::internal::Isolate::inner_pointer_to_code_cache(), is_compacting(), isolate(), v8::internal::Heap::MARK_COMPACT, v8::internal::pc, and RecordRelocSlot().

Referenced by v8::internal::IC::SetTargetAtAddress().

Here is the call graph for this function:

Here is the caller graph for this function:

RecordMigratedSlot()

void v8::internal::MarkCompactCollector::RecordMigratedSlot ( Object *  value, Address  slot  )

private

Definition at line 2860 of file mark-compact.cc.

                                                                         {
  if (heap_->InNewSpace(value)) {
    heap_->store_buffer()->Mark(slot);
  } else if (value->IsHeapObject() && IsOnEvacuationCandidate(value)) {
    SlotsBuffer::AddTo(&slots_buffer_allocator_, &migration_slots_buffer_,
                       reinterpret_cast<Object**>(slot),
                       SlotsBuffer::IGNORE_OVERFLOW);
  }
}

References v8::internal::SlotsBuffer::AddTo(), heap_, v8::internal::SlotsBuffer::IGNORE_OVERFLOW, v8::internal::Heap::InNewSpace(), v8::internal::StoreBuffer::Mark(), migration_slots_buffer_, slots_buffer_allocator_, and v8::internal::Heap::store_buffer().

Referenced by MigrateObject().

Here is the call graph for this function:

Here is the caller graph for this function:

RecordRelocSlot()

void v8::internal::MarkCompactCollector::RecordRelocSlot	(	RelocInfo *	rinfo,
		Object *	target
	)

Definition at line 4437 of file mark-compact.cc.

                                                                           {
  Page* target_page = Page::FromAddress(reinterpret_cast<Address>(target));
  RelocInfo::Mode rmode = rinfo->rmode();
  if (target_page->IsEvacuationCandidate() &&
      (rinfo->host() == NULL ||
       !ShouldSkipEvacuationSlotRecording(rinfo->host()))) {
    bool success;
    if (RelocInfo::IsEmbeddedObject(rmode) && rinfo->IsInConstantPool()) {
      // This doesn't need to be typed since it is just a normal heap pointer.
      Object** target_pointer =
          reinterpret_cast<Object**>(rinfo->constant_pool_entry_address());
      success = SlotsBuffer::AddTo(
          &slots_buffer_allocator_, target_page->slots_buffer_address(),
          target_pointer, SlotsBuffer::FAIL_ON_OVERFLOW);
    } else if (RelocInfo::IsCodeTarget(rmode) && rinfo->IsInConstantPool()) {
      success = SlotsBuffer::AddTo(
          &slots_buffer_allocator_, target_page->slots_buffer_address(),
          SlotsBuffer::CODE_ENTRY_SLOT, rinfo->constant_pool_entry_address(),
          SlotsBuffer::FAIL_ON_OVERFLOW);
    } else {
      success = SlotsBuffer::AddTo(
          &slots_buffer_allocator_, target_page->slots_buffer_address(),
          SlotTypeForRMode(rmode), rinfo->pc(), SlotsBuffer::FAIL_ON_OVERFLOW);
    }
    if (!success) {
      EvictEvacuationCandidate(target_page);
    }
  }
}

References v8::internal::SlotsBuffer::AddTo(), v8::internal::SlotsBuffer::CODE_ENTRY_SLOT, v8::internal::SlotsBuffer::FAIL_ON_OVERFLOW, v8::internal::MemoryChunk::FromAddress(), v8::internal::RelocInfo::host(), v8::internal::RelocInfo::IsCodeTarget(), v8::internal::RelocInfo::IsEmbeddedObject(), v8::internal::MemoryChunk::IsEvacuationCandidate(), v8::internal::RelocInfo::IsInConstantPool(), NULL, v8::internal::RelocInfo::pc(), v8::internal::RelocInfo::rmode(), v8::internal::MemoryChunk::slots_buffer_address(), slots_buffer_allocator_, and v8::internal::SlotTypeForRMode().

Referenced by RecordCodeTargetPatch(), and v8::internal::IncrementalMarking::RecordWriteIntoCodeSlow().

Here is the call graph for this function:

Here is the caller graph for this function:

RefillFreeList()

void v8::internal::MarkCompactCollector::RefillFreeList

(

PagedSpace *

space

)

Definition at line 627 of file mark-compact.cc.

                                                           {
  FreeList* free_list;
 
  if (space == heap()->old_pointer_space()) {
    free_list = free_list_old_pointer_space_.get();
  } else if (space == heap()->old_data_space()) {
    free_list = free_list_old_data_space_.get();
  } else {
    // Any PagedSpace might invoke RefillFreeLists, so we need to make sure
    // to only refill them for old data and pointer spaces.
    return;
  }
 
  intptr_t freed_bytes = space->free_list()->Concatenate(free_list);
  space->AddToAccountingStats(freed_bytes);
  space->DecrementUnsweptFreeBytes(freed_bytes);
}

References free_list_old_data_space_, free_list_old_pointer_space_, heap(), and space().

Referenced by EnsureSweepingCompleted(), and v8::internal::PagedSpace::SlowAllocateRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

RefillMarkingDeque()

void v8::internal::MarkCompactCollector::RefillMarkingDeque ( )

private

Definition at line 2155 of file mark-compact.cc.

                                              {
  DCHECK(marking_deque_.overflowed());
 
  DiscoverGreyObjectsInNewSpace(heap(), &marking_deque_);
  if (marking_deque_.IsFull()) return;
 
  DiscoverGreyObjectsInSpace(heap(), &marking_deque_,
                             heap()->old_pointer_space());
  if (marking_deque_.IsFull()) return;
 
  DiscoverGreyObjectsInSpace(heap(), &marking_deque_, heap()->old_data_space());
  if (marking_deque_.IsFull()) return;
 
  DiscoverGreyObjectsInSpace(heap(), &marking_deque_, heap()->code_space());
  if (marking_deque_.IsFull()) return;
 
  DiscoverGreyObjectsInSpace(heap(), &marking_deque_, heap()->map_space());
  if (marking_deque_.IsFull()) return;
 
  DiscoverGreyObjectsInSpace(heap(), &marking_deque_, heap()->cell_space());
  if (marking_deque_.IsFull()) return;
 
  DiscoverGreyObjectsInSpace(heap(), &marking_deque_,
                             heap()->property_cell_space());
  if (marking_deque_.IsFull()) return;
 
  LargeObjectIterator lo_it(heap()->lo_space());
  DiscoverGreyObjectsWithIterator(heap(), &marking_deque_, &lo_it);
  if (marking_deque_.IsFull()) return;
 
  marking_deque_.ClearOverflowed();
}

References v8::internal::MarkingDeque::ClearOverflowed(), DCHECK, v8::internal::DiscoverGreyObjectsInNewSpace(), v8::internal::DiscoverGreyObjectsInSpace(), v8::internal::DiscoverGreyObjectsWithIterator(), heap(), v8::internal::MarkingDeque::IsFull(), marking_deque_, and v8::internal::MarkingDeque::overflowed().

Referenced by MarkLiveObjects(), MarkRoots(), and ProcessMarkingDeque().

Here is the call graph for this function:

Here is the caller graph for this function:

ReleaseEvacuationCandidates()

void v8::internal::MarkCompactCollector::ReleaseEvacuationCandidates ( )

private

Definition at line 3706 of file mark-compact.cc.

                                                       {
  int npages = evacuation_candidates_.length();
  for (int i = 0; i < npages; i++) {
    Page* p = evacuation_candidates_[i];
    if (!p->IsEvacuationCandidate()) continue;
    PagedSpace* space = static_cast<PagedSpace*>(p->owner());
    space->Free(p->area_start(), p->area_size());
    p->set_scan_on_scavenge(false);
    slots_buffer_allocator_.DeallocateChain(p->slots_buffer_address());
    p->ResetLiveBytes();
    space->ReleasePage(p);
  }
  evacuation_candidates_.Rewind(0);
  compacting_ = false;
  heap()->FreeQueuedChunks();
}

References v8::internal::MemoryChunk::area_size(), v8::internal::MemoryChunk::area_start(), compacting_, v8::internal::SlotsBufferAllocator::DeallocateChain(), evacuation_candidates_, v8::internal::Heap::FreeQueuedChunks(), heap(), v8::internal::MemoryChunk::IsEvacuationCandidate(), v8::internal::MemoryChunk::owner(), v8::internal::MemoryChunk::ResetLiveBytes(), v8::internal::MemoryChunk::set_scan_on_scavenge(), v8::internal::MemoryChunk::slots_buffer_address(), slots_buffer_allocator_, and space().

Referenced by SweepSpaces().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveDeadInvalidatedCode()

void v8::internal::MarkCompactCollector::RemoveDeadInvalidatedCode ( )

private

Definition at line 3487 of file mark-compact.cc.

                                                     {
  int length = invalidated_code_.length();
  for (int i = 0; i < length; i++) {
    if (!IsMarked(invalidated_code_[i])) invalidated_code_[i] = NULL;
  }
}

References invalidated_code_, IsMarked(), and NULL.

Referenced by SweepSpaces().

Here is the call graph for this function:

Here is the caller graph for this function:

ReportDeleteIfNeeded()

void v8::internal::MarkCompactCollector::ReportDeleteIfNeeded ( HeapObject *  obj, Isolate *  isolate  )

static

Definition at line 4381 of file mark-compact.cc.

                                                                  {
  if (obj->IsCode()) {
    PROFILE(isolate, CodeDeleteEvent(obj->address()));
  }
}

References v8::internal::HeapObject::address(), isolate(), and PROFILE.

Referenced by v8::internal::LargeObjectSpace::FreeUnmarkedObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

sequential_sweeping()

bool v8::internal::MarkCompactCollector::sequential_sweeping ( ) const

inline

Definition at line 653 of file mark-compact.h.

{ return sequential_sweeping_; }

References sequential_sweeping_.

Referenced by set_sequential_sweeping().

Here is the caller graph for this function:

set_sequential_sweeping()

void v8::internal::MarkCompactCollector::set_sequential_sweeping ( bool  sequential_sweeping )

inline

Definition at line 649 of file mark-compact.h.

                                                         {
    sequential_sweeping_ = sequential_sweeping;
  }

References sequential_sweeping(), and sequential_sweeping_.

Here is the call graph for this function:

SetFlags()

void v8::internal::MarkCompactCollector::SetFlags ( int  flags )

inline

Definition at line 23 of file mark-compact-inl.h.

                                             {
  reduce_memory_footprint_ = ((flags & Heap::kReduceMemoryFootprintMask) != 0);
  abort_incremental_marking_ =
      ((flags & Heap::kAbortIncrementalMarkingMask) != 0);
}

References abort_incremental_marking_, v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::Heap::kAbortIncrementalMarkingMask, v8::internal::Heap::kReduceMemoryFootprintMask, and reduce_memory_footprint_.

Referenced by v8::internal::AbortIncrementalMarkingAndCollectGarbage(), v8::internal::Heap::CollectAllAvailableGarbage(), and v8::internal::Heap::CollectAllGarbage().

Here is the caller graph for this function:

SetUp()

void v8::internal::MarkCompactCollector::SetUp

(

)

Definition at line 328 of file mark-compact.cc.

                                 {
  free_list_old_data_space_.Reset(new FreeList(heap_->old_data_space()));
  free_list_old_pointer_space_.Reset(new FreeList(heap_->old_pointer_space()));
}

References free_list_old_data_space_, free_list_old_pointer_space_, heap_, v8::internal::Heap::old_data_space(), and v8::internal::Heap::old_pointer_space().

Referenced by v8::internal::Heap::SetUp().

Here is the call graph for this function:

Here is the caller graph for this function:

StartCompaction()

bool v8::internal::MarkCompactCollector::StartCompaction

(

CompactionMode

mode

)

Definition at line 353 of file mark-compact.cc.

                                                              {
  if (!compacting_) {
    DCHECK(evacuation_candidates_.length() == 0);
 
#ifdef ENABLE_GDB_JIT_INTERFACE
    // If GDBJIT interface is active disable compaction.
    if (FLAG_gdbjit) return false;
#endif
 
    CollectEvacuationCandidates(heap()->old_pointer_space());
    CollectEvacuationCandidates(heap()->old_data_space());
 
    if (FLAG_compact_code_space && (mode == NON_INCREMENTAL_COMPACTION ||
                                    FLAG_incremental_code_compaction)) {
      CollectEvacuationCandidates(heap()->code_space());
    } else if (FLAG_trace_fragmentation) {
      TraceFragmentation(heap()->code_space());
    }
 
    if (FLAG_trace_fragmentation) {
      TraceFragmentation(heap()->map_space());
      TraceFragmentation(heap()->cell_space());
      TraceFragmentation(heap()->property_cell_space());
    }
 
    heap()->old_pointer_space()->EvictEvacuationCandidatesFromFreeLists();
    heap()->old_data_space()->EvictEvacuationCandidatesFromFreeLists();
    heap()->code_space()->EvictEvacuationCandidatesFromFreeLists();
 
    compacting_ = evacuation_candidates_.length() > 0;
  }
 
  return compacting_;
}

References v8::internal::Heap::code_space(), CollectEvacuationCandidates(), compacting_, DCHECK, evacuation_candidates_, v8::internal::PagedSpace::EvictEvacuationCandidatesFromFreeLists(), heap(), mode(), NON_INCREMENTAL_COMPACTION, v8::internal::Heap::old_data_space(), v8::internal::Heap::old_pointer_space(), and v8::internal::TraceFragmentation().

Referenced by Prepare(), and v8::internal::IncrementalMarking::StartMarking().

Here is the call graph for this function:

Here is the caller graph for this function:

StartSweeperThreads()

void v8::internal::MarkCompactCollector::StartSweeperThreads ( )

private

Definition at line 556 of file mark-compact.cc.

                                               {
  DCHECK(free_list_old_pointer_space_.get()->IsEmpty());
  DCHECK(free_list_old_data_space_.get()->IsEmpty());
  sweeping_in_progress_ = true;
  for (int i = 0; i < isolate()->num_sweeper_threads(); i++) {
    isolate()->sweeper_threads()[i]->StartSweeping();
  }
  if (FLAG_job_based_sweeping) {
    V8::GetCurrentPlatform()->CallOnBackgroundThread(
        new SweeperTask(heap(), heap()->old_data_space()),
        v8::Platform::kShortRunningTask);
    V8::GetCurrentPlatform()->CallOnBackgroundThread(
        new SweeperTask(heap(), heap()->old_pointer_space()),
        v8::Platform::kShortRunningTask);
  }
}

References v8::Platform::CallOnBackgroundThread(), DCHECK, free_list_old_data_space_, free_list_old_pointer_space_, v8::internal::V8::GetCurrentPlatform(), heap(), isolate(), v8::Platform::kShortRunningTask, v8::internal::Isolate::num_sweeper_threads(), v8::internal::SweeperThread::StartSweeping(), v8::internal::Isolate::sweeper_threads(), and sweeping_in_progress_.

Referenced by SweepSpaces().

Here is the call graph for this function:

Here is the caller graph for this function:

sweeping_in_progress()

bool v8::internal::MarkCompactCollector::sweeping_in_progress ( )

inline

Definition at line 647 of file mark-compact.h.

{ return sweeping_in_progress_; }

References sweeping_in_progress_.

Referenced by v8::internal::Isolate::Deinit(), v8::internal::Heap::IdleNotification(), Prepare(), v8::internal::PagedSpace::SlowAllocateRaw(), v8::internal::IncrementalMarking::Start(), v8::internal::IncrementalMarking::Step(), and v8::internal::PagedSpace::WaitForSweeperThreadsAndRetryAllocation().

Here is the caller graph for this function:

SweepInParallel() [1/2]

int v8::internal::MarkCompactCollector::SweepInParallel	(	Page *	page,
		PagedSpace *	space
	)

Definition at line 4137 of file mark-compact.cc.

                                                                       {
  int max_freed = 0;
  if (page->TryParallelSweeping()) {
    FreeList* free_list = space == heap()->old_pointer_space()
                              ? free_list_old_pointer_space_.get()
                              : free_list_old_data_space_.get();
    FreeList private_free_list(space);
    max_freed = Sweep<SWEEP_ONLY, SWEEP_IN_PARALLEL, IGNORE_SKIP_LIST,
                      IGNORE_FREE_SPACE>(space, &private_free_list, page, NULL);
    free_list->Concatenate(&private_free_list);
  }
  return max_freed;
}

References v8::internal::FreeList::Concatenate(), free_list_old_data_space_, free_list_old_pointer_space_, heap(), v8::internal::IGNORE_FREE_SPACE, v8::internal::IGNORE_SKIP_LIST, NULL, v8::internal::Heap::old_pointer_space(), space(), v8::internal::Sweep(), SWEEP_IN_PARALLEL, v8::internal::SWEEP_ONLY, and v8::internal::MemoryChunk::TryParallelSweeping().

Here is the call graph for this function:

SweepInParallel() [2/2]

int v8::internal::MarkCompactCollector::SweepInParallel	(	PagedSpace *	space,
		int	required_freed_bytes
	)

Definition at line 4118 of file mark-compact.cc.

                                                                    {
  int max_freed = 0;
  int max_freed_overall = 0;
  PageIterator it(space);
  while (it.has_next()) {
    Page* p = it.next();
    max_freed = SweepInParallel(p, space);
    DCHECK(max_freed >= 0);
    if (required_freed_bytes > 0 && max_freed >= required_freed_bytes) {
      return max_freed;
    }
    max_freed_overall = Max(max_freed, max_freed_overall);
    if (p == space->end_of_unswept_pages()) break;
  }
  return max_freed_overall;
}

References DCHECK, v8::internal::Max(), and space().

Referenced by EnsureSweepingCompleted(), v8::internal::StoreBuffer::IteratePointersToNewSpace(), v8::internal::SweeperThread::Run(), v8::internal::MarkCompactCollector::SweeperTask::Run(), and v8::internal::PagedSpace::SlowAllocateRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

SweepSpace()

void v8::internal::MarkCompactCollector::SweepSpace ( PagedSpace *  space, SweeperType  sweeper  )

private

Definition at line 4152 of file mark-compact.cc.

                                                                            {
  space->ClearStats();
 
  // We defensively initialize end_of_unswept_pages_ here with the first page
  // of the pages list.
  space->set_end_of_unswept_pages(space->FirstPage());
 
  PageIterator it(space);
 
  int pages_swept = 0;
  bool unused_page_present = false;
  bool parallel_sweeping_active = false;
 
  while (it.has_next()) {
    Page* p = it.next();
    DCHECK(p->parallel_sweeping() == MemoryChunk::SWEEPING_DONE);
 
    // Clear sweeping flags indicating that marking bits are still intact.
    p->ClearWasSwept();
 
    if (p->IsFlagSet(Page::RESCAN_ON_EVACUATION) ||
        p->IsEvacuationCandidate()) {
      // Will be processed in EvacuateNewSpaceAndCandidates.
      DCHECK(evacuation_candidates_.length() > 0);
      continue;
    }
 
    // One unused page is kept, all further are released before sweeping them.
    if (p->LiveBytes() == 0) {
      if (unused_page_present) {
        if (FLAG_gc_verbose) {
          PrintF("Sweeping 0x%" V8PRIxPTR " released page.\n",
                 reinterpret_cast<intptr_t>(p));
        }
        // Adjust unswept free bytes because releasing a page expects said
        // counter to be accurate for unswept pages.
        space->IncreaseUnsweptFreeBytes(p);
        space->ReleasePage(p);
        continue;
      }
      unused_page_present = true;
    }
 
    switch (sweeper) {
      case CONCURRENT_SWEEPING:
      case PARALLEL_SWEEPING:
        if (!parallel_sweeping_active) {
          if (FLAG_gc_verbose) {
            PrintF("Sweeping 0x%" V8PRIxPTR ".\n",
                   reinterpret_cast<intptr_t>(p));
          }
          Sweep<SWEEP_ONLY, SWEEP_ON_MAIN_THREAD, IGNORE_SKIP_LIST,
                IGNORE_FREE_SPACE>(space, NULL, p, NULL);
          pages_swept++;
          parallel_sweeping_active = true;
        } else {
          if (FLAG_gc_verbose) {
            PrintF("Sweeping 0x%" V8PRIxPTR " in parallel.\n",
                   reinterpret_cast<intptr_t>(p));
          }
          p->set_parallel_sweeping(MemoryChunk::SWEEPING_PENDING);
          space->IncreaseUnsweptFreeBytes(p);
        }
        space->set_end_of_unswept_pages(p);
        break;
      case SEQUENTIAL_SWEEPING: {
        if (FLAG_gc_verbose) {
          PrintF("Sweeping 0x%" V8PRIxPTR ".\n", reinterpret_cast<intptr_t>(p));
        }
        if (space->identity() == CODE_SPACE && FLAG_zap_code_space) {
          Sweep<SWEEP_ONLY, SWEEP_ON_MAIN_THREAD, REBUILD_SKIP_LIST,
                ZAP_FREE_SPACE>(space, NULL, p, NULL);
        } else if (space->identity() == CODE_SPACE) {
          Sweep<SWEEP_ONLY, SWEEP_ON_MAIN_THREAD, REBUILD_SKIP_LIST,
                IGNORE_FREE_SPACE>(space, NULL, p, NULL);
        } else {
          Sweep<SWEEP_ONLY, SWEEP_ON_MAIN_THREAD, IGNORE_SKIP_LIST,
                IGNORE_FREE_SPACE>(space, NULL, p, NULL);
        }
        pages_swept++;
        break;
      }
      default: { UNREACHABLE(); }
    }
  }
 
  if (FLAG_gc_verbose) {
    PrintF("SweepSpace: %s (%d pages swept)\n",
           AllocationSpaceName(space->identity()), pages_swept);
  }
 
  // Give pages that are queued to be freed back to the OS.
  heap()->FreeQueuedChunks();
}

References v8::internal::AllocationSpaceName(), v8::internal::Page::ClearWasSwept(), v8::internal::CODE_SPACE, CONCURRENT_SWEEPING, DCHECK, evacuation_candidates_, v8::internal::Heap::FreeQueuedChunks(), heap(), v8::internal::IGNORE_FREE_SPACE, v8::internal::IGNORE_SKIP_LIST, v8::internal::MemoryChunk::IsEvacuationCandidate(), v8::internal::MemoryChunk::IsFlagSet(), v8::internal::MemoryChunk::LiveBytes(), NULL, PARALLEL_SWEEPING, v8::internal::MemoryChunk::parallel_sweeping(), v8::internal::PrintF(), v8::internal::REBUILD_SKIP_LIST, v8::internal::MemoryChunk::RESCAN_ON_EVACUATION, SEQUENTIAL_SWEEPING, v8::internal::MemoryChunk::set_parallel_sweeping(), space(), v8::internal::Sweep(), SWEEP_ON_MAIN_THREAD, v8::internal::SWEEP_ONLY, v8::internal::MemoryChunk::SWEEPING_DONE, v8::internal::MemoryChunk::SWEEPING_PENDING, UNREACHABLE, V8PRIxPTR, and v8::internal::ZAP_FREE_SPACE.

Referenced by SweepSpaces().

Here is the call graph for this function:

Here is the caller graph for this function:

SweepSpaces()

void v8::internal::MarkCompactCollector::SweepSpaces ( )

private

Definition at line 4260 of file mark-compact.cc.

                                       {
  GCTracer::Scope gc_scope(heap()->tracer(), GCTracer::Scope::MC_SWEEP);
  double start_time = 0.0;
  if (FLAG_print_cumulative_gc_stat) {
    start_time = base::OS::TimeCurrentMillis();
  }
 
#ifdef DEBUG
  state_ = SWEEP_SPACES;
#endif
  SweeperType how_to_sweep = CONCURRENT_SWEEPING;
  if (FLAG_parallel_sweeping) how_to_sweep = PARALLEL_SWEEPING;
  if (FLAG_concurrent_sweeping) how_to_sweep = CONCURRENT_SWEEPING;
 
  MoveEvacuationCandidatesToEndOfPagesList();
 
  // Noncompacting collections simply sweep the spaces to clear the mark
  // bits and free the nonlive blocks (for old and map spaces).  We sweep
  // the map space last because freeing non-live maps overwrites them and
  // the other spaces rely on possibly non-live maps to get the sizes for
  // non-live objects.
  {
    GCTracer::Scope sweep_scope(heap()->tracer(),
                                GCTracer::Scope::MC_SWEEP_OLDSPACE);
    {
      SequentialSweepingScope scope(this);
      SweepSpace(heap()->old_pointer_space(), how_to_sweep);
      SweepSpace(heap()->old_data_space(), how_to_sweep);
    }
 
    if (ShouldStartSweeperThreads(how_to_sweep)) {
      StartSweeperThreads();
    }
 
    if (ShouldWaitForSweeperThreads(how_to_sweep)) {
      EnsureSweepingCompleted();
    }
  }
  RemoveDeadInvalidatedCode();
 
  {
    GCTracer::Scope sweep_scope(heap()->tracer(),
                                GCTracer::Scope::MC_SWEEP_CODE);
    SweepSpace(heap()->code_space(), SEQUENTIAL_SWEEPING);
  }
 
  {
    GCTracer::Scope sweep_scope(heap()->tracer(),
                                GCTracer::Scope::MC_SWEEP_CELL);
    SweepSpace(heap()->cell_space(), SEQUENTIAL_SWEEPING);
    SweepSpace(heap()->property_cell_space(), SEQUENTIAL_SWEEPING);
  }
 
  EvacuateNewSpaceAndCandidates();
 
  // ClearNonLiveTransitions depends on precise sweeping of map space to
  // detect whether unmarked map became dead in this collection or in one
  // of the previous ones.
  {
    GCTracer::Scope sweep_scope(heap()->tracer(),
                                GCTracer::Scope::MC_SWEEP_MAP);
    SweepSpace(heap()->map_space(), SEQUENTIAL_SWEEPING);
  }
 
  // Deallocate unmarked objects and clear marked bits for marked objects.
  heap_->lo_space()->FreeUnmarkedObjects();
 
  // Deallocate evacuated candidate pages.
  ReleaseEvacuationCandidates();
 
  if (FLAG_print_cumulative_gc_stat) {
    heap_->tracer()->AddSweepingTime(base::OS::TimeCurrentMillis() -
                                     start_time);
  }
}

References v8::internal::GCTracer::AddSweepingTime(), CONCURRENT_SWEEPING, EnsureSweepingCompleted(), EvacuateNewSpaceAndCandidates(), v8::internal::LargeObjectSpace::FreeUnmarkedObjects(), heap(), heap_, v8::internal::Heap::lo_space(), v8::internal::GCTracer::Scope::MC_SWEEP, v8::internal::GCTracer::Scope::MC_SWEEP_CELL, v8::internal::GCTracer::Scope::MC_SWEEP_CODE, v8::internal::GCTracer::Scope::MC_SWEEP_MAP, v8::internal::GCTracer::Scope::MC_SWEEP_OLDSPACE, MoveEvacuationCandidatesToEndOfPagesList(), PARALLEL_SWEEPING, ReleaseEvacuationCandidates(), RemoveDeadInvalidatedCode(), SEQUENTIAL_SWEEPING, v8::internal::ShouldStartSweeperThreads(), v8::internal::ShouldWaitForSweeperThreads(), StartSweeperThreads(), SweepSpace(), v8::base::OS::TimeCurrentMillis(), and v8::internal::Heap::tracer().

Referenced by CollectGarbage().

Here is the call graph for this function:

Here is the caller graph for this function:

TearDown()

void v8::internal::MarkCompactCollector::TearDown

(

)

Definition at line 334 of file mark-compact.cc.

{ AbortCompaction(); }

References AbortCompaction().

Referenced by v8::internal::Heap::TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

TrimDescriptorArray()

void v8::internal::MarkCompactCollector::TrimDescriptorArray ( Map *  map, DescriptorArray *  descriptors, int  number_of_own_descriptors  )

private

Definition at line 2654 of file mark-compact.cc.

                                                                              {
  int number_of_descriptors = descriptors->number_of_descriptors_storage();
  int to_trim = number_of_descriptors - number_of_own_descriptors;
  if (to_trim == 0) return;
 
  heap_->RightTrimFixedArray<Heap::FROM_GC>(
      descriptors, to_trim * DescriptorArray::kDescriptorSize);
  descriptors->SetNumberOfDescriptors(number_of_own_descriptors);
 
  if (descriptors->HasEnumCache()) TrimEnumCache(map, descriptors);
  descriptors->Sort();
}

References v8::internal::Heap::FROM_GC, v8::internal::DescriptorArray::HasEnumCache(), heap_, v8::internal::DescriptorArray::kDescriptorSize, map, v8::internal::DescriptorArray::number_of_descriptors_storage(), v8::internal::Heap::RightTrimFixedArray(), v8::internal::DescriptorArray::SetNumberOfDescriptors(), v8::internal::DescriptorArray::Sort(), and TrimEnumCache().

Referenced by ClearMapTransitions().

Here is the call graph for this function:

Here is the caller graph for this function:

TrimEnumCache()

void v8::internal::MarkCompactCollector::TrimEnumCache ( Map *  map, DescriptorArray *  descriptors  )

private

Definition at line 2670 of file mark-compact.cc.

                                                                       {
  int live_enum = map->EnumLength();
  if (live_enum == kInvalidEnumCacheSentinel) {
    live_enum = map->NumberOfDescribedProperties(OWN_DESCRIPTORS, DONT_ENUM);
  }
  if (live_enum == 0) return descriptors->ClearEnumCache();
 
  FixedArray* enum_cache = descriptors->GetEnumCache();
 
  int to_trim = enum_cache->length() - live_enum;
  if (to_trim <= 0) return;
  heap_->RightTrimFixedArray<Heap::FROM_GC>(descriptors->GetEnumCache(),
                                            to_trim);
 
  if (!descriptors->HasEnumIndicesCache()) return;
  FixedArray* enum_indices_cache = descriptors->GetEnumIndicesCache();
  heap_->RightTrimFixedArray<Heap::FROM_GC>(enum_indices_cache, to_trim);
}

References v8::internal::DescriptorArray::ClearEnumCache(), DONT_ENUM, v8::internal::Heap::FROM_GC, v8::internal::DescriptorArray::GetEnumCache(), v8::internal::DescriptorArray::GetEnumIndicesCache(), v8::internal::DescriptorArray::HasEnumIndicesCache(), heap_, v8::internal::kInvalidEnumCacheSentinel, v8::internal::FixedArrayBase::length(), map, v8::internal::OWN_DESCRIPTORS, and v8::internal::Heap::RightTrimFixedArray().

Referenced by TrimDescriptorArray().

Here is the call graph for this function:

Here is the caller graph for this function:

TryPromoteObject()

bool v8::internal::MarkCompactCollector::TryPromoteObject	(	HeapObject *	object,
		int	object_size
	)

Definition at line 3068 of file mark-compact.cc.

                                                             {
  DCHECK(object_size <= Page::kMaxRegularHeapObjectSize);
 
  OldSpace* target_space = heap()->TargetSpace(object);
 
  DCHECK(target_space == heap()->old_pointer_space() ||
         target_space == heap()->old_data_space());
  HeapObject* target;
  AllocationResult allocation = target_space->AllocateRaw(object_size);
  if (allocation.To(&target)) {
    MigrateObject(target, object, object_size, target_space->identity());
    heap()->IncrementPromotedObjectsSize(object_size);
    return true;
  }
 
  return false;
}

References v8::internal::PagedSpace::AllocateRaw(), DCHECK, heap(), v8::internal::Space::identity(), v8::internal::Heap::IncrementPromotedObjectsSize(), v8::internal::Page::kMaxRegularHeapObjectSize, MigrateObject(), v8::internal::Heap::TargetSpace(), and v8::internal::AllocationResult::To().

Referenced by DiscoverAndEvacuateBlackObjectsOnPage().

Here is the call graph for this function:

Here is the caller graph for this function:

WillBeDeoptimized()

bool v8::internal::MarkCompactCollector::WillBeDeoptimized ( Code *  code )

private

Definition at line 3466 of file mark-compact.cc.

                                                       {
  return code->is_optimized_code() && code->marked_for_deoptimization();
}

References v8::internal::Code::is_optimized_code(), and v8::internal::Code::marked_for_deoptimization().

Referenced by ClearNonLiveDependentCodeInGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

CodeMarkingVisitor

friend class CodeMarkingVisitor

friend

Definition at line 729 of file mark-compact.h.

Heap

friend class Heap

friend

Definition at line 893 of file mark-compact.h.

MarkCompactMarkingVisitor

friend class MarkCompactMarkingVisitor

friend

Definition at line 728 of file mark-compact.h.

MarkingVisitor

friend class MarkingVisitor

friend

Definition at line 727 of file mark-compact.h.

RootMarkingVisitor

friend class RootMarkingVisitor

friend

Definition at line 726 of file mark-compact.h.

SharedFunctionInfoMarkingVisitor

friend class SharedFunctionInfoMarkingVisitor

friend

Definition at line 730 of file mark-compact.h.

Member Data Documentation

abort_incremental_marking_

bool v8::internal::MarkCompactCollector::abort_incremental_marking_

private

Definition at line 693 of file mark-compact.h.

Referenced by abort_incremental_marking(), Prepare(), and SetFlags().

code_flusher_

CodeFlusher* v8::internal::MarkCompactCollector::code_flusher_

private

Definition at line 884 of file mark-compact.h.

Referenced by AfterMarking(), code_flusher(), EnableCodeFlushing(), is_code_flushing_enabled(), and ~MarkCompactCollector().

compacting_

bool v8::internal::MarkCompactCollector::compacting_

private

Definition at line 699 of file mark-compact.h.

Referenced by AbortCompaction(), EvacuateNewSpaceAndCandidates(), InvalidateCode(), is_compacting(), MigrateObject(), ReleaseEvacuationCandidates(), and StartCompaction().

evacuation_candidates_

List<Page*> v8::internal::MarkCompactCollector::evacuation_candidates_

private

Definition at line 887 of file mark-compact.h.

Referenced by AbortCompaction(), AddEvacuationCandidate(), EvacuateNewSpaceAndCandidates(), EvacuatePages(), INLINE(), MoveEvacuationCandidatesToEndOfPagesList(), ReleaseEvacuationCandidates(), StartCompaction(), and SweepSpace().

free_list_old_data_space_

SmartPointer<FreeList> v8::internal::MarkCompactCollector::free_list_old_data_space_

private

Definition at line 890 of file mark-compact.h.

Referenced by RefillFreeList(), SetUp(), StartSweeperThreads(), and SweepInParallel().

free_list_old_pointer_space_

SmartPointer<FreeList> v8::internal::MarkCompactCollector::free_list_old_pointer_space_

private

Definition at line 891 of file mark-compact.h.

Referenced by RefillFreeList(), SetUp(), StartSweeperThreads(), and SweepInParallel().

have_code_to_deoptimize_

bool v8::internal::MarkCompactCollector::have_code_to_deoptimize_

private

Definition at line 885 of file mark-compact.h.

Referenced by ClearDependentCode(), and Finish().

heap_

Heap* v8::internal::MarkCompactCollector::heap_

private

Definition at line 882 of file mark-compact.h.

Referenced by ClearMapBackPointer(), ClearMapTransitions(), ClearMarkbits(), ClearNonLiveReferences(), CollectGarbage(), EnsureSweepingCompleted(), EvacuateNewSpace(), EvacuateNewSpaceAndCandidates(), heap(), InvalidateCode(), isolate(), MarkLiveObjects(), RecordMigratedSlot(), SetUp(), SweepSpaces(), TrimDescriptorArray(), and TrimEnumCache().

invalidated_code_

List<Code*> v8::internal::MarkCompactCollector::invalidated_code_

private

Definition at line 888 of file mark-compact.h.

Referenced by AbortCompaction(), InvalidateCode(), MarkInvalidatedCode(), ProcessInvalidatedCode(), and RemoveDeadInvalidatedCode().

kMultiFreeEncoding

const uint32_t v8::internal::MarkCompactCollector::kMultiFreeEncoding = 1

static

Definition at line 538 of file mark-compact.h.

kSingleFreeEncoding

const uint32_t v8::internal::MarkCompactCollector::kSingleFreeEncoding = 0

static

Definition at line 537 of file mark-compact.h.

marking_deque_

MarkingDeque v8::internal::MarkCompactCollector::marking_deque_

private

Definition at line 883 of file mark-compact.h.

Referenced by EmptyMarkingDeque(), MarkLiveObjects(), MarkRoots(), ProcessEphemeralMarking(), ProcessMarkingDeque(), and RefillMarkingDeque().

marking_parity_

MarkingParity v8::internal::MarkCompactCollector::marking_parity_

private

Definition at line 695 of file mark-compact.h.

Referenced by CollectGarbage(), and marking_parity().

migration_slots_buffer_

SlotsBuffer* v8::internal::MarkCompactCollector::migration_slots_buffer_

private

Definition at line 712 of file mark-compact.h.

Referenced by EvacuateNewSpaceAndCandidates(), MigrateObject(), and RecordMigratedSlot().

pending_sweeper_jobs_semaphore_

base::Semaphore v8::internal::MarkCompactCollector::pending_sweeper_jobs_semaphore_

private

Definition at line 706 of file mark-compact.h.

Referenced by EnsureSweepingCompleted(), IsSweepingCompleted(), and v8::internal::MarkCompactCollector::SweeperTask::Run().

reduce_memory_footprint_

bool v8::internal::MarkCompactCollector::reduce_memory_footprint_

private

Definition at line 691 of file mark-compact.h.

Referenced by CollectEvacuationCandidates(), v8::internal::Heap::OldGenerationAllocationLimit(), and SetFlags().

sequential_sweeping_

bool v8::internal::MarkCompactCollector::sequential_sweeping_

private

Definition at line 708 of file mark-compact.h.

Referenced by sequential_sweeping(), and set_sequential_sweeping().

slots_buffer_allocator_

SlotsBufferAllocator v8::internal::MarkCompactCollector::slots_buffer_allocator_

private

Definition at line 710 of file mark-compact.h.

Referenced by AbortCompaction(), EvacuateNewSpaceAndCandidates(), EvacuatePages(), MigrateObject(), RecordCodeEntrySlot(), RecordMigratedSlot(), RecordRelocSlot(), and ReleaseEvacuationCandidates().

sweeping_in_progress_

bool v8::internal::MarkCompactCollector::sweeping_in_progress_

private

Definition at line 704 of file mark-compact.h.

Referenced by EnsureSweepingCompleted(), StartSweeperThreads(), and sweeping_in_progress().

was_marked_incrementally_

bool v8::internal::MarkCompactCollector::was_marked_incrementally_

private

Definition at line 701 of file mark-compact.h.

Referenced by EvacuateNewSpaceAndCandidates(), MarkLiveObjects(), Prepare(), and PrepareForCodeFlushing().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/heap/mark-compact.h
• /mnt/V8SourceCode/src/heap/mark-compact-inl.h
• /mnt/V8SourceCode/src/heap/mark-compact.cc