From Jason Turner

[futures.task]

C++20 → C++23 13.3 KB 125 lines
Current Draft | LaTeX Source
Archived: C++20 | C++23
Markdown: C++20 | C++23
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp9lpozot0/{from.md → to.md} +103 -13
tmp/tmp9lpozot0/{from.md → to.md} RENAMED
@@ -1,7 +1,9 @@
1
  ### Class template `packaged_task` <a id="futures.task">[[futures.task]]</a>
2
 
 
 
3
  The class template `packaged_task` defines a type for wrapping a
4
  function or callable object so that the return value of the function or
5
  callable object is stored in a future when it is invoked.
6
 
7
  When the `packaged_task` object is invoked, its stored task is invoked
@@ -42,11 +44,13 @@ namespace std {
42
 
43
  void reset();
44
  };
45
 
46
  template<class R, class... ArgTypes>
47
- void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
 
 
48
  }
49
  ```
50
 
51
  #### Member functions <a id="futures.task.members">[[futures.task.members]]</a>
52
 
@@ -56,11 +60,11 @@ packaged_task() noexcept;
56
 
57
  *Effects:* The object has no shared state and no stored task.
58
 
59
  ``` cpp
60
  template<class F>
61
- packaged_task(F&& f);
62
  ```
63
 
64
  *Constraints:* `remove_cvref_t<F>` is not the same type as
65
  `packaged_task<R(ArgTypes...)>`.
66
 
@@ -71,13 +75,29 @@ template<class F>
71
 
72
  *Effects:* Constructs a new `packaged_task` object with a shared state
73
  and initializes the object’s stored task with `std::forward<F>(f)`.
74
 
75
  *Throws:* Any exceptions thrown by the copy or move constructor of `f`,
76
- or `bad_alloc` if memory for the internal data structures could not be
77
  allocated.
78
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
79
  ``` cpp
80
  packaged_task(packaged_task&& rhs) noexcept;
81
  ```
82
 
83
  *Effects:* Transfers ownership of `rhs`’s shared state to `*this`,
@@ -120,20 +140,20 @@ bool valid() const noexcept;
120
 
121
  ``` cpp
122
  future<R> get_future();
