#include <store-buffer.h>

Collaboration diagram for v8::internal::StoreBuffer:

Public Member Functions
	StoreBuffer (Heap *heap)

Address	TopAddress ()

void	SetUp ()

void	TearDown ()

void	Mark (Address addr)

void	EnterDirectlyIntoStoreBuffer (Address addr)

void	IteratePointersToNewSpace (ObjectSlotCallback callback)

void	IteratePointersToNewSpaceAndClearMaps (ObjectSlotCallback callback)

void	Compact ()

void	GCPrologue ()

void	GCEpilogue ()

Object ***	Limit ()

Object ***	Start ()

Object ***	Top ()

void	SetTop (Object ***top)

bool	old_buffer_is_sorted ()

bool	old_buffer_is_filtered ()

void	SortUniq ()

void	EnsureSpace (intptr_t space_needed)

void	Verify ()

bool	PrepareForIteration ()

void	Filter (int flag)

Static Public Member Functions
static void	StoreBufferOverflow (Isolate *isolate)

Static Public Attributes
static const int	kStoreBufferOverflowBit = 1 << (14 + kPointerSizeLog2)

static const int	kStoreBufferSize = kStoreBufferOverflowBit

static const int	kStoreBufferLength = kStoreBufferSize / sizeof(Address)

static const int	kOldStoreBufferLength = kStoreBufferLength * 16

static const int	kHashSetLengthLog2 = 12

static const int	kHashSetLength = 1 << kHashSetLengthLog2

Private Member Functions
void	ClearFilteringHashSets ()

bool	SpaceAvailable (intptr_t space_needed)

void	Uniq ()

void	ExemptPopularPages (int prime_sample_step, int threshold)

void	ClearDeadObject (HeapObject *object)

void	IteratePointersToNewSpace (ObjectSlotCallback callback, bool clear_maps)

void	FindPointersToNewSpaceInRegion (Address start, Address end, ObjectSlotCallback slot_callback, bool clear_maps)

void	IteratePointersOnPage (PagedSpace space, Page page, RegionCallback region_callback, ObjectSlotCallback slot_callback)

void	IteratePointersInStoreBuffer (ObjectSlotCallback slot_callback, bool clear_maps)

Friends
class	StoreBufferRebuildScope

class	DontMoveStoreBufferEntriesScope

Detailed Description

Definition at line 28 of file store-buffer.h.

Constructor & Destructor Documentation

◆ StoreBuffer()

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

explicit

Definition at line 16 of file store-buffer.cc.

     : heap_(heap),
       start_(NULL),
       limit_(NULL),
       old_start_(NULL),
       old_limit_(NULL),
       old_top_(NULL),
       old_reserved_limit_(NULL),
       old_buffer_is_sorted_(false),
       old_buffer_is_filtered_(false),
       during_gc_(false),
       store_buffer_rebuilding_enabled_(false),
       callback_(NULL),
       may_move_store_buffer_entries_(true),
       virtual_memory_(NULL),
       hash_set_1_(NULL),
       hash_set_2_(NULL),
       hash_sets_are_empty_(true) {}

Member Function Documentation

◆ ClearDeadObject()

void v8::internal::StoreBuffer::ClearDeadObject ( HeapObject * object )

inlineprivate

Definition at line 54 of file store-buffer-inl.h.

                                                     {
   Address& map_field = Memory::Address_at(object->address());
   if (heap_->map_space()->Contains(map_field)) {
     map_field = NULL;
   }
 }

References v8::internal::HeapObject::address(), v8::internal::Memory::Address_at(), v8::internal::PagedSpace::Contains(), heap_, v8::internal::Heap::map_space(), and NULL.

Referenced by FindPointersToNewSpaceInRegion(), and IteratePointersInStoreBuffer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearFilteringHashSets()

void v8::internal::StoreBuffer::ClearFilteringHashSets ( )

private

Definition at line 312 of file store-buffer.cc.

                                          {
   if (!hash_sets_are_empty_) {
     memset(reinterpret_cast<void*>(hash_set_1_), 0,
            sizeof(uintptr_t) * kHashSetLength);
     memset(reinterpret_cast<void*>(hash_set_2_), 0,
            sizeof(uintptr_t) * kHashSetLength);
     hash_sets_are_empty_ = true;
   }
 }

References hash_set_1_, hash_set_2_, hash_sets_are_empty_, and kHashSetLength.

Referenced by Filter(), GCPrologue(), PrepareForIteration(), SetUp(), and SortUniq().

Here is the caller graph for this function:

◆ Compact()

void v8::internal::StoreBuffer::Compact ( )

