v8::internal::PromotionQueue Class Reference

#include <heap.h>

Collaboration diagram for v8::internal::PromotionQueue:

Classes
struct	Entry

Public Member Functions
	PromotionQueue (Heap *heap)
void	Initialize ()
void	Destroy ()
Page *	GetHeadPage ()
void	SetNewLimit (Address limit)
bool	IsBelowPromotionQueue (Address to_space_top)
bool	is_empty ()
void	insert (HeapObject *target, int size)
void	remove (HeapObject **target, int *size)

Private Member Functions
void	RelocateQueueHead ()
	DISALLOW_COPY_AND_ASSIGN (PromotionQueue)

Private Attributes
intptr_t *	front_
intptr_t *	rear_
intptr_t *	limit_
List< Entry > *	emergency_stack_
Heap *	heap_

Static Private Attributes
static const int	kEntrySizeInWords = 2

Detailed Description

Definition at line 371 of file heap.h.

Constructor & Destructor Documentation

PromotionQueue()

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

inlineexplicit

Definition at line 373 of file heap.h.

      : front_(NULL),
        rear_(NULL),
        limit_(NULL),
        emergency_stack_(0),
        heap_(heap) {}

Member Function Documentation

Destroy()

void v8::internal::PromotionQueue::Destroy ( )

inline

Definition at line 382 of file heap.h.

                 {
    DCHECK(is_empty());
    delete emergency_stack_;
    emergency_stack_ = NULL;
  }

References DCHECK, emergency_stack_, is_empty(), and NULL.

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

Here is the call graph for this function:

Here is the caller graph for this function:

DISALLOW_COPY_AND_ASSIGN()

v8::internal::PromotionQueue::DISALLOW_COPY_AND_ASSIGN ( PromotionQueue  )

private

GetHeadPage()

Page* v8::internal::PromotionQueue::GetHeadPage ( )

inline

Definition at line 388 of file heap.h.

                      {
    return Page::FromAllocationTop(reinterpret_cast<Address>(rear_));
  }

References rear_.

Referenced by IsBelowPromotionQueue().

Here is the caller graph for this function:

Initialize()

void v8::internal::PromotionQueue::Initialize

(

)

Definition at line 1365 of file heap.cc.

                                {
  // Assumes that a NewSpacePage exactly fits a number of promotion queue
  // entries (where each is a pair of intptr_t). This allows us to simplify
  // the test fpr when to switch pages.
  DCHECK((Page::kPageSize - MemoryChunk::kBodyOffset) % (2 * kPointerSize) ==
         0);
  limit_ = reinterpret_cast<intptr_t*>(heap_->new_space()->ToSpaceStart());
  front_ = rear_ =
      reinterpret_cast<intptr_t*>(heap_->new_space()->ToSpaceEnd());
  emergency_stack_ = NULL;
}

References DCHECK, emergency_stack_, front_, heap_, v8::internal::MemoryChunk::kBodyOffset, v8::internal::Page::kPageSize, v8::internal::kPointerSize, limit_, v8::internal::Heap::new_space(), NULL, rear_, v8::internal::NewSpace::ToSpaceEnd(), and v8::internal::NewSpace::ToSpaceStart().

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

Here is the call graph for this function:

Here is the caller graph for this function:

insert()

void v8::internal::PromotionQueue::insert ( HeapObject *  target, int  size  )

inline

Definition at line 24 of file heap-inl.h.

                                                        {
  if (emergency_stack_ != NULL) {
    emergency_stack_->Add(Entry(target, size));
    return;
  }
 
  if (NewSpacePage::IsAtStart(reinterpret_cast<Address>(rear_))) {
    NewSpacePage* rear_page =
        NewSpacePage::FromAddress(reinterpret_cast<Address>(rear_));
    DCHECK(!rear_page->prev_page()->is_anchor());
    rear_ = reinterpret_cast<intptr_t*>(rear_page->prev_page()->area_end());
  }
 
  if ((rear_ - 2) < limit_) {
    RelocateQueueHead();
    emergency_stack_->Add(Entry(target, size));
    return;
  }
 
  *(--rear_) = reinterpret_cast<intptr_t>(target);
  *(--rear_) = size;
// Assert no overflow into live objects.
#ifdef DEBUG
  SemiSpace::AssertValidRange(target->GetIsolate()->heap()->new_space()->top(),
                              reinterpret_cast<Address>(rear_));
#endif
}

References v8::internal::MemoryChunk::area_end(), v8::internal::SemiSpace::AssertValidRange(), DCHECK, emergency_stack_, v8::internal::NewSpacePage::FromAddress(), v8::internal::HeapObject::GetIsolate(), v8::internal::Isolate::heap(), v8::internal::NewSpacePage::is_anchor(), v8::internal::NewSpacePage::IsAtStart(), limit_, v8::internal::Heap::new_space(), NULL, v8::internal::NewSpacePage::prev_page(), rear_, RelocateQueueHead(), size, and v8::internal::NewSpace::top().

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::PromoteObject().

Here is the call graph for this function:

Here is the caller graph for this function:

is_empty()

bool v8::internal::PromotionQueue::is_empty ( )

inline

Definition at line 414 of file heap.h.

                  {
    return (front_ == rear_) &&
           (emergency_stack_ == NULL || emergency_stack_->length() == 0);
  }

References emergency_stack_, front_, NULL, and rear_.

