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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
pub(crate) use self::inner::*;
#[cfg(all(loom, any(test, feature = "loom")))]
mod inner {
pub(crate) mod atomic {
pub use loom::sync::atomic::*;
pub use std::sync::atomic::Ordering;
}
pub(crate) use loom::{
cell::UnsafeCell, hint, lazy_static, sync::Mutex, thread::yield_now, thread_local,
};
pub(crate) mod alloc {
#![allow(dead_code)]
use loom::alloc;
use std::fmt;
/// Track allocations, detecting leaks
///
/// This is a version of `loom::alloc::Track` that adds a missing
/// `Default` impl.
pub struct Track<T>(alloc::Track<T>);
impl<T> Track<T> {
/// Track a value for leaks
#[inline(always)]
pub fn new(value: T) -> Track<T> {
Track(alloc::Track::new(value))
}
/// Get a reference to the value
#[inline(always)]
pub fn get_ref(&self) -> &T {
self.0.get_ref()
}
/// Get a mutable reference to the value
#[inline(always)]
pub fn get_mut(&mut self) -> &mut T {
self.0.get_mut()
}
/// Stop tracking the value for leaks
#[inline(always)]
pub fn into_inner(self) -> T {
self.0.into_inner()
}
}
impl<T: fmt::Debug> fmt::Debug for Track<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
impl<T: Default> Default for Track<T> {
fn default() -> Self {
Self::new(T::default())
}
}
}
}
#[cfg(not(all(loom, any(feature = "loom", test))))]
mod inner {
#![allow(dead_code)]
pub(crate) use lazy_static::lazy_static;
pub(crate) use std::{
sync::{atomic, Mutex},
thread::yield_now,
thread_local,
};
pub(crate) mod hint {
#[inline(always)]
pub(crate) fn spin_loop() {
// MSRV: std::hint::spin_loop() stabilized in 1.49.0
#[allow(deprecated)]
super::atomic::spin_loop_hint()
}
}
#[derive(Debug)]
pub(crate) struct UnsafeCell<T>(std::cell::UnsafeCell<T>);
impl<T> UnsafeCell<T> {
pub fn new(data: T) -> UnsafeCell<T> {
UnsafeCell(std::cell::UnsafeCell::new(data))
}
#[inline(always)]
pub fn with<F, R>(&self, f: F) -> R
where
F: FnOnce(*const T) -> R,
{
f(self.0.get())
}
#[inline(always)]
pub fn with_mut<F, R>(&self, f: F) -> R
where
F: FnOnce(*mut T) -> R,
{
f(self.0.get())
}
}
pub(crate) mod alloc {
/// Track allocations, detecting leaks
#[derive(Debug, Default)]
pub struct Track<T> {
value: T,
}
impl<T> Track<T> {
/// Track a value for leaks
#[inline(always)]
pub fn new(value: T) -> Track<T> {
Track { value }
}
/// Get a reference to the value
#[inline(always)]
pub fn get_ref(&self) -> &T {
&self.value
}
/// Get a mutable reference to the value
#[inline(always)]
pub fn get_mut(&mut self) -> &mut T {
&mut self.value
}
/// Stop tracking the value for leaks
#[inline(always)]
pub fn into_inner(self) -> T {
self.value
}
}
}
}
|
