Allow spawning non Send/Sync tasks from the same prio using local spawner

Author: usbalbin

rtic-macros/CHANGELOG.md

@@ -10,6 +10,7 @@ For each category, *Added*, *Changed*, *Fixed* add new entries at the top!
 ### Added
 
 - Outer attributes applied to RTIC app module are now forwarded to the generated code.
+- Local spawner for spawning tasks with !Send/!Sync args on the same executor
 
 ## [v2.2.0] - 2025-06-22
 

rtic-macros/src/codegen/module.rs

@@ -1,5 +1,6 @@
 use crate::syntax::{ast::App, Context};
 use crate::{analyze::Analysis, codegen::bindings::interrupt_mod, codegen::util};
+
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
 
@@ -112,37 +113,7 @@ pub fn codegen(ctxt: Context, app: &App, analysis: &Analysis) -> TokenStream2 {
     let internal_context_name = util::internal_task_ident(name, "Context");
     let exec_name = util::internal_task_ident(name, "EXEC");
 
-    items.push(quote!(
-        #(#cfgs)*
-        /// Execution context
-        #[allow(non_snake_case)]
-        #[allow(non_camel_case_types)]
-        pub struct #internal_context_name<'a> {
-            #[doc(hidden)]
-            __rtic_internal_p: ::core::marker::PhantomData<&'a ()>,
-            #(#fields,)*
-        }
-
-        #(#cfgs)*
-        impl<'a> #internal_context_name<'a> {
-            #[inline(always)]
-            #[allow(missing_docs)]
-            pub unsafe fn new(#core) -> Self {
-                #internal_context_name {
-                    __rtic_internal_p: ::core::marker::PhantomData,
-                    #(#values,)*
-                }
-            }
-        }
-    ));
-
-    module_items.push(quote!(
-        #(#cfgs)*
-        #[doc(inline)]
-        pub use super::#internal_context_name as Context;
-    ));
-
-    if let Context::SoftwareTask(..) = ctxt {
+    if let Context::SoftwareTask(t) = ctxt {
         let spawnee = &app.software_tasks[name];
         let priority = spawnee.args.priority;
         let cfgs = &spawnee.cfgs;
@@ -158,18 +129,21 @@ pub fn codegen(ctxt: Context, app: &App, analysis: &Analysis) -> TokenStream2 {
         };
 
         let internal_spawn_ident = util::internal_task_ident(name, "spawn");
+        let internal_spawn_helper_ident = util::internal_task_ident(name, "spawn_helper");
         let internal_waker_ident = util::internal_task_ident(name, "waker");
         let from_ptr_n_args = util::from_ptr_n_args_ident(spawnee.inputs.len());
-        let (input_args, input_tupled, input_untupled, input_ty) =
+        let (generic_input_args, input_args, input_tupled, input_untupled, input_ty) =
             util::regroup_inputs(&spawnee.inputs);
 
         // Spawn caller
         items.push(quote!(
             #(#cfgs)*
-            /// Spawns the task directly
+            /// Spawns the task without checking if the spawner and spawnee are the same priority
+            /// 
+            /// SAFETY: The caller needs to check that the spawner and spawnee are the same priority
             #[allow(non_snake_case)]
             #[doc(hidden)]
-            pub fn #internal_spawn_ident(#(#input_args,)*) -> ::core::result::Result<(), #input_ty> {
+            pub unsafe fn #internal_spawn_helper_ident(#(#input_args,)*) -> ::core::result::Result<(), #input_ty> {
                 // SAFETY: If `try_allocate` succeeds one must call `spawn`, which we do.
                 unsafe {
                     let exec = rtic::export::executor::AsyncTaskExecutor::#from_ptr_n_args(#name, &#exec_name);
@@ -183,6 +157,14 @@ pub fn codegen(ctxt: Context, app: &App, analysis: &Analysis) -> TokenStream2 {
                     }
                 }
             }
+            
+            /// Spawns the task directly
+            #[allow(non_snake_case)]
+            #[doc(hidden)]
+            pub fn #internal_spawn_ident(#(#generic_input_args,)*) -> ::core::result::Result<(), #input_ty> {
+                // SAFETY: The generic args require Send + Sync
+                unsafe { #internal_spawn_helper_ident(#(#input_untupled.to()),*) }
+            }
         ));
 
         // Waker
@@ -204,11 +186,63 @@ pub fn codegen(ctxt: Context, app: &App, analysis: &Analysis) -> TokenStream2 {
             }
         ));
 
