Provides volatile wrapper types for raw pointers.
The volatile wrapper types in this crate wrap a pointer to any
type and provide volatile memory access to wrapped value. Volatile memory accesses are
never optimized away by the compiler, and are useful in many low-level systems programming
and concurrent contexts.
This crate provides two different wrapper types:
difference between the two types is that the former behaves like a raw pointer, while the
latter behaves like a Rust reference type. For example,
VolatilePtr can be freely copied,
but not sent across threads because this could introduce mutable aliasing. The
type, on the other hand, requires exclusive access for mutation, so that sharing it across
thread boundaries is safe.
Both wrapper types do not enforce any atomicity guarantees; to also get atomicity, consider
looking at the
Atomic wrapper types found in
Many people expressed interest in a
VolatileCell type, i.e. a transparent wrapper type that
owns the wrapped value. Such a type would be similar to
core::cell::Cell, with the
difference that all methods are volatile.
Unfortunately, it is not sound to implement such a
VolatileCell type in Rust. The reason
is that Rust and LLVM consider
&mut references as dereferencable. This means that
the compiler is allowed to freely access the referenced value without any restrictions. So
no matter how a
VolatileCell type is implemented, the compiler is allowed to perform
non-volatile read operations of the contained value, which can lead to unexpected (or even
undefined?) behavior. For more details, see the discussion
in our repository
- Marker types for limiting access.
- Provides safe field projection for volatile pointers referencing structs.
- Wraps a pointer to make accesses to the referenced value volatile.
- Volatile pointer type that respects Rust’s aliasing rules.