v8::internal::IncrementalMarking Class Reference

#include <incremental-marking.h>

Collaboration diagram for v8::internal::IncrementalMarking:

Public Types
enum	State { STOPPED , SWEEPING , MARKING , COMPLETE }
enum	CompletionAction { GC_VIA_STACK_GUARD , NO_GC_VIA_STACK_GUARD }
enum	CompactionFlag { ALLOW_COMPACTION , PREVENT_COMPACTION }

Public Member Functions
	IncrementalMarking (Heap *heap)
void	TearDown ()
State	state ()
bool	should_hurry ()
void	set_should_hurry (bool val)
bool	IsStopped ()
	INLINE (bool IsMarking())
bool	IsMarkingIncomplete ()
bool	IsComplete ()
bool	WorthActivating ()
bool	ShouldActivate ()
void	Start (CompactionFlag flag=ALLOW_COMPACTION)
void	Stop ()
void	PrepareForScavenge ()
void	UpdateMarkingDequeAfterScavenge ()
void	Hurry ()
void	Finalize ()
void	Abort ()
void	MarkingComplete (CompletionAction action)
void	OldSpaceStep (intptr_t allocated)
void	Step (intptr_t allocated, CompletionAction action, bool force_marking=false)
void	RestartIfNotMarking ()
	INLINE (bool BaseRecordWrite(HeapObject *obj, Object **slot, Object *value))
	INLINE (void RecordWrite(HeapObject *obj, Object **slot, Object *value))
	INLINE (void RecordWriteIntoCode(HeapObject *obj, RelocInfo *rinfo, Object *value))
	INLINE (void RecordWriteOfCodeEntry(JSFunction *host, Object **slot, Code *value))
void	RecordWriteSlow (HeapObject *obj, Object **slot, Object *value)
void	RecordWriteIntoCodeSlow (HeapObject *obj, RelocInfo *rinfo, Object *value)
void	RecordWriteOfCodeEntrySlow (JSFunction *host, Object **slot, Code *value)
void	RecordCodeTargetPatch (Code *host, Address pc, HeapObject *value)
void	RecordCodeTargetPatch (Address pc, HeapObject *value)
void	RecordWrites (HeapObject *obj)
void	BlackToGreyAndUnshift (HeapObject *obj, MarkBit mark_bit)
void	WhiteToGreyAndPush (HeapObject *obj, MarkBit mark_bit)
void	SetOldSpacePageFlags (MemoryChunk *chunk)
void	SetNewSpacePageFlags (NewSpacePage *chunk)
MarkingDeque *	marking_deque ()
bool	IsCompacting ()
void	ActivateGeneratedStub (Code *stub)
void	NotifyOfHighPromotionRate ()
void	EnterNoMarkingScope ()
void	LeaveNoMarkingScope ()
void	UncommitMarkingDeque ()
void	NotifyIncompleteScanOfObject (int unscanned_bytes)

Static Public Member Functions
static void	Initialize ()
static void	RecordWriteFromCode (HeapObject *obj, Object **slot, Isolate *isolate)

Static Public Attributes
static const intptr_t	kAllocatedThreshold = 65536
static const intptr_t	kWriteBarriersInvokedThreshold = 32768
static const intptr_t	kInitialMarkingSpeed = 1
static const intptr_t	kFastMarking = 3
static const intptr_t	kMarkingSpeedAccellerationInterval = 1024
static const intptr_t	kMarkingSpeedAccelleration = 2
static const intptr_t	kMaxMarkingSpeed = 1000

Private Member Functions
int64_t	SpaceLeftInOldSpace ()
void	SpeedUp ()
void	ResetStepCounters ()
void	StartMarking (CompactionFlag flag)
void	ActivateIncrementalWriteBarrier (PagedSpace *space)
void	ActivateIncrementalWriteBarrier ()
void	DeactivateIncrementalWriteBarrier ()
void	EnsureMarkingDequeIsCommitted ()
	INLINE (void ProcessMarkingDeque())
	INLINE (intptr_t ProcessMarkingDeque(intptr_t bytes_to_process))
	INLINE (void VisitObject(Map *map, HeapObject *obj, int size))
	DISALLOW_IMPLICIT_CONSTRUCTORS (IncrementalMarking)

Static Private Member Functions
static void	ActivateIncrementalWriteBarrier (NewSpace *space)
static void	DeactivateIncrementalWriteBarrierForSpace (PagedSpace *space)
static void	DeactivateIncrementalWriteBarrierForSpace (NewSpace *space)
static void	SetOldSpacePageFlags (MemoryChunk *chunk, bool is_marking, bool is_compacting)
static void	SetNewSpacePageFlags (NewSpacePage *chunk, bool is_marking)

Private Attributes
Heap *	heap_
State	state_
bool	is_compacting_
base::VirtualMemory *	marking_deque_memory_
bool	marking_deque_memory_committed_
MarkingDeque	marking_deque_
int	steps_count_
int64_t	old_generation_space_available_at_start_of_incremental_
int64_t	old_generation_space_used_at_start_of_incremental_
int64_t	bytes_rescanned_
bool	should_hurry_
int	marking_speed_
intptr_t	bytes_scanned_
intptr_t	allocated_
intptr_t	write_barriers_invoked_since_last_step_
int	no_marking_scope_depth_
int	unscanned_bytes_of_large_object_

Detailed Description

Definition at line 17 of file incremental-marking.h.

Member Enumeration Documentation

CompactionFlag

enum v8::internal::IncrementalMarking::CompactionFlag

Enumerator
ALLOW_COMPACTION
PREVENT_COMPACTION

Definition at line 49 of file incremental-marking.h.

{ ALLOW_COMPACTION, PREVENT_COMPACTION };

CompletionAction

enum v8::internal::IncrementalMarking::CompletionAction

Enumerator
GC_VIA_STACK_GUARD
NO_GC_VIA_STACK_GUARD

Definition at line 21 of file incremental-marking.h.

{ GC_VIA_STACK_GUARD, NO_GC_VIA_STACK_GUARD };

State

enum v8::internal::IncrementalMarking::State

Enumerator
STOPPED
SWEEPING
MARKING
COMPLETE

Definition at line 19 of file incremental-marking.h.

{ STOPPED, SWEEPING, MARKING, COMPLETE };

Constructor & Destructor Documentation

IncrementalMarking()

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

explicit

Definition at line 19 of file incremental-marking.cc.

    : heap_(heap),
      state_(STOPPED),
      marking_deque_memory_(NULL),
      marking_deque_memory_committed_(false),
      steps_count_(0),
      old_generation_space_available_at_start_of_incremental_(0),
      old_generation_space_used_at_start_of_incremental_(0),
      should_hurry_(false),
      marking_speed_(0),
      allocated_(0),
      no_marking_scope_depth_(0),
      unscanned_bytes_of_large_object_(0) {}

Member Function Documentation

Abort()

void v8::internal::IncrementalMarking::Abort

(

)

Definition at line 757 of file incremental-marking.cc.

                               {
  if (IsStopped()) return;
  if (FLAG_trace_incremental_marking) {
    PrintF("[IncrementalMarking] Aborting.\n");
  }
  heap_->new_space()->LowerInlineAllocationLimit(0);
  IncrementalMarking::set_should_hurry(false);
  ResetStepCounters();
  if (IsMarking()) {
    PatchIncrementalMarkingRecordWriteStubs(heap_,
                                            RecordWriteStub::STORE_BUFFER_ONLY);
    DeactivateIncrementalWriteBarrier();
 
    if (is_compacting_) {
      LargeObjectIterator it(heap_->lo_space());
      for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
        Page* p = Page::FromAddress(obj->address());
        if (p->IsFlagSet(Page::RESCAN_ON_EVACUATION)) {
          p->ClearFlag(Page::RESCAN_ON_EVACUATION);
        }
      }
    }
  }
  heap_->isolate()->stack_guard()->ClearGC();
  state_ = STOPPED;
  is_compacting_ = false;
}

References v8::internal::MemoryChunk::ClearFlag(), DeactivateIncrementalWriteBarrier(), v8::internal::MemoryChunk::FromAddress(), heap_, is_compacting_, v8::internal::MemoryChunk::IsFlagSet(), v8::internal::Heap::isolate(), IsStopped(), v8::internal::Heap::lo_space(), v8::internal::NewSpace::LowerInlineAllocationLimit(), v8::internal::Heap::new_space(), v8::internal::LargeObjectIterator::Next(), NULL, v8::internal::PatchIncrementalMarkingRecordWriteStubs(), v8::internal::PrintF(), v8::internal::MemoryChunk::RESCAN_ON_EVACUATION, ResetStepCounters(), set_should_hurry(), v8::internal::Isolate::stack_guard(), state_, STOPPED, and v8::internal::RecordWriteStub::STORE_BUFFER_ONLY.

