deps/v8/src/heap/normal-page.cc - main - githubmirror/node

deps/v8/src/heap/normal-page.cc
148 строк5 KB
Michaël Zasso
deps: update V8 to 14.6.202.33
24 апр 2026, 19:01
24 апр 2026, 19:01f1e0b83
// Copyright 2023 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/heap/normal-page.h"

#include "src/heap/heap-inl.h"
#include "src/heap/incremental-marking.h"
#include "src/heap/normal-page-inl.h"
#include "src/heap/paged-spaces.h"

namespace v8::internal {

NormalPage::NormalPage(Heap* heap, BaseSpace* space, size_t size,
                       Address area_start, Address area_end,
                       VirtualMemory reservation, Executability executability,
                       MemoryChunk::MainThreadFlags* trusted_flags)
    : MutablePage(heap, space, size, area_start, area_end,
                  std::move(reservation), PageSize::kRegular, executability) {
  DCHECK(!is_large());
  trusted_main_thread_flags_ = ComputeInitialFlags(executability);
  if (trusted_main_thread_flags_ & MemoryChunk::BLACK_ALLOCATED) {
    set_is_black_allocated(true);
  }
  *trusted_flags = trusted_main_thread_flags_;
}

void NormalPage::AllocateFreeListCategories() {
  DCHECK_NULL(categories_);
  categories_ =
      new FreeListCategory*[owner()->free_list()->number_of_categories()]();
  for (int i = kFirstCategory; i <= owner()->free_list()->last_category();
       i++) {
    DCHECK_NULL(categories_[i]);
    categories_[i] = new FreeListCategory();
  }
}

void NormalPage::InitializeFreeListCategories() {
  for (int i = kFirstCategory; i <= owner()->free_list()->last_category();
       i++) {
    categories_[i]->Initialize(static_cast<FreeListCategoryType>(i));
  }
}

void NormalPage::ReleaseFreeListCategories() {
  if (categories_ != nullptr) {
    for (int i = kFirstCategory; i <= owner()->free_list()->last_category();
         i++) {
      if (categories_[i] != nullptr) {
        delete categories_[i];
        categories_[i] = nullptr;
      }
    }
    delete[] categories_;
    categories_ = nullptr;
  }
}

NormalPage* NormalPage::ConvertNewToOld(NormalPage* old_page,
                                        FreeMode free_mode) {
  DCHECK(old_page);
  DCHECK(old_page->Chunk()->InNewSpace());
  old_page->ResetAgeInNewSpace();
  OldSpace* old_space = old_page->heap()->old_space();
  old_page->set_owner(old_space);
  old_page->ClearFlagsNonExecutable(MemoryChunk::kAllFlagsMask);
  DCHECK_NE(old_space->identity(), SHARED_SPACE);
  old_page->SetOldGenerationPageFlags(
      old_page->heap()->incremental_marking()->marking_mode());
  NormalPage* new_page = old_space->InitializePage(old_page);
  old_space->AddPromotedPage(new_page, free_mode);
  return new_page;
}

size_t NormalPage::AvailableInFreeList() {
  size_t sum = 0;
  ForAllFreeListCategories(
      [&sum](FreeListCategory* category) { sum += category->available(); });
  return sum;
}

void NormalPage::MarkNeverAllocateForTesting() {
  DCHECK(this->owner_identity() != NEW_SPACE);
  DCHECK(!never_allocate_on_chunk());
  set_never_allocate_on_chunk(true);
  set_never_evacuate();
  reinterpret_cast<PagedSpace*>(owner())->free_list()->EvictFreeListItems(this);
}

void NormalPage::CreateBlackArea(Address start, Address end) {
  DCHECK(!v8_flags.black_allocated_pages);
  DCHECK_NE(NEW_SPACE, owner_identity());
  DCHECK(v8_flags.sticky_mark_bits ||
         heap()->incremental_marking()->black_allocation());
  DCHECK_EQ(NormalPage::FromAddress(start), this);
  DCHECK_LT(start, end);
  DCHECK_EQ(NormalPage::FromAddress(end - 1), this);
  marking_bitmap()->SetRange<AccessMode::ATOMIC>(
      MarkingBitmap::AddressToIndex(start),
      MarkingBitmap::LimitAddressToIndex(end));
  IncrementLiveBytesAtomically(static_cast<intptr_t>(end - start));
  owner()->NotifyBlackAreaCreated(end - start);
}

void NormalPage::DestroyBlackArea(Address start, Address end) {
  DCHECK(!v8_flags.black_allocated_pages);
  DCHECK_NE(NEW_SPACE, owner_identity());
  DCHECK(v8_flags.sticky_mark_bits ||
         heap()->incremental_marking()->black_allocation());
  DCHECK_EQ(NormalPage::FromAddress(start), this);
  DCHECK_LT(start, end);
  DCHECK_EQ(NormalPage::FromAddress(end - 1), this);
  marking_bitmap()->ClearRange<AccessMode::ATOMIC>(
      MarkingBitmap::AddressToIndex(start),
      MarkingBitmap::LimitAddressToIndex(end));
  IncrementLiveBytesAtomically(-static_cast<intptr_t>(end - start));
  owner()->NotifyBlackAreaDestroyed(end - start);
}

void NormalPage::ClearBlackAllocation() {
  ClearFlagUnlocked(MemoryChunk::BLACK_ALLOCATED);
  set_is_black_allocated(false);
}

void NormalPage::MarkEvacuationCandidate() {
  DCHECK(!never_evacuate());
  DCHECK_NULL(slot_set<OLD_TO_OLD>());
  DCHECK_NULL(typed_slot_set<OLD_TO_OLD>());
  set_is_evacuation_candidate(true);
  SetFlagMaybeExecutable(MemoryChunk::EVACUATION_CANDIDATE);
  reinterpret_cast<PagedSpace*>(owner())->free_list()->EvictFreeListItems(this);
}

void NormalPage::ClearEvacuationCandidate() {
  CHECK(evacuation_was_aborted());
  set_evacuation_was_aborted(false);
  set_is_evacuation_candidate(false);
  ClearFlagMaybeExecutable(MemoryChunk::EVACUATION_CANDIDATE);
  InitializeFreeListCategories();
}

void NormalPage::AbortEvacuation() {
  DCHECK(!evacuation_was_aborted());
  set_evacuation_was_aborted(true);
}

}  // namespace v8::internal