Definition at line 528 of file store-buffer.cc.

                           {
   Address* top = reinterpret_cast<Address*>(heap_->store_buffer_top());
  
   if (top == start_) return;
  
   // There's no check of the limit in the loop below so we check here for
   // the worst case (compaction doesn't eliminate any pointers).
   DCHECK(top <= limit_);
   heap_->public_set_store_buffer_top(start_);
   EnsureSpace(top - start_);
   DCHECK(may_move_store_buffer_entries_);
   // Goes through the addresses in the store buffer attempting to remove
   // duplicates.  In the interest of speed this is a lossy operation.  Some
   // duplicates will remain.  We have two hash sets with different hash
   // functions to reduce the number of unnecessary clashes.
   hash_sets_are_empty_ = false;  // Hash sets are in use.
   for (Address* current = start_; current < top; current++) {
     DCHECK(!heap_->cell_space()->Contains(*current));
     DCHECK(!heap_->code_space()->Contains(*current));
     DCHECK(!heap_->old_data_space()->Contains(*current));
     uintptr_t int_addr = reinterpret_cast<uintptr_t>(*current);
     // Shift out the last bits including any tags.
     int_addr >>= kPointerSizeLog2;
     // The upper part of an address is basically random because of ASLR and OS
     // non-determinism, so we use only the bits within a page for hashing to
     // make v8's behavior (more) deterministic.
     uintptr_t hash_addr =
         int_addr & (Page::kPageAlignmentMask >> kPointerSizeLog2);
     int hash1 = ((hash_addr ^ (hash_addr >> kHashSetLengthLog2)) &
                  (kHashSetLength - 1));
     if (hash_set_1_[hash1] == int_addr) continue;
     uintptr_t hash2 = (hash_addr - (hash_addr >> kHashSetLengthLog2));
     hash2 ^= hash2 >> (kHashSetLengthLog2 * 2);
     hash2 &= (kHashSetLength - 1);
     if (hash_set_2_[hash2] == int_addr) continue;
     if (hash_set_1_[hash1] == 0) {
       hash_set_1_[hash1] = int_addr;
     } else if (hash_set_2_[hash2] == 0) {
       hash_set_2_[hash2] = int_addr;
     } else {
       // Rather than slowing down we just throw away some entries.  This will
       // cause some duplicates to remain undetected.
       hash_set_1_[hash1] = int_addr;
       hash_set_2_[hash2] = 0;
     }
     old_buffer_is_sorted_ = false;
     old_buffer_is_filtered_ = false;
     *old_top_++ = reinterpret_cast<Address>(int_addr << kPointerSizeLog2);
     DCHECK(old_top_ <= old_limit_);
   }
   heap_->isolate()->counters()->store_buffer_compactions()->Increment();
 }

References v8::internal::Heap::cell_space(), v8::internal::Heap::code_space(), v8::internal::PagedSpace::Contains(), v8::internal::Isolate::counters(), DCHECK, EnsureSpace(), hash_set_1_, hash_set_2_, hash_sets_are_empty_, heap_, v8::internal::Heap::isolate(), kHashSetLength, kHashSetLengthLog2, v8::internal::Page::kPageAlignmentMask, v8::internal::kPointerSizeLog2, limit_, may_move_store_buffer_entries_, old_buffer_is_filtered_, old_buffer_is_sorted_, v8::internal::Heap::old_data_space(), old_limit_, old_top_, v8::internal::Heap::public_set_store_buffer_top(), and start_.

Referenced by EnsureSpace(), v8::internal::Heap::FreeQueuedChunks(), Mark(), PrepareForIteration(), SortUniq(), and StoreBufferOverflow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EnsureSpace()

void v8::internal::StoreBuffer::EnsureSpace ( intptr_t space_needed )

Definition at line 127 of file store-buffer.cc.

                                                    {
   while (old_limit_ - old_top_ < space_needed &&
          old_limit_ < old_reserved_limit_) {
     size_t grow = old_limit_ - old_start_;  // Double size.
     CHECK(old_virtual_memory_->Commit(reinterpret_cast<void*>(old_limit_),
                                       grow * kPointerSize, false));
     old_limit_ += grow;
   }
  
   if (SpaceAvailable(space_needed)) return;
  
   if (old_buffer_is_filtered_) return;
   DCHECK(may_move_store_buffer_entries_);
   Compact();
  
   old_buffer_is_filtered_ = true;
   bool page_has_scan_on_scavenge_flag = false;
  
   PointerChunkIterator it(heap_);
   MemoryChunk* chunk;
   while ((chunk = it.next()) != NULL) {
     if (chunk->scan_on_scavenge()) {
       page_has_scan_on_scavenge_flag = true;
       break;
     }
   }
  
   if (page_has_scan_on_scavenge_flag) {
     Filter(MemoryChunk::SCAN_ON_SCAVENGE);
   }
  
   if (SpaceAvailable(space_needed)) return;
  
   // Sample 1 entry in 97 and filter out the pages where we estimate that more
   // than 1 in 8 pointers are to new space.
   static const int kSampleFinenesses = 5;
   static const struct Samples {
     int prime_sample_step;
     int threshold;
   } samples[kSampleFinenesses] = {
         {97, ((Page::kPageSize / kPointerSize) / 97) / 8},
         {23, ((Page::kPageSize / kPointerSize) / 23) / 16},
         {7, ((Page::kPageSize / kPointerSize) / 7) / 32},
         {3, ((Page::kPageSize / kPointerSize) / 3) / 256},
         {1, 0}};
   for (int i = 0; i < kSampleFinenesses; i++) {
     ExemptPopularPages(samples[i].prime_sample_step, samples[i].threshold);
     // As a last resort we mark all pages as being exempt from the store buffer.
     DCHECK(i != (kSampleFinenesses - 1) || old_top_ == old_start_);
     if (SpaceAvailable(space_needed)) return;
   }
   UNREACHABLE();
 }

References CHECK, v8::base::VirtualMemory::Commit(), Compact(), DCHECK, ExemptPopularPages(), Filter(), heap_, v8::internal::Page::kPageSize, v8::internal::kPointerSize, may_move_store_buffer_entries_, NULL, old_buffer_is_filtered_, old_limit_, old_reserved_limit_, old_start_, old_top_, old_virtual_memory_, v8::internal::MemoryChunk::scan_on_scavenge(), v8::internal::MemoryChunk::SCAN_ON_SCAVENGE, SpaceAvailable(), and UNREACHABLE.

Referenced by v8::internal::StoreBufferRebuilder::Callback(), and Compact().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EnterDirectlyIntoStoreBuffer()

void v8::internal::StoreBuffer::EnterDirectlyIntoStoreBuffer ( Address addr )

inline

Definition at line 34 of file store-buffer-inl.h.

                                                            {
   if (store_buffer_rebuilding_enabled_) {
     SLOW_DCHECK(!heap_->cell_space()->Contains(addr) &&
                 !heap_->code_space()->Contains(addr) &&
                 !heap_->old_data_space()->Contains(addr) &&
                 !heap_->new_space()->Contains(addr));
     Address* top = old_top_;
     *top++ = addr;
     old_top_ = top;
     old_buffer_is_sorted_ = false;
     old_buffer_is_filtered_ = false;
     if (top >= old_limit_) {
       DCHECK(callback_ != NULL);
       (*callback_)(heap_, MemoryChunk::FromAnyPointerAddress(heap_, addr),
                    kStoreBufferFullEvent);
     }
   }
 }