Referenced by v8::internal::MarkCompactCollector::MarkLiveObjects(), and v8::internal::MarkCompactCollector::Prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

ActivateGeneratedStub()

void v8::internal::IncrementalMarking::ActivateGeneratedStub

(

Code *

stub

)

Definition at line 448 of file incremental-marking.cc.

                                                         {
  DCHECK(RecordWriteStub::GetMode(stub) == RecordWriteStub::STORE_BUFFER_ONLY);
 
  if (!IsMarking()) {
    // Initially stub is generated in STORE_BUFFER_ONLY mode thus
    // we don't need to do anything if incremental marking is
    // not active.
  } else if (IsCompacting()) {
    RecordWriteStub::Patch(stub, RecordWriteStub::INCREMENTAL_COMPACTION);
  } else {
    RecordWriteStub::Patch(stub, RecordWriteStub::INCREMENTAL);
  }
}

References DCHECK, v8::internal::RecordWriteStub::GetMode(), v8::internal::RecordWriteStub::INCREMENTAL, v8::internal::RecordWriteStub::INCREMENTAL_COMPACTION, IsCompacting(), v8::internal::RecordWriteStub::Patch(), and v8::internal::RecordWriteStub::STORE_BUFFER_ONLY.

Referenced by v8::internal::RecordWriteStub::Activate().

Here is the call graph for this function:

Here is the caller graph for this function:

ActivateIncrementalWriteBarrier() [1/3]

void v8::internal::IncrementalMarking::ActivateIncrementalWriteBarrier ( )

private

Definition at line 407 of file incremental-marking.cc.

                                                         {
  ActivateIncrementalWriteBarrier(heap_->old_pointer_space());
  ActivateIncrementalWriteBarrier(heap_->old_data_space());
  ActivateIncrementalWriteBarrier(heap_->cell_space());
  ActivateIncrementalWriteBarrier(heap_->property_cell_space());
  ActivateIncrementalWriteBarrier(heap_->map_space());
  ActivateIncrementalWriteBarrier(heap_->code_space());
  ActivateIncrementalWriteBarrier(heap_->new_space());
 
  LargePage* lop = heap_->lo_space()->first_page();
  while (lop->is_valid()) {
    SetOldSpacePageFlags(lop, true, is_compacting_);
    lop = lop->next_page();
  }
}

References v8::internal::Heap::cell_space(), v8::internal::Heap::code_space(), v8::internal::LargeObjectSpace::first_page(), heap_, is_compacting_, v8::internal::MemoryChunk::is_valid(), v8::internal::Heap::lo_space(), v8::internal::Heap::map_space(), v8::internal::Heap::new_space(), v8::internal::LargePage::next_page(), v8::internal::Heap::old_data_space(), v8::internal::Heap::old_pointer_space(), v8::internal::Heap::property_cell_space(), and SetOldSpacePageFlags().

Referenced by StartMarking().

Here is the call graph for this function:

Here is the caller graph for this function:

ActivateIncrementalWriteBarrier() [2/3]

void v8::internal::IncrementalMarking::ActivateIncrementalWriteBarrier ( NewSpace *  space )

staticprivate

Definition at line 398 of file incremental-marking.cc.

                                                                        {
  NewSpacePageIterator it(space->ToSpaceStart(), space->ToSpaceEnd());
  while (it.has_next()) {
    NewSpacePage* p = it.next();
    SetNewSpacePageFlags(p, true);
  }
}

References SetNewSpacePageFlags(), and space().

Here is the call graph for this function:

ActivateIncrementalWriteBarrier() [3/3]

void v8::internal::IncrementalMarking::ActivateIncrementalWriteBarrier ( PagedSpace *  space )

private

Definition at line 389 of file incremental-marking.cc.

                                                                          {
  PageIterator it(space);
  while (it.has_next()) {
    Page* p = it.next();
    SetOldSpacePageFlags(p, true, is_compacting_);
  }
}

References is_compacting_, SetOldSpacePageFlags(), and space().

Here is the call graph for this function:

BlackToGreyAndUnshift()

void v8::internal::IncrementalMarking::BlackToGreyAndUnshift ( HeapObject *  obj, MarkBit  mark_bit  )

inline

Definition at line 81 of file incremental-marking-inl.h.

                                                                 {
  DCHECK(Marking::MarkBitFrom(obj) == mark_bit);
  DCHECK(obj->Size() >= 2 * kPointerSize);
  DCHECK(IsMarking());
  Marking::BlackToGrey(mark_bit);
  int obj_size = obj->Size();
  MemoryChunk::IncrementLiveBytesFromGC(obj->address(), -obj_size);
  bytes_scanned_ -= obj_size;
  int64_t old_bytes_rescanned = bytes_rescanned_;
  bytes_rescanned_ = old_bytes_rescanned + obj_size;
  if ((bytes_rescanned_ >> 20) != (old_bytes_rescanned >> 20)) {
    if (bytes_rescanned_ > 2 * heap_->PromotedSpaceSizeOfObjects()) {
      // If we have queued twice the heap size for rescanning then we are
      // going around in circles, scanning the same objects again and again
      // as the program mutates the heap faster than we can incrementally
      // trace it.  In this case we switch to non-incremental marking in
      // order to finish off this marking phase.
      if (FLAG_trace_gc) {
        PrintPID("Hurrying incremental marking because of lack of progress\n");
      }
      marking_speed_ = kMaxMarkingSpeed;
    }
  }
 
  marking_deque_.UnshiftGrey(obj);
}

References v8::internal::HeapObject::address(), bytes_rescanned_, bytes_scanned_, DCHECK, heap_, v8::internal::MemoryChunk::IncrementLiveBytesFromGC(), kMaxMarkingSpeed, v8::internal::kPointerSize, marking_deque_, marking_speed_, v8::internal::PrintPID(), v8::internal::Heap::PromotedSpaceSizeOfObjects(), and v8::internal::HeapObject::Size().

Referenced by RecordWriteIntoCodeSlow(), and RecordWrites().

Here is the call graph for this function:

Here is the caller graph for this function:

DeactivateIncrementalWriteBarrier()

void v8::internal::IncrementalMarking::DeactivateIncrementalWriteBarrier ( )

private

Definition at line 372 of file incremental-marking.cc.

                                                           {
  DeactivateIncrementalWriteBarrierForSpace(heap_->old_pointer_space());
  DeactivateIncrementalWriteBarrierForSpace(heap_->old_data_space());
  DeactivateIncrementalWriteBarrierForSpace(heap_->cell_space());
  DeactivateIncrementalWriteBarrierForSpace(heap_->property_cell_space());
  DeactivateIncrementalWriteBarrierForSpace(heap_->map_space());
  DeactivateIncrementalWriteBarrierForSpace(heap_->code_space());
  DeactivateIncrementalWriteBarrierForSpace(heap_->new_space());
 
  LargePage* lop = heap_->lo_space()->first_page();
  while (lop->is_valid()) {
    SetOldSpacePageFlags(lop, false, false);
    lop = lop->next_page();
  }
}

References v8::internal::Heap::cell_space(), v8::internal::Heap::code_space(), DeactivateIncrementalWriteBarrierForSpace(), v8::internal::LargeObjectSpace::first_page(), heap_, v8::internal::MemoryChunk::is_valid(), v8::internal::Heap::lo_space(), v8::internal::Heap::map_space(), v8::internal::Heap::new_space(), v8::internal::LargePage::next_page(), v8::internal::Heap::old_data_space(), v8::internal::Heap::old_pointer_space(), v8::internal::Heap::property_cell_space(), and SetOldSpacePageFlags().

Referenced by Abort(), and Finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

DeactivateIncrementalWriteBarrierForSpace() [1/2]

void v8::internal::IncrementalMarking::DeactivateIncrementalWriteBarrierForSpace ( NewSpace *  space )

staticprivate

Definition at line 362 of file incremental-marking.cc.

                     {
  NewSpacePageIterator it(space);
  while (it.has_next()) {
    NewSpacePage* p = it.next();
    SetNewSpacePageFlags(p, false);
  }
}

References SetNewSpacePageFlags(), and space().

Here is the call graph for this function:

DeactivateIncrementalWriteBarrierForSpace() [2/2]

void v8::internal::IncrementalMarking::DeactivateIncrementalWriteBarrierForSpace ( PagedSpace *  space )

staticprivate

Definition at line 352 of file incremental-marking.cc.

                       {
  PageIterator it(space);
  while (it.has_next()) {
    Page* p = it.next();
    SetOldSpacePageFlags(p, false, false);
  }
}

References SetOldSpacePageFlags(), and space().

Referenced by DeactivateIncrementalWriteBarrier().

Here is the call graph for this function:

Here is the caller graph for this function:

