71d4e77db8
This commit is a reimplementation of `std::sync` to be based on the
system-provided primitives wherever possible. The previous implementation was
fundamentally built on top of channels, and as part of the runtime reform it has
become clear that this is not the level of abstraction that the standard level
should be providing. This rewrite aims to provide as thin of a shim as possible
on top of the system primitives in order to make them safe.
The overall interface of the `std::sync` module has in general not changed, but
there are a few important distinctions, highlighted below:
* The condition variable type, `Condvar`, has been separated out of a `Mutex`.
A condition variable is now an entirely separate type. This separation
benefits users who only use one mutex, and provides a clearer distinction of
who's responsible for managing condition variables (the application).
* All of `Condvar`, `Mutex`, and `RWLock` are now directly built on top of
system primitives rather than using a custom implementation. The `Once`,
`Barrier`, and `Semaphore` types are still built upon these abstractions of
the system primitives.
* The `Condvar`, `Mutex`, and `RWLock` types all have a new static type and
constant initializer corresponding to them. These are provided primarily for C
FFI interoperation, but are often useful to otherwise simply have a global
lock. The types, however, will leak memory unless `destroy()` is called on
them, which is clearly documented.
* The `Condvar` implementation for an `RWLock` write lock has been removed. This
may be added back in the future with a userspace implementation, but this
commit is focused on exposing the system primitives first.
* The fundamental architecture of this design is to provide two separate layers.
The first layer is that exposed by `sys_common` which is a cross-platform
bare-metal abstraction of the system synchronization primitives. No attempt is
made at making this layer safe, and it is quite unsafe to use! It is currently
not exported as part of the API of the standard library, but the stabilization
of the `sys` module will ensure that these will be exposed in time. The
purpose of this layer is to provide the core cross-platform abstractions if
necessary to implementors.
The second layer is the layer provided by `std::sync` which is intended to be
the thinnest possible layer on top of `sys_common` which is entirely safe to
use. There are a few concerns which need to be addressed when making these
system primitives safe:
* Once used, the OS primitives can never be **moved**. This means that they
essentially need to have a stable address. The static primitives use
`&'static self` to enforce this, and the non-static primitives all use a
`Box` to provide this guarantee.
* Poisoning is leveraged to ensure that invalid data is not accessible from
other tasks after one has panicked.
In addition to these overall blanket safety limitations, each primitive has a
few restrictions of its own:
* Mutexes and rwlocks can only be unlocked from the same thread that they
were locked by. This is achieved through RAII lock guards which cannot be
sent across threads.
* Mutexes and rwlocks can only be unlocked if they were previously locked.
This is achieved by not exposing an unlocking method.
* A condition variable can only be waited on with a locked mutex. This is
achieved by requiring a `MutexGuard` in the `wait()` method.
* A condition variable cannot be used concurrently with more than one mutex.
This is guaranteed by dynamically binding a condition variable to
precisely one mutex for its entire lifecycle. This restriction may be able
to be relaxed in the future (a mutex is unbound when no threads are
waiting on the condvar), but for now it is sufficient to guarantee safety.
* Condvars now support timeouts for their blocking operations. The
implementation for these operations is provided by the system.
Due to the modification of the `Condvar` API, removal of the `std::sync::mutex`
API, and reimplementation, this is a breaking change. Most code should be fairly
easy to port using the examples in the documentation of these primitives.
[breaking-change]
Closes #17094
Closes #18003
68 lines
2.6 KiB
Rust
68 lines
2.6 KiB
Rust
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
use time::Duration;
|
|
use sys_common::mutex::{mod, Mutex};
|
|
use sys::condvar as imp;
|
|
|
|
/// An OS-based condition variable.
|
|
///
|
|
/// This structure is the lowest layer possible on top of the OS-provided
|
|
/// condition variables. It is consequently entirely unsafe to use. It is
|
|
/// recommended to use the safer types at the top level of this crate instead of
|
|
/// this type.
|
|
pub struct Condvar(imp::Condvar);
|
|
|
|
/// Static initializer for condition variables.
|
|
pub const CONDVAR_INIT: Condvar = Condvar(imp::CONDVAR_INIT);
|
|
|
|
impl Condvar {
|
|
/// Creates a new condition variable for use.
|
|
///
|
|
/// Behavior is undefined if the condition variable is moved after it is
|
|
/// first used with any of the functions below.
|
|
#[inline]
|
|
pub unsafe fn new() -> Condvar { Condvar(imp::Condvar::new()) }
|
|
|
|
/// Signal one waiter on this condition variable to wake up.
|
|
#[inline]
|
|
pub unsafe fn notify_one(&self) { self.0.notify_one() }
|
|
|
|
/// Awaken all current waiters on this condition variable.
|
|
#[inline]
|
|
pub unsafe fn notify_all(&self) { self.0.notify_all() }
|
|
|
|
/// Wait for a signal on the specified mutex.
|
|
///
|
|
/// Behavior is undefined if the mutex is not locked by the current thread.
|
|
/// Behavior is also undefined if more than one mutex is used concurrently
|
|
/// on this condition variable.
|
|
#[inline]
|
|
pub unsafe fn wait(&self, mutex: &Mutex) { self.0.wait(mutex::raw(mutex)) }
|
|
|
|
/// Wait for a signal on the specified mutex with a timeout duration
|
|
/// specified by `dur` (a relative time into the future).
|
|
///
|
|
/// Behavior is undefined if the mutex is not locked by the current thread.
|
|
/// Behavior is also undefined if more than one mutex is used concurrently
|
|
/// on this condition variable.
|
|
#[inline]
|
|
pub unsafe fn wait_timeout(&self, mutex: &Mutex, dur: Duration) -> bool {
|
|
self.0.wait_timeout(mutex::raw(mutex), dur)
|
|
}
|
|
|
|
/// Deallocate all resources associated with this condition variable.
|
|
///
|
|
/// Behavior is undefined if there are current or will be future users of
|
|
/// this condition variable.
|
|
#[inline]
|
|
pub unsafe fn destroy(&self) { self.0.destroy() }
|
|
}
|