1 use crate::loom::sync::Mutex;
2 use std::sync::atomic::Ordering;
3 
4 cfg_has_const_mutex_new! {
5     #[path = "atomic_u64_static_const_new.rs"]
6     mod static_macro;
7 }
8 
9 cfg_not_has_const_mutex_new! {
10     #[path = "atomic_u64_static_once_cell.rs"]
11     mod static_macro;
12 }
13 
14 pub(crate) use static_macro::StaticAtomicU64;
15 
16 #[derive(Debug)]
17 pub(crate) struct AtomicU64 {
18     inner: Mutex<u64>,
19 }
20 
21 impl AtomicU64 {
load(&self, _: Ordering) -> u6422     pub(crate) fn load(&self, _: Ordering) -> u64 {
23         *self.inner.lock()
24     }
25 
store(&self, val: u64, _: Ordering)26     pub(crate) fn store(&self, val: u64, _: Ordering) {
27         *self.inner.lock() = val;
28     }
29 
fetch_add(&self, val: u64, _: Ordering) -> u6430     pub(crate) fn fetch_add(&self, val: u64, _: Ordering) -> u64 {
31         let mut lock = self.inner.lock();
32         let prev = *lock;
33         *lock = prev + val;
34         prev
35     }
36 
fetch_or(&self, val: u64, _: Ordering) -> u6437     pub(crate) fn fetch_or(&self, val: u64, _: Ordering) -> u64 {
38         let mut lock = self.inner.lock();
39         let prev = *lock;
40         *lock = prev | val;
41         prev
42     }
43 
compare_exchange( &self, current: u64, new: u64, _success: Ordering, _failure: Ordering, ) -> Result<u64, u64>44     pub(crate) fn compare_exchange(
45         &self,
46         current: u64,
47         new: u64,
48         _success: Ordering,
49         _failure: Ordering,
50     ) -> Result<u64, u64> {
51         let mut lock = self.inner.lock();
52 
53         if *lock == current {
54             *lock = new;
55             Ok(current)
56         } else {
57             Err(*lock)
58         }
59     }
60 
compare_exchange_weak( &self, current: u64, new: u64, success: Ordering, failure: Ordering, ) -> Result<u64, u64>61     pub(crate) fn compare_exchange_weak(
62         &self,
63         current: u64,
64         new: u64,
65         success: Ordering,
66         failure: Ordering,
67     ) -> Result<u64, u64> {
68         self.compare_exchange(current, new, success, failure)
69     }
70 }
71 
72 impl Default for AtomicU64 {
default() -> AtomicU6473     fn default() -> AtomicU64 {
74         AtomicU64::new(u64::default())
75     }
76 }
77