Do not require attribute for 'local tasks'

Author: usbalbin

examples/lm3s6965/examples/spawn_local.rs

@@ -17,7 +17,7 @@ mod app {
     #[init]
     fn init(_cx: init::Context) -> (Shared, Local) {
         task1::spawn().unwrap();
-        //task2::spawn(Default::default()).ok(); <--- This is rejected since it is a local task
+        //task2::spawn(Default::default()).ok(); <--- This is rejected since not all args are Send and Sync
         (Shared {}, Local {})
     }
 
@@ -27,7 +27,8 @@ mod app {
         cx.local_spawner.task2(Default::default()).unwrap();
     }
 
-    #[task(priority = 1, local_task = true)]
+    // Task where some args are !Send/!Sync
+    #[task(priority = 1)]
     async fn task2(_cx: task2::Context, _nsns: NotSendNotSync) {
         hprintln!("Hello from task2!");
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator

rtic-macros/CHANGELOG.md

@@ -11,6 +11,7 @@ For each category, *Added*, *Changed*, *Fixed* add new entries at the top!
 
 - 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
+- Allow tasks with !Send/!Sync to be spawned from the same priority level task using local spawner
 
 ## [v2.2.0] - 2025-06-22
 

rtic-macros/src/codegen/module.rs

@@ -2,7 +2,7 @@ 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;
+use quote::{format_ident, quote};
 
 #[allow(clippy::too_many_lines)]
 pub fn codegen(ctxt: Context, app: &App, analysis: &Analysis) -> TokenStream2 {
@@ -129,26 +129,31 @@ 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) =
             util::regroup_inputs(&spawnee.inputs);
 
-        let local_task = app.software_tasks[t].args.local_task;
-        let unsafety = if local_task {
-            // local tasks are only safe to call from the same executor
-            quote! { unsafe }
-        } else {
-            quote! {}
-        };
+        let generics: Vec<_> = spawnee.inputs.iter().enumerate().map(|(i, _)| format_ident!("T{i}")).collect();
+        let generic_input_args = generics.iter().enumerate().map(|(i, generic)| {
+            let ident = format_ident!("_{i}");
+            quote! { #ident: #generic }
+        });
+        let constraints = generics.iter().zip(&spawnee.inputs).map(|(generic, input)| {
+            let ty = &input.ty;
+            quote!{ #generic: rtic::export::dummy::Dummy<T=#ty> + Send + Sync }
+        });
 
         // 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 #unsafety 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);
@@ -162,6 +167,15 @@ 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<#(#generics),*>(#(#generic_input_args,)*) -> ::core::result::Result<(), #input_ty>
+                where #(#constraints),*
+            {
+                unsafe { #internal_spawn_helper_ident(#(#input_untupled.to()),*) }
+            }
         ));
 
         // Waker
@@ -183,37 +197,31 @@ pub fn codegen(ctxt: Context, app: &App, analysis: &Analysis) -> TokenStream2 {
             }
         ));
 
-        if !local_task {
-            module_items.push(quote!(
-                #(#cfgs)*
-                #[doc(inline)]
-                pub use super::#internal_spawn_ident as spawn;
-            ));
-        }
+        module_items.push(quote!{
+            #(#cfgs)*
+            #[doc(inline)]
+            pub use super::#internal_spawn_ident as spawn;
+        });
 
-        let local_tasks_on_same_executor: Vec<_> = app
+        let tasks_on_same_executor: Vec<_> = app
             .software_tasks
             .iter()
-            .filter(|(_, t)| t.args.local_task && t.args.priority == priority)
+            .filter(|(_, t)| t.args.priority == priority)
             .collect();
 
-        if !local_tasks_on_same_executor.is_empty() {
+        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.
-                ///
-                /// NOTE: This only works with tasks marked `local_task = true`
-                /// and which have the same priority and thus will run on the
-                /// same executor.
                 pub local_spawner: #local_spawner
             });
-            let tasks = local_tasks_on_same_executor
+            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");
+                    let internal_spawn_ident = util::internal_task_ident(ident, "spawn_helper");
                     let attrs = &task.attrs;
                     let cfgs = &task.cfgs;
                     let inputs = &task.inputs;

rtic-macros/src/syntax/analyze.rs

