renames Schedule variants, adds reschedule macro

Author: sunny-g

rustler/src/lib.rs

@@ -51,7 +51,7 @@ pub mod dynamic;
 pub use crate::dynamic::TermType;
 
 pub mod schedule;
-pub use crate::schedule::SchedulerFlags;
+pub use crate::schedule::{Schedule, SchedulerFlags};
 pub mod env;
 pub use crate::env::{Env, OwnedEnv};
 pub mod thread;

rustler/src/schedule.rs

@@ -11,23 +11,19 @@ pub enum SchedulerFlags {
     DirtyIo = ErlNifTaskFlags::ERL_NIF_DIRTY_JOB_IO_BOUND as isize,
 }
 
-impl SchedulerFlags {
-    #[inline]
-    fn from(n: isize) -> Self {
-        match n {
-            _ if n == Self::Normal as isize => Self::Normal,
-            _ if n == Self::DirtyCpu as isize => Self::DirtyCpu,
-            _ if n == Self::DirtyIo as isize => Self::DirtyIo,
-            _ => unreachable!(),
-        }
-    }
-}
-
 pub fn consume_timeslice(env: Env, percent: i32) -> bool {
     let success = unsafe { rustler_sys::enif_consume_timeslice(env.as_c_arg(), percent) };
     success == 1
 }
 
+/// Convenience macro for scheduling a future invokation of a NIF.
+#[macro_export]
+macro_rules! reschedule {
+    ($flags:expr, $($arg:expr),*) => (
+        rustler::schedule::Schedule::from(($flags, $($arg,)*))
+    )
+}
+
 /// Convenience type for scheduling a future invokation of a NIF.
 ///
 /// ## Usage:
@@ -38,76 +34,66 @@ pub fn consume_timeslice(env: Env, percent: i32) -> bool {
 ///
 /// The second generic type defined should be the type of the return value.
 ///
-/// Every other generic type is optional, but should reflect the non-`rustler`
-/// arguments provided to the NIF, in the same order.
+/// Every other generic type is optional, but should reflect the argument types
+/// of the scheduled NIF, in the same order.
 ///
 /// ## Example:
 /// ```rust,ignore
 /// #[nif]
 /// fn factorial(input: u32, result: Option<u32>) -> Schedule<factorial, u32, u32, u32> {
 ///     let result = result.unwrap_or(1);
 ///     if input == 0 {
-///         Schedule::Result(result)
+///         Schedule::Return(result)
 ///     } else {
-///         // alternatively `Schedule::Next2(std::marker::PhantomData, input - 1, result * input)`
-///         // alternatively `(input - 1, result * input).into()`
-///         Schedule::next2(input - 1, result * input)
+///         // alternatively `Schedule::Continue2(std::marker::PhantomData, SchedulerFlags::Normal, input - 1, result * input)`
+///         // alternatively `Schedule::continue2(SchedulerFlags::Normal, input - 1, result * input)`
+///         // alternatively `Schedule::from((SchedulerFlags::Normal, input - 1, result * input))`
+///         // alternatively `(SchedulerFlags::Normal, input - 1, result * input).into()`
+///         reschedule!(SchedulerFlags::Normal, input - 1, result * input)
 ///     }
 /// }
 /// ```
 pub enum Schedule<N: crate::Nif, T, A = (), B = (), C = (), D = (), E = (), F = (), G = ()> {
     /// The final result type to return back to the BEAM.
-    Result(T),
+    Return(T),
     /// Single- and multiple-argument variants that should reflect the scheduled
     /// NIF's function signature.
-    Next(PhantomData<N>, A),
-    Next2(PhantomData<N>, A, B),
-    Next3(PhantomData<N>, A, B, C),
-    Next4(PhantomData<N>, A, B, C, D),
-    Next5(PhantomData<N>, A, B, C, D, E),
-    Next6(PhantomData<N>, A, B, C, D, E, F),
-    Next7(PhantomData<N>, A, B, C, D, E, F, G),
+    Continue(PhantomData<N>, SchedulerFlags, A),
+    Continue2(PhantomData<N>, SchedulerFlags, A, B),
+    Continue3(PhantomData<N>, SchedulerFlags, A, B, C),
+    Continue4(PhantomData<N>, SchedulerFlags, A, B, C, D),
+    Continue5(PhantomData<N>, SchedulerFlags, A, B, C, D, E),
+    Continue6(PhantomData<N>, SchedulerFlags, A, B, C, D, E, F),
+    Continue7(PhantomData<N>, SchedulerFlags, A, B, C, D, E, F, G),
 }
 
 macro_rules! impl_funcs {
     ($variant:ident $func_name:ident($($arg:ident : $ty:ty,)*)) => {
         impl<N: crate::Nif, T, A, B, C, D, E, F, G> Schedule<N, T, A, B, C, D, E, F, G> {
             #[allow(clippy::many_single_char_names)]
             #[inline]
-            pub fn $func_name($($arg: $ty),*) -> Self {
-                Self::$variant(PhantomData, $($arg),*)
+            pub fn $func_name(flags: SchedulerFlags, $($arg: $ty),*) -> Self {
+                Self::$variant(PhantomData, flags, $($arg),*)
             }
         }
 
-        impl<N: crate::Nif, T, A, B, C, D, E, F, G> From<($($ty),*)> for Schedule<N, T, A, B, C, D, E, F, G> {
+        impl<N: crate::Nif, T, A, B, C, D, E, F, G> From<(SchedulerFlags, $($ty),*)> for Schedule<N, T, A, B, C, D, E, F, G> {
             #[allow(clippy::many_single_char_names)]
             #[inline]
-            fn from(($($arg),*): ($($ty),*)) -> Self {
-                Self::$func_name($($arg),*)
+            fn from((flags, $($arg),*): (SchedulerFlags, $($ty),*)) -> Self {
+                Self::$func_name(flags, $($arg),*)
             }
         }
     };
 }
 
-impl<N: crate::Nif, T, A, B, C, D, E, F, G> Schedule<N, T, A, B, C, D, E, F, G> {
-    #[inline]
-    pub fn next(a: A) -> Self {
-        Self::Next(PhantomData, a)
-    }
-}
-
-impl<N: crate::Nif, T, A, B, C, D, E, F, G> From<A> for Schedule<N, T, A, B, C, D, E, F, G> {
-    #[inline]
-    fn from(a: A) -> Self {
-        Self::next(a)
-    }
-}
-impl_funcs! { Next2 next2(a: A, b: B,) }
-impl_funcs! { Next3 next3(a: A, b: B, c: C,) }
-impl_funcs! { Next4 next4(a: A, b: B, c: C, d: D,) }
-impl_funcs! { Next5 next5(a: A, b: B, c: C, d: D, e: E,) }
-impl_funcs! { Next6 next6(a: A, b: B, c: C, d: D, e: E, f: F,) }
-impl_funcs! { Next7 next7(a: A, b: B, c: C, d: D, e: E, f: F, g: G,) }
+impl_funcs! { Continue continue1(a: A,) }
+impl_funcs! { Continue2 continue2(a: A, b: B,) }
+impl_funcs! { Continue3 continue3(a: A, b: B, c: C,) }
+impl_funcs! { Continue4 continue4(a: A, b: B, c: C, d: D,) }
+impl_funcs! { Continue5 continue5(a: A, b: B, c: C, d: D, e: E,) }
+impl_funcs! { Continue6 continue6(a: A, b: B, c: C, d: D, e: E, f: F,) }
+impl_funcs! { Continue7 continue7(a: A, b: B, c: C, d: D, e: E, f: F, g: G,) }
 
 unsafe impl<N, T, A, B, C, D, E, F, G> NifReturnable for Schedule<N, T, A, B, C, D, E, F, G>
 where
@@ -124,10 +110,10 @@ where
     #[inline]
     unsafe fn into_returned(self, env: Env) -> NifReturned {
         macro_rules! branch {
-            ($($arg:tt),*) => (
+            ($flags:expr, $($arg:tt),*) => (
                 NifReturned::Reschedule {
                     fun_name: CStr::from_ptr(N::NAME as *const c_char).into(),
-                    flags: SchedulerFlags::from(N::FLAGS as isize),
+                    flags: $flags,
                     fun: N::RAW_FUNC,
                     args: vec![$($arg.encode(env).as_c_arg()),*],
                 }
@@ -136,14 +122,14 @@ where
 
         #[allow(clippy::many_single_char_names)]
         match self {
-            Self::Result(res) => NifReturned::Term(res.encode(env).as_c_arg()),
-            Self::Next(_, a) => branch!(a),
-            Self::Next2(_, a, b) => branch!(a, b),
-            Self::Next3(_, a, b, c) => branch!(a, b, c),
-            Self::Next4(_, a, b, c, d) => branch!(a, b, c, d),
-            Self::Next5(_, a, b, c, d, e) => branch!(a, b, c, d, e),
-            Self::Next6(_, a, b, c, d, e, f) => branch!(a, b, c, d, e, f),
-            Self::Next7(_, a, b, c, d, e, f, g) => branch!(a, b, c, d, e, f, g),
+            Self::Return(res) => NifReturned::Term(res.encode(env).as_c_arg()),
+            Self::Continue(_, flags, a) => branch!(flags, a),
+            Self::Continue2(_, flags, a, b) => branch!(flags, a, b),
+            Self::Continue3(_, flags, a, b, c) => branch!(flags, a, b, c),
+            Self::Continue4(_, flags, a, b, c, d) => branch!(flags, a, b, c, d),
+            Self::Continue5(_, flags, a, b, c, d, e) => branch!(flags, a, b, c, d, e),
+            Self::Continue6(_, flags, a, b, c, d, e, f) => branch!(flags, a, b, c, d, e, f),
+            Self::Continue7(_, flags, a, b, c, d, e, f, g) => branch!(flags, a, b, c, d, e, f, g),
         }
     }
 }

rustler_tests/native/rustler_test/src/test_schedule.rs

@@ -1,11 +1,11 @@
-use rustler::schedule::Schedule;
+use rustler::{reschedule, Schedule, SchedulerFlags};
 
 #[rustler::nif]
-fn scheduled_fac(input: u32, result: Option<u32>) -> Schedule<scheduled_fac, u32, u32, u32> {
+fn scheduled_fac<'a>(input: u32, result: Option<u32>) -> Schedule<scheduled_fac, u32, u32, u32> {
     let result = result.unwrap_or(1);
     if input == 0 {
-        Schedule::Result(result)
+        Schedule::Return(result)
     } else {
-        (input - 1, result * input).into()
+        reschedule!(SchedulerFlags::Normal, input - 1, result * input)
     }
 }