References callback_, v8::internal::Heap::cell_space(), v8::internal::Heap::code_space(), v8::internal::PagedSpace::Contains(), v8::internal::NewSpace::Contains(), DCHECK, v8::internal::MemoryChunk::FromAnyPointerAddress(), heap_, v8::internal::kStoreBufferFullEvent, v8::internal::Heap::new_space(), NULL, old_buffer_is_filtered_, old_buffer_is_sorted_, v8::internal::Heap::old_data_space(), old_limit_, old_top_, SLOW_DCHECK, and store_buffer_rebuilding_enabled_.

Referenced by FindPointersToNewSpaceInRegion(), v8::internal::Heap::IterateAndMarkPointersToFromSpace(), and IteratePointersInStoreBuffer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExemptPopularPages()

void v8::internal::StoreBuffer::ExemptPopularPages	(	int	prime_sample_step,
		int	threshold
	)

private

Definition at line 184 of file store-buffer.cc.

                                                                          {
   PointerChunkIterator it(heap_);
   MemoryChunk* chunk;
   while ((chunk = it.next()) != NULL) {
     chunk->set_store_buffer_counter(0);
   }
   bool created_new_scan_on_scavenge_pages = false;
   MemoryChunk* previous_chunk = NULL;
   for (Address* p = old_start_; p < old_top_; p += prime_sample_step) {
     Address addr = *p;
     MemoryChunk* containing_chunk = NULL;
     if (previous_chunk != NULL && previous_chunk->Contains(addr)) {
       containing_chunk = previous_chunk;
     } else {
       containing_chunk = MemoryChunk::FromAnyPointerAddress(heap_, addr);
     }
     int old_counter = containing_chunk->store_buffer_counter();
     if (old_counter >= threshold) {
       containing_chunk->set_scan_on_scavenge(true);
       created_new_scan_on_scavenge_pages = true;
     }
     containing_chunk->set_store_buffer_counter(old_counter + 1);
     previous_chunk = containing_chunk;
   }
   if (created_new_scan_on_scavenge_pages) {
     Filter(MemoryChunk::SCAN_ON_SCAVENGE);
   }
   old_buffer_is_filtered_ = true;
 }

References v8::internal::MemoryChunk::Contains(), Filter(), v8::internal::MemoryChunk::FromAnyPointerAddress(), heap_, NULL, old_buffer_is_filtered_, old_start_, old_top_, v8::internal::MemoryChunk::SCAN_ON_SCAVENGE, v8::internal::MemoryChunk::set_scan_on_scavenge(), v8::internal::MemoryChunk::set_store_buffer_counter(), and v8::internal::MemoryChunk::store_buffer_counter().

Referenced by EnsureSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Filter()

void v8::internal::StoreBuffer::Filter ( int flag )

Definition at line 215 of file store-buffer.cc.

                                  {
   Address* new_top = old_start_;
   MemoryChunk* previous_chunk = NULL;
   for (Address* p = old_start_; p < old_top_; p++) {
     Address addr = *p;
     MemoryChunk* containing_chunk = NULL;
     if (previous_chunk != NULL && previous_chunk->Contains(addr)) {
       containing_chunk = previous_chunk;
     } else {
       containing_chunk = MemoryChunk::FromAnyPointerAddress(heap_, addr);
       previous_chunk = containing_chunk;
     }
     if (!containing_chunk->IsFlagSet(flag)) {
       *new_top++ = addr;
     }
   }
   old_top_ = new_top;
  
   // Filtering hash sets are inconsistent with the store buffer after this
   // operation.
   ClearFilteringHashSets();
 }

References ClearFilteringHashSets(), v8::internal::MemoryChunk::Contains(), v8::internal::flag, v8::internal::MemoryChunk::FromAnyPointerAddress(), heap_, v8::internal::MemoryChunk::IsFlagSet(), NULL, old_start_, and old_top_.

Referenced by EnsureSpace(), ExemptPopularPages(), v8::internal::Heap::FreeQueuedChunks(), and PrepareForIteration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindPointersToNewSpaceInRegion()

void v8::internal::StoreBuffer::FindPointersToNewSpaceInRegion	(	Address	start,
		Address	end,
		ObjectSlotCallback	slot_callback,
		bool	clear_maps
	)

private

Definition at line 370 of file store-buffer.cc.

                      {
   for (Address slot_address = start; slot_address < end;
        slot_address += kPointerSize) {
     Object** slot = reinterpret_cast<Object**>(slot_address);
     Object* object = reinterpret_cast<Object*>(
         base::NoBarrier_Load(reinterpret_cast<base::AtomicWord*>(slot)));
     if (heap_->InNewSpace(object)) {
       HeapObject* heap_object = reinterpret_cast<HeapObject*>(object);
       DCHECK(heap_object->IsHeapObject());
       // The new space object was not promoted if it still contains a map
       // pointer. Clear the map field now lazily.
       if (clear_maps) ClearDeadObject(heap_object);
       slot_callback(reinterpret_cast<HeapObject**>(slot), heap_object);
       object = reinterpret_cast<Object*>(
           base::NoBarrier_Load(reinterpret_cast<base::AtomicWord*>(slot)));
       if (heap_->InNewSpace(object)) {
         EnterDirectlyIntoStoreBuffer(slot_address);
       }
     }
   }
 }

References ClearDeadObject(), DCHECK, EnterDirectlyIntoStoreBuffer(), heap_, v8::internal::Heap::InNewSpace(), v8::internal::kPointerSize, and v8::base::NoBarrier_Load().

Referenced by IteratePointersToNewSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GCEpilogue()

