chromium/v8/src/heap/safepoint.cc

// Copyright 2020 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/safepoint.h"

#include <atomic>

#include "src/base/logging.h"
#include "src/base/platform/mutex.h"
#include "src/common/globals.h"
#include "src/execution/isolate.h"
#include "src/handles/handles.h"
#include "src/handles/local-handles.h"
#include "src/handles/persistent-handles.h"
#include "src/heap/gc-tracer-inl.h"
#include "src/heap/gc-tracer.h"
#include "src/heap/heap-inl.h"
#include "src/heap/heap.h"
#include "src/heap/local-heap-inl.h"
#include "src/heap/parked-scope.h"
#include "src/logging/counters-scopes.h"
#include "src/objects/objects.h"

namespace v8 {
namespace internal {

IsolateSafepoint::IsolateSafepoint(Heap* heap) : … { … }

void IsolateSafepoint::EnterLocalSafepointScope() { … }

class PerClientSafepointData final { … };

void IsolateSafepoint::InitiateGlobalSafepointScope(
    Isolate* initiator, PerClientSafepointData* client_data) { … }

void IsolateSafepoint::TryInitiateGlobalSafepointScope(
    Isolate* initiator, PerClientSafepointData* client_data) { … }

class GlobalSafepointInterruptTask : public CancelableTask { … };

void IsolateSafepoint::InitiateGlobalSafepointScopeRaw(
    Isolate* initiator, PerClientSafepointData* client_data) { … }

IsolateSafepoint::IncludeMainThread IsolateSafepoint::ShouldIncludeMainThread(
    Isolate* initiator) { … }

size_t IsolateSafepoint::SetSafepointRequestedFlags(
    IncludeMainThread include_main_thread) { … }

void IsolateSafepoint::LockMutex(LocalHeap* local_heap) { … }

void IsolateSafepoint::LeaveGlobalSafepointScope(Isolate* initiator) { … }

void IsolateSafepoint::LeaveLocalSafepointScope() { … }

void IsolateSafepoint::ClearSafepointRequestedFlags(
    IncludeMainThread include_main_thread) { … }

void IsolateSafepoint::WaitInSafepoint() { … }

void IsolateSafepoint::WaitInUnpark() { … }

void IsolateSafepoint::NotifyPark() { … }

void IsolateSafepoint::WaitUntilRunningThreadsInSafepoint(
    const PerClientSafepointData* client_data) { … }

void IsolateSafepoint::Barrier::Arm() { … }

void IsolateSafepoint::Barrier::Disarm() { … }

void IsolateSafepoint::Barrier::WaitUntilRunningThreadsInSafepoint(
    size_t running) { … }

void IsolateSafepoint::Barrier::NotifyPark() { … }

void IsolateSafepoint::Barrier::WaitInSafepoint() { … }

void IsolateSafepoint::Barrier::WaitInUnpark() { … }

void IsolateSafepoint::Iterate(RootVisitor* visitor) { … }

void IsolateSafepoint::AssertMainThreadIsOnlyThread() { … }

Isolate* IsolateSafepoint::isolate() const { … }

Isolate* IsolateSafepoint::shared_space_isolate() const { … }

IsolateSafepointScope::IsolateSafepointScope(Heap* heap)
    : … { … }

IsolateSafepointScope::~IsolateSafepointScope() { … }

GlobalSafepoint::GlobalSafepoint(Isolate* isolate)
    : … { … }

void GlobalSafepoint::AppendClient(Isolate* client) { … }

void GlobalSafepoint::RemoveClient(Isolate* client) { … }

void GlobalSafepoint::AssertNoClientsOnTearDown() { … }

void GlobalSafepoint::EnterGlobalSafepointScope(Isolate* initiator) { … }

void GlobalSafepoint::LeaveGlobalSafepointScope(Isolate* initiator) { … }

bool GlobalSafepoint::IsRequestedForTesting() { … }

GlobalSafepointScope::GlobalSafepointScope(Isolate* initiator)
    : … { … }

GlobalSafepointScope::~GlobalSafepointScope() { … }

SafepointScope::SafepointScope(Isolate* initiator, SafepointKind kind) { … }

}  // namespace internal
}  // namespace v8