123
  ```
124
 
125
- *Returns:* A `future` object that shares the same shared state as
126
- `*this`.
127
-
128
  *Synchronization:* Calls to this function do not introduce data
129
  races  [[intro.multithread]] with calls to `operator()` or
130
  `make_ready_at_thread_exit`.
131
 
132
  [*Note 1*: Such calls need not synchronize with each
133
  other. — *end note*]
134
 
 
 
 
135
  *Throws:* A `future_error` object if an error occurs.
136
 
137
  *Error conditions:*
138
 
139
  - `future_already_retrieved` if `get_future` has already been called on
@@ -193,12 +213,12 @@ task stored in `*this`.
193
  [*Note 2*: This constructs a new shared state for `*this`. The old
194
  state is abandoned [[futures.state]]. — *end note*]
195
 
196
  *Throws:*
197
 
198
- - `bad_alloc` if memory for the new shared state could not be allocated.
199
- - any exception thrown by the move constructor of the task stored in the
200
  shared state.
201
  - `future_error` with an error condition of `no_state` if `*this` has no
202
  shared state.
203
 
204
  #### Globals <a id="futures.task.nonmembers">[[futures.task.nonmembers]]</a>
@@ -210,139 +230,209 @@ template<class R, class... ArgTypes>
210
 
211
  *Effects:* As if by `x.swap(y)`.
212
 
213
  <!-- Link reference definitions -->
214
  [alg.sorting]: algorithms.md#alg.sorting
215
- [atomics]: atomics.md#atomics
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
216
  [barrier.syn]: #barrier.syn
 
 
217
  [basic.life]: basic.md#basic.life
218
  [basic.stc.thread]: basic.md#basic.stc.thread
219
  [bitmask.types]: library.md#bitmask.types
 
220
  [class.prop]: class.md#class.prop
 
 
221
  [condition.variable.syn]: #condition.variable.syn
222
- [cpp17.allocator]: #cpp17.allocator
223
  [cpp17.defaultconstructible]: #cpp17.defaultconstructible
224
  [cpp17.destructible]: #cpp17.destructible
225
  [cpp17.moveassignable]: #cpp17.moveassignable
226
  [cpp17.moveconstructible]: #cpp17.moveconstructible
227
  [defns.block]: intro.md#defns.block
228
  [except.terminate]: except.md#except.terminate
 
 
 
229
  [func.require]: utilities.md#func.require
 
230
  [future.syn]: #future.syn
231
  [futures]: #futures
232
  [futures.async]: #futures.async
233
  [futures.errors]: #futures.errors
234
  [futures.future.error]: #futures.future.error
235
  [futures.overview]: #futures.overview
236
  [futures.promise]: #futures.promise
237
  [futures.shared.future]: #futures.shared.future
238
  [futures.state]: #futures.state
239
  [futures.task]: #futures.task
 
240
  [futures.task.members]: #futures.task.members
241
  [futures.task.nonmembers]: #futures.task.nonmembers
242
  [futures.unique.future]: #futures.unique.future
243
  [intro.multithread]: basic.md#intro.multithread
 
244
  [intro.races]: basic.md#intro.races
245
  [latch.syn]: #latch.syn
 
246
  [mutex.syn]: #mutex.syn
247
  [res.on.data.races]: library.md#res.on.data.races
248
  [res.on.exception.handling]: library.md#res.on.exception.handling
249
  [semaphore.syn]: #semaphore.syn
250
  [shared.mutex.syn]: #shared.mutex.syn
 
251
  [stopcallback]: #stopcallback
252
  [stopcallback.cons]: #stopcallback.cons
 
253
  [stopsource]: #stopsource
254
  [stopsource.cons]: #stopsource.cons
 
255
  [stopsource.mem]: #stopsource.mem
256
  [stopsource.nonmembers]: #stopsource.nonmembers
257
  [stoptoken]: #stoptoken
258
  [stoptoken.cons]: #stoptoken.cons
 
259
  [stoptoken.mem]: #stoptoken.mem
260
  [stoptoken.nonmembers]: #stoptoken.nonmembers
261
  [syserr]: diagnostics.md#syserr
262
  [syserr.syserr]: diagnostics.md#syserr.syserr
 
 
263
  [thread]: #thread
264
  [thread.barrier]: #thread.barrier
265
  [thread.barrier.class]: #thread.barrier.class
 
266
  [thread.condition]: #thread.condition
267
  [thread.condition.condvar]: #thread.condition.condvar
268
  [thread.condition.condvarany]: #thread.condition.condvarany
 
 
269
  [thread.condition.nonmember]: #thread.condition.nonmember
270
  [thread.condvarany.intwait]: #thread.condvarany.intwait
271
  [thread.condvarany.wait]: #thread.condvarany.wait
272
  [thread.coord]: #thread.coord
 
273
  [thread.general]: #thread.general
274
  [thread.jthread.class]: #thread.jthread.class
 
275
  [thread.jthread.cons]: #thread.jthread.cons
276
  [thread.jthread.mem]: #thread.jthread.mem
277
  [thread.jthread.special]: #thread.jthread.special
278
  [thread.jthread.static]: #thread.jthread.static
279
  [thread.jthread.stop]: #thread.jthread.stop
280
  [thread.latch]: #thread.latch
281
  [thread.latch.class]: #thread.latch.class
 
282
  [thread.lock]: #thread.lock
283
  [thread.lock.algorithm]: #thread.lock.algorithm
 
284
  [thread.lock.guard]: #thread.lock.guard
285
  [thread.lock.scoped]: #thread.lock.scoped
286
  [thread.lock.shared]: #thread.lock.shared
287
  [thread.lock.shared.cons]: #thread.lock.shared.cons
 
288
  [thread.lock.shared.locking]: #thread.lock.shared.locking
289
  [thread.lock.shared.mod]: #thread.lock.shared.mod
290
  [thread.lock.shared.obs]: #thread.lock.shared.obs
291
  [thread.lock.unique]: #thread.lock.unique
292
  [thread.lock.unique.cons]: #thread.lock.unique.cons
 
293
  [thread.lock.unique.locking]: #thread.lock.unique.locking
294
  [thread.lock.unique.mod]: #thread.lock.unique.mod
295
  [thread.lock.unique.obs]: #thread.lock.unique.obs
296
  [thread.mutex]: #thread.mutex
297
  [thread.mutex.class]: #thread.mutex.class
 
298
  [thread.mutex.recursive]: #thread.mutex.recursive
299
  [thread.mutex.requirements]: #thread.mutex.requirements
300
  [thread.mutex.requirements.general]: #thread.mutex.requirements.general
301
  [thread.mutex.requirements.mutex]: #thread.mutex.requirements.mutex
 
302
  [thread.once]: #thread.once
303
  [thread.once.callonce]: #thread.once.callonce
304
  [thread.once.onceflag]: #thread.once.onceflag
305
  [thread.req]: #thread.req
306
  [thread.req.exception]: #thread.req.exception
307
  [thread.req.lockable]: #thread.req.lockable
308
  [thread.req.lockable.basic]: #thread.req.lockable.basic
309
  [thread.req.lockable.general]: #thread.req.lockable.general
310
  [thread.req.lockable.req]: #thread.req.lockable.req
 
 
311
  [thread.req.lockable.timed]: #thread.req.lockable.timed
312
  [thread.req.native]: #thread.req.native
313
  [thread.req.paramname]: #thread.req.paramname
314
  [thread.req.timing]: #thread.req.timing
315
  [thread.sema]: #thread.sema
316
  [thread.sema.cnt]: #thread.sema.cnt
 
317
  [thread.sharedmutex.class]: #thread.sharedmutex.class
318
  [thread.sharedmutex.requirements]: #thread.sharedmutex.requirements
 
319
  [thread.sharedtimedmutex.class]: #thread.sharedtimedmutex.class
320
  [thread.sharedtimedmutex.requirements]: #thread.sharedtimedmutex.requirements
 
321
  [thread.stoptoken]: #thread.stoptoken
322
  [thread.stoptoken.intro]: #thread.stoptoken.intro
323
  [thread.stoptoken.syn]: #thread.stoptoken.syn
324
  [thread.summary]: #thread.summary
325
  [thread.syn]: #thread.syn
326
  [thread.thread.algorithm]: #thread.thread.algorithm
327
  [thread.thread.assign]: #thread.thread.assign
328
  [thread.thread.class]: #thread.thread.class
 
329
  [thread.thread.constr]: #thread.thread.constr
330
  [thread.thread.destr]: #thread.thread.destr
331
  [thread.thread.id]: #thread.thread.id
332
  [thread.thread.member]: #thread.thread.member
333
  [thread.thread.static]: #thread.thread.static
334
  [thread.thread.this]: #thread.thread.this
335
  [thread.threads]: #thread.threads
 
336
  [thread.timedmutex.class]: #thread.timedmutex.class
337
  [thread.timedmutex.recursive]: #thread.timedmutex.recursive
338
  [thread.timedmutex.requirements]: #thread.timedmutex.requirements
 
339
  [time]: time.md#time
340
  [time.clock]: time.md#time.clock
341
  [time.clock.req]: time.md#time.clock.req
342
  [time.duration]: time.md#time.duration
343
  [time.point]: time.md#time.point
344
  [unord.hash]: utilities.md#unord.hash
 
 
 
 
 
345
 
346
- [^1]: All implementations for which standard time units are meaningful
347
- must necessarily have a steady clock within their hardware
348
- implementation.
 
 
 
1
  ### Class template `packaged_task` <a id="futures.task">[[futures.task]]</a>
2
 
3
+ #### General <a id="futures.task.general">[[futures.task.general]]</a>
4
+
5
  The class template `packaged_task` defines a type for wrapping a
6
  function or callable object so that the return value of the function or
7
  callable object is stored in a future when it is invoked.
8
 
9
  When the `packaged_task` object is invoked, its stored task is invoked
 
44
 
45
  void reset();
46
  };
47
 
48
  template<class R, class... ArgTypes>
49
+ packaged_task(R (*)(ArgTypes...)) -> packaged_task<R(ArgTypes...)>;
50
+
51
+ template<class F> packaged_task(F) -> packaged_task<see below>;
52
  }
53
  ```
