ffd 0.1.0-alpha.1

Fast Function Dispatch: Improving the performance of Rust's dynamic function calls
Documentation 
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

#![doc = include_str!("../README.md")]
#![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg), deny(rustdoc::all))]
#![cfg_attr(feature = "nightly", feature(unboxed_closures, tuple_trait, fn_traits))]
#![no_std]

extern crate alloc;

use alloc::boxed::Box;
use core::{marker::PhantomData, mem::MaybeUninit};

/// A boxed function.
///
/// You can see this as semantically equivalent to a `Box<dyn Fn<T, Output = O>>`.
///
/// With the `nightly` feature enabled, this type implements [`Fn`].
pub struct Func<'a, T, O> {
    f: unsafe fn(*const (), T) -> O,
    data: *mut (),
    phantom: PhantomData<&'a ()>,
}

struct WithDrop<F> {
    drop_fn: unsafe fn(*mut ()),
    f: F,
}

impl<'a, T, O> Drop for Func<'a, T, O> {
    fn drop(&mut self) {
        unsafe {
            let drop_fn = core::mem::transmute::<_, &WithDrop<MaybeUninit<()>>>(self.data).drop_fn;
            drop_fn(self.data)
        }
    }
}

impl<'a, T, O> Func<'a, T, O> {
    /// Create a new [`Func`] encapsulating the provided function, `f`.
    ///
    /// When the [`Func`] is dropped, the encapsulated function will be too.
    #[cfg(any(not(feature = "nightly"), docsrs))]
    pub fn new<F: Fn(T) -> O + 'a>(f: F) -> Self {
        #[inline(always)]
        unsafe fn invoke<F: Fn(T) -> O, T, O>(data: *const (), args: T) -> O {
            let wd = core::mem::transmute::<_, &WithDrop<F>>(data);
            (wd.f)(args)
        }

        unsafe fn do_drop<F>(x: *mut F) {
            drop(Box::<WithDrop<F>>::from_raw(x as _))
        }

        Self {
            f: invoke::<F, T, O>,
            data: Box::into_raw(Box::new(WithDrop {
                drop_fn: unsafe { core::mem::transmute(do_drop::<F> as unsafe fn(_)) },
                f,
            })) as _,
            phantom: PhantomData,
        }
    }

    /// Call the encapsulated function with the given argument.
    pub fn call_(&self, arg: T) -> O {
        unsafe { (self.f)(self.data, arg) }
    }
}

#[cfg(feature = "nightly")]
mod nightly {
    use super::*;

    use core::marker::Tuple;

    impl<'a, T: Tuple, O> Func<'a, T, O> {
        /// Create a new [`Func`] encapsulating the provided function, `f`.
        ///
        /// When the [`Func`] is dropped, the encapsulated function will be too.
        ///
        /// Note that the given function can accept an arbitrary set of arguments.
        pub fn new<F: Fn<T, Output = O> + 'a>(f: F) -> Self {
            #[inline(always)]
            unsafe fn invoke<F: Fn<T, Output = O>, T: Tuple, O>(data: *const (), args: T) -> O {
                let wd = core::mem::transmute::<_, &WithDrop<F>>(data);
                wd.f.call(args)
            }

            unsafe fn do_drop<F>(x: *mut F) {
                drop(Box::<WithDrop<F>>::from_raw(x as _))
            }

            Self {
                f: invoke::<F, T, O>,
                data: Box::into_raw(Box::new(WithDrop {
                    drop_fn: unsafe { core::mem::transmute(do_drop::<F> as unsafe fn(_)) },
                    f,
                })) as _,
                phantom: PhantomData,
            }
        }
    }

    impl<'a, T: Tuple, O> FnOnce<T> for Func<'a, T, O> {
        type Output = O;
        #[inline(always)]
        extern "rust-call" fn call_once(self, args: T) -> O {
            unsafe { (self.f)(self.data, args) }
        }
    }
    impl<'a, T: Tuple, O> FnMut<T> for Func<'a, T, O> {
        #[inline(always)]
        extern "rust-call" fn call_mut(&mut self, args: T) -> O {
            unsafe { (self.f)(self.data, args) }
        }
    }
    impl<'a, T: Tuple, O> Fn<T> for Func<'a, T, O> {
        #[inline(always)]
        extern "rust-call" fn call(&self, args: T) -> O {
            unsafe { (self.f)(self.data, args) }
        }
    }
}