11use crate :: sync:: atomic:: {
2- AtomicU32 ,
2+ self ,
33 Ordering :: { Acquire , Relaxed , Release } ,
44} ;
55use crate :: sys:: futex:: { futex_wait, futex_wake} ;
66
7+ cfg_if:: cfg_if! {
8+ if #[ cfg( windows) ] {
9+ // On Windows we can have a smol futex
10+ type Atomic = atomic:: AtomicU8 ;
11+ type State = u8 ;
12+ } else {
13+ type Atomic = atomic:: AtomicU32 ;
14+ type State = u32 ;
15+ }
16+ }
17+
718pub struct Mutex {
8- /// 0: unlocked
9- /// 1: locked, no other threads waiting
10- /// 2: locked, and other threads waiting (contended)
11- futex : AtomicU32 ,
19+ futex : Atomic ,
1220}
1321
22+ const UNLOCKED : State = 0 ;
23+ const LOCKED : State = 1 ; // locked, no other threads waiting
24+ const CONTENDED : State = 2 ; // locked, and other threads waiting (contended)
25+
1426impl Mutex {
1527 #[ inline]
1628 pub const fn new ( ) -> Self {
17- Self { futex : AtomicU32 :: new ( 0 ) }
29+ Self { futex : Atomic :: new ( UNLOCKED ) }
1830 }
1931
2032 #[ inline]
2133 pub fn try_lock ( & self ) -> bool {
22- self . futex . compare_exchange ( 0 , 1 , Acquire , Relaxed ) . is_ok ( )
34+ self . futex . compare_exchange ( UNLOCKED , LOCKED , Acquire , Relaxed ) . is_ok ( )
2335 }
2436
2537 #[ inline]
2638 pub fn lock ( & self ) {
27- if self . futex . compare_exchange ( 0 , 1 , Acquire , Relaxed ) . is_err ( ) {
39+ if self . futex . compare_exchange ( UNLOCKED , LOCKED , Acquire , Relaxed ) . is_err ( ) {
2840 self . lock_contended ( ) ;
2941 }
3042 }
@@ -36,40 +48,40 @@ impl Mutex {
3648
3749 // If it's unlocked now, attempt to take the lock
3850 // without marking it as contended.
39- if state == 0 {
40- match self . futex . compare_exchange ( 0 , 1 , Acquire , Relaxed ) {
51+ if state == UNLOCKED {
52+ match self . futex . compare_exchange ( UNLOCKED , LOCKED , Acquire , Relaxed ) {
4153 Ok ( _) => return , // Locked!
4254 Err ( s) => state = s,
4355 }
4456 }
4557
4658 loop {
4759 // Put the lock in contended state.
48- // We avoid an unnecessary write if it as already set to 2 ,
60+ // We avoid an unnecessary write if it as already set to CONTENDED ,
4961 // to be friendlier for the caches.
50- if state != 2 && self . futex . swap ( 2 , Acquire ) == 0 {
51- // We changed it from 0 to 2 , so we just successfully locked it.
62+ if state != CONTENDED && self . futex . swap ( CONTENDED , Acquire ) == UNLOCKED {
63+ // We changed it from UNLOCKED to CONTENDED , so we just successfully locked it.
5264 return ;
5365 }
5466
55- // Wait for the futex to change state, assuming it is still 2 .
56- futex_wait ( & self . futex , 2 , None ) ;
67+ // Wait for the futex to change state, assuming it is still CONTENDED .
68+ futex_wait ( & self . futex , CONTENDED , None ) ;
5769
5870 // Spin again after waking up.
5971 state = self . spin ( ) ;
6072 }
6173 }
6274
63- fn spin ( & self ) -> u32 {
75+ fn spin ( & self ) -> State {
6476 let mut spin = 100 ;
6577 loop {
6678 // We only use `load` (and not `swap` or `compare_exchange`)
6779 // while spinning, to be easier on the caches.
6880 let state = self . futex . load ( Relaxed ) ;
6981
70- // We stop spinning when the mutex is unlocked (0) ,
71- // but also when it's contended (2) .
72- if state != 1 || spin == 0 {
82+ // We stop spinning when the mutex is UNLOCKED ,
83+ // but also when it's CONTENDED .
84+ if state != LOCKED || spin == 0 {
7385 return state;
7486 }
7587
@@ -80,9 +92,9 @@ impl Mutex {
8092
8193 #[ inline]
8294 pub unsafe fn unlock ( & self ) {
83- if self . futex . swap ( 0 , Release ) == 2 {
95+ if self . futex . swap ( UNLOCKED , Release ) == CONTENDED {
8496 // We only wake up one thread. When that thread locks the mutex, it
85- // will mark the mutex as contended (2) (see lock_contended above),
97+ // will mark the mutex as CONTENDED (see lock_contended above),
8698 // which makes sure that any other waiting threads will also be
8799 // woken up eventually.
88100 self . wake ( ) ;
0 commit comments