DISALLOW_IMPLICIT_CONSTRUCTORS()

v8::internal::IncrementalMarking::DISALLOW_IMPLICIT_CONSTRUCTORS ( IncrementalMarking  )

private

EnsureMarkingDequeIsCommitted()

void v8::internal::IncrementalMarking::EnsureMarkingDequeIsCommitted ( )

private

Definition at line 484 of file incremental-marking.cc.

                                                       {
  if (marking_deque_memory_ == NULL) {
    marking_deque_memory_ = new base::VirtualMemory(4 * MB);
  }
  if (!marking_deque_memory_committed_) {
    bool success = marking_deque_memory_->Commit(
        reinterpret_cast<Address>(marking_deque_memory_->address()),
        marking_deque_memory_->size(),
        false);  // Not executable.
    CHECK(success);
    marking_deque_memory_committed_ = true;
  }
}

References v8::base::VirtualMemory::address(), CHECK, v8::base::VirtualMemory::Commit(), marking_deque_memory_, marking_deque_memory_committed_, v8::internal::MB, NULL, and v8::base::VirtualMemory::size().

Referenced by StartMarking().

Here is the call graph for this function:

Here is the caller graph for this function:

EnterNoMarkingScope()

void v8::internal::IncrementalMarking::EnterNoMarkingScope ( )

inline

Definition at line 158 of file incremental-marking.h.

{ no_marking_scope_depth_++; }

References no_marking_scope_depth_.

Referenced by v8::internal::DescriptorArray::WhitenessWitness::WhitenessWitness().

Here is the caller graph for this function:

Finalize()

void v8::internal::IncrementalMarking::Finalize

(

)

Definition at line 786 of file incremental-marking.cc.

                                  {
  Hurry();
  state_ = STOPPED;
  is_compacting_ = false;
  heap_->new_space()->LowerInlineAllocationLimit(0);
  IncrementalMarking::set_should_hurry(false);
  ResetStepCounters();
  PatchIncrementalMarkingRecordWriteStubs(heap_,
                                          RecordWriteStub::STORE_BUFFER_ONLY);
  DeactivateIncrementalWriteBarrier();
  DCHECK(marking_deque_.IsEmpty());
  heap_->isolate()->stack_guard()->ClearGC();
}

References DCHECK, DeactivateIncrementalWriteBarrier(), heap_, Hurry(), is_compacting_, v8::internal::MarkingDeque::IsEmpty(), v8::internal::Heap::isolate(), v8::internal::NewSpace::LowerInlineAllocationLimit(), marking_deque_, v8::internal::Heap::new_space(), v8::internal::PatchIncrementalMarkingRecordWriteStubs(), ResetStepCounters(), set_should_hurry(), v8::internal::Isolate::stack_guard(), state_, STOPPED, and v8::internal::RecordWriteStub::STORE_BUFFER_ONLY.

Referenced by v8::internal::MarkCompactCollector::MarkLiveObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

Hurry()

void v8::internal::IncrementalMarking::Hurry

(

)

Definition at line 708 of file incremental-marking.cc.

                               {
  if (state() == MARKING) {
    double start = 0.0;
    if (FLAG_trace_incremental_marking || FLAG_print_cumulative_gc_stat) {
      start = base::OS::TimeCurrentMillis();
      if (FLAG_trace_incremental_marking) {
        PrintF("[IncrementalMarking] Hurry\n");
      }
    }
    // TODO(gc) hurry can mark objects it encounters black as mutator
    // was stopped.
    ProcessMarkingDeque();
    state_ = COMPLETE;
    if (FLAG_trace_incremental_marking || FLAG_print_cumulative_gc_stat) {
      double end = base::OS::TimeCurrentMillis();
      double delta = end - start;
      heap_->tracer()->AddMarkingTime(delta);
      if (FLAG_trace_incremental_marking) {
        PrintF("[IncrementalMarking] Complete (hurry), spent %d ms.\n",
               static_cast<int>(delta));
      }
    }
  }
 
  if (FLAG_cleanup_code_caches_at_gc) {
    PolymorphicCodeCache* poly_cache = heap_->polymorphic_code_cache();
    Marking::GreyToBlack(Marking::MarkBitFrom(poly_cache));
    MemoryChunk::IncrementLiveBytesFromGC(poly_cache->address(),
                                          PolymorphicCodeCache::kSize);
  }
 
  Object* context = heap_->native_contexts_list();
  while (!context->IsUndefined()) {
    // GC can happen when the context is not fully initialized,
    // so the cache can be undefined.
    HeapObject* cache = HeapObject::cast(
        Context::cast(context)->get(Context::NORMALIZED_MAP_CACHE_INDEX));
    if (!cache->IsUndefined()) {
      MarkBit mark_bit = Marking::MarkBitFrom(cache);
      if (Marking::IsGrey(mark_bit)) {
        Marking::GreyToBlack(mark_bit);
        MemoryChunk::IncrementLiveBytesFromGC(cache->address(), cache->Size());
      }
    }
    context = Context::cast(context)->get(Context::NEXT_CONTEXT_LINK);
  }
}

References v8::internal::GCTracer::AddMarkingTime(), v8::internal::HeapObject::address(), v8::internal::Context::cast(), COMPLETE, v8::internal::FixedArray::get(), heap_, v8::internal::MemoryChunk::IncrementLiveBytesFromGC(), v8::internal::PolymorphicCodeCache::kSize, MARKING, v8::internal::Heap::native_contexts_list(), v8::internal::Context::NEXT_CONTEXT_LINK, v8::internal::Context::NORMALIZED_MAP_CACHE_INDEX, v8::internal::PrintF(), v8::internal::HeapObject::Size(), state(), state_, v8::base::OS::TimeCurrentMillis(), and v8::internal::Heap::tracer().

Referenced by Finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

Initialize()

void v8::internal::IncrementalMarking::Initialize ( )

static

Definition at line 311 of file incremental-marking.cc.

                                    {
  IncrementalMarkingMarkingVisitor::Initialize();
}

References v8::internal::IncrementalMarkingMarkingVisitor::Initialize().

Referenced by v8::internal::MarkCompactCollector::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

INLINE() [1/8]

v8::internal::IncrementalMarking::INLINE

(

bool

BaseRecordWriteHeapObject *obj, Object **slot, Object *value

)

INLINE() [2/8]

v8::internal::IncrementalMarking::INLINE ( bool   IsMarking() )

inline

Definition at line 39 of file incremental-marking.h.

{ return state() >= MARKING; }

References MARKING, and state().

Here is the call graph for this function:

INLINE() [3/8]

v8::internal::IncrementalMarking::INLINE ( intptr_t   ProcessMarkingDequeintptr_t bytes_to_process )

private

INLINE() [4/8]

v8::internal::IncrementalMarking::INLINE ( void   ProcessMarkingDeque() )

private

INLINE() [5/8]

v8::internal::IncrementalMarking::INLINE

(

void

RecordWriteHeapObject *obj, Object **slot, Object *value

)

INLINE() [6/8]

v8::internal::IncrementalMarking::INLINE

(

void

RecordWriteIntoCodeHeapObject *obj, RelocInfo *rinfo, Object *value

)

INLINE() [7/8]

v8::internal::IncrementalMarking::INLINE

(

void

RecordWriteOfCodeEntryJSFunction *host, Object **slot, Code *value

)

INLINE() [8/8]

v8::internal::IncrementalMarking::INLINE ( void   VisitObjectMap *map, HeapObject *obj, int size )

private

IsCompacting()

bool v8::internal::IncrementalMarking::IsCompacting ( )

inline

Definition at line 140 of file incremental-marking.h.

{ return IsMarking() && is_compacting_; }

References is_compacting_.

Referenced by ActivateGeneratedStub(), v8::internal::MarkCompactCollector::InvalidateCode(), v8::internal::Heap::SelectScavengingVisitorsTable(), and SetOldSpacePageFlags().

Here is the caller graph for this function:

IsComplete()

bool v8::internal::IncrementalMarking::IsComplete ( )

inline

Definition at line 43 of file incremental-marking.h.

{ return state() == COMPLETE; }

References COMPLETE, and state().

Here is the call graph for this function:

IsMarkingIncomplete()

bool v8::internal::IncrementalMarking::IsMarkingIncomplete ( )

inline

Definition at line 41 of file incremental-marking.h.

{ return state() == MARKING; }

References MARKING, and state().

Referenced by v8::internal::FreeList::Allocate().

Here is the call graph for this function:

Here is the caller graph for this function:

IsStopped()

bool v8::internal::IncrementalMarking::IsStopped ( )

inline

Definition at line 37 of file incremental-marking.h.

{ return state() == STOPPED; }

References state(), and STOPPED.

