V8 Project
Public Member Functions | Static Public Member Functions | Static Public Attributes | List of all members
v8::internal::IncrementalMarkingMarkingVisitor Class Reference
+ Inheritance diagram for v8::internal::IncrementalMarkingMarkingVisitor:
+ Collaboration diagram for v8::internal::IncrementalMarkingMarkingVisitor:

Public Member Functions

 INLINE (static void VisitPointer(Heap *heap, Object **p))
 
 INLINE (static void VisitPointers(Heap *heap, Object **start, Object **end))
 
 INLINE (static void VisitPointersWithAnchor(Heap *heap, Object **anchor, Object **start, Object **end))
 
 INLINE (static void MarkObject(Heap *heap, Object *obj))
 
 INLINE (static bool MarkObjectWithoutPush(Heap *heap, Object *obj))
 
- Public Member Functions inherited from v8::internal::StaticMarkingVisitor< IncrementalMarkingMarkingVisitor >
 INLINE (static void IterateBody(Map *map, HeapObject *obj))
 
 INLINE (static void VisitPropertyCell(Map *map, HeapObject *object))
 
 INLINE (static void VisitCodeEntry(Heap *heap, Address entry_address))
 
 INLINE (static void VisitEmbeddedPointer(Heap *heap, RelocInfo *rinfo))
 
 INLINE (static void VisitCell(Heap *heap, RelocInfo *rinfo))
 
 INLINE (static void VisitDebugTarget(Heap *heap, RelocInfo *rinfo))
 
 INLINE (static void VisitCodeTarget(Heap *heap, RelocInfo *rinfo))
 
 INLINE (static void VisitCodeAgeSequence(Heap *heap, RelocInfo *rinfo))
 
 INLINE (static void VisitExternalReference(RelocInfo *rinfo))
 
 INLINE (static void VisitRuntimeEntry(RelocInfo *rinfo))
 
 INLINE (static void VisitNextCodeLink(Heap *heap, Object **slot))
 
- Public Member Functions inherited from v8::internal::StaticVisitorBase
 STATIC_ASSERT (kVisitorIdCount<=256)
 

Static Public Member Functions

static void Initialize ()
 
static void VisitFixedArrayIncremental (Map *map, HeapObject *object)
 
static void VisitNativeContextIncremental (Map *map, HeapObject *object)
 
- Static Public Member Functions inherited from v8::internal::StaticMarkingVisitor< IncrementalMarkingMarkingVisitor >
static void Initialize ()
 
static void MarkInlinedFunctionsCode (Heap *heap, Code *code)
 
- Static Public Member Functions inherited from v8::internal::StaticVisitorBase
static VisitorId GetVisitorId (int instance_type, int instance_size)
 
static VisitorId GetVisitorId (Map *map)
 
static VisitorId GetVisitorIdForSize (VisitorId base, VisitorId generic, int object_size)
 

Static Public Attributes

static const int kProgressBarScanningChunk = 32 * 1024
 

Additional Inherited Members

- Public Types inherited from v8::internal::StaticVisitorBase
enum  VisitorId {
  kVisitorIdCount , kVisitDataObject = kVisitDataObject2 , kVisitJSObject = kVisitJSObject2 , kVisitStruct = kVisitStruct2 ,
  kMinObjectSizeInWords = 2
}
 
- Protected Types inherited from v8::internal::StaticMarkingVisitor< IncrementalMarkingMarkingVisitor >
typedef FlexibleBodyVisitor< IncrementalMarkingMarkingVisitor, FixedArray::BodyDescriptor, void > FixedArrayVisitor
 
typedef FlexibleBodyVisitor< IncrementalMarkingMarkingVisitor, JSObject::BodyDescriptor, void > JSObjectVisitor
 
typedef FlexibleBodyVisitor< IncrementalMarkingMarkingVisitor, StructBodyDescriptor, void > StructObjectVisitor
 
typedef void(* Callback) (Map *map, HeapObject *object)
 
