v8::internal::SlotsBuffer Class Reference

#include <mark-compact.h>

Collaboration diagram for v8::internal::SlotsBuffer:

Public Types
enum	SlotType {   EMBEDDED_OBJECT_SLOT , RELOCATED_CODE_OBJECT , CODE_TARGET_SLOT , CODE_ENTRY_SLOT ,   DEBUG_TARGET_SLOT , JS_RETURN_SLOT , NUMBER_OF_SLOT_TYPES }
enum	AdditionMode { FAIL_ON_OVERFLOW , IGNORE_OVERFLOW }
typedef Object **	ObjectSlot

Public Member Functions
	SlotsBuffer (SlotsBuffer *next_buffer)
	~SlotsBuffer ()
void	Add (ObjectSlot slot)
void	UpdateSlots (Heap *heap)
void	UpdateSlotsWithFilter (Heap *heap)
SlotsBuffer *	next ()
bool	IsFull ()
bool	HasSpaceForTypedSlot ()
	INLINE (static bool AddTo(SlotsBufferAllocator *allocator, SlotsBuffer **buffer_address, ObjectSlot slot, AdditionMode mode))

Static Public Member Functions
static const char *	SlotTypeToString (SlotType type)
static int	SizeOfChain (SlotsBuffer *buffer)
static void	UpdateSlotsRecordedIn (Heap *heap, SlotsBuffer *buffer, bool code_slots_filtering_required)
static bool	ChainLengthThresholdReached (SlotsBuffer *buffer)
static bool	IsTypedSlot (ObjectSlot slot)
static bool	AddTo (SlotsBufferAllocator *allocator, SlotsBuffer **buffer_address, SlotType type, Address addr, AdditionMode mode)

Static Public Attributes
static const int	kNumberOfElements = 1021

Private Attributes
intptr_t	idx_
intptr_t	chain_length_
SlotsBuffer *	next_
ObjectSlot	slots_ [kNumberOfElements]

Static Private Attributes
static const int	kChainLengthThreshold = 15

Detailed Description

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

Member Typedef Documentation

ObjectSlot

typedef Object** v8::internal::SlotsBuffer::ObjectSlot

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

Member Enumeration Documentation

AdditionMode

enum v8::internal::SlotsBuffer::AdditionMode

Enumerator
FAIL_ON_OVERFLOW
IGNORE_OVERFLOW

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

{ FAIL_ON_OVERFLOW, IGNORE_OVERFLOW };

SlotType

enum v8::internal::SlotsBuffer::SlotType

Enumerator
EMBEDDED_OBJECT_SLOT
RELOCATED_CODE_OBJECT
CODE_TARGET_SLOT
CODE_ENTRY_SLOT
DEBUG_TARGET_SLOT
JS_RETURN_SLOT
NUMBER_OF_SLOT_TYPES

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

                {
    EMBEDDED_OBJECT_SLOT,
    RELOCATED_CODE_OBJECT,
    CODE_TARGET_SLOT,
    CODE_ENTRY_SLOT,
    DEBUG_TARGET_SLOT,
    JS_RETURN_SLOT,
    NUMBER_OF_SLOT_TYPES
  };

Constructor & Destructor Documentation

SlotsBuffer()

v8::internal::SlotsBuffer::SlotsBuffer ( SlotsBuffer *  next_buffer )

inlineexplicit

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

      : idx_(0), chain_length_(1), next_(next_buffer) {
    if (next_ != NULL) {
      chain_length_ = next_->chain_length_ + 1;
    }
  }

References chain_length_, next_, and NULL.

~SlotsBuffer()

v8::internal::SlotsBuffer::~SlotsBuffer ( )

inline

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

{}

Member Function Documentation

Add()

void v8::internal::SlotsBuffer::Add ( ObjectSlot  slot )

inline

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

                            {
    DCHECK(0 <= idx_ && idx_ < kNumberOfElements);
    slots_[idx_++] = slot;
  }

References DCHECK, idx_, kNumberOfElements, and slots_.

Referenced by AddTo(), and INLINE().

Here is the caller graph for this function:

AddTo()

bool v8::internal::SlotsBuffer::AddTo ( SlotsBufferAllocator *  allocator, SlotsBuffer **  buffer_address, SlotType  type, Address  addr, AdditionMode  mode  )

static

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

                                                         {
  SlotsBuffer* buffer = *buffer_address;
  if (buffer == NULL || !buffer->HasSpaceForTypedSlot()) {
    if (mode == FAIL_ON_OVERFLOW && ChainLengthThresholdReached(buffer)) {
      allocator->DeallocateChain(buffer_address);
      return false;
    }
    buffer = allocator->AllocateBuffer(buffer);
    *buffer_address = buffer;
  }
  DCHECK(buffer->HasSpaceForTypedSlot());
  buffer->Add(reinterpret_cast<ObjectSlot>(type));
  buffer->Add(reinterpret_cast<ObjectSlot>(addr));
  return true;
}