Referenced by Abort(), v8::internal::MarkCompactCollector::CollectGarbage(), v8::internal::Heap::IdleNotification(), OldSpaceStep(), and v8::internal::Heap::WorthActivatingIncrementalMarking().

Here is the call graph for this function:

Here is the caller graph for this function:

LeaveNoMarkingScope()

void v8::internal::IncrementalMarking::LeaveNoMarkingScope ( )

inline

Definition at line 160 of file incremental-marking.h.

{ no_marking_scope_depth_--; }

References no_marking_scope_depth_.

marking_deque()

MarkingDeque* v8::internal::IncrementalMarking::marking_deque ( )

inline

Definition at line 138 of file incremental-marking.h.

{ return &marking_deque_; }

References marking_deque_.

Referenced by v8::internal::MarkCompactCollector::MarkLiveObjects(), and v8::internal::IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental().

Here is the caller graph for this function:

MarkingComplete()

void v8::internal::IncrementalMarking::MarkingComplete

(

CompletionAction

action

)

Definition at line 801 of file incremental-marking.cc.

                                                                {
  state_ = COMPLETE;
  // We will set the stack guard to request a GC now.  This will mean the rest
  // of the GC gets performed as soon as possible (we can't do a GC here in a
  // record-write context).  If a few things get allocated between now and then
  // that shouldn't make us do a scavenge and keep being incremental, so we set
  // the should-hurry flag to indicate that there can't be much work left to do.
  set_should_hurry(true);
  if (FLAG_trace_incremental_marking) {
    PrintF("[IncrementalMarking] Complete (normal).\n");
  }
  if (action == GC_VIA_STACK_GUARD) {
    heap_->isolate()->stack_guard()->RequestGC();
  }
}

References COMPLETE, GC_VIA_STACK_GUARD, heap_, v8::internal::Heap::isolate(), v8::internal::PrintF(), set_should_hurry(), v8::internal::Isolate::stack_guard(), and state_.

Referenced by Step().

Here is the call graph for this function:

Here is the caller graph for this function:

NotifyIncompleteScanOfObject()

void v8::internal::IncrementalMarking::NotifyIncompleteScanOfObject ( int  unscanned_bytes )

inline

Definition at line 164 of file incremental-marking.h.

                                                         {
    unscanned_bytes_of_large_object_ = unscanned_bytes;
  }

References unscanned_bytes_of_large_object_.

Referenced by v8::internal::IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental().

Here is the caller graph for this function:

NotifyOfHighPromotionRate()

void v8::internal::IncrementalMarking::NotifyOfHighPromotionRate ( )

inline

Definition at line 144 of file incremental-marking.h.

                                   {
    if (IsMarking()) {
      if (marking_speed_ < kFastMarking) {
        if (FLAG_trace_gc) {
          PrintPID(
              "Increasing marking speed to %d "
              "due to high promotion rate\n",
              static_cast<int>(kFastMarking));
        }
        marking_speed_ = kFastMarking;
      }
    }
  }

References kFastMarking, marking_speed_, and v8::internal::PrintPID().

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

Here is the call graph for this function:

Here is the caller graph for this function:

OldSpaceStep()

void v8::internal::IncrementalMarking::OldSpaceStep

(

intptr_t

allocated

)

Definition at line 818 of file incremental-marking.cc.

                                                        {
  if (IsStopped() && ShouldActivate()) {
    // TODO(hpayer): Let's play safe for now, but compaction should be
    // in principle possible.
    Start(PREVENT_COMPACTION);
  } else {
    Step(allocated * kFastMarking / kInitialMarkingSpeed, GC_VIA_STACK_GUARD);
  }
}

References GC_VIA_STACK_GUARD, IsStopped(), kFastMarking, kInitialMarkingSpeed, PREVENT_COMPACTION, ShouldActivate(), Start(), and Step().

Referenced by v8::internal::FreeList::Allocate(), and v8::internal::LargeObjectSpace::AllocateRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

PrepareForScavenge()

void v8::internal::IncrementalMarking::PrepareForScavenge

(

)

Definition at line 592 of file incremental-marking.cc.

                                            {
  if (!IsMarking()) return;
  NewSpacePageIterator it(heap_->new_space()->FromSpaceStart(),
                          heap_->new_space()->FromSpaceEnd());
  while (it.has_next()) {
    Bitmap::Clear(it.next());
  }
}

References v8::internal::Bitmap::Clear(), v8::internal::NewSpace::FromSpaceEnd(), v8::internal::NewSpace::FromSpaceStart(), heap_, and v8::internal::Heap::new_space().

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

Here is the call graph for this function:

Here is the caller graph for this function:

RecordCodeTargetPatch() [1/2]

void v8::internal::IncrementalMarking::RecordCodeTargetPatch	(	Address	pc,
		HeapObject *	value
	)

Definition at line 78 of file incremental-marking.cc.

                                                                            {
  if (IsMarking()) {
    Code* host = heap_->isolate()
                     ->inner_pointer_to_code_cache()
                     ->GcSafeFindCodeForInnerPointer(pc);
    RelocInfo rinfo(pc, RelocInfo::CODE_TARGET, 0, host);
    RecordWriteIntoCode(host, &rinfo, value);
  }
}

References v8::internal::RelocInfo::CODE_TARGET, v8::internal::InnerPointerToCodeCache::GcSafeFindCodeForInnerPointer(), heap_, v8::internal::Isolate::inner_pointer_to_code_cache(), v8::internal::Heap::isolate(), and v8::internal::pc.

Here is the call graph for this function:

RecordCodeTargetPatch() [2/2]

void v8::internal::IncrementalMarking::RecordCodeTargetPatch	(	Code *	host,
		Address	pc,
		HeapObject *	value
	)

Definition at line 69 of file incremental-marking.cc.

                                                                  {
  if (IsMarking()) {
    RelocInfo rinfo(pc, RelocInfo::CODE_TARGET, 0, host);
    RecordWriteIntoCode(host, &rinfo, value);
  }
}

References v8::internal::RelocInfo::CODE_TARGET, and v8::internal::pc.

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

Here is the caller graph for this function:

RecordWriteFromCode()

void v8::internal::IncrementalMarking::RecordWriteFromCode ( HeapObject *  obj, Object **  slot, Isolate *  isolate  )

static

Definition at line 50 of file incremental-marking.cc.

                                                               {
  DCHECK(obj->IsHeapObject());
  IncrementalMarking* marking = isolate->heap()->incremental_marking();
 
  MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
  int counter = chunk->write_barrier_counter();
  if (counter < (MemoryChunk::kWriteBarrierCounterGranularity / 2)) {
    marking->write_barriers_invoked_since_last_step_ +=
        MemoryChunk::kWriteBarrierCounterGranularity -
        chunk->write_barrier_counter();
    chunk->set_write_barrier_counter(
        MemoryChunk::kWriteBarrierCounterGranularity);
  }
 
  marking->RecordWrite(obj, slot, *slot);
}

References v8::internal::HeapObject::address(), DCHECK, v8::internal::MemoryChunk::FromAddress(), v8::internal::Isolate::heap(), v8::internal::Heap::incremental_marking(), v8::internal::MemoryChunk::kWriteBarrierCounterGranularity, v8::internal::MemoryChunk::set_write_barrier_counter(), v8::internal::MemoryChunk::write_barrier_counter(), and write_barriers_invoked_since_last_step_.

Here is the call graph for this function:

RecordWriteIntoCodeSlow()

void v8::internal::IncrementalMarking::RecordWriteIntoCodeSlow	(	HeapObject *	obj,
		RelocInfo *	rinfo,
		Object *	value
	)

Definition at line 100 of file incremental-marking.cc.

                                                                {
  MarkBit value_bit = Marking::MarkBitFrom(HeapObject::cast(value));
  if (Marking::IsWhite(value_bit)) {
    MarkBit obj_bit = Marking::MarkBitFrom(obj);
    if (Marking::IsBlack(obj_bit)) {
      BlackToGreyAndUnshift(obj, obj_bit);
      RestartIfNotMarking();
    }
    // Object is either grey or white.  It will be scanned if survives.
    return;
  }
 
  if (is_compacting_) {
    MarkBit obj_bit = Marking::MarkBitFrom(obj);
    if (Marking::IsBlack(obj_bit)) {
      // Object is not going to be rescanned.  We need to record the slot.
      heap_->mark_compact_collector()->RecordRelocSlot(rinfo,
                                                       Code::cast(value));
    }
  }
}

References BlackToGreyAndUnshift(), heap_, is_compacting_, v8::internal::Heap::mark_compact_collector(), v8::internal::MarkCompactCollector::RecordRelocSlot(), and RestartIfNotMarking().

Here is the call graph for this function:

RecordWriteOfCodeEntrySlow()

