Skip to content

Commit 27e0b12

Browse files
DougGregorDougGregor
committed
[Concurrency] Add the ConcurrentValue protocol.
The ConcurrentValue protocol indicates when a particular type is safe to share in a concurrent context, e.g., that a copy of a given value can be safely used concurrently with the value.
1 parent a25e2cd commit 27e0b12

File tree

6 files changed

+167
-1
lines changed

6 files changed

+167
-1
lines changed

‎include/swift/AST/KnownProtocols.def

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -80,6 +80,8 @@ PROTOCOL(CodingKey)
8080
PROTOCOL(Encodable)
8181
PROTOCOL(Decodable)
8282

83+
PROTOCOL(ConcurrentValue)
84+
8385
PROTOCOL_(ObjectiveCBridgeable)
8486
PROTOCOL_(DestructorSafeContainer)
8587

‎lib/AST/ASTContext.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -971,6 +971,7 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
971971
M = getLoadedModule(Id_Differentiation);
972972
break;
973973
case KnownProtocolKind::Actor:
974+
case KnownProtocolKind::ConcurrentValue:
974975
case KnownProtocolKind::AsyncSequence:
975976
case KnownProtocolKind::AsyncIteratorProtocol:
976977
M = getLoadedModule(Id_Concurrency);

‎lib/IRGen/GenMeta.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5138,6 +5138,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
51385138
case KnownProtocolKind::Differentiable:
51395139
case KnownProtocolKind::FloatingPoint:
51405140
case KnownProtocolKind::Actor:
5141+
case KnownProtocolKind::ConcurrentValue:
51415142
return SpecialProtocol::None;
51425143
}
51435144

