chromium/v8/src/heap/parked-scope-inl.h

// 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.

#ifndef V8_HEAP_PARKED_SCOPE_INL_H_
#define V8_HEAP_PARKED_SCOPE_INL_H_

#include "src/base/platform/condition-variable.h"
#include "src/base/platform/mutex.h"
#include "src/base/platform/semaphore.h"
#include "src/execution/local-isolate.h"
#include "src/heap/local-heap-inl.h"
#include "src/heap/parked-scope.h"

namespace v8 {
namespace internal {

V8_INLINE ParkedMutexGuard::ParkedMutexGuard(LocalIsolate* local_isolate,
                                             base::Mutex* mutex)
    : … { … }

V8_INLINE ParkedMutexGuard::ParkedMutexGuard(LocalHeap* local_heap,
                                             base::Mutex* mutex)
    : … { … }

V8_INLINE ParkedRecursiveMutexGuard::ParkedRecursiveMutexGuard(
    LocalIsolate* local_isolate, base::RecursiveMutex* mutex)
    : … { … }

V8_INLINE ParkedRecursiveMutexGuard::ParkedRecursiveMutexGuard(
    LocalHeap* local_heap, base::RecursiveMutex* mutex)
    : … { … }

template <base::MutexSharedType kIsShared, base::NullBehavior Behavior>
V8_INLINE
ParkedSharedMutexGuardIf<kIsShared, Behavior>::ParkedSharedMutexGuardIf(
    LocalHeap* local_heap, base::SharedMutex* mutex, bool enable_mutex) { … }

V8_INLINE void ParkingConditionVariable::ParkedWait(LocalIsolate* local_isolate,
                                                    base::Mutex* mutex) { … }

V8_INLINE void ParkingConditionVariable::ParkedWait(LocalHeap* local_heap,
                                                    base::Mutex* mutex) { … }

V8_INLINE bool ParkingConditionVariable::ParkedWaitFor(
    LocalIsolate* local_isolate, base::Mutex* mutex,
    const base::TimeDelta& rel_time) { … }

V8_INLINE bool ParkingConditionVariable::ParkedWaitFor(
    LocalHeap* local_heap, base::Mutex* mutex,
    const base::TimeDelta& rel_time) { … }

V8_INLINE void ParkingSemaphore::ParkedWait(LocalIsolate* local_isolate) { … }

V8_INLINE void ParkingSemaphore::ParkedWait(LocalHeap* local_heap) { … }

V8_INLINE bool ParkingSemaphore::ParkedWaitFor(
    LocalIsolate* local_isolate, const base::TimeDelta& rel_time) { … }

V8_INLINE bool ParkingSemaphore::ParkedWaitFor(
    LocalHeap* local_heap, const base::TimeDelta& rel_time) { … }

V8_INLINE void ParkingThread::ParkedJoin(LocalIsolate* local_isolate) { … }

V8_INLINE void ParkingThread::ParkedJoin(LocalHeap* local_heap) { … }

template <typename ThreadCollection>
// static
V8_INLINE void ParkingThread::ParkedJoinAll(LocalIsolate* local_isolate,
                                            const ThreadCollection& threads) { … }

template <typename ThreadCollection>
// static
V8_INLINE void ParkingThread::ParkedJoinAll(LocalHeap* local_heap,
                                            const ThreadCollection& threads) { … }

}  // namespace internal
}  // namespace v8

#endif  // V8_HEAP_PARKED_SCOPE_INL_H_