-        module_items.push(quote!(
+        module_items.push(quote!{
             #(#cfgs)*
             #[doc(inline)]
             pub use super::#internal_spawn_ident as spawn;
-        ));
+        });
+
+        let tasks_on_same_executor: Vec<_> = app
+            .software_tasks
+            .iter()
+            .filter(|(_, t)| t.args.priority == priority)
+            .collect();
+
+        if !tasks_on_same_executor.is_empty() {
+            let local_spawner = util::internal_task_ident(t, "LocalSpawner");
+            fields.push(quote! {
+                /// Used to spawn tasks on the same executor
+                ///
+                /// This is useful for tasks that take args which are !Send/!Sync.
+                pub local_spawner: #local_spawner
+            });
+            let tasks = tasks_on_same_executor
+                .iter()
+                .map(|(ident, task)| {
+                    // Copied mostly from software_tasks.rs
+                    let internal_spawn_ident = util::internal_task_ident(ident, "spawn_helper");
+                    let attrs = &task.attrs;
+                    let cfgs = &task.cfgs;
+                    let generics = if task.is_bottom {
+                        quote!()
+                    } else {
+                        quote!(<'a>)
+                    };
+
+                    let (_generic_input_args, input_args, _input_tupled, input_untupled, input_ty) = util::regroup_inputs(&task.inputs);
+                    quote! {
+                        #(#attrs)*
+                        #(#cfgs)*
+                        #[allow(non_snake_case)]
+                        pub(super) fn #ident #generics(&self #(,#input_args)*) -> ::core::result::Result<(), #input_ty> {
+                            // SAFETY: This is safe to call since this can only be called
+                            // from the same executor
+                            unsafe { #internal_spawn_ident(#(#input_untupled,)*) }
+                        }
+                    }
+                })
+                .collect::<Vec<_>>();
+            values.push(quote!(local_spawner: #local_spawner { _p: core::marker::PhantomData }));
+            items.push(quote! {
+                struct #local_spawner {
+                    _p: core::marker::PhantomData<*mut ()>,
+                }
+
+                impl #local_spawner {
+                    #(#tasks)*
+                }
+            });
+        }
 
         module_items.push(quote!(
             #(#cfgs)*
@@ -217,6 +251,36 @@ pub fn codegen(ctxt: Context, app: &App, analysis: &Analysis) -> TokenStream2 {
         ));
     }
 
+    items.push(quote!(
+        #(#cfgs)*
+        /// Execution context
+        #[allow(non_snake_case)]
+        #[allow(non_camel_case_types)]
+        pub struct #internal_context_name<'a> {
+            #[doc(hidden)]
+            __rtic_internal_p: ::core::marker::PhantomData<&'a ()>,
+            #(#fields,)*
+        }
+
+        #(#cfgs)*
+        impl<'a> #internal_context_name<'a> {
+            #[inline(always)]
+            #[allow(missing_docs)]
+            pub unsafe fn new(#core) -> Self {
+                #internal_context_name {
+                    __rtic_internal_p: ::core::marker::PhantomData,
+                    #(#values,)*
+                }
+            }
+        }
+    ));
+
+    module_items.push(quote!(
+        #(#cfgs)*
+        #[doc(inline)]
+        pub use super::#internal_context_name as Context;
+    ));
+
     if items.is_empty() {
         quote!()
     } else {

rtic-macros/src/codegen/util.rs

@@ -35,6 +35,8 @@ pub fn link_section_uninit() -> TokenStream2 {
 pub fn regroup_inputs(
     inputs: &[PatType],
 ) -> (
+    // Generic args e.g. &[`_0: impl Dummy<T=i32>`, `_1: impl Dummy<T=i64>`]
+    Vec<TokenStream2>,
     // args e.g. &[`_0`],  &[`_0: i32`, `_1: i64`]
     Vec<TokenStream2>,
     // tupled e.g. `_0`, `(_0, _1)`
@@ -48,12 +50,14 @@ pub fn regroup_inputs(
         let ty = &inputs[0].ty;
 
         (
+            vec![quote!(_0: impl rtic::export::dummy::Dummy<T=#ty> + Send + Sync)],
             vec![quote!(_0: #ty)],
             quote!(_0),
             vec![quote!(_0)],
             quote!(#ty),
         )
     } else {
+        let mut generic_args = vec![];
         let mut args = vec![];
         let mut pats = vec![];
         let mut tys = vec![];
@@ -62,6 +66,8 @@ pub fn regroup_inputs(
             let i = Ident::new(&format!("_{i}"), Span::call_site());
             let ty = &input.ty;
 
+            generic_args.push(quote!(#i: impl rtic::export::dummy::Dummy<T=#ty> + Send + Sync));
+
             args.push(quote!(#i: #ty));
 
             pats.push(quote!(#i));
@@ -74,7 +80,7 @@ pub fn regroup_inputs(
             quote!((#(#pats,)*))
         };
         let ty = quote!((#(#tys,)*));
-        (args, tupled, pats, ty)
+        (generic_args, args, tupled, pats, ty)
     }
 }
 

rtic-macros/src/syntax/analyze.rs

@@ -287,11 +287,6 @@ pub(crate) fn app(app: &App) -> Result<Analysis, syn::Error> {
 
         let channel = channels.entry(spawnee_prio).or_default();
         channel.tasks.insert(name.clone());
-
-        // All inputs are send as we do not know from where they may be spawned.
-        spawnee.inputs.iter().for_each(|input| {
-            send_types.insert(input.ty.clone());
-        });
     }
 
     // No channel should ever be empty

rtic/src/export.rs

@@ -1,6 +1,7 @@
 pub use critical_section::CriticalSection;
 pub use portable_atomic as atomic;
 
+pub mod dummy;
 pub mod executor;
 
 // Cortex-M target (any)

rtic/src/export/dummy.rs

@@ -0,0 +1,15 @@
+// TODO: What should we name this?
+
+/// Dummy trait which will only ever be implemented where type T is Self
+pub trait Dummy {
+    /// This should always be same as `Self`
+    type T;
+    fn to(self) -> Self::T;
+}
+
+impl<T> Dummy for T {
+    type T = T;
+    fn to(self) -> T {
+        self
+    }
+}