54
 
55
  #### Member functions <a id="futures.task.members">[[futures.task.members]]</a>
56
 
 
60
 
61
  *Effects:* The object has no shared state and no stored task.
62
 
63
  ``` cpp
64
  template<class F>
65
+ explicit packaged_task(F&& f);
66
  ```
67
 
68
  *Constraints:* `remove_cvref_t<F>` is not the same type as
69
  `packaged_task<R(ArgTypes...)>`.
70
 
 
75
 
76
  *Effects:* Constructs a new `packaged_task` object with a shared state
77
  and initializes the object’s stored task with `std::forward<F>(f)`.
78
 
79
  *Throws:* Any exceptions thrown by the copy or move constructor of `f`,
80
+ or `bad_alloc` if memory for the internal data structures cannot be
81
  allocated.
82
 
83
+ ``` cpp
84
+ template<class F> packaged_task(F) -> packaged_task<see below>;
85
+ ```
86
+
87
+ *Constraints:* `&F::operator()` is well-formed when treated as an
88
+ unevaluated operand [[term.unevaluated.operand]] and either
89
+
90
+ - `F::operator()` is a non-static member function and
91
+ `decltype(&F::operator())` is either of the form
92
+ `R(G::*)(A...)` cv \\ₒₚₜ ` `noexceptₒₚₜ or of the form
93
+ `R(*)(G, A...) `noexceptₒₚₜ for a type `G`, or
94
+ - `F::operator()` is a static member function and
95
+ `decltype(&F::operator())` is of the form `R(*)(A...) `noexceptₒₚₜ .
96
+
97
+ *Remarks:* The deduced type is `packaged_task<R(A...)>`.
98
+
99
  ``` cpp
100
  packaged_task(packaged_task&& rhs) noexcept;
101
  ```