References Add(), v8::internal::SlotsBufferAllocator::AllocateBuffer(), ChainLengthThresholdReached(), DCHECK, v8::internal::SlotsBufferAllocator::DeallocateChain(), FAIL_ON_OVERFLOW, HasSpaceForTypedSlot(), mode(), and NULL.

Referenced by v8::internal::MarkCompactCollector::MigrateObject(), v8::internal::MarkCompactCollector::RecordCodeEntrySlot(), v8::internal::MarkCompactCollector::RecordMigratedSlot(), and v8::internal::MarkCompactCollector::RecordRelocSlot().

Here is the call graph for this function:

Here is the caller graph for this function:

ChainLengthThresholdReached()

static bool v8::internal::SlotsBuffer::ChainLengthThresholdReached ( SlotsBuffer *  buffer )

inlinestatic

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

                                                               {
    return buffer != NULL && buffer->chain_length_ >= kChainLengthThreshold;
  }

References chain_length_, kChainLengthThreshold, and NULL.

Referenced by AddTo(), and INLINE().

Here is the caller graph for this function:

HasSpaceForTypedSlot()

bool v8::internal::SlotsBuffer::HasSpaceForTypedSlot ( )

inline

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

{ return idx_ < kNumberOfElements - 1; }

References idx_, and kNumberOfElements.

Referenced by AddTo().

Here is the caller graph for this function:

INLINE()

v8::internal::SlotsBuffer::INLINE ( static bool   AddToSlotsBufferAllocator *allocator, SlotsBuffer **buffer_address, ObjectSlot slot, AdditionMode mode )

inline

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

                                               {
    SlotsBuffer* buffer = *buffer_address;
    if (buffer == NULL || buffer->IsFull()) {
      if (mode == FAIL_ON_OVERFLOW && ChainLengthThresholdReached(buffer)) {
        allocator->DeallocateChain(buffer_address);
        return false;
      }
      buffer = allocator->AllocateBuffer(buffer);
      *buffer_address = buffer;
    }
    buffer->Add(slot);
    return true;
  }

References Add(), v8::internal::SlotsBufferAllocator::AllocateBuffer(), ChainLengthThresholdReached(), v8::internal::SlotsBufferAllocator::DeallocateChain(), FAIL_ON_OVERFLOW, IsFull(), mode(), and NULL.

Here is the call graph for this function:

IsFull()

bool v8::internal::SlotsBuffer::IsFull ( )

inline

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

{ return idx_ == kNumberOfElements; }

References idx_, and kNumberOfElements.

Referenced by INLINE().

Here is the caller graph for this function:

IsTypedSlot()

bool v8::internal::SlotsBuffer::IsTypedSlot ( ObjectSlot  slot )

static

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

                                             {
  return reinterpret_cast<uintptr_t>(slot) < NUMBER_OF_SLOT_TYPES;
}

References NUMBER_OF_SLOT_TYPES.

Referenced by UpdateSlots(), and UpdateSlotsWithFilter().

Here is the caller graph for this function:

next()

SlotsBuffer* v8::internal::SlotsBuffer::next ( )

inline

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

{ return next_; }

References next_.

Referenced by v8::internal::SlotsBufferAllocator::DeallocateChain(), and UpdateSlotsRecordedIn().

Here is the caller graph for this function:

SizeOfChain()

static int v8::internal::SlotsBuffer::SizeOfChain ( SlotsBuffer *  buffer )

inlinestatic

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

                                              {
    if (buffer == NULL) return 0;
    return static_cast<int>(buffer->idx_ +
                            (buffer->chain_length_ - 1) * kNumberOfElements);
  }

References chain_length_, idx_, kNumberOfElements, and NULL.

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

Here is the caller graph for this function:

SlotTypeToString()

static const char* v8::internal::SlotsBuffer::SlotTypeToString ( SlotType  type )

inlinestatic

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

                                                     {
    switch (type) {
      case EMBEDDED_OBJECT_SLOT:
        return "EMBEDDED_OBJECT_SLOT";
      case RELOCATED_CODE_OBJECT:
        return "RELOCATED_CODE_OBJECT";
      case CODE_TARGET_SLOT:
        return "CODE_TARGET_SLOT";
      case CODE_ENTRY_SLOT:
        return "CODE_ENTRY_SLOT";
      case DEBUG_TARGET_SLOT:
        return "DEBUG_TARGET_SLOT";
      case JS_RETURN_SLOT:
        return "JS_RETURN_SLOT";
      case NUMBER_OF_SLOT_TYPES:
        return "NUMBER_OF_SLOT_TYPES";
    }
    return "UNKNOWN SlotType";
  }

