Locking.swift

//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//

#if canImport(Darwin)
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(WinSDK)
import WinSDK
#elseif canImport(Bionic)
import Bionic
#else
#error("Unsupported platform")
#endif

internalstructLock{
#if canImport(Darwin)
typealiasPrimitive=os_unfair_lock
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
typealiasPrimitive=pthread_mutex_t
#elseif canImport(WinSDK)
typealiasPrimitive=SRWLOCK
#else
#error("Unsupported platform")
#endif

typealiasPlatformLock=UnsafeMutablePointer<Primitive>
letplatformLock:PlatformLock

privateinit(_ platformLock:PlatformLock){
self.platformLock = platformLock
}

fileprivatestaticfunc initialize(_ platformLock:PlatformLock){
#if canImport(Darwin)
 platformLock.initialize(to:os_unfair_lock())
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
letresult=pthread_mutex_init(platformLock,nil)
precondition(result ==0,"pthread_mutex_init failed")
#elseif canImport(WinSDK)
InitializeSRWLock(platformLock)
#else
#error("Unsupported platform")
#endif
}

fileprivatestaticfunc deinitialize(_ platformLock:PlatformLock){
#if canImport(Glibc) || canImport(Musl) || canImport(Bionic)
letresult=pthread_mutex_destroy(platformLock)
precondition(result ==0,"pthread_mutex_destroy failed")
#endif
 platformLock.deinitialize(count:1)
}

fileprivatestaticfunc lock(_ platformLock:PlatformLock){
#if canImport(Darwin)
os_unfair_lock_lock(platformLock)
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
pthread_mutex_lock(platformLock)
#elseif canImport(WinSDK)
AcquireSRWLockExclusive(platformLock)
#else
#error("Unsupported platform")
#endif
}

fileprivatestaticfunc unlock(_ platformLock:PlatformLock){
#if canImport(Darwin)
os_unfair_lock_unlock(platformLock)
#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
letresult=pthread_mutex_unlock(platformLock)
precondition(result ==0,"pthread_mutex_unlock failed")
#elseif canImport(WinSDK)
ReleaseSRWLockExclusive(platformLock)
#else
#error("Unsupported platform")
#endif
}

staticfunc allocate()->Lock{
letplatformLock=PlatformLock.allocate(capacity:1)
initialize(platformLock)
returnLock(platformLock)
}

func deinitialize(){
Lock.deinitialize(platformLock)
 platformLock.deallocate()
}

func lock(){
Lock.lock(platformLock)
}

func unlock(){
Lock.unlock(platformLock)
}

 /// Acquire the lock for the duration of the given block.
 ///
 /// This convenience method should be preferred to `lock` and `unlock` in
 /// most situations, as it ensures that the lock will be released regardless
 /// of how `body` exits.
 ///
 /// - Parameter body: The block to execute while holding the lock.
 /// - Returns: The value returned by the block.
func withLock<T>(_ body:()throws->T)rethrows->T{
self.lock()
defer{
self.unlock()
}
returntrybody()
}

 // specialise Void return (for performance)
func withLockVoid(_ body:()throws->Void)rethrows{
tryself.withLock(body)
}
}

structManagedCriticalState<State>{
privatefinalclassLockedBuffer:ManagedBuffer<State,Lock.Primitive>{
deinit{
withUnsafeMutablePointerToElements{Lock.deinitialize($0)}
}
}

privateletbuffer:ManagedBuffer<State,Lock.Primitive>

init(_ initial:State){
 buffer =LockedBuffer.create(minimumCapacity:1){ buffer in
 buffer.withUnsafeMutablePointerToElements{Lock.initialize($0)}
return initial
}
}

func withCriticalRegion<R>(_ critical:(inoutState)throws->R)rethrows->R{
try buffer.withUnsafeMutablePointers{ header, lock in
Lock.lock(lock)
defer{Lock.unlock(lock)}
returntrycritical(&header.pointee)
}
}
}

extensionManagedCriticalState:@uncheckedSendablewhere State:Sendable{}