102
 
103
  *Effects:* Transfers ownership of `rhs`’s shared state to `*this`,
 
140
 
141
  ``` cpp
142
  future<R> get_future();
143
  ```
144
 
 
 
 
145
  *Synchronization:* Calls to this function do not introduce data
146
  races  [[intro.multithread]] with calls to `operator()` or
147
  `make_ready_at_thread_exit`.
148
 
149
  [*Note 1*: Such calls need not synchronize with each
150
  other. — *end note*]
151
 
152
+ *Returns:* A `future` object that shares the same shared state as
153
+ `*this`.
154
+
155
  *Throws:* A `future_error` object if an error occurs.
156
 
157
  *Error conditions:*
158
 
159
  - `future_already_retrieved` if `get_future` has already been called on
 
213
  [*Note 2*: This constructs a new shared state for `*this`. The old
214
  state is abandoned [[futures.state]]. — *end note*]
215
 
216
  *Throws:*
217
 
218
+ - `bad_alloc` if memory for the new shared state cannot be allocated.
219
+ - Any exception thrown by the move constructor of the task stored in the
220
  shared state.
221
  - `future_error` with an error condition of `no_state` if `*this` has no
222
  shared state.
223
 
224
  #### Globals <a id="futures.task.nonmembers">[[futures.task.nonmembers]]</a>
 
230
 
231
  *Effects:* As if by `x.swap(y)`.
232
 
233
  <!-- Link reference definitions -->
234
  [alg.sorting]: algorithms.md#alg.sorting