References CODE_ENTRY_SLOT, CODE_TARGET_SLOT, DEBUG_TARGET_SLOT, EMBEDDED_OBJECT_SLOT, JS_RETURN_SLOT, NUMBER_OF_SLOT_TYPES, and RELOCATED_CODE_OBJECT.

UpdateSlots()

void v8::internal::SlotsBuffer::UpdateSlots

(

Heap *

heap

)

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

                                        {
  PointersUpdatingVisitor v(heap);
 
  for (int slot_idx = 0; slot_idx < idx_; ++slot_idx) {
    ObjectSlot slot = slots_[slot_idx];
    if (!IsTypedSlot(slot)) {
      PointersUpdatingVisitor::UpdateSlot(heap, slot);
    } else {
      ++slot_idx;
      DCHECK(slot_idx < idx_);
      UpdateSlot(heap->isolate(), &v, DecodeSlotType(slot),
                 reinterpret_cast<Address>(slots_[slot_idx]));
    }
  }
}

References DCHECK, v8::internal::DecodeSlotType(), idx_, v8::internal::Heap::isolate(), IsTypedSlot(), slots_, v8::internal::PointersUpdatingVisitor::UpdateSlot(), and v8::internal::UpdateSlot().

Referenced by UpdateSlotsRecordedIn().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateSlotsRecordedIn()

static void v8::internal::SlotsBuffer::UpdateSlotsRecordedIn ( Heap *  heap, SlotsBuffer *  buffer, bool  code_slots_filtering_required  )

inlinestatic

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

                                                                        {
    while (buffer != NULL) {
      if (code_slots_filtering_required) {
        buffer->UpdateSlotsWithFilter(heap);
      } else {
        buffer->UpdateSlots(heap);
      }
      buffer = buffer->next();
    }
  }

References next(), NULL, UpdateSlots(), and UpdateSlotsWithFilter().

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

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateSlotsWithFilter()

void v8::internal::SlotsBuffer::UpdateSlotsWithFilter

(

Heap *

heap

)

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

                                                  {
  PointersUpdatingVisitor v(heap);
 
  for (int slot_idx = 0; slot_idx < idx_; ++slot_idx) {
    ObjectSlot slot = slots_[slot_idx];
    if (!IsTypedSlot(slot)) {
      if (!IsOnInvalidatedCodeObject(reinterpret_cast<Address>(slot))) {
        PointersUpdatingVisitor::UpdateSlot(heap, slot);
      }
    } else {
      ++slot_idx;
      DCHECK(slot_idx < idx_);
      Address pc = reinterpret_cast<Address>(slots_[slot_idx]);
      if (!IsOnInvalidatedCodeObject(pc)) {
        UpdateSlot(heap->isolate(), &v, DecodeSlotType(slot),
                   reinterpret_cast<Address>(slots_[slot_idx]));
      }
    }
  }
}

References DCHECK, v8::internal::DecodeSlotType(), idx_, v8::internal::Heap::isolate(), v8::internal::IsOnInvalidatedCodeObject(), IsTypedSlot(), v8::internal::pc, slots_, v8::internal::PointersUpdatingVisitor::UpdateSlot(), and v8::internal::UpdateSlot().

Referenced by UpdateSlotsRecordedIn().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

chain_length_

intptr_t v8::internal::SlotsBuffer::chain_length_

private

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

Referenced by ChainLengthThresholdReached(), SizeOfChain(), and SlotsBuffer().

idx_

intptr_t v8::internal::SlotsBuffer::idx_

private

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

Referenced by Add(), HasSpaceForTypedSlot(), IsFull(), SizeOfChain(), UpdateSlots(), and UpdateSlotsWithFilter().

kChainLengthThreshold

const int v8::internal::SlotsBuffer::kChainLengthThreshold = 15

staticprivate

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

Referenced by ChainLengthThresholdReached().

kNumberOfElements

const int v8::internal::SlotsBuffer::kNumberOfElements = 1021

static

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

Referenced by Add(), HasSpaceForTypedSlot(), IsFull(), and SizeOfChain().

next_

SlotsBuffer* v8::internal::SlotsBuffer::next_

private

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

Referenced by next(), and SlotsBuffer().

slots_

ObjectSlot v8::internal::SlotsBuffer::slots_[kNumberOfElements]

private

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

Referenced by Add(), UpdateSlots(), and UpdateSlotsWithFilter().

---

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

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