use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, AtomicUsize, Ordering};
use std::sync::{Condvar, Mutex, OnceLock};
use std::thread;
#[cfg(target_pointer_width = "64")]
const THREADS_BITS: usize = 16;
#[cfg(target_pointer_width = "32")]
const THREADS_BITS: usize = 8;
#[allow(clippy::erasing_op)]
const SLEEPING_SHIFT: usize = 0 * THREADS_BITS;
#[allow(clippy::identity_op)]
const INACTIVE_SHIFT: usize = 1 * THREADS_BITS;
const JEC_SHIFT: usize = 2 * THREADS_BITS;
pub(crate) const THREADS_MAX: usize = (1 << THREADS_BITS) - 1;
const ONE_SLEEPING: usize = 1;
const ONE_INACTIVE: usize = 1 << INACTIVE_SHIFT;
const ONE_JEC: usize = 1 << JEC_SHIFT;
pub(crate) struct AtomicCounters {
value: AtomicUsize,
}
#[derive(Copy, Clone)]
pub(crate) struct Counters {
word: usize,
}
#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
pub(crate) struct JobsEventCounter(usize);
impl JobsEventCounter {
pub(crate) const DUMMY: JobsEventCounter = JobsEventCounter(usize::MAX);
#[inline]
#[allow(dead_code)]
pub(crate) fn as_usize(self) -> usize {
self.0
}
#[inline]
pub(crate) fn is_sleepy(self) -> bool {
(self.0 & 1) == 0
}
#[inline]
pub(crate) fn is_active(self) -> bool {
!self.is_sleepy()
}
}
#[inline]
fn select_thread(word: usize, shift: usize) -> usize {
(word >> shift) & THREADS_MAX
}
#[inline]
fn select_jec(word: usize) -> usize {
word >> JEC_SHIFT
}
impl AtomicCounters {
pub(crate) const fn new() -> Self {
Self { value: AtomicUsize::new(0) }
}
#[inline]
pub(crate) fn load(&self, ordering: Ordering) -> Counters {
Counters { word: self.value.load(ordering) }
}
#[inline]
fn try_exchange(&self, old: Counters, new: Counters, ordering: Ordering) -> bool {
self.value
.compare_exchange(old.word, new.word, ordering, Ordering::Relaxed)
.is_ok()
}
#[inline]
pub(crate) fn add_inactive_thread(&self) {
self.value.fetch_add(ONE_INACTIVE, Ordering::SeqCst);
}
#[inline]
pub(crate) fn sub_inactive_thread(&self) -> usize {
let old = Counters {
word: self.value.fetch_sub(ONE_INACTIVE, Ordering::SeqCst),
};
debug_assert!(old.inactive_threads() > 0);
debug_assert!(old.sleeping_threads() <= old.inactive_threads());
let sleepers = old.sleeping_threads();
Ord::min(sleepers, 2)
}
#[inline]
pub(crate) fn sub_sleeping_thread(&self) {
let old = Counters {
word: self.value.fetch_sub(ONE_SLEEPING, Ordering::SeqCst),
};
debug_assert!(old.sleeping_threads() > 0);
}
#[inline]
pub(crate) fn try_add_sleeping_thread(&self, old: Counters) -> bool {
debug_assert!(old.inactive_threads() > 0);
debug_assert!(old.sleeping_threads() < THREADS_MAX);
let mut new = old;
new.word += ONE_SLEEPING;
self.try_exchange(old, new, Ordering::SeqCst)
}
pub(crate) fn increment_jobs_event_counter_if(
&self,
pred: impl Fn(JobsEventCounter) -> bool,
) -> Counters {
loop {
let old = self.load(Ordering::SeqCst);
if pred(old.jobs_counter()) {
let new = Counters {
word: old.word.wrapping_add(ONE_JEC),
};
if self.try_exchange(old, new, Ordering::SeqCst) {
return new;
}
} else {
return old;
}
}
}
}
impl Counters {
#[inline]
pub(crate) fn jobs_counter(self) -> JobsEventCounter {
JobsEventCounter(select_jec(self.word))
}
#[inline]
pub(crate) fn inactive_threads(self) -> usize {
select_thread(self.word, INACTIVE_SHIFT)
}
#[inline]
pub(crate) fn sleeping_threads(self) -> usize {
select_thread(self.word, SLEEPING_SHIFT)
}
#[inline]
pub(crate) fn awake_but_idle_threads(self) -> usize {
debug_assert!(self.sleeping_threads() <= self.inactive_threads());
self.inactive_threads() - self.sleeping_threads()
}
}
impl std::fmt::Debug for Counters {
fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
fmt.debug_struct("Counters")
.field("word", &format!("{:016x}", self.word))
.field("jobs", &self.jobs_counter().0)
.field("inactive", &self.inactive_threads())
.field("sleeping", &self.sleeping_threads())
.finish()
}
}
const ROUNDS_UNTIL_SLEEPY: u32 = 32;
const DEFAULT_SPIN_WINDOW_ROUNDS: u32 = 500;
const FLOOR_SPIN_WINDOW_ROUNDS: u32 = 8;
static SPIN_WINDOW: AtomicU32 = AtomicU32::new(DEFAULT_SPIN_WINDOW_ROUNDS);
static ADAPTIVE: AtomicBool = AtomicBool::new(false);
static PARK_EVENTS: AtomicU32 = AtomicU32::new(0);
static RESCUE_EVENTS: AtomicU32 = AtomicU32::new(0);
static TOTAL_YIELDS: AtomicU64 = AtomicU64::new(0);
fn spin_init() {
static INIT: OnceLock<()> = OnceLock::new();
INIT.get_or_init(|| {
if let Some(v) = std::env::var("FLYNNEL_SPIN_WINDOW_ROUNDS")
.ok()
.and_then(|s| s.parse::<u32>().ok())
{
SPIN_WINDOW.store(v, Ordering::Relaxed);
ADAPTIVE.store(false, Ordering::Relaxed);
}
if std::env::var("FLYNNEL_ADAPTIVE_SPIN").as_deref() == Ok("1") {
ADAPTIVE.store(true, Ordering::Relaxed);
}
});
}
#[inline]
fn rounds_until_sleeping() -> u32 {
spin_init();
ROUNDS_UNTIL_SLEEPY + SPIN_WINDOW.load(Ordering::Relaxed)
}
fn maybe_adapt() {
if !ADAPTIVE.load(Ordering::Relaxed) {
return;
}
let park = PARK_EVENTS.load(Ordering::Relaxed);
let rescue = RESCUE_EVENTS.load(Ordering::Relaxed);
if park + rescue < 256 {
return;
}
let cur = SPIN_WINDOW.load(Ordering::Relaxed);
let new = if park > rescue.saturating_mul(3) {
(cur / 2).max(FLOOR_SPIN_WINDOW_ROUNDS)
} else if rescue > park {
(cur + cur / 4 + 1).min(DEFAULT_SPIN_WINDOW_ROUNDS)
} else {
cur
};
SPIN_WINDOW.store(new, Ordering::Relaxed);
PARK_EVENTS.store(0, Ordering::Relaxed);
RESCUE_EVENTS.store(0, Ordering::Relaxed);
}
pub fn spin_window() -> u32 {
SPIN_WINDOW.load(Ordering::Relaxed)
}
pub fn total_idle_yields() -> u64 {
TOTAL_YIELDS.load(Ordering::Relaxed)
}
pub fn reset_spin_stats() {
TOTAL_YIELDS.store(0, Ordering::Relaxed);
PARK_EVENTS.store(0, Ordering::Relaxed);
RESCUE_EVENTS.store(0, Ordering::Relaxed);
}
pub fn set_spin_window(rounds: u32) {
spin_init();
SPIN_WINDOW.store(rounds, Ordering::Relaxed);
ADAPTIVE.store(false, Ordering::Relaxed);
}
pub fn set_spin_adaptive(on: bool) {
ADAPTIVE.store(on, Ordering::Relaxed);
}
#[repr(align(128))]
struct WorkerSleepState {
is_blocked: Mutex<bool>,
condvar: Condvar,
}
pub(crate) struct IdleState {
pub worker_index: usize,
pub rounds: u32,
pub jobs_counter: JobsEventCounter,
pub parked: bool,
}
impl IdleState {
pub(crate) fn new(worker_index: usize) -> Self {
Self {
worker_index,
rounds: 0,
jobs_counter: JobsEventCounter::DUMMY,
parked: false,
}
}
fn wake_fully(&mut self) {
self.rounds = 0;
self.jobs_counter = JobsEventCounter::DUMMY;
}
fn wake_partly(&mut self) {
self.rounds = ROUNDS_UNTIL_SLEEPY;
self.jobs_counter = JobsEventCounter::DUMMY;
}
}
pub(crate) struct SleepDebug {
pub(crate) sleeping: usize,
pub(crate) inactive: usize,
pub(crate) jec: usize,
pub(crate) blocked: Vec<Option<bool>>,
}
pub(crate) struct Sleep {
counters: AtomicCounters,
worker_states: Vec<WorkerSleepState>,
}
impl Sleep {
pub(crate) fn new(num_workers: usize) -> Self {
assert!(num_workers <= THREADS_MAX, "too many workers");
let mut states = Vec::with_capacity(num_workers);
for _ in 0..num_workers {
states.push(WorkerSleepState {
is_blocked: Mutex::new(false),
condvar: Condvar::new(),
});
}
Self {
counters: AtomicCounters::new(),
worker_states: states,
}
}
#[allow(dead_code)]
pub(crate) fn num_workers(&self) -> usize {
self.worker_states.len()
}
pub(crate) fn debug_state(&self) -> SleepDebug {
let c = self.counters.load(Ordering::SeqCst);
let blocked = self
.worker_states
.iter()
.map(|s| s.is_blocked.try_lock().ok().map(|g| *g))
.collect();
SleepDebug {
sleeping: c.sleeping_threads(),
inactive: c.inactive_threads(),
jec: c.jobs_counter().as_usize(),
blocked,
}
}
#[inline]
pub(crate) fn start_looking(&self, worker_index: usize) -> IdleState {
self.counters.add_inactive_thread();
IdleState::new(worker_index)
}
#[inline]
pub(crate) fn work_found(&self, idle: &IdleState) {
if idle.rounds > ROUNDS_UNTIL_SLEEPY && !idle.parked {
RESCUE_EVENTS.fetch_add(1, Ordering::Relaxed);
}
let wake_count = self.counters.sub_inactive_thread();
if wake_count > 0 {
self.wake_any_threads(wake_count as u32);
}
}
pub(crate) fn no_work_found(
&self,
idle: &mut IdleState,
has_injected_jobs: impl FnOnce() -> bool,
) {
if idle.rounds < ROUNDS_UNTIL_SLEEPY {
TOTAL_YIELDS.fetch_add(1, Ordering::Relaxed);
thread::yield_now();
idle.rounds += 1;
} else if idle.rounds == ROUNDS_UNTIL_SLEEPY {
idle.jobs_counter = self.announce_sleepy();
idle.rounds += 1;
TOTAL_YIELDS.fetch_add(1, Ordering::Relaxed);
thread::yield_now();
} else if idle.rounds < rounds_until_sleeping() {
idle.rounds += 1;
TOTAL_YIELDS.fetch_add(1, Ordering::Relaxed);
thread::yield_now();
} else {
self.sleep(idle, has_injected_jobs);
}
}
fn announce_sleepy(&self) -> JobsEventCounter {
self.counters
.increment_jobs_event_counter_if(JobsEventCounter::is_active)
.jobs_counter()
}
fn sleep(
&self,
idle: &mut IdleState,
has_injected_jobs: impl FnOnce() -> bool,
) {
let state = &self.worker_states[idle.worker_index];
let mut is_blocked = state.is_blocked.lock().unwrap();
debug_assert!(!*is_blocked);
loop {
let counters = self.counters.load(Ordering::SeqCst);
debug_assert!(idle.jobs_counter.is_sleepy());
if counters.jobs_counter() != idle.jobs_counter {
idle.wake_partly();
return;
}
if self.counters.try_add_sleeping_thread(counters) {
break;
}
}
std::sync::atomic::fence(Ordering::SeqCst);
if has_injected_jobs() {
self.counters.sub_sleeping_thread();
} else {
idle.parked = true;
PARK_EVENTS.fetch_add(1, Ordering::Relaxed);
maybe_adapt();
*is_blocked = true;
while *is_blocked {
is_blocked = state.condvar.wait(is_blocked).unwrap();
}
}
idle.wake_fully();
}
#[inline]
pub(crate) fn new_internal_jobs(&self, num_jobs: u32, queue_was_empty: bool) {
let counters = self
.counters
.increment_jobs_event_counter_if(JobsEventCounter::is_sleepy);
let awake_but_idle = counters.awake_but_idle_threads() as u32;
let num_sleepers = counters.sleeping_threads() as u32;
if num_sleepers == 0 {
return;
}
if !queue_was_empty {
let n = num_jobs.min(num_sleepers);
self.wake_any_threads(n);
} else if awake_but_idle < num_jobs {
let n = (num_jobs - awake_but_idle).min(num_sleepers);
self.wake_any_threads(n);
}
}
fn wake_any_threads(&self, mut num: u32) {
if num == 0 {
return;
}
for i in 0..self.worker_states.len() {
if self.wake_specific_thread(i) {
num -= 1;
if num == 0 {
return;
}
}
}
}
fn wake_specific_thread(&self, idx: usize) -> bool {
let state = &self.worker_states[idx];
let mut is_blocked = state.is_blocked.lock().unwrap();
if *is_blocked {
*is_blocked = false;
state.condvar.notify_one();
self.counters.sub_sleeping_thread();
true
} else {
false
}
}
pub(crate) fn wake_all_for_shutdown(&self) {
for i in 0..self.worker_states.len() {
self.wake_specific_thread(i);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn counters_initial_state_is_zero() {
let c = AtomicCounters::new();
let snap = c.load(Ordering::SeqCst);
assert_eq!(snap.inactive_threads(), 0);
assert_eq!(snap.sleeping_threads(), 0);
assert_eq!(snap.awake_but_idle_threads(), 0);
}
#[test]
fn add_then_sub_inactive_returns_to_zero() {
let c = AtomicCounters::new();
c.add_inactive_thread();
assert_eq!(c.load(Ordering::SeqCst).inactive_threads(), 1);
c.sub_inactive_thread();
assert_eq!(c.load(Ordering::SeqCst).inactive_threads(), 0);
}
#[test]
fn jec_starts_sleepy_and_flips_active_on_increment() {
let c = AtomicCounters::new();
let snap = c.load(Ordering::SeqCst);
assert!(snap.jobs_counter().is_sleepy());
let after = c.increment_jobs_event_counter_if(|_| true);
assert!(after.jobs_counter().is_active());
}
#[test]
fn sleep_struct_constructs_with_n_workers() {
let s = Sleep::new(8);
assert_eq!(s.num_workers(), 8);
}
}