235
+ [allocator.requirements.general]: library.md#allocator.requirements.general
236
+ [atomic.types.int.comp]: #atomic.types.int.comp
237
+ [atomic.types.pointer.comp]: #atomic.types.pointer.comp
238
+ [atomics]: #atomics
239
+ [atomics.alias]: #atomics.alias
240
+ [atomics.fences]: #atomics.fences
241
+ [atomics.flag]: #atomics.flag
242
+ [atomics.general]: #atomics.general
243
+ [atomics.lockfree]: #atomics.lockfree
244
+ [atomics.nonmembers]: #atomics.nonmembers
245
+ [atomics.order]: #atomics.order
246
+ [atomics.ref.float]: #atomics.ref.float
247
+ [atomics.ref.generic]: #atomics.ref.generic
248
+ [atomics.ref.generic.general]: #atomics.ref.generic.general
249
+ [atomics.ref.int]: #atomics.ref.int
250
+ [atomics.ref.memop]: #atomics.ref.memop
251
+ [atomics.ref.ops]: #atomics.ref.ops
252
+ [atomics.ref.pointer]: #atomics.ref.pointer
253
+ [atomics.syn]: #atomics.syn
254
+ [atomics.types.float]: #atomics.types.float
255
+ [atomics.types.generic]: #atomics.types.generic
256
+ [atomics.types.generic.general]: #atomics.types.generic.general
257
+ [atomics.types.int]: #atomics.types.int
258
+ [atomics.types.memop]: #atomics.types.memop
259
+ [atomics.types.operations]: #atomics.types.operations
260
+ [atomics.types.pointer]: #atomics.types.pointer
261
+ [atomics.wait]: #atomics.wait
262
  [barrier.syn]: #barrier.syn
263
+ [basic.align]: basic.md#basic.align
264
+ [basic.fundamental]: basic.md#basic.fundamental
265
  [basic.life]: basic.md#basic.life
266
  [basic.stc.thread]: basic.md#basic.stc.thread
267
  [bitmask.types]: library.md#bitmask.types
268
+ [cfenv]: numerics.md#cfenv
269
  [class.prop]: class.md#class.prop
270
+ [compliance]: library.md#compliance
271
+ [concept.booleantestable]: concepts.md#concept.booleantestable
272
  [condition.variable.syn]: #condition.variable.syn
273
+ [conv.rval]: expr.md#conv.rval
274
  [cpp17.defaultconstructible]: #cpp17.defaultconstructible
275
  [cpp17.destructible]: #cpp17.destructible
276
  [cpp17.moveassignable]: #cpp17.moveassignable
277
  [cpp17.moveconstructible]: #cpp17.moveconstructible
278
  [defns.block]: intro.md#defns.block
279
  [except.terminate]: except.md#except.terminate
280
+ [expr.pre]: expr.md#expr.pre
281
+ [format.string.std]: utilities.md#format.string.std
282
+ [func.invoke]: utilities.md#func.invoke
283
  [func.require]: utilities.md#func.require
284
+ [function.objects]: utilities.md#function.objects
285
  [future.syn]: #future.syn
286
  [futures]: #futures
287
  [futures.async]: #futures.async
288
  [futures.errors]: #futures.errors
289
  [futures.future.error]: #futures.future.error
290
  [futures.overview]: #futures.overview
291
  [futures.promise]: #futures.promise
292
  [futures.shared.future]: #futures.shared.future
293
  [futures.state]: #futures.state
294
  [futures.task]: #futures.task
295
+ [futures.task.general]: #futures.task.general
296
  [futures.task.members]: #futures.task.members
297
  [futures.task.nonmembers]: #futures.task.nonmembers
298
  [futures.unique.future]: #futures.unique.future
299
  [intro.multithread]: basic.md#intro.multithread
300
+ [intro.progress]: basic.md#intro.progress
301
  [intro.races]: basic.md#intro.races
302
  [latch.syn]: #latch.syn
303
+ [limits.syn]: support.md#limits.syn
304
  [mutex.syn]: #mutex.syn
305
  [res.on.data.races]: library.md#res.on.data.races
306
  [res.on.exception.handling]: library.md#res.on.exception.handling
307
  [semaphore.syn]: #semaphore.syn
308
  [shared.mutex.syn]: #shared.mutex.syn
309
+ [stdatomic.h.syn]: #stdatomic.h.syn
310
  [stopcallback]: #stopcallback
311
  [stopcallback.cons]: #stopcallback.cons