- Protected Member Functions inherited from v8::internal::StaticMarkingVisitor< IncrementalMarkingMarkingVisitor >
 INLINE (static void VisitMap(Map *map, HeapObject *object))
 
 INLINE (static void VisitCode(Map *map, HeapObject *object))
 
 INLINE (static void VisitSharedFunctionInfo(Map *map, HeapObject *object))
 
 INLINE (static void VisitConstantPoolArray(Map *map, HeapObject *object))
 
 INLINE (static void VisitAllocationSite(Map *map, HeapObject *object))
 
 INLINE (static void VisitWeakCollection(Map *map, HeapObject *object))
 
 INLINE (static void VisitJSFunction(Map *map, HeapObject *object))
 
 INLINE (static void VisitJSRegExp(Map *map, HeapObject *object))
 
 INLINE (static void VisitJSArrayBuffer(Map *map, HeapObject *object))
 
 INLINE (static void VisitJSTypedArray(Map *map, HeapObject *object))
 
 INLINE (static void VisitJSDataView(Map *map, HeapObject *object))
 
 INLINE (static void VisitNativeContext(Map *map, HeapObject *object))
 
 INLINE (static bool IsFlushable(Heap *heap, JSFunction *function))
 
 INLINE (static bool IsFlushable(Heap *heap, SharedFunctionInfo *shared_info))
 
- Static Protected Member Functions inherited from v8::internal::StaticMarkingVisitor< IncrementalMarkingMarkingVisitor >
static void MarkMapContents (Heap *heap, Map *map)
 
static void MarkTransitionArray (Heap *heap, TransitionArray *transitions)
 
static void VisitSharedFunctionInfoStrongCode (Heap *heap, HeapObject *object)
 
static void VisitSharedFunctionInfoWeakCode (Heap *heap, HeapObject *object)
 
static void VisitJSFunctionStrongCode (Heap *heap, HeapObject *object)
 
static void VisitJSFunctionWeakCode (Heap *heap, HeapObject *object)
 
- Static Protected Attributes inherited from v8::internal::StaticMarkingVisitor< IncrementalMarkingMarkingVisitor >
static VisitorDispatchTable< Callback > table_
 

Detailed Description

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

Member Function Documentation

◆ Initialize()

static void v8::internal::IncrementalMarkingMarkingVisitor::Initialize ( )
inlinestatic

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

161  {
162  StaticMarkingVisitor<IncrementalMarkingMarkingVisitor>::Initialize();
163  table_.Register(kVisitFixedArray, &VisitFixedArrayIncremental);
164  table_.Register(kVisitNativeContext, &VisitNativeContextIncremental);
165  table_.Register(kVisitJSRegExp, &VisitJSRegExp);
166  }
v8::internal::IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental
static void VisitFixedArrayIncremental(Map *map, HeapObject *object)
Definition: incremental-marking.cc:170
v8::internal::IncrementalMarkingMarkingVisitor::VisitNativeContextIncremental
static void VisitNativeContextIncremental(Map *map, HeapObject *object)
Definition: incremental-marking.cc:210

References v8::internal::StaticMarkingVisitor< StaticVisitor >::Initialize(), v8::internal::StaticMarkingVisitor< IncrementalMarkingMarkingVisitor >::table_, VisitFixedArrayIncremental(), and VisitNativeContextIncremental().

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

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ INLINE() [1/5]

v8::internal::IncrementalMarkingMarkingVisitor::INLINE ( static bool   MarkObjectWithoutPushHeap *heap, Object *obj)
inline

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

265  {
266  HeapObject* heap_object = HeapObject::cast(obj);
267  MarkBit mark_bit = Marking::MarkBitFrom(heap_object);
268  if (Marking::IsWhite(mark_bit)) {
269  mark_bit.Set();
270  MemoryChunk::IncrementLiveBytesFromGC(heap_object->address(),
271  heap_object->Size());
272  return true;
273  }
274  return false;
275  }
v8::internal::MemoryChunk::IncrementLiveBytesFromGC
static void IncrementLiveBytesFromGC(Address address, int by)
Definition: spaces.h:517

References v8::internal::HeapObject::address(), v8::internal::MemoryChunk::IncrementLiveBytesFromGC(), v8::internal::MarkBit::Set(), and v8::internal::HeapObject::Size().

+ Here is the call graph for this function:

◆ INLINE() [2/5]

v8::internal::IncrementalMarkingMarkingVisitor::INLINE ( static void   MarkObjectHeap *heap, Object *obj)
inline

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

