ThreadLocalStorage.swift

//===--- ThreadLocalStorage.swift -----------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2021 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
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

import SwiftShims

// For testing purposes, a thread-safe counter to guarantee that destructors get
// called by pthread.
#if INTERNAL_CHECKS_ENABLED
internalclass_TLSAtomicInt{
internalvarvalue:Int
internalinit(){self.value =0}

internalvarvaluePtr:UnsafeMutablePointer<Int>{
return unsafe _getUnsafePointerToStoredProperties(self).assumingMemoryBound(
 to:Int.self)
}

internalfunc increment(){
 _ =unsafe _swift_stdlib_atomicFetchAddInt(
 object: valuePtr,
 operand:1)
}

internalfunc load()->Int{
returnunsafe _swift_stdlib_atomicLoadInt(object: valuePtr)
}
}

internallet_destroyTLSCounter=_TLSAtomicInt()

public // @testable
func _loadDestroyTLSCounter()->Int{
return _destroyTLSCounter.load()
}

#endif

// Thread local storage for all of the Swift standard library
//
// @moveonly/@pointeronly: shouldn't be used as a value, only through its
// pointer. Similarly, shouldn't be created, except by
// _initializeThreadLocalStorage.
//
internalstruct_ThreadLocalStorage{
 // private: Should only be called by _initializeThreadLocalStorage
internalinit(){}

 // Get the current thread's TLS pointer. On first call for a given thread,
 // creates and initializes a new one.
internalstaticfunc getPointer()
->UnsafeMutablePointer<_ThreadLocalStorage>
{
returnunsafe _swift_stdlib_threadLocalStorageGet().assumingMemoryBound(
 to: _ThreadLocalStorage.self)
}
}

// Destructor to register with pthreads. Responsible for deallocating any memory
// owned.
@_silgen_name("_stdlib_destroyTLS")
internalfunc _destroyTLS(_ ptr:UnsafeMutableRawPointer?){
 unsafe _internalInvariant(ptr !=nil,
"_destroyTLS was called, but with nil...")
lettlsPtr=unsafe ptr!.assumingMemoryBound(to: _ThreadLocalStorage.self)
unsafe tlsPtr.deinitialize(count:1)
unsafe tlsPtr.deallocate()

#if INTERNAL_CHECKS_ENABLED
 // Log the fact we've destroyed our storage
 _destroyTLSCounter.increment()
#endif
}

@_silgen_name("_stdlib_createTLS")
internalfunc _createThreadLocalStorage()
->UnsafeMutablePointer<_ThreadLocalStorage>
{
lettlsPtr:UnsafeMutablePointer<_ThreadLocalStorage>
= UnsafeMutablePointer<_ThreadLocalStorage>.allocate(
 capacity:1
)
unsafe tlsPtr.initialize(to:_ThreadLocalStorage())

return unsafe tlsPtr
}