‎stdlib/public/Concurrency/Actor.swift

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ import Swift
1919
/// which involves enqueuing new partial tasks to be executed at some
2020
/// point. Actor classes implicitly conform to this protocol as part of their
2121
/// primary class definition.
22-
public protocol Actor: AnyObject {
22+
public protocol Actor: AnyObject, ConcurrentValue {
2323
/// Enqueue a new partial task that will be executed in the actor's context.
2424
func enqueue(partialTask: PartialAsyncTask)
2525
}

‎stdlib/public/Concurrency/CMakeLists.txt

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -37,6 +37,7 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
3737
Actor.cpp
3838
Actor.swift
3939
CheckedContinuation.swift
40+
ConcurrentValue.swift
4041
GlobalExecutor.cpp
4142
AsyncIteratorProtocol.swift
4243
AsyncSequence.swift

‎stdlib/public/Concurrency/ConcurrentValue.swift

Lines changed: 161 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,161 @@
1+
////===----------------------------------------------------------------------===//
2+
////
3+
//// This source file is part of the Swift.org open source project
4+
////
5+
//// Copyright (c) 2020 Apple Inc. and the Swift project authors
6+
//// Licensed under Apache License v2.0 with Runtime Library Exception
7+
////
8+
//// See https://swift.org/LICENSE.txt for license information
9+
//// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
10+
////
11+
////===----------------------------------------------------------------------===//
12+
13+
import Swift
14+
15+
/// The ConcurrentValue protocol indicates that value of the given type can
16+
/// be safely used in concurrent code.
17+
public protocol ConcurrentValue { }
18+
19+
extension Array: ConcurrentValue where Element: ConcurrentValue { }
20+
extension ArraySlice: ConcurrentValue where Element: ConcurrentValue { }
21+
extension Bool: ConcurrentValue { }
22+
extension AutoreleasingUnsafeMutablePointer: ConcurrentValue { }
23+
extension Character: ConcurrentValue { }
24+
extension KeyedEncodingContainer: ConcurrentValue { }
25+
extension KeyedDecodingContainer: ConcurrentValue { }
26+
extension CodingUserInfoKey: ConcurrentValue { }
27+
extension EncodingError: ConcurrentValue { }
28+
extension DecodingError: ConcurrentValue { }
29+
extension IndexingIterator: ConcurrentValue { }
30+
extension ContiguousArray: ConcurrentValue { }
31+
extension ClosedRange: ConcurrentValue where Bound: ConcurrentValue { }
32+
extension ClosedRange.Index: ConcurrentValue where Bound: ConcurrentValue { }
33+
extension OpaquePointer: ConcurrentValue { }
34+
extension CVaListPointer: ConcurrentValue { }
35+
extension Dictionary: ConcurrentValue where Key: ConcurrentValue, Value: ConcurrentValue { }
36+
extension Dictionary.Keys: ConcurrentValue where Key: ConcurrentValue, Value: ConcurrentValue { }
37+
extension Dictionary.Values: ConcurrentValue where Key: ConcurrentValue, Value: ConcurrentValue { }
38+
extension Dictionary.Keys.Iterator: ConcurrentValue where Key: ConcurrentValue, Value: ConcurrentValue { }
39+
extension Dictionary.Values.Iterator: ConcurrentValue where Key: ConcurrentValue, Value: ConcurrentValue { }
40+
extension Dictionary.Index: ConcurrentValue where Key: ConcurrentValue, Value: ConcurrentValue { }
41+
extension Dictionary.Iterator: ConcurrentValue where Key: ConcurrentValue, Value: ConcurrentValue { }
42+
extension EmptyCollection: ConcurrentValue { }
43+
extension EmptyCollection.Iterator: ConcurrentValue { }
44+
extension Hasher: ConcurrentValue { }
45+
extension DefaultIndices: ConcurrentValue where Elements: ConcurrentValue { }
46+
extension KeyValuePairs: ConcurrentValue where Key: ConcurrentValue, Value: ConcurrentValue { }
47+
extension ManagedBufferPointer: ConcurrentValue where Header: ConcurrentValue, Element: ConcurrentValue { }
48+
extension Unicode.Scalar: ConcurrentValue { }
49+
extension Unicode.Scalar.UTF16View: ConcurrentValue { }
50+
51+
@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
52+
extension Unicode.Scalar.UTF8View: ConcurrentValue { }
53+
54+
extension ObjectIdentifier: ConcurrentValue { }
55+
extension SystemRandomNumberGenerator: ConcurrentValue { }
56+
extension Range: ConcurrentValue where Bound: ConcurrentValue { }
57+
extension PartialRangeUpTo: ConcurrentValue where Bound: ConcurrentValue { }
58+
extension PartialRangeThrough: ConcurrentValue where Bound: ConcurrentValue { }
59+
extension PartialRangeFrom: ConcurrentValue where Bound: ConcurrentValue { }
60+
extension PartialRangeFrom.Iterator: ConcurrentValue where Bound: ConcurrentValue { }
61+
extension Repeated: ConcurrentValue where Element: ConcurrentValue { }
62+
extension IteratorSequence: ConcurrentValue where Base: ConcurrentValue { }
63+
extension Set: ConcurrentValue where Element: ConcurrentValue { }
64+
extension Set.Index: ConcurrentValue where Element: ConcurrentValue { }
65+
extension Set.Iterator: ConcurrentValue where Element: ConcurrentValue { }
66+
extension Slice: ConcurrentValue where Base: ConcurrentValue { }
67+
extension StaticString: ConcurrentValue { }
68+
extension StrideToIterator: ConcurrentValue where Element: ConcurrentValue { }
69+
extension StrideTo: ConcurrentValue where Element: ConcurrentValue { }
70+
extension StrideThroughIterator: ConcurrentValue where Element: ConcurrentValue { }
71+
extension StrideThrough: ConcurrentValue where Element: Strideable { }
72+
extension String: ConcurrentValue { }
73+
extension String.Iterator: ConcurrentValue { }
74+
extension String.Index: ConcurrentValue { }
75+
extension DefaultStringInterpolation: ConcurrentValue { }
76+
extension String.UnicodeScalarView: ConcurrentValue { }
77+
extension String.UnicodeScalarView.Iterator: ConcurrentValue { }
78+
extension String.UTF16View: ConcurrentValue { }
79+
extension String.UTF16View.Iterator: ConcurrentValue { }
80+
extension String.UTF8View: ConcurrentValue { }
81+
extension Substring: ConcurrentValue { }
82+
extension Substring.UnicodeScalarView: ConcurrentValue { }
83+
extension Substring.UTF16View: ConcurrentValue { }
84+
extension Substring.UTF8View: ConcurrentValue { }
85+
extension Unicode.Scalar.Properties: ConcurrentValue { }
86+
extension Unicode.CanonicalCombiningClass: ConcurrentValue { }
87+
extension Unmanaged: ConcurrentValue { }
88+
extension UnsafePointer: ConcurrentValue { }
89+
extension UnsafeMutablePointer: ConcurrentValue { }
90+
extension UnsafeRawPointer: ConcurrentValue { }
91+
extension UnsafeMutableRawPointer: ConcurrentValue { }
92+
extension Unicode.UTF8.ForwardParser: ConcurrentValue { }
93+
extension Unicode.UTF8.ReverseParser: ConcurrentValue { }
94+
extension Unicode.UTF16.ForwardParser: ConcurrentValue { }
95+
extension Unicode.UTF16.ReverseParser: ConcurrentValue { }
96+
extension Unicode.UTF32.Parser: ConcurrentValue { }
97+
extension Unicode.ParseResult: ConcurrentValue where T: ConcurrentValue { }
98+
extension Unicode.GeneralCategory: ConcurrentValue { }
99+
extension Unicode.NumericType: ConcurrentValue { }
100+
extension Unicode.UTF8: ConcurrentValue { }
101+
extension Unicode.UTF16: ConcurrentValue { }
102+
extension Unicode.UTF32: ConcurrentValue { }
103+
extension UnicodeDecodingResult: ConcurrentValue { }
104+
105+
@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
106+
extension CollectionDifference: ConcurrentValue where ChangeElement: ConcurrentValue { }
107+
@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
108+
extension CollectionDifference.Change: ConcurrentValue where ChangeElement: ConcurrentValue { }
109+
@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
110+
extension CollectionDifference.Index: ConcurrentValue where ChangeElement: ConcurrentValue { }
111+
112+
extension CollectionOfOne: ConcurrentValue where Element: ConcurrentValue { }
113+
extension CollectionOfOne.Iterator: ConcurrentValue where Element: ConcurrentValue { }
114+
extension Mirror: ConcurrentValue { }
115+
extension Mirror.AncestorRepresentation: ConcurrentValue { }
116+
extension Mirror.DisplayStyle: ConcurrentValue { }
117+
118+
// FIXME: Float16 when available
119+
extension Float: ConcurrentValue { }
120+
extension Double: ConcurrentValue { }
121+
// FIXME: Float80 when available
122+
123+
// FIXME: hacks to enumerate integer types, and ".Words", and "SIMDnStorage"
124+
extension UInt8: ConcurrentValue { }
125+
extension Int8: ConcurrentValue { }
126+
extension UInt16: ConcurrentValue { }
127+
extension Int16: ConcurrentValue { }
128+
extension UInt32: ConcurrentValue { }
129+
extension Int32: ConcurrentValue { }
130+
extension UInt64: ConcurrentValue { }
131+
extension Int64: ConcurrentValue { }
132+
extension UInt: ConcurrentValue { }
133+
extension Int: ConcurrentValue { }
134+
135+
extension UnsafeMutableBufferPointer: ConcurrentValue { }
136+
extension UnsafeBufferPointer: ConcurrentValue { }
137+
extension UnsafeBufferPointer.Iterator: ConcurrentValue { }
138+
extension UnsafeMutableRawBufferPointer: ConcurrentValue { }
139+
extension UnsafeRawBufferPointer: ConcurrentValue { }
140+
extension UnsafeRawBufferPointer.Iterator: ConcurrentValue { }
141+
142+
extension SIMDMask: ConcurrentValue where Storage: ConcurrentValue { }
143+
// FIXME: enumerate SIMD types
144+
extension SIMD2: ConcurrentValue where Scalar: ConcurrentValue { }
145+
extension SIMD3: ConcurrentValue where Scalar: ConcurrentValue { }
146+
extension SIMD4: ConcurrentValue where Scalar: ConcurrentValue { }
147+
extension SIMD8: ConcurrentValue where Scalar: ConcurrentValue { }
148+
extension SIMD16: ConcurrentValue where Scalar: ConcurrentValue { }
149+
extension SIMD32: ConcurrentValue where Scalar: ConcurrentValue { }
150+
extension SIMD64: ConcurrentValue where Scalar: ConcurrentValue { }
151+
152+
extension PartialKeyPath: ConcurrentValue where Root: ConcurrentValue { }
153+
154+
extension FloatingPointSign: ConcurrentValue { }
155+
extension FloatingPointClassification: ConcurrentValue { }
156+
extension FloatingPointRoundingRule: ConcurrentValue { }
157+
158+
extension Optional: ConcurrentValue where Wrapped: ConcurrentValue { }
159+
extension Never: ConcurrentValue { }
160+
extension Result: ConcurrentValue where Success: ConcurrentValue, Failure: ConcurrentValue { }
161+

0 commit comments

Comments
 (0)