1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
//! Common utilities for lock-free and concurrent programming. //! //! This crate provides fine-grained control over its contents through cargo //! feature flags: //! //! # `#![no_std]` Compatibility //! //! By default, `conquer-utils` enables the `std` feature, which links against //! the standard library and requires e.g. OS support. //! Disabling this feature allows this crate to be used in `#![no_std]` //! environments. //! If the targeted environment does not allow using `std` features but provides //! the means for dynamic memory allocation, the `alloc` feature can be used to //! enable additional functionality. //! Note that the `std` feature implicitly activates all `alloc` features as //! well. //! //! # Features //! //! The following utilities are provided when compiling this crate with the //! appropriate feature flags: //! //! ## Alignment //! //! When the `align` feature is enabled, the same-named module can be used, //! which provides generic thin wrapper types for specifying the alignment for //! instances of the respective type. //! Particularly useful is the [`CacheAligned`][crate::align::CacheAligned] //! type, which forces an alignment to the size of a cache-line. //! This helps to avoid *false sharing*. //! The provided types can be used in their entirety in a `#![no_std]` //! environment. //! //! ## Back-Off //! //! By enabling the `back-off` feature, this crate provides the //! [`BackOff`][crate::BackOff] type, which can be used to perform exponential //! back-off in e.g. spin-loops. //! This type is `#![no_std]` compatible, but provides additional features when //! the `std` feature is also enabled. //! //! ### Randomized Exponential Back-Off //! //! Enabling the `random` feature in addition to the `back-off` feature pulls in //! the `rand` dependency and additionally adds `#![no_std]` compatible //! randomized exponential back-off, which adds some slight variations the time //! each thread spends spinning. //! This may help avoid issues such as *convoying*. //! //! ## TLS //! //! Enabling the `tls` feature makes the //! [`BoundedThreadLocal`][crate::BoundedThreadLocal] available, which is useful //! for iterable per-object thread local storage for bounded numbers of threads. #![cfg_attr(not(feature = "std"), no_std)] #![warn(missing_docs)] #[cfg(all(feature = "alloc", not(feature = "std")))] extern crate alloc; #[cfg(feature = "align")] pub mod align; #[cfg(feature = "back-off")] mod backoff; #[cfg(feature = "tls")] mod local; #[cfg(feature = "back-off")] pub use crate::backoff::BackOff; #[cfg(feature = "tls")] pub use crate::local::{BoundedThreadLocal, BoundsError, IntoIter, Local, Token};