253  {
254  HeapObject* heap_object = HeapObject::cast(obj);
255  MarkBit mark_bit = Marking::MarkBitFrom(heap_object);
256  if (mark_bit.data_only()) {
257  MarkBlackOrKeepGrey(heap_object, mark_bit, heap_object->Size());
258  } else if (Marking::IsWhite(mark_bit)) {
259  heap->incremental_marking()->WhiteToGreyAndPush(heap_object, mark_bit);
260  }
261  }
v8::internal::MarkBlackOrKeepGrey
static void MarkBlackOrKeepGrey(HeapObject *heap_object, MarkBit mark_bit, int size)
Definition: incremental-marking.cc:138

References v8::internal::MarkBit::data_only(), v8::internal::Heap::incremental_marking(), v8::internal::MarkBlackOrKeepGrey(), v8::internal::HeapObject::Size(), and v8::internal::IncrementalMarking::WhiteToGreyAndPush().

+ Here is the call graph for this function:

◆ INLINE() [3/5]

v8::internal::IncrementalMarkingMarkingVisitor::INLINE ( static void   VisitPointerHeap *heap, Object **p)
inline

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

223  {
224  Object* obj = *p;
225  if (obj->IsHeapObject()) {
226  heap->mark_compact_collector()->RecordSlot(p, p, obj);
227  MarkObject(heap, obj);
228  }
229  }
v8::internal::Object
kSerializedDataOffset Object
Definition: objects-inl.h:5322

References v8::internal::Heap::mark_compact_collector().

+ Here is the call graph for this function:

◆ INLINE() [4/5]

v8::internal::IncrementalMarkingMarkingVisitor::INLINE ( static void   VisitPointersHeap *heap, Object **start, Object **end)
inline

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

231  {
232  for (Object** p = start; p < end; p++) {
233  Object* obj = *p;
234  if (obj->IsHeapObject()) {
235  heap->mark_compact_collector()->RecordSlot(start, p, obj);
236  MarkObject(heap, obj);
237  }
238  }
239  }

References v8::internal::Heap::mark_compact_collector().

+ Here is the call graph for this function:

◆ INLINE() [5/5]

v8::internal::IncrementalMarkingMarkingVisitor::INLINE ( static void   VisitPointersWithAnchorHeap *heap, Object **anchor, Object **start, Object **end)
inline

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

242  {
243  for (Object** p = start; p < end; p++) {
244  Object* obj = *p;
245  if (obj->IsHeapObject()) {
246  heap->mark_compact_collector()->RecordSlot(anchor, p, obj);
247  MarkObject(heap, obj);
248  }
249  }
250  }

References v8::internal::Heap::mark_compact_collector().

+ Here is the call graph for this function:

◆ VisitFixedArrayIncremental()

static void v8::internal::IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental ( Map *  map,
HeapObject *  object 
)
inlinestatic

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