void v8::internal::StoreBuffer::GCEpilogue ( )

Definition at line 360 of file store-buffer.cc.

                              {
   during_gc_ = false;
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     Verify();
   }
 #endif
 }

References during_gc_, and Verify().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GCPrologue()

void v8::internal::StoreBuffer::GCPrologue ( )

Definition at line 323 of file store-buffer.cc.

                              {
   ClearFilteringHashSets();
   during_gc_ = true;
 }

References ClearFilteringHashSets(), and during_gc_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IteratePointersInStoreBuffer()

void v8::internal::StoreBuffer::IteratePointersInStoreBuffer	(	ObjectSlotCallback	slot_callback,
		bool	clear_maps
	)

private

Definition at line 395 of file store-buffer.cc.

                                                                 {
   Address* limit = old_top_;
   old_top_ = old_start_;
   {
     DontMoveStoreBufferEntriesScope scope(this);
     for (Address* current = old_start_; current < limit; current++) {
 #ifdef DEBUG
       Address* saved_top = old_top_;
 #endif
       Object** slot = reinterpret_cast<Object**>(*current);
       Object* object = reinterpret_cast<Object*>(
           base::NoBarrier_Load(reinterpret_cast<base::AtomicWord*>(slot)));
       if (heap_->InFromSpace(object)) {
         HeapObject* heap_object = reinterpret_cast<HeapObject*>(object);
         // The new space object was not promoted if it still contains a map
         // pointer. Clear the map field now lazily.
         if (clear_maps) ClearDeadObject(heap_object);
         slot_callback(reinterpret_cast<HeapObject**>(slot), heap_object);
         object = reinterpret_cast<Object*>(
             base::NoBarrier_Load(reinterpret_cast<base::AtomicWord*>(slot)));
         if (heap_->InNewSpace(object)) {
           EnterDirectlyIntoStoreBuffer(reinterpret_cast<Address>(slot));
         }
       }
       DCHECK(old_top_ == saved_top + 1 || old_top_ == saved_top);
     }
   }
 }

References ClearDeadObject(), DCHECK, EnterDirectlyIntoStoreBuffer(), heap_, v8::internal::Heap::InFromSpace(), v8::internal::Heap::InNewSpace(), v8::base::NoBarrier_Load(), old_start_, and old_top_.

Referenced by IteratePointersToNewSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IteratePointersOnPage()

void v8::internal::StoreBuffer::IteratePointersOnPage	(	PagedSpace *	space,
		Page *	page,
		RegionCallback	region_callback,
		ObjectSlotCallback	slot_callback
	)

private

◆ IteratePointersToNewSpace() [1/2]

void v8::internal::StoreBuffer::IteratePointersToNewSpace ( ObjectSlotCallback callback )

Definition at line 426 of file store-buffer.cc.

                                                                             {
   IteratePointersToNewSpace(slot_callback, false);
 }

Referenced by IteratePointersToNewSpaceAndClearMaps(), and v8::internal::Heap::Scavenge().

Here is the caller graph for this function:

◆ IteratePointersToNewSpace() [2/2]

void v8::internal::StoreBuffer::IteratePointersToNewSpace	(	ObjectSlotCallback	callback,
		bool	clear_maps
	)

private

Definition at line 437 of file store-buffer.cc.

                                                              {
   // We do not sort or remove duplicated entries from the store buffer because
   // we expect that callback will rebuild the store buffer thus removing
   // all duplicates and pointers to old space.
   bool some_pages_to_scan = PrepareForIteration();
  
   // TODO(gc): we want to skip slots on evacuation candidates
   // but we can't simply figure that out from slot address
   // because slot can belong to a large object.
   IteratePointersInStoreBuffer(slot_callback, clear_maps);
  
   // We are done scanning all the pointers that were in the store buffer, but
   // there may be some pages marked scan_on_scavenge that have pointers to new
   // space that are not in the store buffer.  We must scan them now.  As we
   // scan, the surviving pointers to new space will be added to the store
   // buffer.  If there are still a lot of pointers to new space then we will
   // keep the scan_on_scavenge flag on the page and discard the pointers that
   // were added to the store buffer.  If there are not many pointers to new
   // space left on the page we will keep the pointers in the store buffer and
   // remove the flag from the page.
   if (some_pages_to_scan) {
     if (callback_ != NULL) {
       (*callback_)(heap_, NULL, kStoreBufferStartScanningPagesEvent);
     }
     PointerChunkIterator it(heap_);
     MemoryChunk* chunk;
     while ((chunk = it.next()) != NULL) {
       if (chunk->scan_on_scavenge()) {
         chunk->set_scan_on_scavenge(false);
         if (callback_ != NULL) {
           (*callback_)(heap_, chunk, kStoreBufferScanningPageEvent);
         }
         if (chunk->owner() == heap_->lo_space()) {
           LargePage* large_page = reinterpret_cast<LargePage*>(chunk);
           HeapObject* array = large_page->GetObject();
           DCHECK(array->IsFixedArray());
           Address start = array->address();
           Address end = start + array->Size();
           FindPointersToNewSpaceInRegion(start, end, slot_callback, clear_maps);
         } else {
           Page* page = reinterpret_cast<Page*>(chunk);
           PagedSpace* owner = reinterpret_cast<PagedSpace*>(page->owner());
           if (owner == heap_->map_space()) {
             DCHECK(page->WasSwept());
             HeapObjectIterator iterator(page, NULL);
             for (HeapObject* heap_object = iterator.Next(); heap_object != NULL;
                  heap_object = iterator.Next()) {
               // We skip free space objects.
               if (!heap_object->IsFiller()) {
                 DCHECK(heap_object->IsMap());
                 FindPointersToNewSpaceInRegion(
                     heap_object->address() + Map::kPointerFieldsBeginOffset,
                     heap_object->address() + Map::kPointerFieldsEndOffset,
                     slot_callback, clear_maps);
               }
             }
           } else {
             if (!page->SweepingCompleted()) {
               heap_->mark_compact_collector()->SweepInParallel(page, owner);
               if (!page->SweepingCompleted()) {
                 // We were not able to sweep that page, i.e., a concurrent
                 // sweeper thread currently owns this page.
                 // TODO(hpayer): This may introduce a huge pause here. We
                 // just care about finish sweeping of the scan on scavenge page.
                 heap_->mark_compact_collector()->EnsureSweepingCompleted();
               }
             }
             CHECK(page->owner() == heap_->old_pointer_space());
             HeapObjectIterator iterator(page, NULL);
             for (HeapObject* heap_object = iterator.Next(); heap_object != NULL;
                  heap_object = iterator.Next()) {
               // We iterate over objects that contain new space pointers only.
               if (!heap_object->MayContainRawValues()) {
                 FindPointersToNewSpaceInRegion(
                     heap_object->address() + HeapObject::kHeaderSize,
                     heap_object->address() + heap_object->Size(), slot_callback,
                     clear_maps);
               }
             }
           }
         }
       }
     }
     if (callback_ != NULL) {
       (*callback_)(heap_, NULL, kStoreBufferScanningPageEvent);
     }
   }
 }