void v8::internal::IncrementalMarking::RecordWriteOfCodeEntrySlow	(	JSFunction *	host,
		Object **	slot,
		Code *	value
	)

Definition at line 89 of file incremental-marking.cc.

                                                                 {
  if (BaseRecordWrite(host, slot, value)) {
    DCHECK(slot != NULL);
    heap_->mark_compact_collector()->RecordCodeEntrySlot(
        reinterpret_cast<Address>(slot), value);
  }
}

References DCHECK, heap_, v8::internal::Heap::mark_compact_collector(), NULL, and v8::internal::MarkCompactCollector::RecordCodeEntrySlot().

Here is the call graph for this function:

RecordWrites()

void v8::internal::IncrementalMarking::RecordWrites ( HeapObject *  obj )

inline

Definition at line 66 of file incremental-marking-inl.h.

                                                     {
  if (IsMarking()) {
    MarkBit obj_bit = Marking::MarkBitFrom(obj);
    if (Marking::IsBlack(obj_bit)) {
      MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
      if (chunk->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR)) {
        chunk->set_progress_bar(0);
      }
      BlackToGreyAndUnshift(obj, obj_bit);
      RestartIfNotMarking();
    }
  }
}

References v8::internal::HeapObject::address(), BlackToGreyAndUnshift(), v8::internal::MemoryChunk::FromAddress(), v8::internal::MemoryChunk::HAS_PROGRESS_BAR, v8::internal::MemoryChunk::IsFlagSet(), RestartIfNotMarking(), and v8::internal::MemoryChunk::set_progress_bar().

Referenced by v8::internal::CopyDictionaryToObjectElements(), v8::internal::CopyObjectToObjectElements(), v8::internal::Map::DeprecateTarget(), v8::internal::Map::EnsureDescriptorSlack(), v8::internal::CodeFlusher::EvictCandidate(), v8::internal::CodeFlusher::EvictOptimizedCodeMap(), and v8::internal::Heap::MoveElements().

Here is the call graph for this function:

Here is the caller graph for this function:

RecordWriteSlow()

void v8::internal::IncrementalMarking::RecordWriteSlow	(	HeapObject *	obj,
		Object **	slot,
		Object *	value
	)

Definition at line 37 of file incremental-marking.cc.

                                                        {
  if (BaseRecordWrite(obj, slot, value) && slot != NULL) {
    MarkBit obj_bit = Marking::MarkBitFrom(obj);
    if (Marking::IsBlack(obj_bit)) {
      // Object is not going to be rescanned we need to record the slot.
      heap_->mark_compact_collector()->RecordSlot(HeapObject::RawField(obj, 0),
                                                  slot, value);
    }
  }
}

References heap_, v8::internal::Heap::mark_compact_collector(), NULL, and v8::internal::HeapObject::RawField().

Here is the call graph for this function:

ResetStepCounters()

void v8::internal::IncrementalMarking::ResetStepCounters ( )

private

Definition at line 965 of file incremental-marking.cc.

                                           {
  steps_count_ = 0;
  old_generation_space_available_at_start_of_incremental_ =
      SpaceLeftInOldSpace();
  old_generation_space_used_at_start_of_incremental_ =
      heap_->PromotedTotalSize();
  bytes_rescanned_ = 0;
  marking_speed_ = kInitialMarkingSpeed;
  bytes_scanned_ = 0;
  write_barriers_invoked_since_last_step_ = 0;
}

References bytes_rescanned_, bytes_scanned_, heap_, kInitialMarkingSpeed, marking_speed_, old_generation_space_available_at_start_of_incremental_, old_generation_space_used_at_start_of_incremental_, v8::internal::Heap::PromotedTotalSize(), SpaceLeftInOldSpace(), steps_count_, and write_barriers_invoked_since_last_step_.

Referenced by Abort(), Finalize(), and Start().

Here is the call graph for this function:

Here is the caller graph for this function:

RestartIfNotMarking()

void v8::internal::IncrementalMarking::RestartIfNotMarking ( )

inline

Definition at line 91 of file incremental-marking.h.

                                    {
    if (state_ == COMPLETE) {
      state_ = MARKING;
      if (FLAG_trace_incremental_marking) {
        PrintF("[IncrementalMarking] Restarting (new grey objects)\n");
      }
    }
  }

References COMPLETE, MARKING, v8::internal::PrintF(), and state_.

Referenced by RecordWriteIntoCodeSlow(), RecordWrites(), and v8::internal::Marking::TransferMark().

Here is the call graph for this function:

Here is the caller graph for this function:

set_should_hurry()

void v8::internal::IncrementalMarking::set_should_hurry ( bool  val )

inline

Definition at line 35 of file incremental-marking.h.

{ should_hurry_ = val; }

References should_hurry_.

Referenced by Abort(), Finalize(), and MarkingComplete().

Here is the caller graph for this function:

SetNewSpacePageFlags() [1/2]

void v8::internal::IncrementalMarking::SetNewSpacePageFlags ( NewSpacePage *  chunk )

inline

Definition at line 134 of file incremental-marking.h.

                                                        {
    SetNewSpacePageFlags(chunk, IsMarking());
  }

Referenced by ActivateIncrementalWriteBarrier(), DeactivateIncrementalWriteBarrierForSpace(), and v8::internal::NewSpacePage::Initialize().

Here is the caller graph for this function:

SetNewSpacePageFlags() [2/2]

void v8::internal::IncrementalMarking::SetNewSpacePageFlags ( NewSpacePage *  chunk, bool  is_marking  )

staticprivate

Definition at line 340 of file incremental-marking.cc.

                                                               {
  chunk->SetFlag(MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING);
  if (is_marking) {
    chunk->SetFlag(MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING);
  } else {
    chunk->ClearFlag(MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING);
  }
  chunk->SetFlag(MemoryChunk::SCAN_ON_SCAVENGE);
}

References v8::internal::MemoryChunk::ClearFlag(), v8::internal::MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING, v8::internal::MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING, v8::internal::MemoryChunk::SCAN_ON_SCAVENGE, and v8::internal::MemoryChunk::SetFlag().

Here is the call graph for this function:

SetOldSpacePageFlags() [1/2]

void v8::internal::IncrementalMarking::SetOldSpacePageFlags ( MemoryChunk *  chunk )

inline

Definition at line 130 of file incremental-marking.h.

                                                       {
    SetOldSpacePageFlags(chunk, IsMarking(), IsCompacting());
  }

References IsCompacting().

Referenced by ActivateIncrementalWriteBarrier(), DeactivateIncrementalWriteBarrier(), DeactivateIncrementalWriteBarrierForSpace(), v8::internal::LargePage::Initialize(), v8::internal::Page::Initialize(), and v8::internal::MemoryChunk::set_scan_on_scavenge().

Here is the call graph for this function:

Here is the caller graph for this function:

SetOldSpacePageFlags() [2/2]

void v8::internal::IncrementalMarking::SetOldSpacePageFlags ( MemoryChunk *  chunk, bool  is_marking, bool  is_compacting  )

staticprivate

Definition at line 316 of file incremental-marking.cc.

                                                                  {
  if (is_marking) {
    chunk->SetFlag(MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING);
    chunk->SetFlag(MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING);
 
    // It's difficult to filter out slots recorded for large objects.
    if (chunk->owner()->identity() == LO_SPACE &&
        chunk->size() > static_cast<size_t>(Page::kPageSize) && is_compacting) {
      chunk->SetFlag(MemoryChunk::RESCAN_ON_EVACUATION);
    }
  } else if (chunk->owner()->identity() == CELL_SPACE ||
             chunk->owner()->identity() == PROPERTY_CELL_SPACE ||
             chunk->scan_on_scavenge()) {
    chunk->ClearFlag(MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING);
    chunk->ClearFlag(MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING);
  } else {
    chunk->ClearFlag(MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING);
    chunk->SetFlag(MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING);
  }
}

References v8::internal::CELL_SPACE, v8::internal::MemoryChunk::ClearFlag(), v8::internal::Space::identity(), v8::internal::Page::kPageSize, v8::internal::LO_SPACE, v8::internal::MemoryChunk::owner(), v8::internal::MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING, v8::internal::MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING, v8::internal::PROPERTY_CELL_SPACE, v8::internal::MemoryChunk::RESCAN_ON_EVACUATION, v8::internal::MemoryChunk::scan_on_scavenge(), v8::internal::MemoryChunk::SetFlag(), and v8::internal::MemoryChunk::size().

Here is the call graph for this function:

should_hurry()

bool v8::internal::IncrementalMarking::should_hurry ( )

inline

Definition at line 34 of file incremental-marking.h.

{ return should_hurry_; }

References should_hurry_.

ShouldActivate()

bool v8::internal::IncrementalMarking::ShouldActivate

(

)