312
+ [stopcallback.general]: #stopcallback.general
313
  [stopsource]: #stopsource
314
  [stopsource.cons]: #stopsource.cons
315
+ [stopsource.general]: #stopsource.general
316
  [stopsource.mem]: #stopsource.mem
317
  [stopsource.nonmembers]: #stopsource.nonmembers
318
  [stoptoken]: #stoptoken
319
  [stoptoken.cons]: #stoptoken.cons
320
+ [stoptoken.general]: #stoptoken.general
321
  [stoptoken.mem]: #stoptoken.mem
322
  [stoptoken.nonmembers]: #stoptoken.nonmembers
323
  [syserr]: diagnostics.md#syserr
324
  [syserr.syserr]: diagnostics.md#syserr.syserr
325
+ [term.padding.bits]: basic.md#term.padding.bits
326
+ [term.unevaluated.operand]: expr.md#term.unevaluated.operand
327
  [thread]: #thread
328
  [thread.barrier]: #thread.barrier
329
  [thread.barrier.class]: #thread.barrier.class
330
+ [thread.barrier.general]: #thread.barrier.general
331
  [thread.condition]: #thread.condition
332
  [thread.condition.condvar]: #thread.condition.condvar
333
  [thread.condition.condvarany]: #thread.condition.condvarany
334
+ [thread.condition.condvarany.general]: #thread.condition.condvarany.general
335
+ [thread.condition.general]: #thread.condition.general
336
  [thread.condition.nonmember]: #thread.condition.nonmember
337
  [thread.condvarany.intwait]: #thread.condvarany.intwait
338
  [thread.condvarany.wait]: #thread.condvarany.wait
339
  [thread.coord]: #thread.coord
340
+ [thread.coord.general]: #thread.coord.general
341
  [thread.general]: #thread.general
342
  [thread.jthread.class]: #thread.jthread.class
343
+ [thread.jthread.class.general]: #thread.jthread.class.general
344
  [thread.jthread.cons]: #thread.jthread.cons
345
  [thread.jthread.mem]: #thread.jthread.mem
346
  [thread.jthread.special]: #thread.jthread.special
347
  [thread.jthread.static]: #thread.jthread.static
348
  [thread.jthread.stop]: #thread.jthread.stop
349
  [thread.latch]: #thread.latch
350
  [thread.latch.class]: #thread.latch.class
351
+ [thread.latch.general]: #thread.latch.general
352
  [thread.lock]: #thread.lock
353
  [thread.lock.algorithm]: #thread.lock.algorithm
354
+ [thread.lock.general]: #thread.lock.general
355
  [thread.lock.guard]: #thread.lock.guard
356
  [thread.lock.scoped]: #thread.lock.scoped
357
  [thread.lock.shared]: #thread.lock.shared
358
  [thread.lock.shared.cons]: #thread.lock.shared.cons
359
+ [thread.lock.shared.general]: #thread.lock.shared.general
360
  [thread.lock.shared.locking]: #thread.lock.shared.locking
361
  [thread.lock.shared.mod]: #thread.lock.shared.mod
362
  [thread.lock.shared.obs]: #thread.lock.shared.obs
363
  [thread.lock.unique]: #thread.lock.unique
364
  [thread.lock.unique.cons]: #thread.lock.unique.cons
365
+ [thread.lock.unique.general]: #thread.lock.unique.general
366
  [thread.lock.unique.locking]: #thread.lock.unique.locking
367
  [thread.lock.unique.mod]: #thread.lock.unique.mod
368
  [thread.lock.unique.obs]: #thread.lock.unique.obs
369
  [thread.mutex]: #thread.mutex
370
  [thread.mutex.class]: #thread.mutex.class
371
+ [thread.mutex.general]: #thread.mutex.general
372
  [thread.mutex.recursive]: #thread.mutex.recursive
373
  [thread.mutex.requirements]: #thread.mutex.requirements
374
  [thread.mutex.requirements.general]: #thread.mutex.requirements.general
375
  [thread.mutex.requirements.mutex]: #thread.mutex.requirements.mutex