170  {
171  MemoryChunk* chunk = MemoryChunk::FromAddress(object->address());
172  // TODO(mstarzinger): Move setting of the flag to the allocation site of
173  // the array. The visitor should just check the flag.
174  if (FLAG_use_marking_progress_bar &&
175  chunk->owner()->identity() == LO_SPACE) {
176  chunk->SetFlag(MemoryChunk::HAS_PROGRESS_BAR);
177  }
178  if (chunk->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR)) {
179  Heap* heap = map->GetHeap();
180  // When using a progress bar for large fixed arrays, scan only a chunk of
181  // the array and try to push it onto the marking deque again until it is
182  // fully scanned. Fall back to scanning it through to the end in case this
183  // fails because of a full deque.
184  int object_size = FixedArray::BodyDescriptor::SizeOf(map, object);
185  int start_offset =
186  Max(FixedArray::BodyDescriptor::kStartOffset, chunk->progress_bar());
187  int end_offset =
188  Min(object_size, start_offset + kProgressBarScanningChunk);
189  int already_scanned_offset = start_offset;
190  bool scan_until_end = false;
191  do {
192  VisitPointersWithAnchor(heap, HeapObject::RawField(object, 0),
193  HeapObject::RawField(object, start_offset),
194  HeapObject::RawField(object, end_offset));
195  start_offset = end_offset;
196  end_offset = Min(object_size, end_offset + kProgressBarScanningChunk);
197  scan_until_end = heap->incremental_marking()->marking_deque()->IsFull();
198  } while (scan_until_end && start_offset < object_size);
199  chunk->set_progress_bar(start_offset);
200  if (start_offset < object_size) {
201  heap->incremental_marking()->marking_deque()->UnshiftGrey(object);
202  heap->incremental_marking()->NotifyIncompleteScanOfObject(
203  object_size - (start_offset - already_scanned_offset));
204  }
205  } else {
206  FixedArrayVisitor::Visit(map, object);
207  }
208  }
v8::internal::FixedArray::BodyDescriptor::SizeOf
static int SizeOf(Map *map, HeapObject *object)
Definition: objects.h:2491
v8::internal::HeapObject::RawField
static Object ** RawField(HeapObject *obj, int offset)
Definition: objects-inl.h:1311
v8::internal::MemoryChunk::FromAddress
static MemoryChunk * FromAddress(Address a)
Definition: spaces.h:276
map
enable harmony numeric enable harmony object literal extensions Optimize object Array DOM strings and string trace pretenuring decisions of HAllocate instructions Enables optimizations which favor memory size over execution speed maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining trace the tracking of allocation sites deoptimize every n garbage collections perform array bounds checks elimination analyze liveness of environment slots and zap dead values flushes the cache of optimized code for closures on every GC allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms do not emit check maps for constant values that have a leaf map
Definition: flag-definitions.h:328
v8::internal::Min
static LifetimePosition Min(LifetimePosition a, LifetimePosition b)
Definition: lithium-allocator.cc:15
v8::internal::Max
static LifetimePosition Max(LifetimePosition a, LifetimePosition b)
Definition: lithium-allocator.cc:20

References v8::internal::HeapObject::address(), v8::internal::MemoryChunk::FromAddress(), v8::internal::MemoryChunk::HAS_PROGRESS_BAR, v8::internal::Space::identity(), v8::internal::Heap::incremental_marking(), v8::internal::MemoryChunk::IsFlagSet(), v8::internal::MarkingDeque::IsFull(), kProgressBarScanningChunk, v8::internal::FlexibleBodyDescriptor< kHeaderSize >::kStartOffset, v8::internal::LO_SPACE, map, v8::internal::IncrementalMarking::marking_deque(), v8::internal::Max(), v8::internal::Min(), v8::internal::IncrementalMarking::NotifyIncompleteScanOfObject(), v8::internal::MemoryChunk::owner(), v8::internal::MemoryChunk::progress_bar(), v8::internal::HeapObject::RawField(), v8::internal::MemoryChunk::set_progress_bar(), v8::internal::MemoryChunk::SetFlag(), and v8::internal::FixedArray::BodyDescriptor::SizeOf().

Referenced by Initialize().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ VisitNativeContextIncremental()

static void v8::internal::IncrementalMarkingMarkingVisitor::VisitNativeContextIncremental ( Map *  map,
HeapObject *  object 
)
inlinestatic

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

210  {
211  Context* context = Context::cast(object);
212 
213  // We will mark cache black with a separate pass when we finish marking.
214  // Note that GC can happen when the context is not fully initialized,
215  // so the cache can be undefined.
216  Object* cache = context->get(Context::NORMALIZED_MAP_CACHE_INDEX);
217  if (!cache->IsUndefined()) {
218  MarkObjectGreyDoNotEnqueue(cache);
219  }
220  VisitNativeContext(map, context);
221  }
v8::internal::Context::cast
static Context * cast(Object *context)
Definition: contexts.h:255
v8::internal::MarkObjectGreyDoNotEnqueue
static void MarkObjectGreyDoNotEnqueue(Object *obj)
Definition: incremental-marking.cc:125

References v8::internal::Context::cast(), v8::internal::FixedArray::get(), map, v8::internal::MarkObjectGreyDoNotEnqueue(), and v8::internal::Context::NORMALIZED_MAP_CACHE_INDEX.

Referenced by Initialize().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Member Data Documentation

◆ kProgressBarScanningChunk

const int v8::internal::IncrementalMarkingMarkingVisitor::kProgressBarScanningChunk = 32 * 1024
static

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

Referenced by VisitFixedArrayIncremental().

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