Definition at line 424 of file incremental-marking.cc.

                                        {
  return WorthActivating() && heap_->NextGCIsLikelyToBeFull();
}

References heap_, v8::internal::Heap::NextGCIsLikelyToBeFull(), and WorthActivating().

Referenced by v8::internal::Heap::IdleNotification(), and OldSpaceStep().

Here is the call graph for this function:

Here is the caller graph for this function:

SpaceLeftInOldSpace()

int64_t v8::internal::IncrementalMarking::SpaceLeftInOldSpace ( )

private

Definition at line 978 of file incremental-marking.cc.

                                                {
  return heap_->MaxOldGenerationSize() - heap_->PromotedSpaceSizeOfObjects();
}

References heap_, v8::internal::Heap::MaxOldGenerationSize(), and v8::internal::Heap::PromotedSpaceSizeOfObjects().

Referenced by ResetStepCounters(), and SpeedUp().

Here is the call graph for this function:

Here is the caller graph for this function:

SpeedUp()

void v8::internal::IncrementalMarking::SpeedUp ( )

private

Definition at line 829 of file incremental-marking.cc.

                                 {
  bool speed_up = false;
 
  if ((steps_count_ % kMarkingSpeedAccellerationInterval) == 0) {
    if (FLAG_trace_gc) {
      PrintPID("Speed up marking after %d steps\n",
               static_cast<int>(kMarkingSpeedAccellerationInterval));
    }
    speed_up = true;
  }
 
  bool space_left_is_very_small =
      (old_generation_space_available_at_start_of_incremental_ < 10 * MB);
 
  bool only_1_nth_of_space_that_was_available_still_left =
      (SpaceLeftInOldSpace() * (marking_speed_ + 1) <
       old_generation_space_available_at_start_of_incremental_);
 
  if (space_left_is_very_small ||
      only_1_nth_of_space_that_was_available_still_left) {
    if (FLAG_trace_gc) PrintPID("Speed up marking because of low space left\n");
    speed_up = true;
  }
 
  bool size_of_old_space_multiplied_by_n_during_marking =
      (heap_->PromotedTotalSize() >
       (marking_speed_ + 1) *
           old_generation_space_used_at_start_of_incremental_);
  if (size_of_old_space_multiplied_by_n_during_marking) {
    speed_up = true;
    if (FLAG_trace_gc) {
      PrintPID("Speed up marking because of heap size increase\n");
    }
  }
 
  int64_t promoted_during_marking =
      heap_->PromotedTotalSize() -
      old_generation_space_used_at_start_of_incremental_;
  intptr_t delay = marking_speed_ * MB;
  intptr_t scavenge_slack = heap_->MaxSemiSpaceSize();
 
  // We try to scan at at least twice the speed that we are allocating.
  if (promoted_during_marking > bytes_scanned_ / 2 + scavenge_slack + delay) {
    if (FLAG_trace_gc) {
      PrintPID("Speed up marking because marker was not keeping up\n");
    }
    speed_up = true;
  }
 
  if (speed_up) {
    if (state_ != MARKING) {
      if (FLAG_trace_gc) {
        PrintPID("Postponing speeding up marking until marking starts\n");
      }
    } else {
      marking_speed_ += kMarkingSpeedAccelleration;
      marking_speed_ = static_cast<int>(
          Min(kMaxMarkingSpeed, static_cast<intptr_t>(marking_speed_ * 1.3)));
      if (FLAG_trace_gc) {
        PrintPID("Marking speed increased to %d\n", marking_speed_);
      }
    }
  }
}

References bytes_scanned_, heap_, kMarkingSpeedAccelleration, kMarkingSpeedAccellerationInterval, kMaxMarkingSpeed, MARKING, marking_speed_, v8::internal::Heap::MaxSemiSpaceSize(), v8::internal::MB, v8::internal::Min(), old_generation_space_available_at_start_of_incremental_, old_generation_space_used_at_start_of_incremental_, v8::internal::PrintPID(), v8::internal::Heap::PromotedTotalSize(), SpaceLeftInOldSpace(), state_, and steps_count_.

Referenced by Step().

Here is the call graph for this function:

Here is the caller graph for this function:

Start()

void v8::internal::IncrementalMarking::Start

(

CompactionFlag

flag = ALLOW_COMPACTION

)

Definition at line 510 of file incremental-marking.cc.

                                                  {
  if (FLAG_trace_incremental_marking) {
    PrintF("[IncrementalMarking] Start\n");
  }
  DCHECK(FLAG_incremental_marking);
  DCHECK(FLAG_incremental_marking_steps);
  DCHECK(state_ == STOPPED);
  DCHECK(heap_->gc_state() == Heap::NOT_IN_GC);
  DCHECK(!heap_->isolate()->serializer_enabled());
  DCHECK(heap_->isolate()->IsInitialized());
 
  ResetStepCounters();
 
  if (!heap_->mark_compact_collector()->sweeping_in_progress()) {
    StartMarking(flag);
  } else {
    if (FLAG_trace_incremental_marking) {
      PrintF("[IncrementalMarking] Start sweeping.\n");
    }
    state_ = SWEEPING;
  }
 
  heap_->new_space()->LowerInlineAllocationLimit(kAllocatedThreshold);
}

References DCHECK, v8::internal::flag, v8::internal::Heap::gc_state(), heap_, v8::internal::Isolate::IsInitialized(), v8::internal::Heap::isolate(), kAllocatedThreshold, v8::internal::NewSpace::LowerInlineAllocationLimit(), v8::internal::Heap::mark_compact_collector(), v8::internal::Heap::new_space(), v8::internal::Heap::NOT_IN_GC, v8::internal::PrintF(), ResetStepCounters(), v8::internal::Isolate::serializer_enabled(), StartMarking(), state_, STOPPED, SWEEPING, and v8::internal::MarkCompactCollector::sweeping_in_progress().

Referenced by v8::internal::Heap::CollectGarbage(), v8::internal::Heap::IdleNotification(), and OldSpaceStep().

Here is the call graph for this function:

Here is the caller graph for this function:

StartMarking()

void v8::internal::IncrementalMarking::StartMarking ( CompactionFlag  flag )

private

Definition at line 536 of file incremental-marking.cc.

                                                         {
  if (FLAG_trace_incremental_marking) {
    PrintF("[IncrementalMarking] Start marking\n");
  }
 
  is_compacting_ = !FLAG_never_compact && (flag == ALLOW_COMPACTION) &&
                   heap_->mark_compact_collector()->StartCompaction(
                       MarkCompactCollector::INCREMENTAL_COMPACTION);
 
  state_ = MARKING;
 
  RecordWriteStub::Mode mode = is_compacting_
                                   ? RecordWriteStub::INCREMENTAL_COMPACTION
                                   : RecordWriteStub::INCREMENTAL;
 
  PatchIncrementalMarkingRecordWriteStubs(heap_, mode);
 
  EnsureMarkingDequeIsCommitted();
 
  // Initialize marking stack.
  Address addr = static_cast<Address>(marking_deque_memory_->address());
  size_t size = marking_deque_memory_->size();
  if (FLAG_force_marking_deque_overflows) size = 64 * kPointerSize;
  marking_deque_.Initialize(addr, addr + size);
 
  ActivateIncrementalWriteBarrier();
 
// Marking bits are cleared by the sweeper.
#ifdef VERIFY_HEAP
  if (FLAG_verify_heap) {
    heap_->mark_compact_collector()->VerifyMarkbitsAreClean();
  }
#endif
 
  heap_->CompletelyClearInstanceofCache();
  heap_->isolate()->compilation_cache()->MarkCompactPrologue();
 
  if (FLAG_cleanup_code_caches_at_gc) {
    // We will mark cache black with a separate pass
    // when we finish marking.
    MarkObjectGreyDoNotEnqueue(heap_->polymorphic_code_cache());
  }
 
  // Mark strong roots grey.
  IncrementalMarkingRootMarkingVisitor visitor(this);
  heap_->IterateStrongRoots(&visitor, VISIT_ONLY_STRONG);
 
  heap_->mark_compact_collector()->MarkWeakObjectToCodeTable();
 
  // Ready to start incremental marking.
  if (FLAG_trace_incremental_marking) {
    PrintF("[IncrementalMarking] Running\n");
  }
}