376
+ [thread.mutex.requirements.mutex.general]: #thread.mutex.requirements.mutex.general
377
  [thread.once]: #thread.once
378
  [thread.once.callonce]: #thread.once.callonce
379
  [thread.once.onceflag]: #thread.once.onceflag
380
  [thread.req]: #thread.req
381
  [thread.req.exception]: #thread.req.exception
382
  [thread.req.lockable]: #thread.req.lockable
383
  [thread.req.lockable.basic]: #thread.req.lockable.basic
384
  [thread.req.lockable.general]: #thread.req.lockable.general
385
  [thread.req.lockable.req]: #thread.req.lockable.req
386
+ [thread.req.lockable.shared]: #thread.req.lockable.shared
387
+ [thread.req.lockable.shared.timed]: #thread.req.lockable.shared.timed
388
  [thread.req.lockable.timed]: #thread.req.lockable.timed
389
  [thread.req.native]: #thread.req.native
390
  [thread.req.paramname]: #thread.req.paramname
391
  [thread.req.timing]: #thread.req.timing
392
  [thread.sema]: #thread.sema
393
  [thread.sema.cnt]: #thread.sema.cnt
394
+ [thread.sema.general]: #thread.sema.general
395
  [thread.sharedmutex.class]: #thread.sharedmutex.class
396
  [thread.sharedmutex.requirements]: #thread.sharedmutex.requirements
397
+ [thread.sharedmutex.requirements.general]: #thread.sharedmutex.requirements.general
398
  [thread.sharedtimedmutex.class]: #thread.sharedtimedmutex.class
399
  [thread.sharedtimedmutex.requirements]: #thread.sharedtimedmutex.requirements
400
+ [thread.sharedtimedmutex.requirements.general]: #thread.sharedtimedmutex.requirements.general
401
  [thread.stoptoken]: #thread.stoptoken
402
  [thread.stoptoken.intro]: #thread.stoptoken.intro
403
  [thread.stoptoken.syn]: #thread.stoptoken.syn
404
  [thread.summary]: #thread.summary
405
  [thread.syn]: #thread.syn
406
  [thread.thread.algorithm]: #thread.thread.algorithm
407
  [thread.thread.assign]: #thread.thread.assign
408
  [thread.thread.class]: #thread.thread.class
409
+ [thread.thread.class.general]: #thread.thread.class.general
410
  [thread.thread.constr]: #thread.thread.constr
411
  [thread.thread.destr]: #thread.thread.destr
412
  [thread.thread.id]: #thread.thread.id
413
  [thread.thread.member]: #thread.thread.member
414
  [thread.thread.static]: #thread.thread.static
415
  [thread.thread.this]: #thread.thread.this
416
  [thread.threads]: #thread.threads
417
+ [thread.threads.general]: #thread.threads.general
418
  [thread.timedmutex.class]: #thread.timedmutex.class
419
  [thread.timedmutex.recursive]: #thread.timedmutex.recursive
420
  [thread.timedmutex.requirements]: #thread.timedmutex.requirements
421
+ [thread.timedmutex.requirements.general]: #thread.timedmutex.requirements.general
422
  [time]: time.md#time
423
  [time.clock]: time.md#time.clock
424
  [time.clock.req]: time.md#time.clock.req
425
  [time.duration]: time.md#time.duration
426
  [time.point]: time.md#time.point
427
  [unord.hash]: utilities.md#unord.hash
428
+ [util.sharedptr]: mem.md#util.sharedptr
429
+ [util.smartptr.atomic]: #util.smartptr.atomic
430
+ [util.smartptr.atomic.general]: #util.smartptr.atomic.general
431
+ [util.smartptr.atomic.shared]: #util.smartptr.atomic.shared
432
+ [util.smartptr.atomic.weak]: #util.smartptr.atomic.weak
433
 
434
+ [^1]: Implementations for which standard time units are meaningful will
435
+ typically have a steady clock within their hardware implementation.
436
+
437
+ [^2]: That is, atomic operations on the same memory location via two
438
+ different addresses will communicate atomically.