@@ -285,16 +285,8 @@ pub(crate) fn app(app: &App) -> Result<Analysis, syn::Error> {
     for (name, spawnee) in &app.software_tasks {
         let spawnee_prio = spawnee.args.priority;
 
-        // TODO: What is this?
         let channel = channels.entry(spawnee_prio).or_default();
         channel.tasks.insert(name.clone());
-
-        if !spawnee.args.local_task {
-            // 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-macros/src/syntax/ast.rs

@@ -256,12 +256,6 @@ pub struct SoftwareTaskArgs {
 
     /// Shared resources that can be accessed from this context
     pub shared_resources: SharedResources,
-
-    /// Local tasks
-    /// 
-    /// Local tasks can only be spawned from the same executor.
-    /// However they do not require Send and Sync
-    pub local_task: bool,
 }
 
 impl Default for SoftwareTaskArgs {
@@ -270,7 +264,6 @@ impl Default for SoftwareTaskArgs {
             priority: 0,
             local_resources: LocalResources::new(),
             shared_resources: SharedResources::new(),
-            local_task: false,
         }
     }
 }

rtic-macros/src/syntax/parse.rs

@@ -11,7 +11,7 @@ use syn::{
     braced,
     parse::{self, Parse, ParseStream, Parser},
     token::Brace,
-    Attribute, Ident, Item, LitBool, LitInt, Meta, Token,
+    Attribute, Ident, Item, LitInt, Meta, Token,
 };
 
 use crate::syntax::{
@@ -197,7 +197,6 @@ fn task_args(tokens: TokenStream2) -> parse::Result<Either<HardwareTaskArgs, Sof
         let mut shared_resources = None;
         let mut local_resources = None;
         let mut prio_span = None;
-        let mut local_task = None;
 
         loop {
             if input.is_empty() {
@@ -209,27 +208,7 @@ fn task_args(tokens: TokenStream2) -> parse::Result<Either<HardwareTaskArgs, Sof
             let ident_s = ident.to_string();
 
             // Handle equal sign
-            let eq = input.parse::<Token![=]>();
-
-            // Only local_task supports omitting the value
-            if &*ident_s == "local_task" {
-                if local_task.is_some() {
-                    return Err(parse::Error::new(
-                        ident.span(),
-                        "argument appears more than once",
-                    ));
-                }
-
-                if eq.is_ok() {
-                    let lit: LitBool = input.parse()?;
-                    local_task = Some(lit.value);
-                } else {
-                    local_task = Some(true); // Default to true
-                }
-                break;
-            } else if let Err(e) = eq {
-                return Err(e);
-            };
+            let _: Token![=] = input.parse()?;
 
             match &*ident_s {
                 "binds" => {
@@ -312,7 +291,6 @@ fn task_args(tokens: TokenStream2) -> parse::Result<Either<HardwareTaskArgs, Sof
         }
         let shared_resources = shared_resources.unwrap_or_default();
         let local_resources = local_resources.unwrap_or_default();
-        let local_task = local_task.unwrap_or(false);
 
         Ok(if let Some(binds) = binds {
             // Hardware tasks can't run at anything lower than 1
@@ -339,7 +317,6 @@ fn task_args(tokens: TokenStream2) -> parse::Result<Either<HardwareTaskArgs, Sof
                 priority,
                 shared_resources,
                 local_resources,
-                local_task,
             })
         })
     })

rtic/CHANGELOG.md

@@ -23,6 +23,7 @@ Example:
 ### Added
 
 - Outer attributes applied to RTIC app module are now forwarded to the generated code.
+- Allow tasks with !Send/!Sync to be spawned from the same priority level task using local spawner
 
 ### Changed
 

rtic/src/export/dummy.rs

@@ -0,0 +1,16 @@
+
+// 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
+    }
+}

rtic/ui/spawn-local-different-exec.rs rtic/ui/spawn-non-send-different-exec.rsrtic/ui/spawn-local-different-exec.rs renamed to rtic/ui/spawn-non-send-different-exec.rs

@@ -2,6 +2,8 @@
 
 #[rtic::app(device = lm3s6965, dispatchers = [SSI0, GPIOA])]
 mod app {
+    use super::*;
+
     #[shared]
     struct Shared {}
 
@@ -14,10 +16,13 @@ mod app {
     }
 
     #[task(priority = 1, local_task)]
-    async fn foo(_cx: foo::Context) {}
+    async fn foo(_cx: foo::Context, _nsns: NotSendNotSync) {}
 
     #[task(priority = 2)]
     async fn bar(cx: bar::Context) {
-        cx.local_spawner.foo().ok();
+        cx.local_spawner.foo(Default::default()).ok();
     }
 }
+
+#[derive(Default, Debug)]
+struct NotSendNotSync(core::marker::PhantomData<*mut u8>);