References ActivateIncrementalWriteBarrier(), v8::base::VirtualMemory::address(), ALLOW_COMPACTION, v8::internal::Isolate::compilation_cache(), v8::internal::Heap::CompletelyClearInstanceofCache(), EnsureMarkingDequeIsCommitted(), v8::internal::flag, heap_, v8::internal::RecordWriteStub::INCREMENTAL, v8::internal::RecordWriteStub::INCREMENTAL_COMPACTION, v8::internal::MarkCompactCollector::INCREMENTAL_COMPACTION, v8::internal::MarkingDeque::Initialize(), is_compacting_, v8::internal::Heap::isolate(), v8::internal::Heap::IterateStrongRoots(), v8::internal::kPointerSize, v8::internal::Heap::mark_compact_collector(), v8::internal::CompilationCache::MarkCompactPrologue(), MARKING, marking_deque_, marking_deque_memory_, v8::internal::MarkObjectGreyDoNotEnqueue(), v8::internal::MarkCompactCollector::MarkWeakObjectToCodeTable(), mode(), v8::internal::PatchIncrementalMarkingRecordWriteStubs(), v8::internal::PrintF(), v8::base::VirtualMemory::size(), size, v8::internal::MarkCompactCollector::StartCompaction(), state_, and v8::internal::VISIT_ONLY_STRONG.

Referenced by Start(), and Step().

Here is the call graph for this function:

Here is the caller graph for this function:

state()

State v8::internal::IncrementalMarking::state ( )

inline

Definition at line 29 of file incremental-marking.h.

                {
    DCHECK(state_ == STOPPED || FLAG_incremental_marking);
    return state_;
  }

References DCHECK, state_, and STOPPED.

Referenced by Hurry(), INLINE(), IsComplete(), IsMarkingIncomplete(), and IsStopped().

Here is the caller graph for this function:

Step()

void v8::internal::IncrementalMarking::Step	(	intptr_t	allocated,
		CompletionAction	action,
		bool	force_marking = false
	)

Definition at line 895 of file incremental-marking.cc.

                                                  {
  if (heap_->gc_state() != Heap::NOT_IN_GC || !FLAG_incremental_marking ||
      !FLAG_incremental_marking_steps ||
      (state_ != SWEEPING && state_ != MARKING)) {
    return;
  }
 
  allocated_ += allocated_bytes;
 
  if (!force_marking && allocated_ < kAllocatedThreshold &&
      write_barriers_invoked_since_last_step_ <
          kWriteBarriersInvokedThreshold) {
    return;
  }
 
  if (state_ == MARKING && no_marking_scope_depth_ > 0) return;
 
  {
    HistogramTimerScope incremental_marking_scope(
        heap_->isolate()->counters()->gc_incremental_marking());
    double start = base::OS::TimeCurrentMillis();
 
    // The marking speed is driven either by the allocation rate or by the rate
    // at which we are having to check the color of objects in the write
    // barrier.
    // It is possible for a tight non-allocating loop to run a lot of write
    // barriers before we get here and check them (marking can only take place
    // on
    // allocation), so to reduce the lumpiness we don't use the write barriers
    // invoked since last step directly to determine the amount of work to do.
    intptr_t bytes_to_process =
        marking_speed_ *
        Max(allocated_, write_barriers_invoked_since_last_step_);
    allocated_ = 0;
    write_barriers_invoked_since_last_step_ = 0;
 
    bytes_scanned_ += bytes_to_process;
    intptr_t bytes_processed = 0;
 
    if (state_ == SWEEPING) {
      if (heap_->mark_compact_collector()->sweeping_in_progress() &&
          heap_->mark_compact_collector()->IsSweepingCompleted()) {
        heap_->mark_compact_collector()->EnsureSweepingCompleted();
      }
      if (!heap_->mark_compact_collector()->sweeping_in_progress()) {
        bytes_scanned_ = 0;
        StartMarking(PREVENT_COMPACTION);
      }
    } else if (state_ == MARKING) {
      bytes_processed = ProcessMarkingDeque(bytes_to_process);
      if (marking_deque_.IsEmpty()) MarkingComplete(action);
    }
 
    steps_count_++;
 
    // Speed up marking if we are marking too slow or if we are almost done
    // with marking.
    SpeedUp();
 
    double end = base::OS::TimeCurrentMillis();
    double duration = (end - start);
    // Note that we report zero bytes here when sweeping was in progress or
    // when we just started incremental marking. In these cases we did not
    // process the marking deque.
    heap_->tracer()->AddIncrementalMarkingStep(duration, bytes_processed);
  }
}

References v8::internal::GCTracer::AddIncrementalMarkingStep(), allocated_, bytes_scanned_, v8::internal::Isolate::counters(), v8::internal::MarkCompactCollector::EnsureSweepingCompleted(), v8::internal::Heap::gc_state(), heap_, v8::internal::MarkingDeque::IsEmpty(), v8::internal::Heap::isolate(), v8::internal::MarkCompactCollector::IsSweepingCompleted(), kAllocatedThreshold, kWriteBarriersInvokedThreshold, v8::internal::Heap::mark_compact_collector(), MARKING, marking_deque_, marking_speed_, MarkingComplete(), v8::internal::Max(), no_marking_scope_depth_, v8::internal::Heap::NOT_IN_GC, PREVENT_COMPACTION, SpeedUp(), StartMarking(), state_, steps_count_, SWEEPING, v8::internal::MarkCompactCollector::sweeping_in_progress(), v8::base::OS::TimeCurrentMillis(), v8::internal::Heap::tracer(), and write_barriers_invoked_since_last_step_.

Referenced by v8::internal::Heap::AdvanceIdleIncrementalMarking(), v8::internal::Heap::CollectGarbage(), OldSpaceStep(), and v8::internal::NewSpace::SlowAllocateRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

Stop()

void v8::internal::IncrementalMarking::Stop

(

)

TearDown()

void v8::internal::IncrementalMarking::TearDown

(

)

Definition at line 34 of file incremental-marking.cc.

{ delete marking_deque_memory_; }

References marking_deque_memory_.

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

Here is the caller graph for this function:

UncommitMarkingDeque()

void v8::internal::IncrementalMarking::UncommitMarkingDeque

(

)

Definition at line 499 of file incremental-marking.cc.

                                              {
  if (state_ == STOPPED && marking_deque_memory_committed_) {
    bool success = marking_deque_memory_->Uncommit(
        reinterpret_cast<Address>(marking_deque_memory_->address()),
        marking_deque_memory_->size());
    CHECK(success);
    marking_deque_memory_committed_ = false;
  }
}

References v8::base::VirtualMemory::address(), CHECK, marking_deque_memory_, marking_deque_memory_committed_, v8::base::VirtualMemory::size(), state_, STOPPED, and v8::base::VirtualMemory::Uncommit().

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

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateMarkingDequeAfterScavenge()

void v8::internal::IncrementalMarking::UpdateMarkingDequeAfterScavenge

(

)

Definition at line 602 of file incremental-marking.cc.

                                                         {
  if (!IsMarking()) return;
 
  int current = marking_deque_.bottom();
  int mask = marking_deque_.mask();
  int limit = marking_deque_.top();
  HeapObject** array = marking_deque_.array();
  int new_top = current;
 
  Map* filler_map = heap_->one_pointer_filler_map();
 
  while (current != limit) {
    HeapObject* obj = array[current];
    DCHECK(obj->IsHeapObject());
    current = ((current + 1) & mask);
    if (heap_->InNewSpace(obj)) {
      MapWord map_word = obj->map_word();
      if (map_word.IsForwardingAddress()) {
        HeapObject* dest = map_word.ToForwardingAddress();
        array[new_top] = dest;
        new_top = ((new_top + 1) & mask);
        DCHECK(new_top != marking_deque_.bottom());
#ifdef DEBUG
        MarkBit mark_bit = Marking::MarkBitFrom(obj);
        DCHECK(Marking::IsGrey(mark_bit) ||
               (obj->IsFiller() && Marking::IsWhite(mark_bit)));
#endif
      }
    } else if (obj->map() != filler_map) {
      // Skip one word filler objects that appear on the
      // stack when we perform in place array shift.
      array[new_top] = obj;
      new_top = ((new_top + 1) & mask);
      DCHECK(new_top != marking_deque_.bottom());
#ifdef DEBUG
      MarkBit mark_bit = Marking::MarkBitFrom(obj);
      MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
      DCHECK(Marking::IsGrey(mark_bit) ||
             (obj->IsFiller() && Marking::IsWhite(mark_bit)) ||
             (chunk->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR) &&
              Marking::IsBlack(mark_bit)));
#endif
    }
  }
  marking_deque_.set_top(new_top);
}

References v8::internal::HeapObject::address(), v8::internal::MarkingDeque::array(), v8::internal::MarkingDeque::bottom(), DCHECK, v8::internal::MemoryChunk::FromAddress(), v8::internal::MemoryChunk::HAS_PROGRESS_BAR, heap_, v8::internal::Heap::InNewSpace(), v8::internal::MemoryChunk::IsFlagSet(), v8::internal::HeapObject::map(), v8::internal::HeapObject::map_word(), marking_deque_, v8::internal::MarkingDeque::mask(), v8::internal::MarkingDeque::set_top(), and v8::internal::MarkingDeque::top().

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