Referenced by Destroy(), and remove().

Here is the caller graph for this function:

IsBelowPromotionQueue()

bool v8::internal::PromotionQueue::IsBelowPromotionQueue ( Address  to_space_top )

inline

Definition at line 402 of file heap.h.

                                                   {
    // If the given to-space top pointer and the head of the promotion queue
    // are not on the same page, then the to-space objects are below the
    // promotion queue.
    if (GetHeadPage() != Page::FromAddress(to_space_top)) {
      return true;
    }
    // If the to space top pointer is smaller or equal than the promotion
    // queue head, then the to-space objects are below the promotion queue.
    return reinterpret_cast<intptr_t*>(to_space_top) <= rear_;
  }

References v8::internal::MemoryChunk::FromAddress(), GetHeadPage(), and rear_.

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::INLINE().

Here is the call graph for this function:

Here is the caller graph for this function:

RelocateQueueHead()

void v8::internal::PromotionQueue::RelocateQueueHead ( )

private

Definition at line 1378 of file heap.cc.

                                       {
  DCHECK(emergency_stack_ == NULL);
 
  Page* p = Page::FromAllocationTop(reinterpret_cast<Address>(rear_));
  intptr_t* head_start = rear_;
  intptr_t* head_end = Min(front_, reinterpret_cast<intptr_t*>(p->area_end()));
 
  int entries_count =
      static_cast<int>(head_end - head_start) / kEntrySizeInWords;
 
  emergency_stack_ = new List<Entry>(2 * entries_count);
 
  while (head_start != head_end) {
    int size = static_cast<int>(*(head_start++));
    HeapObject* obj = reinterpret_cast<HeapObject*>(*(head_start++));
    emergency_stack_->Add(Entry(obj, size));
  }
  rear_ = head_end;
}

References v8::internal::MemoryChunk::area_end(), DCHECK, emergency_stack_, front_, kEntrySizeInWords, v8::internal::Min(), NULL, rear_, and size.

Referenced by insert(), and SetNewLimit().

Here is the call graph for this function:

Here is the caller graph for this function:

remove()

void v8::internal::PromotionQueue::remove ( HeapObject **  target, int *  size  )

inline

Definition at line 421 of file heap.h.

                                              {
    DCHECK(!is_empty());
    if (front_ == rear_) {
      Entry e = emergency_stack_->RemoveLast();
      *target = e.obj_;
      *size = e.size_;
      return;
    }
 
    if (NewSpacePage::IsAtStart(reinterpret_cast<Address>(front_))) {
      NewSpacePage* front_page =
          NewSpacePage::FromAddress(reinterpret_cast<Address>(front_));
      DCHECK(!front_page->prev_page()->is_anchor());
      front_ = reinterpret_cast<intptr_t*>(front_page->prev_page()->area_end());
    }
    *target = reinterpret_cast<HeapObject*>(*(--front_));
    *size = static_cast<int>(*(--front_));
    // Assert no underflow.
    SemiSpace::AssertValidRange(reinterpret_cast<Address>(rear_),
                                reinterpret_cast<Address>(front_));
  }

References v8::internal::MemoryChunk::area_end(), v8::internal::SemiSpace::AssertValidRange(), DCHECK, emergency_stack_, v8::internal::NewSpacePage::FromAddress(), front_, v8::internal::NewSpacePage::is_anchor(), is_empty(), v8::internal::NewSpacePage::IsAtStart(), v8::internal::PromotionQueue::Entry::obj_, v8::internal::NewSpacePage::prev_page(), rear_, size, and v8::internal::PromotionQueue::Entry::size_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

SetNewLimit()

void v8::internal::PromotionQueue::SetNewLimit ( Address  limit )

inline

Definition at line 392 of file heap.h.

                                  {
    limit_ = reinterpret_cast<intptr_t*>(limit);
 
    if (limit_ <= rear_) {
      return;
    }
 
    RelocateQueueHead();
  }

References limit_, rear_, and RelocateQueueHead().

Referenced by v8::internal::NewSpace::AddFreshPage(), and v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::SemiSpaceCopyObject().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

emergency_stack_

List<Entry>* v8::internal::PromotionQueue::emergency_stack_

private

Definition at line 457 of file heap.h.

Referenced by Destroy(), Initialize(), insert(), is_empty(), RelocateQueueHead(), and remove().

front_

intptr_t* v8::internal::PromotionQueue::front_

private

Definition at line 445 of file heap.h.

Referenced by Initialize(), is_empty(), RelocateQueueHead(), and remove().

heap_

Heap* v8::internal::PromotionQueue::heap_

private

Definition at line 459 of file heap.h.

Referenced by Initialize().

kEntrySizeInWords

const int v8::internal::PromotionQueue::kEntrySizeInWords = 2

staticprivate

Definition at line 449 of file heap.h.

Referenced by RelocateQueueHead().

limit_

intptr_t* v8::internal::PromotionQueue::limit_

private

Definition at line 447 of file heap.h.

Referenced by Initialize(), insert(), and SetNewLimit().

rear_

intptr_t* v8::internal::PromotionQueue::rear_

private

Definition at line 446 of file heap.h.

Referenced by GetHeadPage(), Initialize(), insert(), is_empty(), IsBelowPromotionQueue(), RelocateQueueHead(), remove(), and SetNewLimit().

---

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

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