References v8::internal::HeapObject::address(), callback_, CHECK, DCHECK, v8::internal::MarkCompactCollector::EnsureSweepingCompleted(), FindPointersToNewSpaceInRegion(), v8::internal::LargePage::GetObject(), heap_, IteratePointersInStoreBuffer(), v8::internal::HeapObject::kHeaderSize, v8::internal::Map::kPointerFieldsBeginOffset, v8::internal::Map::kPointerFieldsEndOffset, v8::internal::kStoreBufferScanningPageEvent, v8::internal::kStoreBufferStartScanningPagesEvent, v8::internal::Heap::lo_space(), v8::internal::Heap::map_space(), v8::internal::Heap::mark_compact_collector(), v8::internal::HeapObjectIterator::Next(), NULL, v8::internal::Heap::old_pointer_space(), v8::internal::MemoryChunk::owner(), PrepareForIteration(), v8::internal::MemoryChunk::scan_on_scavenge(), v8::internal::MemoryChunk::set_scan_on_scavenge(), v8::internal::HeapObject::Size(), v8::internal::MemoryChunk::SweepingCompleted(), v8::internal::MarkCompactCollector::SweepInParallel(), and v8::internal::Page::WasSwept().

Here is the call graph for this function:

◆ IteratePointersToNewSpaceAndClearMaps()

void v8::internal::StoreBuffer::IteratePointersToNewSpaceAndClearMaps ( ObjectSlotCallback callback )

Definition at line 431 of file store-buffer.cc.

                                       {
   IteratePointersToNewSpace(slot_callback, true);
 }

References IteratePointersToNewSpace().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Limit()

Object*** v8::internal::StoreBuffer::Limit ( )

inline

Definition at line 79 of file store-buffer.h.

79 { return reinterpret_cast<Object***>(old_limit_); }

References old_limit_.

Referenced by v8::internal::StoreBufferRebuilder::Callback(), and SetTop().

Here is the caller graph for this function:

◆ Mark()

void v8::internal::StoreBuffer::Mark ( Address addr )

inline

Definition at line 18 of file store-buffer-inl.h.

                                    {
   DCHECK(!heap_->cell_space()->Contains(addr));
   DCHECK(!heap_->code_space()->Contains(addr));
   DCHECK(!heap_->old_data_space()->Contains(addr));
   Address* top = reinterpret_cast<Address*>(heap_->store_buffer_top());
   *top++ = addr;
   heap_->public_set_store_buffer_top(top);
   if ((reinterpret_cast<uintptr_t>(top) & kStoreBufferOverflowBit) != 0) {
     DCHECK(top == limit_);
     Compact();
   } else {
     DCHECK(top < limit_);
   }
 }

References v8::internal::Heap::cell_space(), v8::internal::Heap::code_space(), Compact(), v8::internal::PagedSpace::Contains(), DCHECK, heap_, kStoreBufferOverflowBit, limit_, v8::internal::Heap::old_data_space(), and v8::internal::Heap::public_set_store_buffer_top().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ old_buffer_is_filtered()

bool v8::internal::StoreBuffer::old_buffer_is_filtered ( )

inline

Definition at line 89 of file store-buffer.h.

89 { return old_buffer_is_filtered_; }

References old_buffer_is_filtered_.

◆ old_buffer_is_sorted()

bool v8::internal::StoreBuffer::old_buffer_is_sorted ( )

inline

Definition at line 88 of file store-buffer.h.

88 { return old_buffer_is_sorted_; }

References old_buffer_is_sorted_.

◆ PrepareForIteration()

bool v8::internal::StoreBuffer::PrepareForIteration ( )

Definition at line 253 of file store-buffer.cc.

                                       {
   Compact();
   PointerChunkIterator it(heap_);
   MemoryChunk* chunk;
   bool page_has_scan_on_scavenge_flag = false;
   while ((chunk = it.next()) != NULL) {
     if (chunk->scan_on_scavenge()) {
       page_has_scan_on_scavenge_flag = true;
       break;
     }
   }
  
   if (page_has_scan_on_scavenge_flag) {
     Filter(MemoryChunk::SCAN_ON_SCAVENGE);
   }
  
   // Filtering hash sets are inconsistent with the store buffer after
   // iteration.
   ClearFilteringHashSets();
  
   return page_has_scan_on_scavenge_flag;
 }

References ClearFilteringHashSets(), Compact(), Filter(), heap_, NULL, v8::internal::MemoryChunk::scan_on_scavenge(), and v8::internal::MemoryChunk::SCAN_ON_SCAVENGE.

Referenced by IteratePointersToNewSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetTop()