Here is the call graph for this function:

Here is the caller graph for this function:

WhiteToGreyAndPush()

void v8::internal::IncrementalMarking::WhiteToGreyAndPush ( HeapObject *  obj, MarkBit  mark_bit  )

inline

Definition at line 110 of file incremental-marking-inl.h.

                                                                             {
  Marking::WhiteToGrey(mark_bit);
  marking_deque_.PushGrey(obj);
}

References marking_deque_.

Referenced by v8::internal::IncrementalMarkingMarkingVisitor::INLINE(), v8::internal::IncrementalMarkingRootMarkingVisitor::MarkObjectByPointer(), and v8::internal::Marking::TransferMark().

Here is the caller graph for this function:

WorthActivating()

bool v8::internal::IncrementalMarking::WorthActivating

(

)

Definition at line 429 of file incremental-marking.cc.

                                         {
#ifndef DEBUG
  static const intptr_t kActivationThreshold = 8 * MB;
#else
  // TODO(gc) consider setting this to some low level so that some
  // debug tests run with incremental marking and some without.
  static const intptr_t kActivationThreshold = 0;
#endif
  // Only start incremental marking in a safe state: 1) when incremental
  // marking is turned on, 2) when we are currently not in a GC, and
  // 3) when we are currently not serializing or deserializing the heap.
  return FLAG_incremental_marking && FLAG_incremental_marking_steps &&
         heap_->gc_state() == Heap::NOT_IN_GC &&
         !heap_->isolate()->serializer_enabled() &&
         heap_->isolate()->IsInitialized() &&
         heap_->PromotedSpaceSizeOfObjects() > kActivationThreshold;
}

References v8::internal::Heap::gc_state(), heap_, v8::internal::Isolate::IsInitialized(), v8::internal::Heap::isolate(), v8::internal::MB, v8::internal::Heap::NOT_IN_GC, v8::internal::Heap::PromotedSpaceSizeOfObjects(), and v8::internal::Isolate::serializer_enabled().

Referenced by ShouldActivate(), and v8::internal::Heap::WorthActivatingIncrementalMarking().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

allocated_

intptr_t v8::internal::IncrementalMarking::allocated_

private

Definition at line 214 of file incremental-marking.h.

Referenced by Step().

bytes_rescanned_

int64_t v8::internal::IncrementalMarking::bytes_rescanned_

private

Definition at line 210 of file incremental-marking.h.

Referenced by BlackToGreyAndUnshift(), and ResetStepCounters().

bytes_scanned_

intptr_t v8::internal::IncrementalMarking::bytes_scanned_

private

Definition at line 213 of file incremental-marking.h.

Referenced by BlackToGreyAndUnshift(), ResetStepCounters(), SpeedUp(), and Step().

heap_

Heap* v8::internal::IncrementalMarking::heap_

private

Definition at line 198 of file incremental-marking.h.

Referenced by Abort(), ActivateIncrementalWriteBarrier(), BlackToGreyAndUnshift(), DeactivateIncrementalWriteBarrier(), Finalize(), Hurry(), MarkingComplete(), PrepareForScavenge(), RecordCodeTargetPatch(), RecordWriteIntoCodeSlow(), RecordWriteOfCodeEntrySlow(), RecordWriteSlow(), ResetStepCounters(), ShouldActivate(), SpaceLeftInOldSpace(), SpeedUp(), Start(), StartMarking(), Step(), UpdateMarkingDequeAfterScavenge(), and WorthActivating().

is_compacting_

bool v8::internal::IncrementalMarking::is_compacting_

private

Definition at line 201 of file incremental-marking.h.

Referenced by Abort(), ActivateIncrementalWriteBarrier(), Finalize(), IsCompacting(), RecordWriteIntoCodeSlow(), and StartMarking().

kAllocatedThreshold

const intptr_t v8::internal::IncrementalMarking::kAllocatedThreshold = 65536

static

Definition at line 73 of file incremental-marking.h.

Referenced by v8::internal::FreeList::Allocate(), Start(), and Step().

kFastMarking

const intptr_t v8::internal::IncrementalMarking::kFastMarking = 3

static

Definition at line 79 of file incremental-marking.h.

Referenced by NotifyOfHighPromotionRate(), and OldSpaceStep().

kInitialMarkingSpeed

const intptr_t v8::internal::IncrementalMarking::kInitialMarkingSpeed = 1

static

Definition at line 76 of file incremental-marking.h.

Referenced by OldSpaceStep(), and ResetStepCounters().

kMarkingSpeedAccelleration

const intptr_t v8::internal::IncrementalMarking::kMarkingSpeedAccelleration = 2

static

Definition at line 83 of file incremental-marking.h.

Referenced by SpeedUp().

kMarkingSpeedAccellerationInterval

const intptr_t v8::internal::IncrementalMarking::kMarkingSpeedAccellerationInterval = 1024

static

Definition at line 81 of file incremental-marking.h.

Referenced by SpeedUp().

kMaxMarkingSpeed

const intptr_t v8::internal::IncrementalMarking::kMaxMarkingSpeed = 1000

static

Definition at line 84 of file incremental-marking.h.

Referenced by BlackToGreyAndUnshift(), and SpeedUp().

kWriteBarriersInvokedThreshold

const intptr_t v8::internal::IncrementalMarking::kWriteBarriersInvokedThreshold = 32768

static

Definition at line 74 of file incremental-marking.h.

Referenced by Step().

marking_deque_

MarkingDeque v8::internal::IncrementalMarking::marking_deque_

private

Definition at line 205 of file incremental-marking.h.

Referenced by BlackToGreyAndUnshift(), Finalize(), marking_deque(), StartMarking(), Step(), UpdateMarkingDequeAfterScavenge(), and WhiteToGreyAndPush().

marking_deque_memory_

base::VirtualMemory* v8::internal::IncrementalMarking::marking_deque_memory_

private

Definition at line 203 of file incremental-marking.h.

Referenced by EnsureMarkingDequeIsCommitted(), StartMarking(), TearDown(), and UncommitMarkingDeque().

marking_deque_memory_committed_

bool v8::internal::IncrementalMarking::marking_deque_memory_committed_

private

Definition at line 204 of file incremental-marking.h.

Referenced by EnsureMarkingDequeIsCommitted(), and UncommitMarkingDeque().

marking_speed_

int v8::internal::IncrementalMarking::marking_speed_

private

Definition at line 212 of file incremental-marking.h.

Referenced by BlackToGreyAndUnshift(), NotifyOfHighPromotionRate(), ResetStepCounters(), SpeedUp(), and Step().

no_marking_scope_depth_

int v8::internal::IncrementalMarking::no_marking_scope_depth_

private

Definition at line 217 of file incremental-marking.h.

Referenced by EnterNoMarkingScope(), LeaveNoMarkingScope(), and Step().

old_generation_space_available_at_start_of_incremental_

int64_t v8::internal::IncrementalMarking::old_generation_space_available_at_start_of_incremental_

private

Definition at line 208 of file incremental-marking.h.

Referenced by ResetStepCounters(), and SpeedUp().

old_generation_space_used_at_start_of_incremental_

int64_t v8::internal::IncrementalMarking::old_generation_space_used_at_start_of_incremental_

private

Definition at line 209 of file incremental-marking.h.

Referenced by ResetStepCounters(), and SpeedUp().

should_hurry_

bool v8::internal::IncrementalMarking::should_hurry_

private

Definition at line 211 of file incremental-marking.h.

Referenced by set_should_hurry(), and should_hurry().

state_

State v8::internal::IncrementalMarking::state_

private

Definition at line 200 of file incremental-marking.h.

Referenced by Abort(), Finalize(), Hurry(), MarkingComplete(), RestartIfNotMarking(), SpeedUp(), Start(), StartMarking(), state(), Step(), and UncommitMarkingDeque().

steps_count_

int v8::internal::IncrementalMarking::steps_count_

private

Definition at line 207 of file incremental-marking.h.

Referenced by ResetStepCounters(), SpeedUp(), and Step().

unscanned_bytes_of_large_object_

int v8::internal::IncrementalMarking::unscanned_bytes_of_large_object_

private

Definition at line 219 of file incremental-marking.h.

Referenced by NotifyIncompleteScanOfObject().

write_barriers_invoked_since_last_step_

intptr_t v8::internal::IncrementalMarking::write_barriers_invoked_since_last_step_

private

Definition at line 215 of file incremental-marking.h.

Referenced by RecordWriteFromCode(), ResetStepCounters(), and Step().

---

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

• /mnt/V8SourceCode/src/heap/incremental-marking.h
• /mnt/V8SourceCode/src/heap/incremental-marking-inl.h
• /mnt/V8SourceCode/src/heap/incremental-marking.cc