72 | 11.3M | } <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_skiplist::base::Node<i32, i32>>::decrement::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 1 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 1 | let size = mem::size_of::<F>(); | 35 | 1 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 1 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 1 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 1 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 1 | | 42 | 1 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 1 | let f: F = ptr::read(raw as *mut F); | 44 | 1 | f(); | 45 | 1 | } | 46 | 1 | | 47 | 1 | Deferred { | 48 | 1 | call: call::<F>, | 49 | 1 | data: data.assume_init(), | 50 | 1 | _marker: PhantomData, | 51 | 1 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 1 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_skiplist::base::Node<i32, i32>>::decrement_with_pin<crossbeam_epoch::default::pin>::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 3 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 3 | let size = mem::size_of::<F>(); | 35 | 3 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 3 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 3 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 3 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 3 | | 42 | 3 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 3 | let f: F = ptr::read(raw as *mut F); | 44 | 3 | f(); | 45 | 3 | } | 46 | 3 | | 47 | 3 | Deferred { | 48 | 3 | call: call::<F>, | 49 | 3 | data: data.assume_init(), | 50 | 3 | _marker: PhantomData, | 51 | 3 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 3 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_epoch::guard::Guard>::defer_destroy<crossbeam_epoch::sync::queue::Node<crossbeam_epoch::internal::SealedBag>>::{closure#0}, crossbeam_epoch::atomic::Owned<crossbeam_epoch::sync::queue::Node<crossbeam_epoch::internal::SealedBag>>>::{closure#0}> Line | Count | Source | 33 | 165 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 165 | let size = mem::size_of::<F>(); | 35 | 165 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 165 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 165 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 165 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 165 | | 42 | 165 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 165 | let f: F = ptr::read(raw as *mut F); | 44 | 165 | f(); | 45 | 165 | } | 46 | 165 | | 47 | 165 | Deferred { | 48 | 165 | call: call::<F>, | 49 | 165 | data: data.assume_init(), | 50 | 165 | _marker: PhantomData, | 51 | 165 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 165 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_epoch::guard::Guard>::defer_destroy<crossbeam_epoch::internal::Local>::{closure#0}, crossbeam_epoch::atomic::Owned<crossbeam_epoch::internal::Local>>::{closure#0}> Line | Count | Source | 33 | 97 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 97 | let size = mem::size_of::<F>(); | 35 | 97 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 97 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 97 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 97 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 97 | | 42 | 97 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 97 | let f: F = ptr::read(raw as *mut F); | 44 | 97 | f(); | 45 | 97 | } | 46 | 97 | | 47 | 97 | Deferred { | 48 | 97 | call: call::<F>, | 49 | 97 | data: data.assume_init(), | 50 | 97 | _marker: PhantomData, | 51 | 97 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 97 | } |
<crossbeam_epoch::deferred::Deferred>::new::<crossbeam_epoch::internal::no_op_func> Line | Count | Source | 33 | 22.5k | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 22.5k | let size = mem::size_of::<F>(); | 35 | 22.5k | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 22.5k | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>()22.5k { | 39 | 22.5k | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 22.5k | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 22.5k | | 42 | 22.5k | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 22.5k | let f: F = ptr::read(raw as *mut F); | 44 | 22.5k | f(); | 45 | 22.5k | } | 46 | 22.5k | | 47 | 22.5k | Deferred { | 48 | 22.5k | call: call::<F>, | 49 | 22.5k | data: data.assume_init(), | 50 | 22.5k | _marker: PhantomData, | 51 | 22.5k | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 22.5k | } |
Unexecuted instantiation: <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_deque::deque::Worker<usize>>::resize::{closure#0}, ()>::{closure#0}> Unexecuted instantiation: <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_deque::deque::Worker<injector::destructors::Elem>>::resize::{closure#0}, ()>::{closure#0}> Unexecuted instantiation: <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_skiplist::base::Node<i32, ()>>::decrement::{closure#0}, ()>::{closure#0}> Unexecuted instantiation: <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_skiplist::base::Node<i32, ()>>::decrement_with_pin<crossbeam_epoch::default::pin>::{closure#0}, ()>::{closure#0}> <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_skiplist::base::Node<base::drops::Key, base::drops::Value>>::decrement::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 1 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 1 | let size = mem::size_of::<F>(); | 35 | 1 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 1 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 1 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 1 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 1 | | 42 | 1 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 1 | let f: F = ptr::read(raw as *mut F); | 44 | 1 | f(); | 45 | 1 | } | 46 | 1 | | 47 | 1 | Deferred { | 48 | 1 | call: call::<F>, | 49 | 1 | data: data.assume_init(), | 50 | 1 | _marker: PhantomData, | 51 | 1 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 1 | } |
Unexecuted instantiation: <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_skiplist::base::Node<i32, i32>>::decrement::{closure#0}, ()>::{closure#0}> Unexecuted instantiation: <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_deque::deque::Worker<i32>>::resize::{closure#0}, ()>::{closure#0}> <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_deque::deque::Worker<usize>>::resize::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 16 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 16 | let size = mem::size_of::<F>(); | 35 | 16 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 16 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 16 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 16 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 16 | | 42 | 16 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 16 | let f: F = ptr::read(raw as *mut F); | 44 | 16 | f(); | 45 | 16 | } | 46 | 16 | | 47 | 16 | Deferred { | 48 | 16 | call: call::<F>, | 49 | 16 | data: data.assume_init(), | 50 | 16 | _marker: PhantomData, | 51 | 16 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 16 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_deque::deque::Worker<alloc::boxed::Box<usize>>>::resize::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 15 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 15 | let size = mem::size_of::<F>(); | 35 | 15 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 15 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 15 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 15 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 15 | | 42 | 15 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 15 | let f: F = ptr::read(raw as *mut F); | 44 | 15 | f(); | 45 | 15 | } | 46 | 15 | | 47 | 15 | Deferred { | 48 | 15 | call: call::<F>, | 49 | 15 | data: data.assume_init(), | 50 | 15 | _marker: PhantomData, | 51 | 15 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 15 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_deque::deque::Worker<fifo::destructors::Elem>>::resize::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 10 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 10 | let size = mem::size_of::<F>(); | 35 | 10 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 10 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 10 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 10 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 10 | | 42 | 10 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 10 | let f: F = ptr::read(raw as *mut F); | 44 | 10 | f(); | 45 | 10 | } | 46 | 10 | | 47 | 10 | Deferred { | 48 | 10 | call: call::<F>, | 49 | 10 | data: data.assume_init(), | 50 | 10 | _marker: PhantomData, | 51 | 10 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 10 | } |
Unexecuted instantiation: <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_deque::deque::Worker<i32>>::resize::{closure#0}, ()>::{closure#0}> Unexecuted instantiation: <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_deque::deque::Worker<i32>>::resize::{closure#0}, ()>::{closure#0}> <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_deque::deque::Worker<alloc::boxed::Box<usize>>>::resize::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 11 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 11 | let size = mem::size_of::<F>(); | 35 | 11 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 11 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 11 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 11 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 11 | | 42 | 11 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 11 | let f: F = ptr::read(raw as *mut F); | 44 | 11 | f(); | 45 | 11 | } | 46 | 11 | | 47 | 11 | Deferred { | 48 | 11 | call: call::<F>, | 49 | 11 | data: data.assume_init(), | 50 | 11 | _marker: PhantomData, | 51 | 11 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 11 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_deque::deque::Worker<lifo::destructors::Elem>>::resize::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 10 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 10 | let size = mem::size_of::<F>(); | 35 | 10 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 10 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 10 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 10 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 10 | | 42 | 10 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 10 | let f: F = ptr::read(raw as *mut F); | 44 | 10 | f(); | 45 | 10 | } | 46 | 10 | | 47 | 10 | Deferred { | 48 | 10 | call: call::<F>, | 49 | 10 | data: data.assume_init(), | 50 | 10 | _marker: PhantomData, | 51 | 10 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 10 | } |
Unexecuted instantiation: <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_deque::deque::Worker<i32>>::resize::{closure#0}, ()>::{closure#0}> <crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_deque::deque::Worker<usize>>::resize::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 10 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 10 | let size = mem::size_of::<F>(); | 35 | 10 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 10 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 10 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 10 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 10 | | 42 | 10 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 10 | let f: F = ptr::read(raw as *mut F); | 44 | 10 | f(); | 45 | 10 | } | 46 | 10 | | 47 | 10 | Deferred { | 48 | 10 | call: call::<F>, | 49 | 10 | data: data.assume_init(), | 50 | 10 | _marker: PhantomData, | 51 | 10 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 10 | } |
<crossbeam_epoch::deferred::Deferred>::new::<crossbeam_epoch::deferred::tests::boxed_slice_i32::{closure#0}> Line | Count | Source | 33 | 1 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 1 | let size = mem::size_of::<F>(); | 35 | 1 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 1 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 1 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 1 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 1 | | 42 | 1 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 1 | let f: F = ptr::read(raw as *mut F); | 44 | 1 | f(); | 45 | 1 | } | 46 | 1 | | 47 | 1 | Deferred { | 48 | 1 | call: call::<F>, | 49 | 1 | data: data.assume_init(), | 50 | 1 | _marker: PhantomData, | 51 | 1 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 1 | } |
<crossbeam_epoch::deferred::Deferred>::new::<crossbeam_epoch::deferred::tests::long_slice_usize::{closure#0}> Line | Count | Source | 33 | 1 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 1 | let size = mem::size_of::<F>(); | 35 | 1 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 1 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>()0 { | 39 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 0 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 0 |
| 42 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 0 | let f: F = ptr::read(raw as *mut F); | 44 | 0 | f(); | 45 | 0 | } | 46 | 0 |
| 47 | 0 | Deferred { | 48 | 0 | call: call::<F>, | 49 | 0 | data: data.assume_init(), | 50 | 0 | _marker: PhantomData, | 51 | 0 | } | 52 | | } else { | 53 | 1 | let b: Box<F> = Box::new(f); | 54 | 1 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 1 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 1 | | 57 | 1 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 1 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 1 | // originally derived from `*mut Box<F>`. | 60 | 1 | #[allow(clippy::cast_ptr_alignment)] | 61 | 1 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 1 | (*b)(); | 63 | 1 | } | 64 | 1 | | 65 | 1 | Deferred { | 66 | 1 | call: call::<F>, | 67 | 1 | data: data.assume_init(), | 68 | 1 | _marker: PhantomData, | 69 | 1 | } | 70 | | } | 71 | | } | 72 | 1 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_epoch::guard::Guard>::defer_destroy<crossbeam_epoch::collector::tests::count_drops::Elem>::{closure#0}, crossbeam_epoch::atomic::Owned<crossbeam_epoch::collector::tests::count_drops::Elem>>::{closure#0}> Line | Count | Source | 33 | 100k | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 100k | let size = mem::size_of::<F>(); | 35 | 100k | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 100k | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 100k | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 100k | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 100k | | 42 | 100k | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 100k | let f: F = ptr::read(raw as *mut F); | 44 | 100k | f(); | 45 | 100k | } | 46 | 100k | | 47 | 100k | Deferred { | 48 | 100k | call: call::<F>, | 49 | 100k | data: data.assume_init(), | 50 | 100k | _marker: PhantomData, | 51 | 100k | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 100k | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<crossbeam_epoch::collector::tests::count_destroy::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 100k | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 100k | let size = mem::size_of::<F>(); | 35 | 100k | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 100k | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 100k | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 100k | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 100k | | 42 | 100k | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 100k | let f: F = ptr::read(raw as *mut F); | 44 | 100k | f(); | 45 | 100k | } | 46 | 100k | | 47 | 100k | Deferred { | 48 | 100k | call: call::<F>, | 49 | 100k | data: data.assume_init(), | 50 | 100k | _marker: PhantomData, | 51 | 100k | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 100k | } |
<crossbeam_epoch::deferred::Deferred>::new::<crossbeam_epoch::internal::tests::check_bag::incr> Line | Count | Source | 33 | 63 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 63 | let size = mem::size_of::<F>(); | 35 | 63 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 63 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 63 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 63 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 63 | | 42 | 63 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 63 | let f: F = ptr::read(raw as *mut F); | 44 | 63 | f(); | 45 | 63 | } | 46 | 63 | | 47 | 63 | Deferred { | 48 | 63 | call: call::<F>, | 49 | 63 | data: data.assume_init(), | 50 | 63 | _marker: PhantomData, | 51 | 63 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 63 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_epoch::guard::Guard>::defer_destroy<crossbeam_epoch::sync::list::Entry>::{closure#0}, crossbeam_epoch::atomic::Owned<crossbeam_epoch::sync::list::Entry>>::{closure#0}> Line | Count | Source | 33 | 8.18k | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 8.18k | let size = mem::size_of::<F>(); | 35 | 8.18k | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 8.18k | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>()8.15k { | 39 | 8.17k | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 8.17k | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 8.17k | | 42 | 8.17k | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 8.17k | let f: F = ptr::read(raw as *mut F); | 44 | 8.17k | f(); | 45 | 8.17k | } | 46 | 8.17k | | 47 | 8.17k | Deferred { | 48 | 8.17k | call: call::<F>, | 49 | 8.17k | data: data.assume_init(), | 50 | 8.17k | _marker: PhantomData, | 51 | 8.17k | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 8.17k | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<crossbeam_epoch::collector::tests::destroy_array::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 1 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 1 | let size = mem::size_of::<F>(); | 35 | 1 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 1 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 1 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 1 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 1 | | 42 | 1 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 1 | let f: F = ptr::read(raw as *mut F); | 44 | 1 | f(); | 45 | 1 | } | 46 | 1 | | 47 | 1 | Deferred { | 48 | 1 | call: call::<F>, | 49 | 1 | data: data.assume_init(), | 50 | 1 | _marker: PhantomData, | 51 | 1 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 1 | } |
<crossbeam_epoch::deferred::Deferred>::new::<crossbeam_epoch::deferred::tests::string::{closure#0}> Line | Count | Source | 33 | 1 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 1 | let size = mem::size_of::<F>(); | 35 | 1 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 1 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 1 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 1 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 1 | | 42 | 1 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 1 | let f: F = ptr::read(raw as *mut F); | 44 | 1 | f(); | 45 | 1 | } | 46 | 1 | | 47 | 1 | Deferred { | 48 | 1 | call: call::<F>, | 49 | 1 | data: data.assume_init(), | 50 | 1 | _marker: PhantomData, | 51 | 1 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 1 | } |
<crossbeam_epoch::deferred::Deferred>::new::<crossbeam_epoch::deferred::tests::on_heap::{closure#0}> Line | Count | Source | 33 | 1 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 1 | let size = mem::size_of::<F>(); | 35 | 1 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 1 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>()0 { | 39 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 0 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 0 |
| 42 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 0 | let f: F = ptr::read(raw as *mut F); | 44 | 0 | f(); | 45 | 0 | } | 46 | 0 |
| 47 | 0 | Deferred { | 48 | 0 | call: call::<F>, | 49 | 0 | data: data.assume_init(), | 50 | 0 | _marker: PhantomData, | 51 | 0 | } | 52 | | } else { | 53 | 1 | let b: Box<F> = Box::new(f); | 54 | 1 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 1 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 1 | | 57 | 1 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 1 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 1 | // originally derived from `*mut Box<F>`. | 60 | 1 | #[allow(clippy::cast_ptr_alignment)] | 61 | 1 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 1 | (*b)(); | 63 | 1 | } | 64 | 1 | | 65 | 1 | Deferred { | 66 | 1 | call: call::<F>, | 67 | 1 | data: data.assume_init(), | 68 | 1 | _marker: PhantomData, | 69 | 1 | } | 70 | | } | 71 | | } | 72 | 1 | } |
<crossbeam_epoch::deferred::Deferred>::new::<crossbeam_epoch::deferred::tests::on_stack::{closure#0}> Line | Count | Source | 33 | 1 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 1 | let size = mem::size_of::<F>(); | 35 | 1 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 1 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 1 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 1 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 1 | | 42 | 1 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 1 | let f: F = ptr::read(raw as *mut F); | 44 | 1 | f(); | 45 | 1 | } | 46 | 1 | | 47 | 1 | Deferred { | 48 | 1 | call: call::<F>, | 49 | 1 | data: data.assume_init(), | 50 | 1 | _marker: PhantomData, | 51 | 1 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 1 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_epoch::guard::Guard>::defer_destroy<i32>::{closure#0}, crossbeam_epoch::atomic::Owned<i32>>::{closure#0}> Line | Count | Source | 33 | 110 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 110 | let size = mem::size_of::<F>(); | 35 | 110 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 110 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 110 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 110 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 110 | | 42 | 110 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 110 | let f: F = ptr::read(raw as *mut F); | 44 | 110 | f(); | 45 | 110 | } | 46 | 110 | | 47 | 110 | Deferred { | 48 | 110 | call: call::<F>, | 49 | 110 | data: data.assume_init(), | 50 | 110 | _marker: PhantomData, | 51 | 110 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 110 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_epoch::guard::Guard>::defer_destroy<alloc::vec::Vec<crossbeam_epoch::collector::tests::drop_array::Elem>>::{closure#0}, crossbeam_epoch::atomic::Owned<alloc::vec::Vec<crossbeam_epoch::collector::tests::drop_array::Elem>>>::{closure#0}> Line | Count | Source | 33 | 1 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 1 | let size = mem::size_of::<F>(); | 35 | 1 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 1 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 1 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 1 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 1 | | 42 | 1 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 1 | let f: F = ptr::read(raw as *mut F); | 44 | 1 | f(); | 45 | 1 | } | 46 | 1 | | 47 | 1 | Deferred { | 48 | 1 | call: call::<F>, | 49 | 1 | data: data.assume_init(), | 50 | 1 | _marker: PhantomData, | 51 | 1 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 1 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_epoch::guard::Guard>::defer_destroy<crossbeam_epoch::sync::queue::Node<crossbeam_epoch::internal::SealedBag>>::{closure#0}, crossbeam_epoch::atomic::Owned<crossbeam_epoch::sync::queue::Node<crossbeam_epoch::internal::SealedBag>>>::{closure#0}> Line | Count | Source | 33 | 64.7k | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 64.7k | let size = mem::size_of::<F>(); | 35 | 64.7k | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 64.7k | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>()64.7k { | 39 | 64.7k | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 64.7k | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 64.7k | | 42 | 64.7k | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 64.7k | let f: F = ptr::read(raw as *mut F); | 44 | 64.7k | f(); | 45 | 64.7k | } | 46 | 64.7k | | 47 | 64.7k | Deferred { | 48 | 64.7k | call: call::<F>, | 49 | 64.7k | data: data.assume_init(), | 50 | 64.7k | _marker: PhantomData, | 51 | 64.7k | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 64.7k | } |
<crossbeam_epoch::deferred::Deferred>::new::<crossbeam_epoch::internal::no_op_func> Line | Count | Source | 33 | 7.51M | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 7.51M | let size = mem::size_of::<F>(); | 35 | 7.51M | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 7.53M | if size <= mem::size_of::<Data>()7.51M && align <= mem::align_of::<Data>() { | 39 | 7.45M | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 7.45M | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 7.45M | | 42 | 7.45M | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 7.45M | let f: F = ptr::read(raw as *mut F); | 44 | 7.45M | f(); | 45 | 7.45M | } | 46 | 7.45M | | 47 | 7.45M | Deferred { | 48 | 7.45M | call: call::<F>, | 49 | 7.45M | data: data.assume_init(), | 50 | 7.45M | _marker: PhantomData, | 51 | 7.45M | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 7.45M | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_epoch::guard::Guard>::defer_destroy<crossbeam_epoch::internal::Local>::{closure#0}, crossbeam_epoch::atomic::Owned<crossbeam_epoch::internal::Local>>::{closure#0}> Line | Count | Source | 33 | 52 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 52 | let size = mem::size_of::<F>(); | 35 | 52 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 52 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 52 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 52 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 52 | | 42 | 52 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 52 | let f: F = ptr::read(raw as *mut F); | 44 | 52 | f(); | 45 | 52 | } | 46 | 52 | | 47 | 52 | Deferred { | 48 | 52 | call: call::<F>, | 49 | 52 | data: data.assume_init(), | 50 | 52 | _marker: PhantomData, | 51 | 52 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 52 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_epoch::guard::Guard>::defer_destroy<crossbeam_epoch::collector::tests::stress::Elem>::{closure#0}, crossbeam_epoch::atomic::Owned<crossbeam_epoch::collector::tests::stress::Elem>>::{closure#0}> Line | Count | Source | 33 | 681k | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 681k | let size = mem::size_of::<F>(); | 35 | 681k | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 739k | if size <= mem::size_of::<Data>()681k && align <= mem::align_of::<Data>() { | 39 | 738k | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 738k | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 738k | | 42 | 738k | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 738k | let f: F = ptr::read(raw as *mut F); | 44 | 738k | f(); | 45 | 738k | } | 46 | 738k | | 47 | 738k | Deferred { | 48 | 738k | call: call::<F>, | 49 | 738k | data: data.assume_init(), | 50 | 738k | _marker: PhantomData, | 51 | 738k | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 738k | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<crossbeam_epoch::collector::tests::incremental::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 100k | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 100k | let size = mem::size_of::<F>(); | 35 | 100k | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 100k | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 100k | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 100k | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 100k | | 42 | 100k | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 100k | let f: F = ptr::read(raw as *mut F); | 44 | 100k | f(); | 45 | 100k | } | 46 | 100k | | 47 | 100k | Deferred { | 48 | 100k | call: call::<F>, | 49 | 100k | data: data.assume_init(), | 50 | 100k | _marker: PhantomData, | 51 | 100k | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 100k | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_epoch::guard::Guard>::defer_destroy<crossbeam_epoch::sync::queue::Node<crossbeam_epoch::sync::queue::test::push_try_pop_many_mpmc::LR>>::{closure#0}, crossbeam_epoch::atomic::Owned<crossbeam_epoch::sync::queue::Node<crossbeam_epoch::sync::queue::test::push_try_pop_many_mpmc::LR>>>::{closure#0}> Line | Count | Source | 33 | 4 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 4 | let size = mem::size_of::<F>(); | 35 | 4 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 4 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 4 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 4 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 4 | | 42 | 4 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 4 | let f: F = ptr::read(raw as *mut F); | 44 | 4 | f(); | 45 | 4 | } | 46 | 4 | | 47 | 4 | Deferred { | 48 | 4 | call: call::<F>, | 49 | 4 | data: data.assume_init(), | 50 | 4 | _marker: PhantomData, | 51 | 4 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 4 | } |
<crossbeam_epoch::deferred::Deferred>::new::<crossbeam_epoch::internal::tests::check_defer::set> Line | Count | Source | 33 | 1 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 1 | let size = mem::size_of::<F>(); | 35 | 1 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 1 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 1 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 1 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 1 | | 42 | 1 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 1 | let f: F = ptr::read(raw as *mut F); | 44 | 1 | f(); | 45 | 1 | } | 46 | 1 | | 47 | 1 | Deferred { | 48 | 1 | call: call::<F>, | 49 | 1 | data: data.assume_init(), | 50 | 1 | _marker: PhantomData, | 51 | 1 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 1 | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<<crossbeam_epoch::guard::Guard>::defer_destroy<crossbeam_epoch::sync::queue::Node<i64>>::{closure#0}, crossbeam_epoch::atomic::Owned<crossbeam_epoch::sync::queue::Node<i64>>>::{closure#0}> Line | Count | Source | 33 | 2.72M | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 2.72M | let size = mem::size_of::<F>(); | 35 | 2.72M | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 2.73M | if size <= mem::size_of::<Data>()2.72M && align <= mem::align_of::<Data>() { | 39 | 2.73M | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 2.73M | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 2.73M | | 42 | 2.73M | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 2.73M | let f: F = ptr::read(raw as *mut F); | 44 | 2.73M | f(); | 45 | 2.73M | } | 46 | 2.73M | | 47 | 2.73M | Deferred { | 48 | 2.73M | call: call::<F>, | 49 | 2.73M | data: data.assume_init(), | 50 | 2.73M | _marker: PhantomData, | 51 | 2.73M | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 2.73M | } |
<crossbeam_epoch::deferred::Deferred>::new::<<crossbeam_epoch::guard::Guard>::defer_unchecked<crossbeam_epoch::collector::tests::buffering::{closure#0}, ()>::{closure#0}> Line | Count | Source | 33 | 10 | pub(crate) fn new<F: FnOnce()>(f: F) -> Self { | 34 | 10 | let size = mem::size_of::<F>(); | 35 | 10 | let align = mem::align_of::<F>(); | 36 | | | 37 | | unsafe { | 38 | 10 | if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() { | 39 | 10 | let mut data = MaybeUninit::<Data>::uninit(); | 40 | 10 | ptr::write(data.as_mut_ptr() as *mut F, f); | 41 | 10 | | 42 | 10 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 43 | 10 | let f: F = ptr::read(raw as *mut F); | 44 | 10 | f(); | 45 | 10 | } | 46 | 10 | | 47 | 10 | Deferred { | 48 | 10 | call: call::<F>, | 49 | 10 | data: data.assume_init(), | 50 | 10 | _marker: PhantomData, | 51 | 10 | } | 52 | | } else { | 53 | 0 | let b: Box<F> = Box::new(f); | 54 | 0 | let mut data = MaybeUninit::<Data>::uninit(); | 55 | 0 | ptr::write(data.as_mut_ptr() as *mut Box<F>, b); | 56 | 0 |
| 57 | 0 | unsafe fn call<F: FnOnce()>(raw: *mut u8) { | 58 | 0 | // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is | 59 | 0 | // originally derived from `*mut Box<F>`. | 60 | 0 | #[allow(clippy::cast_ptr_alignment)] | 61 | 0 | let b: Box<F> = ptr::read(raw as *mut Box<F>); | 62 | 0 | (*b)(); | 63 | 0 | } | 64 | 0 |
| 65 | 0 | Deferred { | 66 | 0 | call: call::<F>, | 67 | 0 | data: data.assume_init(), | 68 | 0 | _marker: PhantomData, | 69 | 0 | } | 70 | | } | 71 | | } | 72 | 10 | } |
|