void v8::internal::StoreBuffer::SetTop ( Object *** top )

inline

Definition at line 82 of file store-buffer.h.

                              {
     DCHECK(top >= Start());
     DCHECK(top <= Limit());
     old_top_ = reinterpret_cast<Address*>(top);
   }

References DCHECK, Limit(), old_top_, and Start().

Referenced by v8::internal::StoreBufferRebuilder::Callback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetUp()

void v8::internal::StoreBuffer::SetUp ( )

Definition at line 36 of file store-buffer.cc.

                         {
   virtual_memory_ = new base::VirtualMemory(kStoreBufferSize * 3);
   uintptr_t start_as_int =
       reinterpret_cast<uintptr_t>(virtual_memory_->address());
   start_ =
       reinterpret_cast<Address*>(RoundUp(start_as_int, kStoreBufferSize * 2));
   limit_ = start_ + (kStoreBufferSize / kPointerSize);
  
   old_virtual_memory_ =
       new base::VirtualMemory(kOldStoreBufferLength * kPointerSize);
   old_top_ = old_start_ =
       reinterpret_cast<Address*>(old_virtual_memory_->address());
   // Don't know the alignment requirements of the OS, but it is certainly not
   // less than 0xfff.
   DCHECK((reinterpret_cast<uintptr_t>(old_start_) & 0xfff) == 0);
   int initial_length =
       static_cast<int>(base::OS::CommitPageSize() / kPointerSize);
   DCHECK(initial_length > 0);
   DCHECK(initial_length <= kOldStoreBufferLength);
   old_limit_ = old_start_ + initial_length;
   old_reserved_limit_ = old_start_ + kOldStoreBufferLength;
  
   CHECK(old_virtual_memory_->Commit(reinterpret_cast<void*>(old_start_),
                                     (old_limit_ - old_start_) * kPointerSize,
                                     false));
  
   DCHECK(reinterpret_cast<Address>(start_) >= virtual_memory_->address());
   DCHECK(reinterpret_cast<Address>(limit_) >= virtual_memory_->address());
   Address* vm_limit = reinterpret_cast<Address*>(
       reinterpret_cast<char*>(virtual_memory_->address()) +
       virtual_memory_->size());
   DCHECK(start_ <= vm_limit);
   DCHECK(limit_ <= vm_limit);
   USE(vm_limit);
   DCHECK((reinterpret_cast<uintptr_t>(limit_) & kStoreBufferOverflowBit) != 0);
   DCHECK((reinterpret_cast<uintptr_t>(limit_ - 1) & kStoreBufferOverflowBit) ==
          0);
  
   CHECK(virtual_memory_->Commit(reinterpret_cast<Address>(start_),
                                 kStoreBufferSize,
                                 false));  // Not executable.
   heap_->public_set_store_buffer_top(start_);
  
   hash_set_1_ = new uintptr_t[kHashSetLength];
   hash_set_2_ = new uintptr_t[kHashSetLength];
   hash_sets_are_empty_ = false;
  
   ClearFilteringHashSets();
 }

References v8::base::VirtualMemory::address(), CHECK, ClearFilteringHashSets(), v8::base::VirtualMemory::Commit(), v8::base::OS::CommitPageSize(), DCHECK, hash_set_1_, hash_set_2_, hash_sets_are_empty_, heap_, kHashSetLength, kOldStoreBufferLength, v8::internal::kPointerSize, kStoreBufferOverflowBit, kStoreBufferSize, limit_, old_limit_, old_reserved_limit_, old_start_, old_top_, old_virtual_memory_, v8::internal::Heap::public_set_store_buffer_top(), v8::internal::RoundUp(), v8::base::VirtualMemory::size(), start_, USE(), and virtual_memory_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SortUniq()

void v8::internal::StoreBuffer::SortUniq ( )

Definition at line 239 of file store-buffer.cc.

                            {
   Compact();
   if (old_buffer_is_sorted_) return;
   std::sort(old_start_, old_top_);
   Uniq();
  
   old_buffer_is_sorted_ = true;
  
   // Filtering hash sets are inconsistent with the store buffer after this
   // operation.
   ClearFilteringHashSets();
 }

References ClearFilteringHashSets(), Compact(), old_buffer_is_sorted_, old_start_, old_top_, and Uniq().

Here is the call graph for this function:

◆ SpaceAvailable()

bool v8::internal::StoreBuffer::SpaceAvailable ( intptr_t space_needed )

private

Definition at line 122 of file store-buffer.cc.

                                                       {
   return old_limit_ - old_top_ >= space_needed;
 }

References old_limit_, and old_top_.

Referenced by EnsureSpace().

Here is the caller graph for this function:

◆ Start()

Object*** v8::internal::StoreBuffer::Start ( )

inline

Definition at line 80 of file store-buffer.h.

80 { return reinterpret_cast<Object***>(old_start_); }

References old_start_.

Referenced by SetTop().

Here is the caller graph for this function:

◆ StoreBufferOverflow()

void v8::internal::StoreBuffer::StoreBufferOverflow ( Isolate * isolate )

static

Definition at line 98 of file store-buffer.cc.

                                                       {
   isolate->heap()->store_buffer()->Compact();
   isolate->counters()->store_buffer_overflows()->Increment();
 }

References Compact(), v8::internal::Isolate::counters(), v8::internal::Isolate::heap(), and v8::internal::Heap::store_buffer().

Here is the call graph for this function:

◆ TearDown()

void v8::internal::StoreBuffer::TearDown ( )

Definition at line 87 of file store-buffer.cc.

                            {
   delete virtual_memory_;
   delete old_virtual_memory_;
   delete[] hash_set_1_;
   delete[] hash_set_2_;
   old_start_ = old_top_ = old_limit_ = old_reserved_limit_ = NULL;
   start_ = limit_ = NULL;
   heap_->public_set_store_buffer_top(start_);
 }

References hash_set_1_, hash_set_2_, heap_, limit_, NULL, old_limit_, old_reserved_limit_, old_start_, old_top_, old_virtual_memory_, v8::internal::Heap::public_set_store_buffer_top(), start_, and virtual_memory_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Top()

Object*** v8::internal::StoreBuffer::Top ( )

inline

Definition at line 81 of file store-buffer.h.

81 { return reinterpret_cast<Object***>(old_top_); }

References old_top_.

Referenced by v8::internal::StoreBufferRebuilder::Callback().

Here is the caller graph for this function:

◆ TopAddress()

Address v8::internal::StoreBuffer::TopAddress ( )

inline

Definition at line 13 of file store-buffer-inl.h.

                                 {
   return reinterpret_cast<Address>(heap_->store_buffer_top_address());
 }

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

Here is the call graph for this function:

◆ Uniq()

void v8::internal::StoreBuffer::Uniq ( )

private

Definition at line 104 of file store-buffer.cc.

                        {
   // Remove adjacent duplicates and cells that do not point at new space.
   Address previous = NULL;
   Address* write = old_start_;
   DCHECK(may_move_store_buffer_entries_);
   for (Address* read = old_start_; read < old_top_; read++) {
     Address current = *read;
     if (current != previous) {
       if (heap_->InNewSpace(*reinterpret_cast<Object**>(current))) {
         *write++ = current;
       }
     }
     previous = current;
   }
   old_top_ = write;
 }

References DCHECK, heap_, v8::internal::Heap::InNewSpace(), may_move_store_buffer_entries_, NULL, old_start_, and old_top_.

Referenced by SortUniq().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Verify()

void v8::internal::StoreBuffer::Verify ( )

Definition at line 353 of file store-buffer.cc.

                          {
 #ifdef VERIFY_HEAP
   VerifyPointers(heap_->lo_space());
 #endif
 }

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

Referenced by GCEpilogue().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ DontMoveStoreBufferEntriesScope

friend class DontMoveStoreBufferEntriesScope

friend

Definition at line 174 of file store-buffer.h.

◆ StoreBufferRebuildScope

friend class StoreBufferRebuildScope

friend

Definition at line 173 of file store-buffer.h.

Member Data Documentation

◆ callback_

StoreBufferCallback v8::internal::StoreBuffer::callback_

private

Definition at line 130 of file store-buffer.h.

Referenced by EnterDirectlyIntoStoreBuffer(), IteratePointersToNewSpace(), v8::internal::StoreBufferRebuildScope::StoreBufferRebuildScope(), and v8::internal::StoreBufferRebuildScope::~StoreBufferRebuildScope().

◆ during_gc_

bool v8::internal::StoreBuffer::during_gc_

private

Definition at line 125 of file store-buffer.h.

Referenced by GCEpilogue(), and GCPrologue().

◆ hash_set_1_

uintptr_t* v8::internal::StoreBuffer::hash_set_1_

private

Definition at line 138 of file store-buffer.h.

Referenced by ClearFilteringHashSets(), Compact(), SetUp(), and TearDown().

◆ hash_set_2_

uintptr_t* v8::internal::StoreBuffer::hash_set_2_

private

Definition at line 139 of file store-buffer.h.

Referenced by ClearFilteringHashSets(), Compact(), SetUp(), and TearDown().

◆ hash_sets_are_empty_

bool v8::internal::StoreBuffer::hash_sets_are_empty_

private

Definition at line 140 of file store-buffer.h.

Referenced by ClearFilteringHashSets(), Compact(), and SetUp().

◆ heap_

Heap* v8::internal::StoreBuffer::heap_

private

Definition at line 109 of file store-buffer.h.

Referenced by ClearDeadObject(), Compact(), EnsureSpace(), EnterDirectlyIntoStoreBuffer(), ExemptPopularPages(), Filter(), FindPointersToNewSpaceInRegion(), IteratePointersInStoreBuffer(), IteratePointersToNewSpace(), Mark(), PrepareForIteration(), SetUp(), TearDown(), TopAddress(), Uniq(), and Verify().

◆ kHashSetLength

const int v8::internal::StoreBuffer::kHashSetLength = 1 << kHashSetLengthLog2

static

Definition at line 72 of file store-buffer.h.

Referenced by ClearFilteringHashSets(), Compact(), and SetUp().

◆ kHashSetLengthLog2

const int v8::internal::StoreBuffer::kHashSetLengthLog2 = 12

static

Definition at line 71 of file store-buffer.h.

Referenced by Compact().

◆ kOldStoreBufferLength

const int v8::internal::StoreBuffer::kOldStoreBufferLength = kStoreBufferLength * 16

static

Definition at line 70 of file store-buffer.h.

Referenced by SetUp().

◆ kStoreBufferLength

const int v8::internal::StoreBuffer::kStoreBufferLength = kStoreBufferSize / sizeof(Address)

static

Definition at line 69 of file store-buffer.h.

◆ kStoreBufferOverflowBit

const int v8::internal::StoreBuffer::kStoreBufferOverflowBit = 1 << (14 + kPointerSizeLog2)

static

Definition at line 67 of file store-buffer.h.

Referenced by Mark(), and SetUp().

◆ kStoreBufferSize

const int v8::internal::StoreBuffer::kStoreBufferSize = kStoreBufferOverflowBit

static

Definition at line 68 of file store-buffer.h.

Referenced by v8::internal::StoreBufferRebuilder::Callback(), and SetUp().

◆ limit_

Address* v8::internal::StoreBuffer::limit_

private

Definition at line 115 of file store-buffer.h.

Referenced by Compact(), Mark(), SetUp(), and TearDown().

◆ may_move_store_buffer_entries_

bool v8::internal::StoreBuffer::may_move_store_buffer_entries_

private

Definition at line 131 of file store-buffer.h.

Referenced by Compact(), v8::internal::DontMoveStoreBufferEntriesScope::DontMoveStoreBufferEntriesScope(), EnsureSpace(), Uniq(), and v8::internal::DontMoveStoreBufferEntriesScope::~DontMoveStoreBufferEntriesScope().

◆ old_buffer_is_filtered_

bool v8::internal::StoreBuffer::old_buffer_is_filtered_

private

Definition at line 124 of file store-buffer.h.

Referenced by Compact(), EnsureSpace(), EnterDirectlyIntoStoreBuffer(), ExemptPopularPages(), and old_buffer_is_filtered().

◆ old_buffer_is_sorted_

bool v8::internal::StoreBuffer::old_buffer_is_sorted_

private

Definition at line 123 of file store-buffer.h.

Referenced by Compact(), EnterDirectlyIntoStoreBuffer(), old_buffer_is_sorted(), and SortUniq().

◆ old_limit_

Address* v8::internal::StoreBuffer::old_limit_

private

Definition at line 118 of file store-buffer.h.

Referenced by Compact(), EnsureSpace(), EnterDirectlyIntoStoreBuffer(), Limit(), SetUp(), SpaceAvailable(), and TearDown().

◆ old_reserved_limit_

Address* v8::internal::StoreBuffer::old_reserved_limit_

private

Definition at line 120 of file store-buffer.h.

Referenced by EnsureSpace(), SetUp(), and TearDown().

◆ old_start_

Address* v8::internal::StoreBuffer::old_start_

private

Definition at line 117 of file store-buffer.h.

Referenced by EnsureSpace(), ExemptPopularPages(), Filter(), IteratePointersInStoreBuffer(), SetUp(), SortUniq(), Start(), TearDown(), and Uniq().

◆ old_top_

Address* v8::internal::StoreBuffer::old_top_

private

Definition at line 119 of file store-buffer.h.

Referenced by Compact(), EnsureSpace(), EnterDirectlyIntoStoreBuffer(), ExemptPopularPages(), Filter(), IteratePointersInStoreBuffer(), SetTop(), SetUp(), SortUniq(), SpaceAvailable(), TearDown(), Top(), and Uniq().

◆ old_virtual_memory_

base::VirtualMemory* v8::internal::StoreBuffer::old_virtual_memory_

private

Definition at line 121 of file store-buffer.h.

Referenced by EnsureSpace(), SetUp(), and TearDown().

◆ start_

Address* v8::internal::StoreBuffer::start_

private

Definition at line 114 of file store-buffer.h.

Referenced by Compact(), SetUp(), and TearDown().

◆ store_buffer_rebuilding_enabled_

bool v8::internal::StoreBuffer::store_buffer_rebuilding_enabled_

private

Definition at line 129 of file store-buffer.h.

Referenced by EnterDirectlyIntoStoreBuffer(), v8::internal::StoreBufferRebuildScope::StoreBufferRebuildScope(), and v8::internal::StoreBufferRebuildScope::~StoreBufferRebuildScope().

◆ virtual_memory_

base::VirtualMemory* v8::internal::StoreBuffer::virtual_memory_

private

Definition at line 133 of file store-buffer.h.

Referenced by SetUp(), and TearDown().

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

/mnt/V8SourceCode/src/heap/store-buffer.h
/mnt/V8SourceCode/src/heap/store-buffer-inl.h
/mnt/V8SourceCode/src/heap/store-buffer.cc

Private Attributes
Heap *	heap_

Address *	start_

Address *	limit_

Address *	old_start_

Address *	old_limit_

Address *	old_top_

Address *	old_reserved_limit_

base::VirtualMemory *	old_virtual_memory_

bool	old_buffer_is_sorted_

bool	old_buffer_is_filtered_

bool	during_gc_

bool	store_buffer_rebuilding_enabled_

StoreBufferCallback	callback_

bool	may_move_store_buffer_entries_

base::VirtualMemory *	virtual_memory_

uintptr_t *	hash_set_1_

uintptr_t *	hash_set_2_

bool	hash_sets_are_empty_

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ StoreBuffer()

Member Function Documentation

◆ ClearDeadObject()

◆ ClearFilteringHashSets()

◆ Compact()

◆ EnsureSpace()

◆ EnterDirectlyIntoStoreBuffer()

◆ ExemptPopularPages()

◆ Filter()

◆ FindPointersToNewSpaceInRegion()

◆ GCEpilogue()

◆ GCPrologue()

◆ IteratePointersInStoreBuffer()

◆ IteratePointersOnPage()

◆ IteratePointersToNewSpace() [1/2]

◆ IteratePointersToNewSpace() [2/2]

◆ IteratePointersToNewSpaceAndClearMaps()

◆ Limit()

◆ Mark()

◆ old_buffer_is_filtered()

◆ old_buffer_is_sorted()

◆ PrepareForIteration()

◆ SetTop()

◆ SetUp()

◆ SortUniq()

◆ SpaceAvailable()

◆ Start()

◆ StoreBufferOverflow()

◆ TearDown()

◆ Top()

◆ TopAddress()

◆ Uniq()

◆ Verify()

Friends And Related Function Documentation

◆ DontMoveStoreBufferEntriesScope

◆ StoreBufferRebuildScope

Member Data Documentation

◆ callback_

◆ during_gc_

◆ hash_set_1_

◆ hash_set_2_

◆ hash_sets_are_empty_

◆ heap_

◆ kHashSetLength

◆ kHashSetLengthLog2

◆ kOldStoreBufferLength

◆ kStoreBufferLength

◆ kStoreBufferOverflowBit

◆ kStoreBufferSize

◆ limit_

◆ may_move_store_buffer_entries_

◆ old_buffer_is_filtered_

◆ old_buffer_is_sorted_

◆ old_limit_

◆ old_reserved_limit_

◆ old_start_

◆ old_top_

◆ old_virtual_memory_

◆ start_

◆ store_buffer_rebuilding_enabled_

◆ virtual_memory_