diff options
85 files changed, 1088 insertions, 1773 deletions
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 93e32545..4d7ed950 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -138,7 +138,7 @@ jobs: with: use-cross: false command: check - args: --examples --target=${{ matrix.target }} --features __min_r1_43,${{ env.V7 }} + args: --examples --target=${{ matrix.target }} --features ${{ env.V7 }} # Verify the example output with run-pass tests testexamples: @@ -244,18 +244,15 @@ jobs: resource lock multilock - late only-shared-access task message capacity - types not-sync generics - cfg pool ramfunc diff --git a/CHANGELOG.md b/CHANGELOG.md index d7bcfc63..4a99b584 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,12 @@ This project adheres to [Semantic Versioning](http://semver.org/). ## [Unreleased] +## [v0.6.0-alpha.5] - 2021-07-09 + +### Changed + +- The new resources syntax is implemented. + ## [v0.6.0-alpha.4] - 2021-05-27 ### Fixed @@ -14,7 +14,7 @@ name = "cortex-m-rtic" readme = "README.md" repository = "https://github.com/rtic-rs/cortex-m-rtic" -version = "0.6.0-alpha.4" +version = "0.6.0-alpha.5" [lib] name = "rtic" @@ -32,36 +32,24 @@ name = "schedule" required-features = ["__v7"] [[example]] -name = "t-cfg" -required-features = ["__v7"] - -[[example]] -name = "t-cfg-resources" -required-features = ["__min_r1_43"] - -[[example]] name = "t-schedule" required-features = ["__v7"] [[example]] -name = "types" -required-features = ["__v7"] - -[[example]] name = "double_schedule" required-features = ["__v7"] [dependencies] cortex-m = "0.7.0" cortex-m-rtic-macros = { path = "macros", version = "0.6.0-alpha.4" } -rtic-monotonic = "0.1.0-alpha.1" +rtic-monotonic = "0.1.0-alpha.2" rtic-core = "0.3.1" heapless = "0.6.1" bare-metal = "1.0.0" generic-array = "0.14" [dependencies.dwt-systick-monotonic] -version = "0.1.0-alpha.2" +version = "0.1.0-alpha.3" optional = true [build-dependencies] @@ -81,7 +69,6 @@ trybuild = "1" [features] # used for testing this crate; do not use in applications __v7 = ["dwt-systick-monotonic"] -__min_r1_43 = [] [profile.release] codegen-units = 1 diff --git a/examples/big-struct-opt.rs b/examples/big-struct-opt.rs index e6a5c172..2d0cc83d 100644 --- a/examples/big-struct-opt.rs +++ b/examples/big-struct-opt.rs @@ -25,27 +25,32 @@ mod app { use super::BigStruct; use core::mem::MaybeUninit; - #[resources] - struct Resources { + #[shared] + struct Shared { big_struct: &'static mut BigStruct, } - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - let big_struct = unsafe { - static mut BIG_STRUCT: MaybeUninit<BigStruct> = MaybeUninit::uninit(); + #[local] + struct Local {} + #[init(local = [bs: MaybeUninit<BigStruct> = MaybeUninit::uninit()])] + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { + let big_struct = unsafe { // write directly into the static storage - BIG_STRUCT.as_mut_ptr().write(BigStruct::new()); - &mut *BIG_STRUCT.as_mut_ptr() + cx.local.bs.as_mut_ptr().write(BigStruct::new()); + &mut *cx.local.bs.as_mut_ptr() }; ( - init::LateResources { + Shared { // assign the reference so we can use the resource big_struct, }, + Local {}, init::Monotonics(), ) } + + #[task(binds = UART0, shared = [big_struct])] + fn task(_: task::Context) {} } diff --git a/examples/binds.rs b/examples/binds.rs index 9cbe2994..0b30af65 100644 --- a/examples/binds.rs +++ b/examples/binds.rs @@ -13,13 +13,19 @@ mod app { use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { rtic::pend(Interrupt::UART0); hprintln!("init").unwrap(); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } #[idle] @@ -35,16 +41,14 @@ mod app { } } - #[task(binds = UART0)] - fn foo(_: foo::Context) { - static mut TIMES: u32 = 0; - - *TIMES += 1; + #[task(binds = UART0, local = [times: u32 = 0])] + fn foo(cx: foo::Context) { + *cx.local.times += 1; hprintln!( "foo called {} time{}", - *TIMES, - if *TIMES > 1 { "s" } else { "" } + *cx.local.times, + if *cx.local.times > 1 { "s" } else { "" } ) .unwrap(); } diff --git a/examples/capacity.rs b/examples/capacity.rs index 06bd921e..ea1613f7 100644 --- a/examples/capacity.rs +++ b/examples/capacity.rs @@ -12,11 +12,17 @@ mod app { use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { rtic::pend(Interrupt::UART0); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } #[task(binds = UART0)] diff --git a/examples/cfg-whole-task.rs b/examples/cfg-whole-task.rs index 47c3530e..3fbdb2d1 100644 --- a/examples/cfg-whole-task.rs +++ b/examples/cfg-whole-task.rs @@ -13,22 +13,32 @@ mod app { #[cfg(debug_assertions)] use cortex_m_semihosting::hprintln; - #[resources] - struct Resources { + #[shared] + struct Shared { #[cfg(debug_assertions)] // <- `true` when using the `dev` profile - #[init(0)] count: u32, #[cfg(never)] - #[init(0)] unused: u32, } + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { foo::spawn().unwrap(); foo::spawn().unwrap(); - (init::LateResources {}, init::Monotonics()) + ( + Shared { + #[cfg(debug_assertions)] + count: 0, + #[cfg(never)] + unused: 1, + }, + Local {}, + init::Monotonics(), + ) } #[idle] @@ -40,17 +50,17 @@ mod app { } } - #[task(capacity = 2, resources = [count])] + #[task(capacity = 2, shared = [count])] fn foo(mut _cx: foo::Context) { #[cfg(debug_assertions)] { - _cx.resources.count.lock(|count| *count += 1); + _cx.shared.count.lock(|count| *count += 1); - log::spawn(_cx.resources.count.lock(|count| *count)).unwrap(); + log::spawn(_cx.shared.count.lock(|count| *count)).unwrap(); } // this wouldn't compile in `release` mode - // *_cx.resources.count += 1; + // *_cx.shared.count += 1; // .. } @@ -58,17 +68,17 @@ mod app { // The whole task should disappear, // currently still present in the Tasks enum #[cfg(never)] - #[task(capacity = 2, resources = [count])] + #[task(capacity = 2, shared = [count])] fn foo2(mut _cx: foo2::Context) { #[cfg(debug_assertions)] { - _cx.resources.count.lock(|count| *count += 10); + _cx.shared.count.lock(|count| *count += 10); - log::spawn(_cx.resources.count.lock(|count| *count)).unwrap(); + log::spawn(_cx.shared.count.lock(|count| *count)).unwrap(); } // this wouldn't compile in `release` mode - // *_cx.resources.count += 1; + // *_cx.shared.count += 1; // .. } diff --git a/examples/cfg.rs b/examples/cfg.rs deleted file mode 100644 index 43c2593c..00000000 --- a/examples/cfg.rs +++ /dev/null @@ -1,65 +0,0 @@ -//! examples/cfg.rs - -#![deny(unsafe_code)] -#![deny(warnings)] -#![no_main] -#![no_std] - -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965, dispatchers = [SSI0, QEI0])] -mod app { - use cortex_m_semihosting::debug; - #[cfg(debug_assertions)] - use cortex_m_semihosting::hprintln; - - #[resources] - struct Resources { - #[cfg(debug_assertions)] // <- `true` when using the `dev` profile - #[init(0)] - count: u32, - } - - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - foo::spawn().unwrap(); - foo::spawn().unwrap(); - - (init::LateResources {}, init::Monotonics()) - } - - #[idle] - fn idle(_: idle::Context) -> ! { - debug::exit(debug::EXIT_SUCCESS); - - loop { - cortex_m::asm::nop(); - } - } - - #[task(capacity = 2, resources = [count])] - fn foo(mut _cx: foo::Context) { - #[cfg(debug_assertions)] - { - _cx.resources.count.lock(|count| *count += 1); - - log::spawn(_cx.resources.count.lock(|count| *count)).unwrap(); - } - - // this wouldn't compile in `release` mode - // *_cx.resources.count += 1; - - // .. - } - - #[cfg(debug_assertions)] - #[task(capacity = 2)] - fn log(_: log::Context, n: u32) { - hprintln!( - "foo has been called {} time{}", - n, - if n == 1 { "" } else { "s" } - ) - .ok(); - } -} diff --git a/examples/destructure.rs b/examples/destructure.rs index d085e4bf..984c9b8a 100644 --- a/examples/destructure.rs +++ b/examples/destructure.rs @@ -12,39 +12,39 @@ mod app { use cortex_m_semihosting::hprintln; use lm3s6965::Interrupt; - #[resources] - struct Resources { + #[shared] + struct Shared { // Some resources to work with - #[init(0)] a: u32, - #[init(0)] b: u32, - #[init(0)] c: u32, } + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { rtic::pend(Interrupt::UART0); rtic::pend(Interrupt::UART1); - (init::LateResources {}, init::Monotonics()) + (Shared { a: 0, b: 0, c: 0 }, Local {}, init::Monotonics()) } // Direct destructure - #[task(binds = UART0, resources = [&a, &b, &c])] + #[task(binds = UART0, shared = [&a, &b, &c])] fn uart0(cx: uart0::Context) { - let a = cx.resources.a; - let b = cx.resources.b; - let c = cx.resources.c; + let a = cx.shared.a; + let b = cx.shared.b; + let c = cx.shared.c; hprintln!("UART0: a = {}, b = {}, c = {}", a, b, c).unwrap(); } // De-structure-ing syntax - #[task(binds = UART1, resources = [&a, &b, &c])] + #[task(binds = UART1, shared = [&a, &b, &c])] fn uart1(cx: uart1::Context) { - let uart1::Resources { a, b, c } = cx.resources; + let uart1::SharedResources { a, b, c } = cx.shared; hprintln!("UART0: a = {}, b = {}, c = {}", a, b, c).unwrap(); } diff --git a/examples/double_schedule.rs b/examples/double_schedule.rs index 9da57ae5..6f24297e 100644 --- a/examples/double_schedule.rs +++ b/examples/double_schedule.rs @@ -15,8 +15,14 @@ mod app { #[monotonic(binds = SysTick, default = true)] type MyMono = DwtSystick<8_000_000>; // 8 MHz + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { task1::spawn().ok(); let mut dcb = cx.core.DCB; @@ -25,7 +31,7 @@ mod app { let mono = DwtSystick::new(&mut dcb, dwt, systick, 8_000_000); - (init::LateResources {}, init::Monotonics(mono)) + (Shared {}, Local {}, init::Monotonics(mono)) } #[task] diff --git a/examples/extern_binds.rs b/examples/extern_binds.rs index 3c8786dd..ce4bc17e 100644 --- a/examples/extern_binds.rs +++ b/examples/extern_binds.rs @@ -19,13 +19,19 @@ mod app { use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { rtic::pend(Interrupt::UART0); hprintln!("init").unwrap(); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } #[idle] diff --git a/examples/extern_spawn.rs b/examples/extern_spawn.rs index 275ac539..d035fe7f 100644 --- a/examples/extern_spawn.rs +++ b/examples/extern_spawn.rs @@ -21,11 +21,17 @@ fn foo(_c: app::foo::Context, x: i32, y: u32) { mod app { use crate::foo; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_c: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { foo::spawn(1, 2).unwrap(); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } extern "Rust" { diff --git a/examples/generics.rs b/examples/generics.rs index eabfff7e..b2c59a08 100644 --- a/examples/generics.rs +++ b/examples/generics.rs @@ -14,42 +14,40 @@ mod app { use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; - #[resources] - struct Resources { - #[init(0)] + #[shared] + struct Shared { shared: u32, } + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { rtic::pend(Interrupt::UART0); rtic::pend(Interrupt::UART1); - (init::LateResources {}, init::Monotonics()) + (Shared { shared: 0 }, Local {}, init::Monotonics()) } - #[task(binds = UART0, resources = [shared])] + #[task(binds = UART0, shared = [shared], local = [state: u32 = 0])] fn uart0(c: uart0::Context) { - static mut STATE: u32 = 0; - - hprintln!("UART0(STATE = {})", *STATE).unwrap(); + hprintln!("UART0(STATE = {})", *c.local.state).unwrap(); - // second argument has type `resources::shared` - super::advance(STATE, c.resources.shared); + // second argument has type `shared::shared` + super::advance(c.local.state, c.shared.shared); rtic::pend(Interrupt::UART1); debug::exit(debug::EXIT_SUCCESS); } - #[task(binds = UART1, priority = 2, resources = [shared])] + #[task(binds = UART1, priority = 2, shared = [shared], local = [state: u32 = 0])] fn uart1(c: uart1::Context) { - static mut STATE: u32 = 0; - - hprintln!("UART1(STATE = {})", *STATE).unwrap(); + hprintln!("UART1(STATE = {})", *c.local.state).unwrap(); - // second argument has type `resources::shared` - super::advance(STATE, c.resources.shared); + // second argument has type `shared::shared` + super::advance(c.local.state, c.shared.shared); } } diff --git a/examples/hardware.rs b/examples/hardware.rs index 3cf98807..5dff8222 100644 --- a/examples/hardware.rs +++ b/examples/hardware.rs @@ -12,15 +12,21 @@ mod app { use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { // Pends the UART0 interrupt but its handler won't run until *after* // `init` returns because interrupts are disabled rtic::pend(Interrupt::UART0); // equivalent to NVIC::pend hprintln!("init").unwrap(); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } #[idle] @@ -38,17 +44,15 @@ mod app { } } - #[task(binds = UART0)] - fn uart0(_: uart0::Context) { - static mut TIMES: u32 = 0; - + #[task(binds = UART0, local = [times: u32 = 0])] + fn uart0(cx: uart0::Context) { // Safe access to local `static mut` variable - *TIMES += 1; + *cx.local.times += 1; hprintln!( "UART0 called {} time{}", - *TIMES, - if *TIMES > 1 { "s" } else { "" } + *cx.local.times, + if *cx.local.times > 1 { "s" } else { "" } ) .unwrap(); } diff --git a/examples/idle.rs b/examples/idle.rs index db03dc70..34c861b9 100644 --- a/examples/idle.rs +++ b/examples/idle.rs @@ -11,19 +11,23 @@ use panic_semihosting as _; mod app { use cortex_m_semihosting::{debug, hprintln}; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { hprintln!("init").unwrap(); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } - #[idle] - fn idle(_: idle::Context) -> ! { - static mut X: u32 = 0; - - // Safe access to local `static mut` variable - let _x: &'static mut u32 = X; + #[idle(local = [x: u32 = 0])] + fn idle(cx: idle::Context) -> ! { + // Locals in idle have lifetime 'static + let _x: &'static mut u32 = cx.local.x; hprintln!("idle").unwrap(); diff --git a/examples/init.rs b/examples/init.rs index 9de79581..97e3c513 100644 --- a/examples/init.rs +++ b/examples/init.rs @@ -11,18 +11,22 @@ use panic_semihosting as _; mod app { use cortex_m_semihosting::{debug, hprintln}; - #[init] - fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) { - static mut X: u32 = 0; + #[shared] + struct Shared {} + #[local] + struct Local {} + + #[init(local = [x: u32 = 0])] + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { // Cortex-M peripherals let _core: cortex_m::Peripherals = cx.core; // Device specific peripherals let _device: lm3s6965::Peripherals = cx.device; - // Safe access to local `static mut` variable - let _x: &'static mut u32 = X; + // Locals in `init` have 'static lifetime + let _x: &'static mut u32 = cx.local.x; // Access to the critical section token, // to indicate that this is a critical seciton @@ -32,6 +36,6 @@ mod app { debug::exit(debug::EXIT_SUCCESS); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } } diff --git a/examples/lock.rs b/examples/lock.rs index 75d47d24..aeadd295 100644 --- a/examples/lock.rs +++ b/examples/lock.rs @@ -12,26 +12,28 @@ mod app { use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; - #[resources] - struct Resources { - #[init(0)] + #[shared] + struct Shared { shared: u32, } + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { rtic::pend(Interrupt::GPIOA); - (init::LateResources {}, init::Monotonics()) + (Shared { shared: 0 }, Local {}, init::Monotonics()) } // when omitted priority is assumed to be `1` - #[task(binds = GPIOA, resources = [shared])] + #[task(binds = GPIOA, shared = [shared])] fn gpioa(mut c: gpioa::Context) { hprintln!("A").unwrap(); // the lower priority task requires a critical section to access the data - c.resources.shared.lock(|shared| { + c.shared.shared.lock(|shared| { // data can only be modified within this critical section (closure) *shared += 1; @@ -51,10 +53,10 @@ mod app { debug::exit(debug::EXIT_SUCCESS); } - #[task(binds = GPIOB, priority = 2, resources = [shared])] + #[task(binds = GPIOB, priority = 2, shared = [shared])] fn gpiob(mut c: gpiob::Context) { // the higher priority task does still need a critical section - let shared = c.resources.shared.lock(|shared| { + let shared = c.shared.shared.lock(|shared| { *shared += 1; *shared diff --git a/examples/message.rs b/examples/message.rs index 722e73a7..7318d4b7 100644 --- a/examples/message.rs +++ b/examples/message.rs @@ -11,21 +11,25 @@ use panic_semihosting as _; mod app { use cortex_m_semihosting::{debug, hprintln}; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { foo::spawn(/* no message */).unwrap(); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } - #[task] - fn foo(_: foo::Context) { - static mut COUNT: u32 = 0; - + #[task(local = [count: u32 = 0])] + fn foo(cx: foo::Context) { hprintln!("foo").unwrap(); - bar::spawn(*COUNT).unwrap(); - *COUNT += 1; + bar::spawn(*cx.local.count).unwrap(); + *cx.local.count += 1; } #[task] diff --git a/examples/multilock.rs b/examples/multilock.rs index ad9d72ab..7d8d7d24 100644 --- a/examples/multilock.rs +++ b/examples/multilock.rs @@ -14,29 +14,37 @@ mod app { use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; - #[resources] - struct Resources { - #[init(0)] + #[shared] + struct Shared { shared1: u32, - #[init(0)] shared2: u32, - #[init(0)] shared3: u32, } + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { rtic::pend(Interrupt::GPIOA); - (init::LateResources {}, init::Monotonics()) + ( + Shared { + shared1: 0, + shared2: 0, + shared3: 0, + }, + Local {}, + init::Monotonics(), + ) } // when omitted priority is assumed to be `1` - #[task(binds = GPIOA, resources = [shared1, shared2, shared3])] + #[task(binds = GPIOA, shared = [shared1, shared2, shared3])] fn locks(c: locks::Context) { - let mut s1 = c.resources.shared1; - let mut s2 = c.resources.shared2; - let mut s3 = c.resources.shared3; + let mut s1 = c.shared.shared1; + let mut s2 = c.shared.shared2; + let mut s3 = c.shared.shared3; hprintln!("Multiple single locks").unwrap(); s1.lock(|s1| { diff --git a/examples/not-sync.rs b/examples/not-sync.rs index f01d4043..1510e504 100644 --- a/examples/not-sync.rs +++ b/examples/not-sync.rs @@ -1,6 +1,6 @@ //! `examples/not-sync.rs` -#![deny(unsafe_code)] +// #![deny(unsafe_code)] #![deny(warnings)] #![no_main] #![no_std] @@ -12,32 +12,42 @@ pub struct NotSync { _0: PhantomData<*const ()>, } +unsafe impl Send for NotSync {} + #[rtic::app(device = lm3s6965, dispatchers = [SSI0])] mod app { use super::NotSync; use core::marker::PhantomData; use cortex_m_semihosting::debug; - #[resources] - struct Resources { - #[init(NotSync { _0: PhantomData })] + #[shared] + struct Shared { shared: NotSync, } + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { debug::exit(debug::EXIT_SUCCESS); - (init::LateResources {}, init::Monotonics()) + ( + Shared { + shared: NotSync { _0: PhantomData }, + }, + Local {}, + init::Monotonics(), + ) } - #[task(resources = [&shared])] + #[task(shared = [&shared])] fn foo(c: foo::Context) { - let _: &NotSync = c.resources.shared; + let _: &NotSync = c.shared.shared; } - #[task(resources = [&shared])] + #[task(shared = [&shared])] fn bar(c: bar::Context) { - let _: &NotSync = c.resources.shared; + let _: &NotSync = c.shared.shared; } } diff --git a/examples/only-shared-access.rs b/examples/only-shared-access.rs index 2c6ad4c4..e3f1dbd3 100644 --- a/examples/only-shared-access.rs +++ b/examples/only-shared-access.rs @@ -12,29 +12,32 @@ mod app { use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; - #[resources] - struct Resources { + #[shared] + struct Shared { key: u32, } + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { rtic::pend(Interrupt::UART0); rtic::pend(Interrupt::UART1); - (init::LateResources { key: 0xdeadbeef }, init::Monotonics()) + (Shared { key: 0xdeadbeef }, Local {}, init::Monotonics()) } - #[task(binds = UART0, resources = [&key])] + #[task(binds = UART0, shared = [&key])] fn uart0(cx: uart0::Context) { - let key: &u32 = cx.resources.key; + let key: &u32 = cx.shared.key; hprintln!("UART0(key = {:#x})", key).unwrap(); debug::exit(debug::EXIT_SUCCESS); } - #[task(binds = UART1, priority = 2, resources = [&key])] + #[task(binds = UART1, priority = 2, shared = [&key])] fn uart1(cx: uart1::Context) { - hprintln!("UART1(key = {:#x})", cx.resources.key).unwrap(); + hprintln!("UART1(key = {:#x})", cx.shared.key).unwrap(); } } diff --git a/examples/periodic.rs b/examples/periodic.rs index 01061c9f..b1868839 100644 --- a/examples/periodic.rs +++ b/examples/periodic.rs @@ -16,8 +16,14 @@ mod app { #[monotonic(binds = SysTick, default = true)] type MyMono = DwtSystick<8_000_000>; // 8 MHz + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { let mut dcb = cx.core.DCB; let dwt = cx.core.DWT; let systick = cx.core.SYST; @@ -26,7 +32,7 @@ mod app { foo::spawn_after(Seconds(1_u32)).unwrap(); - (init::LateResources {}, init::Monotonics(mono)) + (Shared {}, Local {}, init::Monotonics(mono)) } #[task] diff --git a/examples/peripherals-taken.rs b/examples/peripherals-taken.rs index 6b4a282b..cb90319e 100644 --- a/examples/peripherals-taken.rs +++ b/examples/peripherals-taken.rs @@ -9,11 +9,17 @@ use panic_semihosting as _; mod app { use cortex_m_semihosting::debug; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { assert!(cortex_m::Peripherals::take().is_none()); debug::exit(debug::EXIT_SUCCESS); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } } diff --git a/examples/pool.rs b/examples/pool.rs index 44405b49..63be899e 100644 --- a/examples/pool.rs +++ b/examples/pool.rs @@ -24,16 +24,20 @@ mod app { // Import the memory pool into scope use super::P; - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - static mut MEMORY: [u8; 512] = [0; 512]; + #[shared] + struct Shared {} + #[local] + struct Local {} + + #[init(local = [memory: [u8; 512] = [0; 512]])] + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { // Increase the capacity of the memory pool by ~4 - P::grow(MEMORY); + P::grow(cx.local.memory); rtic::pend(Interrupt::I2C0); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } #[task(binds = I2C0, priority = 2)] diff --git a/examples/preempt.rs b/examples/preempt.rs index 14b3a0a6..8d9f9ead 100644 --- a/examples/preempt.rs +++ b/examples/preempt.rs @@ -11,11 +11,17 @@ mod app { use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { rtic::pend(Interrupt::GPIOA); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } #[task(binds = GPIOA, priority = 1)] diff --git a/examples/ramfunc.rs b/examples/ramfunc.rs index d9c8143f..ecff8530 100644 --- a/examples/ramfunc.rs +++ b/examples/ramfunc.rs @@ -18,11 +18,17 @@ use panic_semihosting as _; mod app { use cortex_m_semihosting::{debug, hprintln}; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { foo::spawn().unwrap(); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } #[inline(never)] diff --git a/examples/resource-user-struct.rs b/examples/resource-user-struct.rs index 6ad540b0..1ebaa59e 100644 --- a/examples/resource-user-struct.rs +++ b/examples/resource-user-struct.rs @@ -12,26 +12,28 @@ mod app { use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; - #[resources] - struct Resources { + #[shared] + struct Shared { // A resource - #[init(0)] shared: u32, } // Should not collide with the struct above #[allow(dead_code)] - struct Resources2 { + struct Shared2 { // A resource shared: u32, } + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { rtic::pend(Interrupt::UART0); rtic::pend(Interrupt::UART1); - (init::LateResources {}, init::Monotonics()) + (Shared { shared: 0 }, Local {}, init::Monotonics()) } // `shared` cannot be accessed from this context @@ -39,16 +41,16 @@ mod app { fn idle(_cx: idle::Context) -> ! { debug::exit(debug::EXIT_SUCCESS); - // error: no `resources` field in `idle::Context` - // _cx.resources.shared += 1; + // error: no `shared` field in `idle::Context` + // _cx.shared.shared += 1; loop {} } // `shared` can be accessed from this context - #[task(binds = UART0, resources = [shared])] + #[task(binds = UART0, shared = [shared])] fn uart0(mut cx: uart0::Context) { - let shared = cx.resources.shared.lock(|shared| { + let shared = cx.shared.shared.lock(|shared| { *shared += 1; *shared }); @@ -57,9 +59,9 @@ mod app { } // `shared` can be accessed from this context - #[task(binds = UART1, resources = [shared])] + #[task(binds = UART1, shared = [shared])] fn uart1(mut cx: uart1::Context) { - let shared = cx.resources.shared.lock(|shared| { + let shared = cx.shared.shared.lock(|shared| { *shared += 1; *shared }); diff --git a/examples/resource.rs b/examples/resource.rs index c8c57bf5..2c7dffe3 100644 --- a/examples/resource.rs +++ b/examples/resource.rs @@ -12,19 +12,20 @@ mod app { use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; - #[resources] - struct Resources { - // A resource - #[init(0)] + #[shared] + struct Shared { shared: u32, } + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { rtic::pend(Interrupt::UART0); rtic::pend(Interrupt::UART1); - (init::LateResources {}, init::Monotonics()) + (Shared { shared: 0 }, Local {}, init::Monotonics()) } // `shared` cannot be accessed from this context @@ -32,8 +33,8 @@ mod app { fn idle(_cx: idle::Context) -> ! { debug::exit(debug::EXIT_SUCCESS); - // error: no `resources` field in `idle::Context` - // _cx.resources.shared += 1; + // error: no `shared` field in `idle::Context` + // _cx.shared.shared += 1; loop { cortex_m::asm::nop(); @@ -42,9 +43,9 @@ mod app { // `shared` can be accessed from this context // defaults to priority 1 - #[task(binds = UART0, resources = [shared])] + #[task(binds = UART0, shared = [shared])] fn uart0(mut cx: uart0::Context) { - let shared = cx.resources.shared.lock(|shared| { + let shared = cx.shared.shared.lock(|shared| { *shared += 1; *shared }); @@ -54,9 +55,9 @@ mod app { // `shared` can be accessed from this context // explicitly set to priority 2 - #[task(binds = UART1, resources = [shared], priority = 2)] + #[task(binds = UART1, shared = [shared], priority = 2)] fn uart1(mut cx: uart1::Context) { - let shared = cx.resources.shared.lock(|shared| { + let shared = cx.shared.shared.lock(|shared| { *shared += 1; *shared }); diff --git a/examples/schedule.rs b/examples/schedule.rs index bb5119c2..f62f24a7 100644 --- a/examples/schedule.rs +++ b/examples/schedule.rs @@ -19,8 +19,14 @@ mod app { #[monotonic(binds = SysTick, default = true)] type MyMono = DwtSystick<MONO_HZ>; - #[init()] - fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) { + #[shared] + struct Shared {} + + #[local] + struct Local {} + + #[init] + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { let mut dcb = cx.core.DCB; let dwt = cx.core.DWT; let systick = cx.core.SYST; @@ -35,7 +41,7 @@ mod app { // Schedule `bar` to run 2 seconds in the future bar::spawn_after(Seconds(2_u32)).ok(); - (init::LateResources {}, init::Monotonics(mono)) + (Shared {}, Local {}, init::Monotonics(mono)) } #[task] diff --git a/examples/late.rs b/examples/shared.rs index e65b6e69..c3fa07b9 100644 --- a/examples/late.rs +++ b/examples/shared.rs @@ -17,27 +17,27 @@ mod app { }; use lm3s6965::Interrupt; - // Late resources - #[resources] - struct Resources { + #[shared] + struct Shared { p: Producer<'static, u32, U4>, c: Consumer<'static, u32, U4>, } - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - static mut Q: Queue<u32, U4> = Queue(i::Queue::new()); + #[local] + struct Local {} - let (p, c) = Q.split(); + #[init(local = [q: Queue<u32, U4> = Queue(i::Queue::new())])] + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { + let (p, c) = cx.local.q.split(); - // Initialization of late resources - (init::LateResources { p, c }, init::Monotonics()) + // Initialization of shared resources + (Shared { p, c }, Local {}, init::Monotonics()) } - #[idle(resources = [c])] + #[idle(shared = [c])] fn idle(mut c: idle::Context) -> ! { loop { - if let Some(byte) = c.resources.c.lock(|c| c.dequeue()) { + if let Some(byte) = c.shared.c.lock(|c| c.dequeue()) { hprintln!("received message: {}", byte).unwrap(); debug::exit(debug::EXIT_SUCCESS); @@ -47,8 +47,8 @@ mod app { } } - #[task(binds = UART0, resources = [p])] + #[task(binds = UART0, shared = [p])] fn uart0(mut c: uart0::Context) { - c.resources.p.lock(|p| p.enqueue(42).unwrap()); + c.shared.p.lock(|p| p.enqueue(42).unwrap()); } } diff --git a/examples/smallest.rs b/examples/smallest.rs index b8cbf87e..6afcfbd4 100644 --- a/examples/smallest.rs +++ b/examples/smallest.rs @@ -7,4 +7,15 @@ use panic_semihosting as _; // panic handler use rtic::app; #[app(device = lm3s6965)] -mod app {} +mod app { + #[shared] + struct Shared {} + + #[local] + struct Local {} + + #[init] + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { + (Shared {}, Local {}, init::Monotonics {}) + } +} diff --git a/examples/spawn.rs b/examples/spawn.rs index 987ebf7d..bcb4fb23 100644 --- a/examples/spawn.rs +++ b/examples/spawn.rs @@ -11,11 +11,17 @@ use panic_semihosting as _; mod app { use cortex_m_semihosting::{debug, hprintln}; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_c: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { foo::spawn(1, 2).unwrap(); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics {}) } #[task()] diff --git a/examples/spawn2.rs b/examples/spawn2.rs index be113f79..ff9516a6 100644 --- a/examples/spawn2.rs +++ b/examples/spawn2.rs @@ -11,11 +11,17 @@ use panic_semihosting as _; mod app { use cortex_m_semihosting::{debug, hprintln}; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_c: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { foo::spawn(1, 2).unwrap(); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics {}) } #[task] diff --git a/examples/static.rs b/examples/static.rs index cbbc5399..f51c5f2d 100644 --- a/examples/static.rs +++ b/examples/static.rs @@ -18,27 +18,26 @@ mod app { }; use lm3s6965::Interrupt; - // Late resources - #[resources] - struct Resources { + #[shared] + struct Shared { p: Producer<'static, u32, U4>, c: Consumer<'static, u32, U4>, } - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - static mut Q: Queue<u32, U4> = Queue(i::Queue::new()); + #[local] + struct Local {} - let (p, c) = Q.split(); + #[init(local = [q: Queue<u32, U4> = Queue(i::Queue::new())])] + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { + let (p, c) = cx.local.q.split(); - // Initialization of late resources - (init::LateResources { p, c }, init::Monotonics()) + (Shared { p, c }, Local {}, init::Monotonics()) } - #[idle(resources = [c])] + #[idle(shared = [c])] fn idle(mut c: idle::Context) -> ! { loop { - if let Some(byte) = c.resources.c.lock(|c| c.dequeue()) { + if let Some(byte) = c.shared.c.lock(|c| c.dequeue()) { hprintln!("received message: {}", byte).unwrap(); debug::exit(debug::EXIT_SUCCESS); @@ -48,10 +47,9 @@ mod app { } } - #[task(binds = UART0, resources = [p])] + #[task(binds = UART0, shared = [p], local = [kalle: u32 = 0])] fn uart0(mut c: uart0::Context) { - static mut KALLE: u32 = 0; - *KALLE += 1; - c.resources.p.lock(|p| p.enqueue(42).unwrap()); + *c.local.kalle += 1; + c.shared.p.lock(|p| p.enqueue(42).unwrap()); } } diff --git a/examples/t-binds.rs b/examples/t-binds.rs index fbc89e88..2c405ea0 100644 --- a/examples/t-binds.rs +++ b/examples/t-binds.rs @@ -9,9 +9,15 @@ use panic_semihosting as _; #[rtic::app(device = lm3s6965)] mod app { + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - (init::LateResources {}, init::Monotonics()) + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { + (Shared {}, Local {}, init::Monotonics()) } // Cortex-M exception diff --git a/examples/t-cfg-resources.rs b/examples/t-cfg-resources.rs index 1adcb905..3b06f0e0 100644 --- a/examples/t-cfg-resources.rs +++ b/examples/t-cfg-resources.rs @@ -7,25 +7,24 @@ use panic_semihosting as _; #[rtic::app(device = lm3s6965)] mod app { - #[resources] - struct Resources { - // A resource - #[init(0)] - shared: u32, + #[shared] + struct Shared { // A conditionally compiled resource behind feature_x #[cfg(feature = "feature_x")] x: u32, - dummy: (), // dummy such that we have at least one late resource } + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { ( - init::LateResources { - // The feature needs to be applied everywhere x is defined or used + Shared { #[cfg(feature = "feature_x")] x: 0, - dummy: (), // dummy such that we have at least one late resource }, + Local {}, init::Monotonics(), ) } diff --git a/examples/t-cfg.rs b/examples/t-cfg.rs deleted file mode 100644 index ef591c4d..00000000 --- a/examples/t-cfg.rs +++ /dev/null @@ -1,50 +0,0 @@ -//! [compile-pass] check that `#[cfg]` attributes are respected - -#![no_main] -#![no_std] - -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965, dispatchers = [SSI0, QEI0])] -mod app { - #[resources] - struct Resources { - #[cfg(never)] - #[init(0)] - foo: u32, - } - - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - #[cfg(never)] - static mut BAR: u32 = 0; - - (init::LateResources {}, init::Monotonics()) - } - - #[idle] - fn idle(_: idle::Context) -> ! { - #[cfg(never)] - static mut BAR: u32 = 0; - - loop { - cortex_m::asm::nop(); - } - } - - #[task(resources = [foo])] - fn foo(_: foo::Context) { - #[cfg(never)] - static mut BAR: u32 = 0; - } - - #[task(priority = 3, resources = [foo])] - fn bar(_: bar::Context) { - #[cfg(never)] - static mut BAR: u32 = 0; - } - - #[cfg(never)] - #[task] - fn quux(_: quux::Context) {} -} diff --git a/examples/t-htask-main.rs b/examples/t-htask-main.rs index 2d480d0b..39404322 100644 --- a/examples/t-htask-main.rs +++ b/examples/t-htask-main.rs @@ -9,11 +9,17 @@ use panic_semihosting as _; mod app { use cortex_m_semihosting::debug; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { rtic::pend(lm3s6965::Interrupt::UART0); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } #[task(binds = UART0)] diff --git a/examples/t-idle-main.rs b/examples/t-idle-main.rs index 891896fa..c649a973 100644 --- a/examples/t-idle-main.rs +++ b/examples/t-idle-main.rs @@ -9,9 +9,15 @@ use panic_semihosting as _; mod app { use cortex_m_semihosting::debug; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - (init::LateResources {}, init::Monotonics()) + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { + (Shared {}, Local {}, init::Monotonics()) } #[idle] diff --git a/examples/t-init-main.rs b/examples/t-init-main.rs deleted file mode 100644 index b77a7df8..00000000 --- a/examples/t-init-main.rs +++ /dev/null @@ -1,18 +0,0 @@ -#![deny(unsafe_code)] -#![deny(warnings)] -#![no_main] -#![no_std] - -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965)] -mod app { - use cortex_m_semihosting::debug; - - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - debug::exit(debug::EXIT_SUCCESS); - - (init::LateResources {}, init::Monotonics()) - } -} diff --git a/examples/t-late-not-send.rs b/examples/t-late-not-send.rs index 579f8436..7408a1eb 100644 --- a/examples/t-late-not-send.rs +++ b/examples/t-late-not-send.rs @@ -1,4 +1,4 @@ -//! [compile-pass] late resources don't need to be `Send` if they are owned by `idle` +//! [compile-pass] shared resources don't need to be `Send` if they are owned by `idle` #![no_main] #![no_std] @@ -16,24 +16,28 @@ mod app { use super::NotSend; use core::marker::PhantomData; - #[resources] - struct Resources { + #[shared] + struct Shared { x: NotSend, - #[init(None)] y: Option<NotSend>, } + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { ( - init::LateResources { + Shared { x: NotSend { _0: PhantomData }, + y: None, }, + Local {}, init::Monotonics(), ) } - #[idle(resources = [x, y])] + #[idle(shared = [x, y])] fn idle(_: idle::Context) -> ! { loop { cortex_m::asm::nop(); diff --git a/examples/t-resource.rs b/examples/t-resource.rs deleted file mode 100644 index 6e83069d..00000000 --- a/examples/t-resource.rs +++ /dev/null @@ -1,81 +0,0 @@ -//! [compile-pass] Check code generation of resources - -#![deny(unsafe_code)] -#![deny(warnings)] -#![no_main] -#![no_std] - -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965)] -mod app { - #[resources] - struct Resources { - #[init(0)] - o1: u32, // init - #[init(0)] - o2: u32, // idle - #[init(0)] - o3: u32, // EXTI0 - #[init(0)] - o4: u32, // idle - #[init(0)] - o5: u32, // EXTI1 - #[init(0)] - o6: u32, // init - #[init(0)] - s1: u32, // idle & uart0 - #[init(0)] - s2: u32, // uart0 & uart1 - #[init(0)] - s3: u32, // idle & uart0 - } - - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - (init::LateResources {}, init::Monotonics()) - } - - #[idle(resources = [o2, &o4, s1, &s3])] - fn idle(mut c: idle::Context) -> ! { - // owned by `idle` == `&'static mut` - let _: resources::o2 = c.resources.o2; - - // owned by `idle` == `&'static` if read-only - let _: &u32 = c.resources.o4; - - // shared with `idle` == `Mutex` - c.resources.s1.lock(|_| {}); - - // `&` if read-only - let _: &u32 = c.resources.s3; - - loop { - cortex_m::asm::nop(); - } - } - - #[task(binds = UART0, resources = [o3, s1, s2, &s3])] - fn uart0(c: uart0::Context) { - // owned by interrupt == `&mut` - let _: resources::o3 = c.resources.o3; - - // no `Mutex` proxy when access from highest priority task - let _: resources::s1 = c.resources.s1; - - // no `Mutex` proxy when co-owned by cooperative (same priority) tasks - let _: resources::s2 = c.resources.s2; - - // `&` if read-only - let _: &u32 = c.resources.s3; - } - - #[task(binds = UART1, resources = [s2, &o5])] - fn uart1(c: uart1::Context) { - // owned by interrupt == `&` if read-only - let _: &u32 = c.resources.o5; - - // no `Mutex` proxy when co-owned by cooperative (same priority) tasks - let _: resources::s2 = c.resources.s2; - } -} diff --git a/examples/t-schedule-core-stable.rs b/examples/t-schedule-core-stable.rs deleted file mode 100644 index 98d42ce7..00000000 --- a/examples/t-schedule-core-stable.rs +++ /dev/null @@ -1,21 +0,0 @@ -//! [compile-pass] Check `schedule` code generation - -#![deny(unsafe_code)] -#![deny(warnings)] -#![no_main] -#![no_std] - -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965, dispatchers = [SSI0])] -mod app { - #[init] - fn init(c: init::Context) -> (init::LateResources, init::Monotonics) { - let _c: cortex_m::Peripherals = c.core; - - (init::LateResources {}, init::Monotonics()) - } - - #[task] - fn some_task(_: some_task::Context) {} -} diff --git a/examples/t-schedule.rs b/examples/t-schedule.rs index d7051609..6708c689 100644 --- a/examples/t-schedule.rs +++ b/examples/t-schedule.rs @@ -15,8 +15,14 @@ mod app { #[monotonic(binds = SysTick, default = true)] type MyMono = DwtSystick<8_000_000>; // 8 MHz + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { let mut dcb = cx.core.DCB; let dwt = cx.core.DWT; let systick = cx.core.SYST; @@ -114,7 +120,7 @@ mod app { let handle: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_after(Seconds(1_u32), 0, 1); let _: Result<(u32, u32), ()> = handle.unwrap().cancel(); - (init::LateResources {}, init::Monotonics(mono)) + (Shared {}, Local {}, init::Monotonics(mono)) } #[idle] diff --git a/examples/t-spawn.rs b/examples/t-spawn.rs index ca5c61b2..0f98592e 100644 --- a/examples/t-spawn.rs +++ b/examples/t-spawn.rs @@ -9,13 +9,19 @@ use panic_semihosting as _; #[rtic::app(device = lm3s6965, dispatchers = [SSI0])] mod app { + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { let _: Result<(), ()> = foo::spawn(); let _: Result<(), u32> = bar::spawn(0); let _: Result<(), (u32, u32)> = baz::spawn(0, 1); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } #[idle] diff --git a/examples/t-stask-main.rs b/examples/t-stask-main.rs deleted file mode 100644 index cfc93425..00000000 --- a/examples/t-stask-main.rs +++ /dev/null @@ -1,23 +0,0 @@ -#![deny(unsafe_code)] -#![deny(warnings)] -#![no_main] -#![no_std] - -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965, dispatchers = [SSI0])] -mod app { - use cortex_m_semihosting::debug; - - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - taskmain::spawn().ok(); - - (init::LateResources {}, init::Monotonics()) - } - - #[task] - fn taskmain(_: taskmain::Context) { - debug::exit(debug::EXIT_SUCCESS); - } -} diff --git a/examples/task-local-minimal.rs b/examples/task-local-minimal.rs deleted file mode 100644 index f83493c2..00000000 --- a/examples/task-local-minimal.rs +++ /dev/null @@ -1,34 +0,0 @@ -//! examples/task-local_minimal.rs -#![deny(unsafe_code)] -#![deny(warnings)] -#![no_main] -#![no_std] - -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965)] -mod app { - use cortex_m_semihosting::{debug, hprintln}; - - #[resources] - struct Resources { - // A local (move), late resource - #[task_local] - l: u32, - } - - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - (init::LateResources { l: 42 }, init::Monotonics()) - } - - // l is task_local - #[idle(resources =[l])] - fn idle(cx: idle::Context) -> ! { - hprintln!("IDLE:l = {}", cx.resources.l).unwrap(); - debug::exit(debug::EXIT_SUCCESS); - loop { - cortex_m::asm::nop(); - } - } -} diff --git a/examples/task-local.rs b/examples/task-local.rs deleted file mode 100644 index 3020c3b3..00000000 --- a/examples/task-local.rs +++ /dev/null @@ -1,87 +0,0 @@ -//! examples/task-local.rs - -#![deny(unsafe_code)] -#![deny(warnings)] -#![no_main] -#![no_std] - -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965)] -mod app { - use cortex_m_semihosting::{debug, hprintln}; - use lm3s6965::Interrupt; - - #[resources] - struct Resources { - // An early resource - #[init(0)] - shared: u32, - - // A local (move), early resource - #[task_local] - #[init(1)] - l1: u32, - - // An exclusive, early resource - #[lock_free] - #[init(1)] - e1: u32, - - // A local (move), late resource - #[task_local] - l2: u32, - - // An exclusive, late resource - #[lock_free] - e2: u32, - } - - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - rtic::pend(Interrupt::UART0); - rtic::pend(Interrupt::UART1); - (init::LateResources { e2: 2, l2: 2 }, init::Monotonics()) - } - - // `shared` cannot be accessed from this context - // l1 ok (task_local) - // e2 ok (lock_free) - #[idle(resources =[l1, e2])] - fn idle(cx: idle::Context) -> ! { - hprintln!("IDLE:l1 = {}", cx.resources.l1).unwrap(); - hprintln!("IDLE:e2 = {}", cx.resources.e2).unwrap(); - debug::exit(debug::EXIT_SUCCESS); - loop { - cortex_m::asm::nop(); - } - } - - // `shared` can be accessed from this context - // l2 ok (task_local) - // e1 ok (lock_free) - #[task(priority = 1, binds = UART0, resources = [shared, l2, e1])] - fn uart0(mut cx: uart0::Context) { - let shared = cx.resources.shared.lock(|shared| { - *shared += 1; - *shared - }); - *cx.resources.e1 += 10; - hprintln!("UART0: shared = {}", shared).unwrap(); - hprintln!("UART0:l2 = {}", cx.resources.l2).unwrap(); - hprintln!("UART0:e1 = {}", cx.resources.e1).unwrap(); - } - - // `shared` can be accessed from this context - // e1 ok (lock_free) - #[task(priority = 1, binds = UART1, resources = [shared, e1])] - fn uart1(mut cx: uart1::Context) { - let shared = cx.resources.shared.lock(|shared| { - *shared += 1; - *shared - }); - - hprintln!("UART1: shared = {}", shared).unwrap(); - hprintln!("UART1:e1 = {}", cx.resources.e1).unwrap(); - } -} diff --git a/examples/task.rs b/examples/task.rs index 9d4492f2..bec7b1ab 100644 --- a/examples/task.rs +++ b/examples/task.rs @@ -11,11 +11,17 @@ use panic_semihosting as _; mod app { use cortex_m_semihosting::{debug, hprintln}; + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { foo::spawn().unwrap(); - (init::LateResources {}, init::Monotonics()) + (Shared {}, Local {}, init::Monotonics()) } #[task] diff --git a/examples/task_named_main.rs b/examples/task_named_main.rs deleted file mode 100644 index c2c4e62d..00000000 --- a/examples/task_named_main.rs +++ /dev/null @@ -1,26 +0,0 @@ -//! examples/task_named_main.rs - -#![deny(unsafe_code)] -#![deny(warnings)] -#![no_main] -#![no_std] - -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965, dispatchers = [SSI0])] -mod app { - use cortex_m_semihosting::{debug, hprintln}; - - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - main::spawn().unwrap(); - - (init::LateResources {}, init::Monotonics()) - } - - #[task] - fn main(_: main::Context) { - hprintln!("This task is named main, useful for rust-analyzer").unwrap(); - debug::exit(debug::EXIT_SUCCESS); - } -} diff --git a/examples/type-usage.rs b/examples/type-usage.rs deleted file mode 100644 index 9bb7eb8d..00000000 --- a/examples/type-usage.rs +++ /dev/null @@ -1,15 +0,0 @@ -//! examples/type-usage.rs - -#![no_main] -#![no_std] - -use panic_semihosting as _; // panic handler -use rtic::app; - -#[app(device = lm3s6965, dispatchers = [SSI0])] -mod app { - type Test = u32; - - #[task] - fn t1(_: t1::Context, _val: Test) {} -} diff --git a/examples/types.rs b/examples/types.rs deleted file mode 100644 index cdcf80c2..00000000 --- a/examples/types.rs +++ /dev/null @@ -1,57 +0,0 @@ -//! examples/types.rs - -#![deny(unsafe_code)] -#![deny(warnings)] -#![no_main] -#![no_std] - -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965, peripherals = true, dispatchers = [SSI0])] -mod app { - use cortex_m_semihosting::debug; - use dwt_systick_monotonic::DwtSystick; - - #[monotonic(binds = SysTick, default = true)] - type MyMono = DwtSystick<8_000_000>; // 8 MHz - - #[resources] - struct Resources { - #[init(0)] - shared: u32, - } - - #[init] - fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) { - let _: cortex_m::Peripherals = cx.core; - let _: lm3s6965::Peripherals = cx.device; - - debug::exit(debug::EXIT_SUCCESS); - - let mut dcb = cx.core.DCB; - let dwt = cx.core.DWT; - let systick = cx.core.SYST; - - let mono = DwtSystick::new(&mut dcb, dwt, systick, 8_000_000); - - (init::LateResources {}, init::Monotonics(mono)) - } - - #[idle] - fn idle(_: idle::Context) -> ! { - loop { - cortex_m::asm::nop(); - } - } - - #[task(binds = UART0, resources = [shared])] - fn uart0(cx: uart0::Context) { - let _: resources::shared = cx.resources.shared; - } - - #[task(priority = 2, resources = [shared])] - fn foo(cx: foo::Context) { - let _: resources::shared = cx.resources.shared; - let _: foo::Resources = cx.resources; - } -} diff --git a/macros/Cargo.toml b/macros/Cargo.toml index aa96d09e..56bfd5cd 100644 --- a/macros/Cargo.toml +++ b/macros/Cargo.toml @@ -12,7 +12,7 @@ license = "MIT OR Apache-2.0" name = "cortex-m-rtic-macros" readme = "../README.md" repository = "https://github.com/rtic-rs/cortex-m-rtic" -version = "0.6.0-alpha.4" +version = "0.6.0-alpha.5" [lib] proc-macro = true @@ -22,4 +22,4 @@ proc-macro2 = "1" proc-macro-error = "1" quote = "1" syn = "1" -rtic-syntax = "0.5.0-alpha.3" +rtic-syntax = "0.5.0-alpha.4" diff --git a/macros/src/codegen.rs b/macros/src/codegen.rs index 113d17f9..6920031a 100644 --- a/macros/src/codegen.rs +++ b/macros/src/codegen.rs @@ -9,17 +9,17 @@ mod dispatchers; mod hardware_tasks; mod idle; mod init; -mod locals; +mod local_resources; +mod local_resources_struct; mod module; mod post_init; mod pre_init; -mod resources; -mod resources_struct; +mod shared_resources; +mod shared_resources_struct; mod software_tasks; mod timer_queue; mod util; -// TODO document the syntax here or in `rtic-syntax` pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 { let mut mod_app = vec![]; let mut mains = vec![]; @@ -52,7 +52,7 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 { mod_app.push(quote!( #mod_app_init - #mod_app_idle + #(#mod_app_idle)* )); let main = util::suffixed("main"); @@ -83,7 +83,10 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 { } )); - let (mod_app_resources, mod_resources) = resources::codegen(app, analysis, extra); + let (mod_app_shared_resources, mod_shared_resources) = + shared_resources::codegen(app, analysis, extra); + let (mod_app_local_resources, mod_local_resources) = + local_resources::codegen(app, analysis, extra); let (mod_app_hardware_tasks, root_hardware_tasks, user_hardware_tasks) = hardware_tasks::codegen(app, analysis, extra); @@ -185,7 +188,9 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 { #(#root)* - #mod_resources + #mod_shared_resources + + #mod_local_resources #(#root_hardware_tasks)* @@ -194,7 +199,9 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 { /// app module #(#mod_app)* - #(#mod_app_resources)* + #(#mod_app_shared_resources)* + + #(#mod_app_local_resources)* #(#mod_app_hardware_tasks)* diff --git a/macros/src/codegen/dispatchers.rs b/macros/src/codegen/dispatchers.rs index 65a3f5f6..ac550036 100644 --- a/macros/src/codegen/dispatchers.rs +++ b/macros/src/codegen/dispatchers.rs @@ -76,12 +76,6 @@ pub fn codegen(app: &App, analysis: &Analysis, _extra: &Extra) -> Vec<TokenStrea let inputs = util::mark_internal_ident(&inputs); let (_, tupled, pats, _) = util::regroup_inputs(&task.inputs); - let locals_new = if task.locals.is_empty() { - quote!() - } else { - quote!(#name::Locals::new(),) - }; - quote!( #(#cfgs)* #t::#name => { @@ -94,7 +88,6 @@ pub fn codegen(app: &App, analysis: &Analysis, _extra: &Extra) -> Vec<TokenStrea #fq.get_mut_unchecked().split().0.enqueue_unchecked(index); let priority = &rtic::export::Priority::new(PRIORITY); #name( - #locals_new #name::Context::new(priority) #(,#pats)* ) diff --git a/macros/src/codegen/hardware_tasks.rs b/macros/src/codegen/hardware_tasks.rs index 003660c7..e6192e2c 100644 --- a/macros/src/codegen/hardware_tasks.rs +++ b/macros/src/codegen/hardware_tasks.rs @@ -5,7 +5,7 @@ use rtic_syntax::{ast::App, Context}; use crate::{ analyze::Analysis, check::Extra, - codegen::{locals, module, resources_struct}, + codegen::{local_resources_struct, module, shared_resources_struct}, }; /// Generate support code for hardware tasks (`#[exception]`s and `#[interrupt]`s) @@ -29,12 +29,6 @@ pub fn codegen( let mut user_tasks = vec![]; for (name, task) in &app.hardware_tasks { - let locals_new = if task.locals.is_empty() { - quote!() - } else { - quote!(#name::Locals::new(),) - }; - let symbol = task.args.binds.clone(); let priority = task.args.priority; let cfgs = &task.cfgs; @@ -50,19 +44,35 @@ pub fn codegen( rtic::export::run(PRIORITY, || { #name( - #locals_new #name::Context::new(&rtic::export::Priority::new(PRIORITY)) ) }); } )); - let mut needs_lt = false; + let mut shared_needs_lt = false; + let mut local_needs_lt = false; + + // `${task}Locals` + if !task.args.local_resources.is_empty() { + let (item, constructor) = local_resources_struct::codegen( + Context::HardwareTask(name), + &mut local_needs_lt, + app, + ); + + root.push(item); + + mod_app.push(constructor); + } // `${task}Resources` - if !task.args.resources.is_empty() { - let (item, constructor) = - resources_struct::codegen(Context::HardwareTask(name), &mut needs_lt, app); + if !task.args.shared_resources.is_empty() { + let (item, constructor) = shared_resources_struct::codegen( + Context::HardwareTask(name), + &mut shared_needs_lt, + app, + ); root.push(item); @@ -71,30 +81,21 @@ pub fn codegen( root.push(module::codegen( Context::HardwareTask(name), - needs_lt, + shared_needs_lt, + local_needs_lt, app, analysis, extra, )); - // `${task}Locals` - let mut locals_pat = None; - if !task.locals.is_empty() { - let (struct_, pat) = locals::codegen(Context::HardwareTask(name), &task.locals, app); - - root.push(struct_); - locals_pat = Some(pat); - } - - if !&task.is_extern { + if !task.is_extern { let attrs = &task.attrs; let context = &task.context; let stmts = &task.stmts; - let locals_pat = locals_pat.iter(); user_tasks.push(quote!( #(#attrs)* #[allow(non_snake_case)] - fn #name(#(#locals_pat,)* #context: #name::Context) { + fn #name(#context: #name::Context) { use rtic::Mutex as _; use rtic::mutex_prelude::*; diff --git a/macros/src/codegen/idle.rs b/macros/src/codegen/idle.rs index 4bc41c13..d6539316 100644 --- a/macros/src/codegen/idle.rs +++ b/macros/src/codegen/idle.rs @@ -5,7 +5,7 @@ use rtic_syntax::{ast::App, Context}; use crate::{ analyze::Analysis, check::Extra, - codegen::{locals, module, resources_struct}, + codegen::{local_resources_struct, module, shared_resources_struct}, }; /// Generates support code for `#[idle]` functions @@ -15,7 +15,7 @@ pub fn codegen( extra: &Extra, ) -> ( // mod_app_idle -- the `${idle}Resources` constructor - Option<TokenStream2>, + Vec<TokenStream2>, // root_idle -- items that must be placed in the root of the crate: // - the `${idle}Locals` struct // - the `${idle}Resources` struct @@ -26,34 +26,35 @@ pub fn codegen( // call_idle TokenStream2, ) { - if !app.idles.is_empty() { - let idle = &app.idles.first().unwrap(); - let mut needs_lt = false; - let mut mod_app = None; + if let Some(idle) = &app.idle { + let mut shared_needs_lt = false; + let mut local_needs_lt = false; + let mut mod_app = vec![]; let mut root_idle = vec![]; - let mut locals_pat = None; - let mut locals_new = None; let name = &idle.name; - if !idle.args.resources.is_empty() { - let (item, constructor) = resources_struct::codegen(Context::Idle, &mut needs_lt, app); + if !idle.args.shared_resources.is_empty() { + let (item, constructor) = + shared_resources_struct::codegen(Context::Idle, &mut shared_needs_lt, app); root_idle.push(item); - mod_app = Some(constructor); + mod_app.push(constructor); } - if !idle.locals.is_empty() { - let (locals, pat) = locals::codegen(Context::Idle, &idle.locals, app); + if !idle.args.local_resources.is_empty() { + let (item, constructor) = + local_resources_struct::codegen(Context::Idle, &mut local_needs_lt, app); + + root_idle.push(item); - locals_new = Some(quote!(#name::Locals::new())); - locals_pat = Some(pat); - root_idle.push(locals); + mod_app.push(constructor); } root_idle.push(module::codegen( Context::Idle, - needs_lt, + shared_needs_lt, + local_needs_lt, app, analysis, extra, @@ -62,11 +63,10 @@ pub fn codegen( let attrs = &idle.attrs; let context = &idle.context; let stmts = &idle.stmts; - let locals_pat = locals_pat.iter(); let user_idle = Some(quote!( #(#attrs)* #[allow(non_snake_case)] - fn #name(#(#locals_pat,)* #context: #name::Context) -> ! { + fn #name(#context: #name::Context) -> ! { use rtic::Mutex as _; use rtic::mutex_prelude::*; @@ -74,16 +74,14 @@ pub fn codegen( } )); - let locals_new = locals_new.iter(); let call_idle = quote!(#name( - #(#locals_new,)* #name::Context::new(&rtic::export::Priority::new(0)) )); (mod_app, root_idle, user_idle, call_idle) } else { ( - None, + vec![], vec![], None, quote!(loop { diff --git a/macros/src/codegen/init.rs b/macros/src/codegen/init.rs index fe8a1263..b6d3f72e 100644 --- a/macros/src/codegen/init.rs +++ b/macros/src/codegen/init.rs @@ -5,7 +5,7 @@ use rtic_syntax::{ast::App, Context}; use crate::{ analyze::Analysis, check::Extra, - codegen::{locals, module, resources_struct}, + codegen::{local_resources_struct, module}, }; type CodegenResult = ( @@ -18,68 +18,96 @@ type CodegenResult = ( // - the `${init}` module, which contains types like `${init}::Context` Vec<TokenStream2>, // user_init -- the `#[init]` function written by the user - Option<TokenStream2>, - // call_init -- the call to the user `#[init]` if there's one - Option<TokenStream2>, + TokenStream2, + // call_init -- the call to the user `#[init]` + TokenStream2, ); /// Generates support code for `#[init]` functions pub fn codegen(app: &App, analysis: &Analysis, extra: &Extra) -> CodegenResult { - if !app.inits.is_empty() { - let init = &app.inits.first().unwrap(); - let mut needs_lt = false; - let name = &init.name; + let init = &app.init; + let mut local_needs_lt = false; + let name = &init.name; - let mut root_init = vec![]; + let mut root_init = vec![]; - let mut locals_pat = None; - let mut locals_new = None; - if !init.locals.is_empty() { - let (struct_, pat) = locals::codegen(Context::Init, &init.locals, app); + let context = &init.context; + let attrs = &init.attrs; + let stmts = &init.stmts; + let shared = &init.user_shared_struct; + let local = &init.user_local_struct; - locals_new = Some(quote!(#name::Locals::new())); - locals_pat = Some(pat); - root_init.push(struct_); + let shared_resources: Vec<_> = app + .shared_resources + .iter() + .map(|(k, v)| { + let ty = &v.ty; + let cfgs = &v.cfgs; + quote!( + #(#cfgs)* + #k: #ty, + ) + }) + .collect(); + let local_resources: Vec<_> = app + .local_resources + .iter() + .map(|(k, v)| { + let ty = &v.ty; + let cfgs = &v.cfgs; + quote!( + #(#cfgs)* + #k: #ty, + ) + }) + .collect(); + root_init.push(quote! { + struct #shared { + #(#shared_resources)* } - let context = &init.context; - let attrs = &init.attrs; - let stmts = &init.stmts; - let locals_pat = locals_pat.iter(); - - let user_init_return = quote! {#name::LateResources, #name::Monotonics}; + struct #local { + #(#local_resources)* + } + }); - let user_init = Some(quote!( - #(#attrs)* - #[allow(non_snake_case)] - fn #name(#(#locals_pat,)* #context: #name::Context) -> (#user_init_return) { - #(#stmts)* - } - )); + // let locals_pat = locals_pat.iter(); - let mut mod_app = None; - if !init.args.resources.is_empty() { - let (item, constructor) = resources_struct::codegen(Context::Init, &mut needs_lt, app); + let user_init_return = quote! {#shared, #local, #name::Monotonics}; - root_init.push(item); - mod_app = Some(constructor); + let user_init = quote!( + #(#attrs)* + #[allow(non_snake_case)] + fn #name(#context: #name::Context) -> (#user_init_return) { + #(#stmts)* } + ); + + let mut mod_app = None; - let locals_new = locals_new.iter(); - let call_init = Some( - quote!(let (late, mut monotonics) = #name(#(#locals_new,)* #name::Context::new(core.into()));), - ); - - root_init.push(module::codegen( - Context::Init, - needs_lt, - app, - analysis, - extra, - )); - - (mod_app, root_init, user_init, call_init) - } else { - (None, vec![], None, None) + // `${task}Locals` + if !init.args.local_resources.is_empty() { + let (item, constructor) = + local_resources_struct::codegen(Context::Init, &mut local_needs_lt, app); + + root_init.push(item); + + mod_app = Some(constructor); } + + // let locals_new = locals_new.iter(); + let call_init = quote! { + let (shared_resources, local_resources, mut monotonics) = #name(#name::Context::new(core.into())); + }; + + root_init.push(module::codegen( + Context::Init, + false, + local_needs_lt, + app, + analysis, + extra, + )); + + (mod_app, root_init, user_init, call_init) } diff --git a/macros/src/codegen/local_resources.rs b/macros/src/codegen/local_resources.rs new file mode 100644 index 00000000..a9ffa925 --- /dev/null +++ b/macros/src/codegen/local_resources.rs @@ -0,0 +1,71 @@ +use proc_macro2::TokenStream as TokenStream2; +use quote::quote; +use rtic_syntax::ast::App; + +use crate::{analyze::Analysis, check::Extra, codegen::util}; + +/// Generates `local` variables and local resource proxies +/// +/// I.e. the `static` variables and theirs proxies. +pub fn codegen( + app: &App, + _analysis: &Analysis, + _extra: &Extra, +) -> ( + // mod_app -- the `static` variables behind the proxies + Vec<TokenStream2>, + // mod_resources -- the `resources` module + TokenStream2, +) { + let mut mod_app = vec![]; + // let mut mod_resources: _ = vec![]; + + // All local resources declared in the `#[local]' struct + for (name, res) in &app.local_resources { + let cfgs = &res.cfgs; + let ty = &res.ty; + let mangled_name = util::mark_internal_ident(&util::static_local_resource_ident(name)); + + let attrs = &res.attrs; + // late resources in `util::link_section_uninit` + let section = util::link_section_uninit(); + + // For future use + // let doc = format!(" RTIC internal: {}:{}", file!(), line!()); + mod_app.push(quote!( + #[allow(non_upper_case_globals)] + // #[doc = #doc] + #[doc(hidden)] + #(#attrs)* + #(#cfgs)* + #section + static #mangled_name: rtic::RacyCell<core::mem::MaybeUninit<#ty>> = rtic::RacyCell::new(core::mem::MaybeUninit::uninit()); + )); + } + + // All declared `local = [NAME: TY = EXPR]` local resources + for (task_name, resource_name, task_local) in app.declared_local_resources() { + let cfgs = &task_local.cfgs; + let ty = &task_local.ty; + let expr = &task_local.expr; + let attrs = &task_local.attrs; + + let mangled_name = util::mark_internal_ident(&util::declared_static_local_resource_ident( + resource_name, + &task_name, + )); + + // For future use + // let doc = format!(" RTIC internal: {}:{}", file!(), line!()); + mod_app.push(quote!( + #[allow(non_upper_case_globals)] + // #[doc = #doc] + #[doc(hidden)] + #(#attrs)* + #(#cfgs)* + static #mangled_name: rtic::RacyCell<#ty> = rtic::RacyCell::new(#expr); + )); + } + + (mod_app, TokenStream2::new()) +} diff --git a/macros/src/codegen/local_resources_struct.rs b/macros/src/codegen/local_resources_struct.rs new file mode 100644 index 00000000..4bd9e2a4 --- /dev/null +++ b/macros/src/codegen/local_resources_struct.rs @@ -0,0 +1,110 @@ +use proc_macro2::TokenStream as TokenStream2; +use quote::quote; +use rtic_syntax::{ + ast::{App, TaskLocal}, + Context, +}; + +use crate::codegen::util; + +/// Generates local resources structs +pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2, TokenStream2) { + let mut lt = None; + + let resources = match ctxt { + Context::Init => &app.init.args.local_resources, + Context::Idle => &app.idle.as_ref().unwrap().args.local_resources, + Context::HardwareTask(name) => &app.hardware_tasks[name].args.local_resources, + Context::SoftwareTask(name) => &app.software_tasks[name].args.local_resources, + }; + + let task_name = util::get_task_name(ctxt, app); + + let mut fields = vec![]; + let mut values = vec![]; + let mut has_cfgs = false; + + for (name, task_local) in resources { + let (cfgs, ty, is_declared) = match task_local { + TaskLocal::External => { + let r = app.local_resources.get(name).expect("UNREACHABLE"); + (&r.cfgs, &r.ty, false) + } + TaskLocal::Declared(r) => (&r.cfgs, &r.ty, true), + _ => unreachable!(), + }; + + has_cfgs |= !cfgs.is_empty(); + + let lt = if ctxt.runs_once() { + quote!('static) + } else { + lt = Some(quote!('a)); + quote!('a) + }; + + let mangled_name = if matches!(task_local, TaskLocal::External) { + util::mark_internal_ident(&util::static_local_resource_ident(name)) + } else { + util::mark_internal_ident(&util::declared_static_local_resource_ident( + name, &task_name, + )) + }; + + fields.push(quote!( + #(#cfgs)* + pub #name: &#lt mut #ty + )); + + let expr = if is_declared { + // If the local resources is already initialized, we only need to access its value and + // not go through an `MaybeUninit` + quote!(#mangled_name.get_mut_unchecked()) + } else { + quote!(&mut *#mangled_name.get_mut_unchecked().as_mut_ptr()) + }; + + values.push(quote!( + #(#cfgs)* + #name: #expr + )); + } + + if lt.is_some() { + *needs_lt = true; + + // The struct could end up empty due to `cfg`s leading to an error due to `'a` being unused + if has_cfgs { + fields.push(quote!( + #[doc(hidden)] + pub __marker__: core::marker::PhantomData<&'a ()> + )); + + values.push(quote!(__marker__: core::marker::PhantomData)) + } + } + + let doc = format!("Local resources `{}` has access to", ctxt.ident(app)); + let ident = util::local_resources_ident(ctxt, app); + let ident = util::mark_internal_ident(&ident); + let item = quote!( + #[allow(non_snake_case)] + #[doc = #doc] + pub struct #ident<#lt> { + #(#fields,)* + } + ); + + let constructor = quote!( + impl<#lt> #ident<#lt> { + #[inline(always)] + pub unsafe fn new() -> Self { + #ident { + #(#values,)* + } + } + } + ); + + (item, constructor) +} diff --git a/macros/src/codegen/locals.rs b/macros/src/codegen/locals.rs deleted file mode 100644 index 0fb8c6d2..00000000 --- a/macros/src/codegen/locals.rs +++ /dev/null @@ -1,95 +0,0 @@ -use proc_macro2::TokenStream as TokenStream2; -use quote::quote; -use rtic_syntax::{ - ast::{App, Local}, - Context, Map, -}; - -use crate::codegen::util; - -pub fn codegen( - ctxt: Context, - locals: &Map<Local>, - app: &App, -) -> ( - // locals - TokenStream2, - // pat - TokenStream2, -) { - assert!(!locals.is_empty()); - - let runs_once = ctxt.runs_once(); - let ident = util::locals_ident(ctxt, app); - - let mut lt = None; - let mut fields = vec![]; - let mut items = vec![]; - let mut names = vec![]; - let mut values = vec![]; - let mut pats = vec![]; - let mut has_cfgs = false; - - for (name, local) in locals { - let lt = if runs_once { - quote!('static) - } else { - lt = Some(quote!('a)); - quote!('a) - }; - - let cfgs = &local.cfgs; - has_cfgs |= !cfgs.is_empty(); - - let expr = &local.expr; - let ty = &local.ty; - fields.push(quote!( - #(#cfgs)* - #name: &#lt mut #ty - )); - items.push(quote!( - #(#cfgs)* - #[doc(hidden)] - static #name: rtic::RacyCell<#ty> = rtic::RacyCell::new(#expr) - )); - values.push(quote!( - #(#cfgs)* - #name: #name.get_mut_unchecked() - )); - names.push(name); - pats.push(quote!( - #(#cfgs)* - #name - )); - } - - if lt.is_some() && has_cfgs { - fields.push(quote!(__marker__: core::marker::PhantomData<&'a ()>)); - values.push(quote!(__marker__: core::marker::PhantomData)); - } - - let locals = quote!( - #[allow(non_snake_case)] - #[doc(hidden)] - pub struct #ident<#lt> { - #(#fields),* - } - - impl<#lt> #ident<#lt> { - #[inline(always)] - unsafe fn new() -> Self { - #(#items;)* - - #ident { - #(#values),* - } - } - } - ); - - let ident = ctxt.ident(app); - ( - locals, - quote!(#ident::Locals { #(#pats,)* .. }: #ident::Locals), - ) -} diff --git a/macros/src/codegen/module.rs b/macros/src/codegen/module.rs index a3d3fab2..a59d6628 100644 --- a/macros/src/codegen/module.rs +++ b/macros/src/codegen/module.rs @@ -5,7 +5,8 @@ use rtic_syntax::{ast::App, Context}; pub fn codegen( ctxt: Context, - resources_tick: bool, + shared_resources_tick: bool, + local_resources_tick: bool, app: &App, analysis: &Analysis, extra: &Extra, @@ -56,18 +57,41 @@ pub fn codegen( Context::SoftwareTask(_) => {} } - if ctxt.has_locals(app) { - let ident = util::locals_ident(ctxt, app); + // if ctxt.has_locals(app) { + // let ident = util::locals_ident(ctxt, app); + // module_items.push(quote!( + // #[doc(inline)] + // pub use super::#ident as Locals; + // )); + // } + + if ctxt.has_local_resources(app) { + let ident = util::local_resources_ident(ctxt, app); + let ident = util::mark_internal_ident(&ident); + let lt = if local_resources_tick { + lt = Some(quote!('a)); + Some(quote!('a)) + } else { + None + }; + module_items.push(quote!( #[doc(inline)] - pub use super::#ident as Locals; + pub use super::#ident as LocalResources; + )); + + fields.push(quote!( + /// Local Resources this task has access to + pub local: #name::LocalResources<#lt> )); + + values.push(quote!(local: #name::LocalResources::new())); } - if ctxt.has_resources(app) { - let ident = util::resources_ident(ctxt, app); + if ctxt.has_shared_resources(app) { + let ident = util::shared_resources_ident(ctxt, app); let ident = util::mark_internal_ident(&ident); - let lt = if resources_tick { + let lt = if shared_resources_tick { lt = Some(quote!('a)); Some(quote!('a)) } else { @@ -76,12 +100,12 @@ pub fn codegen( module_items.push(quote!( #[doc(inline)] - pub use super::#ident as Resources; + pub use super::#ident as SharedResources; )); fields.push(quote!( - /// Resources this task has access to - pub resources: #name::Resources<#lt> + /// Shared Resources this task has access to + pub shared: #name::SharedResources<#lt> )); let priority = if ctxt.is_init() { @@ -89,38 +113,10 @@ pub fn codegen( } else { Some(quote!(priority)) }; - values.push(quote!(resources: #name::Resources::new(#priority))); + values.push(quote!(shared: #name::SharedResources::new(#priority))); } if let Context::Init = ctxt { - let late_fields = analysis - .late_resources - .iter() - .flat_map(|resources| { - resources.iter().map(|name| { - let ty = &app.late_resources[name].ty; - let cfgs = &app.late_resources[name].cfgs; - - quote!( - #(#cfgs)* - pub #name: #ty - ) - }) - }) - .collect::<Vec<_>>(); - - let internal_late_ident = util::mark_internal_name("LateResources"); - items.push(quote!( - /// Resources initialized at runtime - #[allow(non_snake_case)] - pub struct #internal_late_ident { - #(#late_fields),* - } - )); - module_items.push(quote!( - pub use super::#internal_late_ident as LateResources; - )); - let monotonic_types: Vec<_> = app .monotonics .iter() @@ -202,9 +198,6 @@ pub fn codegen( pub use super::#internal_context_name as Context; )); - // not sure if this is the right way, maybe its backwards, - // that spawn_module should put in in root - if let Context::SoftwareTask(..) = ctxt { let spawnee = &app.software_tasks[name]; let priority = spawnee.args.priority; diff --git a/macros/src/codegen/post_init.rs b/macros/src/codegen/post_init.rs index 78548bcd..161068d2 100644 --- a/macros/src/codegen/post_init.rs +++ b/macros/src/codegen/post_init.rs @@ -9,24 +9,39 @@ use crate::{analyze::Analysis, codegen::util}; pub fn codegen(app: &App, analysis: &Analysis) -> Vec<TokenStream2> { let mut stmts = vec![]; - // Initialize late resources - if !analysis.late_resources.is_empty() { - // BTreeSet wrapped in a vector - for name in analysis.late_resources.first().unwrap() { - let mangled_name = util::mark_internal_ident(&name); - // If it's live - let cfgs = app.late_resources[name].cfgs.clone(); - if analysis.locations.get(name).is_some() { - stmts.push(quote!( - // We include the cfgs - #(#cfgs)* - // Late resource is a RacyCell<MaybeUninit<T>> - // - `get_mut_unchecked` to obtain `MaybeUninit<T>` - // - `as_mut_ptr` to obtain a raw pointer to `MaybeUninit<T>` - // - `write` the defined value for the late resource T - #mangled_name.get_mut_unchecked().as_mut_ptr().write(late.#name); - )); - } + // Initialize shared resources + for (name, res) in &app.shared_resources { + let mangled_name = util::mark_internal_ident(&util::static_shared_resource_ident(name)); + // If it's live + let cfgs = res.cfgs.clone(); + if analysis.shared_resource_locations.get(name).is_some() { + stmts.push(quote!( + // We include the cfgs + #(#cfgs)* + // Resource is a RacyCell<MaybeUninit<T>> + // - `get_mut_unchecked` to obtain `MaybeUninit<T>` + // - `as_mut_ptr` to obtain a raw pointer to `MaybeUninit<T>` + // - `write` the defined value for the late resource T + #mangled_name.get_mut_unchecked().as_mut_ptr().write(shared_resources.#name); + )); + } + } + + // Initialize local resources + for (name, res) in &app.local_resources { + let mangled_name = util::mark_internal_ident(&util::static_local_resource_ident(name)); + // If it's live + let cfgs = res.cfgs.clone(); + if analysis.local_resource_locations.get(name).is_some() { + stmts.push(quote!( + // We include the cfgs + #(#cfgs)* + // Resource is a RacyCell<MaybeUninit<T>> + // - `get_mut_unchecked` to obtain `MaybeUninit<T>` + // - `as_mut_ptr` to obtain a raw pointer to `MaybeUninit<T>` + // - `write` the defined value for the late resource T + #mangled_name.get_mut_unchecked().as_mut_ptr().write(local_resources.#name); + )); } } diff --git a/macros/src/codegen/pre_init.rs b/macros/src/codegen/pre_init.rs index 531debac..ae628f6e 100644 --- a/macros/src/codegen/pre_init.rs +++ b/macros/src/codegen/pre_init.rs @@ -126,7 +126,7 @@ pub fn codegen(app: &App, analysis: &Analysis, extra: &Extra) -> Vec<TokenStream } // If there's no user `#[idle]` then optimize returning from interrupt handlers - if app.idles.is_empty() { + if app.idle.is_none() { // Set SLEEPONEXIT bit to enter sleep mode when returning from ISR stmts.push(quote!(core.SCB.scr.modify(|r| r | 1 << 1);)); } diff --git a/macros/src/codegen/resources.rs b/macros/src/codegen/resources.rs deleted file mode 100644 index a623ea60..00000000 --- a/macros/src/codegen/resources.rs +++ /dev/null @@ -1,152 +0,0 @@ -use proc_macro2::TokenStream as TokenStream2; -use quote::quote; -use rtic_syntax::{analyze::Ownership, ast::App}; - -use crate::{analyze::Analysis, check::Extra, codegen::util}; - -/// Generates `static` variables and resource proxies -/// Early resources are stored in `RacyCell<T>` -/// Late resource are stored in `RacyCell<MaybeUninit<T>>` -/// -/// Safety: -/// - RacyCell<T> access is `unsafe`. -/// - RacyCell<MaybeUninit> is always written to before user access, thus -// the generated code for user access can safely `assume_init`. -pub fn codegen( - app: &App, - analysis: &Analysis, - extra: &Extra, -) -> ( - // mod_app -- the `static` variables behind the proxies - Vec<TokenStream2>, - // mod_resources -- the `resources` module - TokenStream2, -) { - let mut mod_app = vec![]; - let mut mod_resources = vec![]; - - for (name, res, expr, _) in app.resources(analysis) { - let cfgs = &res.cfgs; - let ty = &res.ty; - let mangled_name = util::mark_internal_ident(&name); - - { - // late resources in `util::link_section_uninit` - let section = if expr.is_none() { - util::link_section_uninit(true) - } else { - None - }; - - // resource type and assigned value - let (ty, expr) = if let Some(expr) = expr { - // early resource - ( - quote!(rtic::RacyCell<#ty>), - quote!(rtic::RacyCell::new(#expr)), - ) - } else { - // late resource - ( - quote!(rtic::RacyCell<core::mem::MaybeUninit<#ty>>), - quote!(rtic::RacyCell::new(core::mem::MaybeUninit::uninit())), - ) - }; - - let attrs = &res.attrs; - - // For future use - // let doc = format!(" RTIC internal: {}:{}", file!(), line!()); - mod_app.push(quote!( - #[allow(non_upper_case_globals)] - // #[doc = #doc] - #[doc(hidden)] - #(#attrs)* - #(#cfgs)* - #section - static #mangled_name: #ty = #expr; - )); - } - - let r_prop = &res.properties; - // For future use - // let doc = format!(" RTIC internal: {}:{}", file!(), line!()); - - if !r_prop.task_local && !r_prop.lock_free { - mod_resources.push(quote!( - // #[doc = #doc] - #[doc(hidden)] - #[allow(non_camel_case_types)] - #(#cfgs)* - pub struct #name<'a> { - priority: &'a Priority, - } - - #(#cfgs)* - impl<'a> #name<'a> { - #[inline(always)] - pub unsafe fn new(priority: &'a Priority) -> Self { - #name { priority } - } - - #[inline(always)] - pub unsafe fn priority(&self) -> &Priority { - self.priority - } - } - )); - - let (ptr, _doc) = if expr.is_none() { - // late resource - ( - quote!( - #(#cfgs)* - #mangled_name.get_mut_unchecked().as_mut_ptr() - ), - "late", - ) - } else { - // early resource - ( - quote!( - #(#cfgs)* - #mangled_name.get_mut_unchecked() - ), - "early", - ) - }; - - let ceiling = match analysis.ownerships.get(name) { - Some(Ownership::Owned { priority }) => *priority, - Some(Ownership::CoOwned { priority }) => *priority, - Some(Ownership::Contended { ceiling }) => *ceiling, - None => 0, - }; - - // For future use - // let doc = format!(" RTIC internal ({} resource): {}:{}", doc, file!(), line!()); - - mod_app.push(util::impl_mutex( - extra, - cfgs, - true, - name, - quote!(#ty), - ceiling, - ptr, - )); - } - } - - let mod_resources = if mod_resources.is_empty() { - quote!() - } else { - quote!(mod resources { - use rtic::export::Priority; - - #(#mod_resources)* - }) - }; - - (mod_app, mod_resources) -} diff --git a/macros/src/codegen/shared_resources.rs b/macros/src/codegen/shared_resources.rs new file mode 100644 index 00000000..181832fd --- /dev/null +++ b/macros/src/codegen/shared_resources.rs @@ -0,0 +1,107 @@ +use proc_macro2::TokenStream as TokenStream2; +use quote::quote; +use rtic_syntax::{analyze::Ownership, ast::App}; + +use crate::{analyze::Analysis, check::Extra, codegen::util}; + +/// Generates `static` variables and shared resource proxies +pub fn codegen( + app: &App, + analysis: &Analysis, + extra: &Extra, +) -> ( + // mod_app -- the `static` variables behind the proxies + Vec<TokenStream2>, + // mod_resources -- the `resources` module + TokenStream2, +) { + let mut mod_app = vec![]; + let mut mod_resources = vec![]; + + for (name, res) in &app.shared_resources { + let cfgs = &res.cfgs; + let ty = &res.ty; + let mangled_name = util::mark_internal_ident(&util::static_shared_resource_ident(&name)); + + // late resources in `util::link_section_uninit` + let section = util::link_section_uninit(); + let attrs = &res.attrs; + + // For future use + // let doc = format!(" RTIC internal: {}:{}", file!(), line!()); + mod_app.push(quote!( + #[allow(non_upper_case_globals)] + // #[doc = #doc] + #[doc(hidden)] + #(#attrs)* + #(#cfgs)* + #section + static #mangled_name: rtic::RacyCell<core::mem::MaybeUninit<#ty>> = rtic::RacyCell::new(core::mem::MaybeUninit::uninit()); + )); + + // For future use + // let doc = format!(" RTIC internal: {}:{}", file!(), line!()); + + if !res.properties.lock_free { + mod_resources.push(quote!( + // #[doc = #doc] + #[doc(hidden)] + #[allow(non_camel_case_types)] + #(#cfgs)* + pub struct #name<'a> { + priority: &'a Priority, + } + + #(#cfgs)* + impl<'a> #name<'a> { + #[inline(always)] + pub unsafe fn new(priority: &'a Priority) -> Self { + #name { priority } + } + + #[inline(always)] + pub unsafe fn priority(&self) -> &Priority { + self.priority + } + } + )); + + let ptr = quote!( + #(#cfgs)* + #mangled_name.get_mut_unchecked().as_mut_ptr() + ); + + let ceiling = match analysis.ownerships.get(name) { + Some(Ownership::Owned { priority }) => *priority, + Some(Ownership::CoOwned { priority }) => *priority, + Some(Ownership::Contended { ceiling }) => *ceiling, + None => 0, + }; + + // For future use + // let doc = format!(" RTIC internal ({} resource): {}:{}", doc, file!(), line!()); + + mod_app.push(util::impl_mutex( + extra, + cfgs, + true, + &name, + quote!(#ty), + ceiling, + ptr, + )); + } + } + + let mod_resources = if mod_resources.is_empty() { + quote!() + } else { + quote!(mod shared_resources { + use rtic::export::Priority; + + #(#mod_resources)* + }) + }; + + (mod_app, mod_resources) +} diff --git a/macros/src/codegen/resources_struct.rs b/macros/src/codegen/shared_resources_struct.rs index 6fe4678a..301bef73 100644 --- a/macros/src/codegen/resources_struct.rs +++ b/macros/src/codegen/shared_resources_struct.rs @@ -4,14 +4,15 @@ use rtic_syntax::{ast::App, Context}; use crate::codegen::util; +/// Generate shared resources structs pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2, TokenStream2) { let mut lt = None; let resources = match ctxt { - Context::Init => &app.inits.first().unwrap().args.resources, - Context::Idle => &app.idles.first().unwrap().args.resources, - Context::HardwareTask(name) => &app.hardware_tasks[name].args.resources, - Context::SoftwareTask(name) => &app.software_tasks[name].args.resources, + Context::Init => unreachable!("Tried to generate shared resources struct for init"), + Context::Idle => &app.idle.as_ref().unwrap().args.shared_resources, + Context::HardwareTask(name) => &app.hardware_tasks[name].args.shared_resources, + Context::SoftwareTask(name) => &app.software_tasks[name].args.shared_resources, }; let mut fields = vec![]; @@ -19,7 +20,7 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2, let mut has_cfgs = false; for (name, access) in resources { - let (res, expr) = app.resource(name).expect("UNREACHABLE"); + let res = app.shared_resources.get(name).expect("UNREACHABLE"); let cfgs = &res.cfgs; has_cfgs |= !cfgs.is_empty(); @@ -31,12 +32,9 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2, None }; let ty = &res.ty; - let mangled_name = util::mark_internal_ident(&name); + let mangled_name = util::mark_internal_ident(&util::static_shared_resource_ident(&name)); - // let ownership = &analysis.ownerships[name]; - let r_prop = &res.properties; - - if !r_prop.task_local && !r_prop.lock_free { + if !res.properties.lock_free { if access.is_shared() { lt = Some(quote!('a)); @@ -50,12 +48,12 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2, fields.push(quote!( #(#cfgs)* - pub #name: resources::#name<'a> + pub #name: shared_resources::#name<'a> )); values.push(quote!( #(#cfgs)* - #name: resources::#name::new(priority) + #name: shared_resources::#name::new(priority) )); @@ -76,24 +74,16 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2, )); } - let is_late = expr.is_none(); - if is_late { - let expr = if access.is_exclusive() { - quote!(&mut *#mangled_name.get_mut_unchecked().as_mut_ptr()) - } else { - quote!(&*#mangled_name.get_unchecked().as_ptr()) - }; - - values.push(quote!( - #(#cfgs)* - #name: #expr - )); + let expr = if access.is_exclusive() { + quote!(&mut *#mangled_name.get_mut_unchecked().as_mut_ptr()) } else { - values.push(quote!( - #(#cfgs)* - #name: #mangled_name.get_mut_unchecked() - )); - } + quote!(&*#mangled_name.get_unchecked().as_ptr()) + }; + + values.push(quote!( + #(#cfgs)* + #name: #expr + )); } if lt.is_some() { @@ -110,8 +100,8 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2, } } - let doc = format!("Resources `{}` has access to", ctxt.ident(app)); - let ident = util::resources_ident(ctxt, app); + let doc = format!("Shared resources `{}` has access to", ctxt.ident(app)); + let ident = util::shared_resources_ident(ctxt, app); let ident = util::mark_internal_ident(&ident); let item = quote!( #[allow(non_snake_case)] diff --git a/macros/src/codegen/software_tasks.rs b/macros/src/codegen/software_tasks.rs index 0372e8ec..cfd21e40 100644 --- a/macros/src/codegen/software_tasks.rs +++ b/macros/src/codegen/software_tasks.rs @@ -5,7 +5,7 @@ use rtic_syntax::{ast::App, Context}; use crate::{ analyze::Analysis, check::Extra, - codegen::{locals, module, resources_struct, util}, + codegen::{local_resources_struct, module, shared_resources_struct, util}, }; pub fn codegen( @@ -45,7 +45,7 @@ pub fn codegen( quote!(rtic::export::Queue(unsafe { rtic::export::iQueue::u8_sc() })), - Box::new(|| util::link_section_uninit(true)), + Box::new(|| util::link_section_uninit()), ) }; mod_app.push(quote!( @@ -90,23 +90,32 @@ pub fn codegen( )); // `${task}Resources` - let mut needs_lt = false; - if !task.args.resources.is_empty() { - let (item, constructor) = - resources_struct::codegen(Context::SoftwareTask(name), &mut needs_lt, app); + let mut shared_needs_lt = false; + let mut local_needs_lt = false; + + // `${task}Locals` + if !task.args.local_resources.is_empty() { + let (item, constructor) = local_resources_struct::codegen( + Context::SoftwareTask(name), + &mut local_needs_lt, + app, + ); root.push(item); mod_app.push(constructor); } - // `${task}Locals` - let mut locals_pat = None; - if !task.locals.is_empty() { - let (struct_, pat) = locals::codegen(Context::SoftwareTask(name), &task.locals, app); + if !task.args.shared_resources.is_empty() { + let (item, constructor) = shared_resources_struct::codegen( + Context::SoftwareTask(name), + &mut shared_needs_lt, + app, + ); - locals_pat = Some(pat); - root.push(struct_); + root.push(item); + + mod_app.push(constructor); } if !&task.is_extern { @@ -114,12 +123,11 @@ pub fn codegen( let attrs = &task.attrs; let cfgs = &task.cfgs; let stmts = &task.stmts; - let locals_pat = locals_pat.iter(); user_tasks.push(quote!( #(#attrs)* #(#cfgs)* #[allow(non_snake_case)] - fn #name(#(#locals_pat,)* #context: #name::Context #(,#inputs)*) { + fn #name(#context: #name::Context #(,#inputs)*) { use rtic::Mutex as _; use rtic::mutex_prelude::*; @@ -130,7 +138,8 @@ pub fn codegen( root.push(module::codegen( Context::SoftwareTask(name), - needs_lt, + shared_needs_lt, + local_needs_lt, app, analysis, extra, diff --git a/macros/src/codegen/util.rs b/macros/src/codegen/util.rs index 3e42eda9..86bd6955 100644 --- a/macros/src/codegen/util.rs +++ b/macros/src/codegen/util.rs @@ -41,7 +41,7 @@ pub fn impl_mutex( ptr: TokenStream2, ) -> TokenStream2 { let (path, priority) = if resources_prefix { - (quote!(resources::#name), quote!(self.priority())) + (quote!(shared_resources::#name), quote!(self.priority())) } else { (quote!(#name), quote!(self.priority)) }; @@ -152,30 +152,12 @@ fn link_section_index() -> usize { } // NOTE `None` means in shared memory -pub fn link_section_uninit(empty_expr: bool) -> Option<TokenStream2> { - let section = if empty_expr { - let index = link_section_index(); - format!(".uninit.rtic{}", index) - } else { - format!(".uninit.rtic{}", link_section_index()) - }; +pub fn link_section_uninit() -> Option<TokenStream2> { + let section = format!(".uninit.rtic{}", link_section_index()); Some(quote!(#[link_section = #section])) } -/// Generates a pre-reexport identifier for the "locals" struct -pub fn locals_ident(ctxt: Context, app: &App) -> Ident { - let mut s = match ctxt { - Context::Init => app.inits.first().unwrap().name.to_string(), - Context::Idle => app.idles.first().unwrap().name.to_string(), - Context::HardwareTask(ident) | Context::SoftwareTask(ident) => ident.to_string(), - }; - - s.push_str("Locals"); - - Ident::new(&s, Span::call_site()) -} - // Regroups the inputs of a task // // `inputs` could be &[`input: Foo`] OR &[`mut x: i32`, `ref y: i64`] @@ -225,15 +207,39 @@ pub fn regroup_inputs( } } -/// Generates a pre-reexport identifier for the "resources" struct -pub fn resources_ident(ctxt: Context, app: &App) -> Ident { +/// Get the ident for the name of the task +pub fn get_task_name(ctxt: Context, app: &App) -> Ident { + let s = match ctxt { + Context::Init => app.init.name.to_string(), + Context::Idle => app.idle.as_ref().unwrap().name.to_string(), + Context::HardwareTask(ident) | Context::SoftwareTask(ident) => ident.to_string(), + }; + + Ident::new(&s, Span::call_site()) +} + +/// Generates a pre-reexport identifier for the "shared resources" struct +pub fn shared_resources_ident(ctxt: Context, app: &App) -> Ident { let mut s = match ctxt { - Context::Init => app.inits.first().unwrap().name.to_string(), - Context::Idle => app.idles.first().unwrap().name.to_string(), + Context::Init => app.init.name.to_string(), + Context::Idle => app.idle.as_ref().unwrap().name.to_string(), Context::HardwareTask(ident) | Context::SoftwareTask(ident) => ident.to_string(), }; - s.push_str("Resources"); + s.push_str("SharedResources"); + + Ident::new(&s, Span::call_site()) +} + +/// Generates a pre-reexport identifier for the "local resources" struct +pub fn local_resources_ident(ctxt: Context, app: &App) -> Ident { + let mut s = match ctxt { + Context::Init => app.init.name.to_string(), + Context::Idle => app.idle.as_ref().unwrap().name.to_string(), + Context::HardwareTask(ident) | Context::SoftwareTask(ident) => ident.to_string(), + }; + + s.push_str("LocalResources"); Ident::new(&s, Span::call_site()) } @@ -275,6 +281,27 @@ pub fn monotonic_ident(name: &str) -> Ident { Ident::new(&format!("MONOTONIC_STORAGE_{}", name), Span::call_site()) } +pub fn static_shared_resource_ident(name: &Ident) -> Ident { + Ident::new( + &format!("shared_resource_{}", name.to_string()), + Span::call_site(), + ) +} + +pub fn static_local_resource_ident(name: &Ident) -> Ident { + Ident::new( + &format!("local_resource_{}", name.to_string()), + Span::call_site(), + ) +} + +pub fn declared_static_local_resource_ident(name: &Ident, task_name: &Ident) -> Ident { + Ident::new( + &format!("local_{}_{}", task_name.to_string(), name.to_string()), + Span::call_site(), + ) +} + /// The name to get better RT flag errors pub fn rt_err_ident() -> Ident { Ident::new( diff --git a/macros/src/tests/single.rs b/macros/src/tests/single.rs index 8c026e99..27118856 100644 --- a/macros/src/tests/single.rs +++ b/macros/src/tests/single.rs @@ -10,6 +10,17 @@ fn analyze() { quote!(device = pac, dispatchers = [B, A]), quote!( mod app { + #[shared] + struct Shared {} + + #[local] + struct Local {} + + #[init] + fn init(_: init::Context) -> (Shared, Local, init::Monotonics) { + (Shared {}, Local {}, init::Monotonics {}) + } + #[task(priority = 1)] fn a(_: a::Context) {} diff --git a/ui/exception-invalid.rs b/ui/exception-invalid.rs index 04d9bc75..d899443b 100644 --- a/ui/exception-invalid.rs +++ b/ui/exception-invalid.rs @@ -2,6 +2,17 @@ #[rtic::app(device = lm3s6965)] mod app { + #[shared] + struct Shared {} + + #[local] + struct Local {} + + #[init] + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { + (Shared {}, Local {}, init::Monotonics {}) + } + #[task(binds = NonMaskableInt)] fn nmi(_: nmi::Context) {} } diff --git a/ui/exception-invalid.stderr b/ui/exception-invalid.stderr index 90213768..32123680 100644 --- a/ui/exception-invalid.stderr +++ b/ui/exception-invalid.stderr @@ -1,5 +1,5 @@ error: only exceptions with configurable priority can be used as hardware tasks - --> $DIR/exception-invalid.rs:6:8 - | -6 | fn nmi(_: nmi::Context) {} - | ^^^ + --> $DIR/exception-invalid.rs:17:8 + | +17 | fn nmi(_: nmi::Context) {} + | ^^^ diff --git a/ui/extern-interrupt-not-enough.rs b/ui/extern-interrupt-not-enough.rs index f2624036..6e786347 100644 --- a/ui/extern-interrupt-not-enough.rs +++ b/ui/extern-interrupt-not-enough.rs @@ -2,6 +2,17 @@ #[rtic::app(device = lm3s6965)] mod app { + #[shared] + struct Shared {} + + #[local] + struct Local {} + + #[init] + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { + (Shared {}, Local {}, init::Monotonics {}) + } + #[task] fn a(_: a::Context) {} } diff --git a/ui/extern-interrupt-not-enough.stderr b/ui/extern-interrupt-not-enough.stderr index 14f8fe9c..a667c588 100644 --- a/ui/extern-interrupt-not-enough.stderr +++ b/ui/extern-interrupt-not-enough.stderr @@ -1,5 +1,5 @@ error: not enough interrupts to dispatch all software tasks (need: 1; given: 0) - --> $DIR/extern-interrupt-not-enough.rs:6:8 - | -6 | fn a(_: a::Context) {} - | ^ + --> $DIR/extern-interrupt-not-enough.rs:17:8 + | +17 | fn a(_: a::Context) {} + | ^ diff --git a/ui/extern-interrupt-used.rs b/ui/extern-interrupt-used.rs index 240e7363..a22b85f4 100644 --- a/ui/extern-interrupt-used.rs +++ b/ui/extern-interrupt-used.rs @@ -2,6 +2,17 @@ #[rtic::app(device = lm3s6965, dispatchers = [UART0])] mod app { + #[shared] + struct Shared {} + + #[local] + struct Local {} + + #[init] + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { + (Shared {}, Local {}, init::Monotonics {}) + } + #[task(binds = UART0)] fn a(_: a::Context) {} } diff --git a/ui/extern-interrupt-used.stderr b/ui/extern-interrupt-used.stderr index b4d8d160..75657399 100644 --- a/ui/extern-interrupt-used.stderr +++ b/ui/extern-interrupt-used.stderr @@ -1,5 +1,5 @@ error: dispatcher interrupts can't be used as hardware tasks - --> $DIR/extern-interrupt-used.rs:5:20 - | -5 | #[task(binds = UART0)] - | ^^^^^ + --> $DIR/extern-interrupt-used.rs:16:20 + | +16 | #[task(binds = UART0)] + | ^^^^^ diff --git a/ui/local-cfg-task-local-err.rs b/ui/local-cfg-task-local-err.rs deleted file mode 100644 index d4752edf..00000000 --- a/ui/local-cfg-task-local-err.rs +++ /dev/null @@ -1,69 +0,0 @@ -//! examples/local-cfg-task-local.rs - -#![deny(unsafe_code)] -//#![deny(warnings)] -#![no_main] -#![no_std] - -use cortex_m_semihosting::debug; -use cortex_m_semihosting::hprintln; -use lm3s6965::Interrupt; -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965)] -mod app { - #[resources] - struct Resources { - // A local (move), early resource - #[cfg(feature = "feature_l1")] - #[task_local] - #[init(1)] - l1: u32, - - // A local (move), late resource - #[task_local] - l2: u32, - } - - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - rtic::pend(Interrupt::UART0); - rtic::pend(Interrupt::UART1); - ( - init::LateResources { - #[cfg(feature = "feature_l2")] - l2: 2, - #[cfg(not(feature = "feature_l2"))] - l2: 5, - }, - init::Monotonics(), - ) - } - - // l1 ok (task_local) - #[idle(resources =[#[cfg(feature = "feature_l1")]l1])] - fn idle(_cx: idle::Context) -> ! { - #[cfg(feature = "feature_l1")] - hprintln!("IDLE:l1 = {}", _cx.resources.l1).unwrap(); - debug::exit(debug::EXIT_SUCCESS); - loop {} - } - - // l2 ok (task_local) - #[task(priority = 1, binds = UART0, resources = [ - #[cfg(feature = "feature_l2")]l2, - ])] - fn uart0(_cx: uart0::Context) { - #[cfg(feature = "feature_l2")] - hprintln!("UART0:l2 = {}", _cx.resources.l2).unwrap(); - } - - // l2 error, conflicting with uart0 for l2 (task_local) - #[task(priority = 1, binds = UART1, resources = [ - #[cfg(not(feature = "feature_l2"))]l2 - ])] - fn uart1(_cx: uart1::Context) { - #[cfg(not(feature = "feature_l2"))] - hprintln!("UART0:l2 = {}", _cx.resources.l2).unwrap(); - } -} diff --git a/ui/local-cfg-task-local-err.stderr b/ui/local-cfg-task-local-err.stderr deleted file mode 100644 index 73dfaeb6..00000000 --- a/ui/local-cfg-task-local-err.stderr +++ /dev/null @@ -1,37 +0,0 @@ -error: task local resource "l2" is used by multiple tasks - --> $DIR/local-cfg-task-local-err.rs:25:9 - | -25 | l2: u32, - | ^^ - -error: task local resource "l2" is used by task "uart0" with priority 1 - --> $DIR/local-cfg-task-local-err.rs:54:39 - | -54 | #[cfg(feature = "feature_l2")]l2, - | ^^ - -error: task local resource "l2" is used by task "uart1" with priority 1 - --> $DIR/local-cfg-task-local-err.rs:63:44 - | -63 | #[cfg(not(feature = "feature_l2"))]l2 - | ^^ - -warning: unused import: `cortex_m_semihosting::debug` - --> $DIR/local-cfg-task-local-err.rs:8:5 - | -8 | use cortex_m_semihosting::debug; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: `#[warn(unused_imports)]` on by default - -warning: unused import: `cortex_m_semihosting::hprintln` - --> $DIR/local-cfg-task-local-err.rs:9:5 - | -9 | use cortex_m_semihosting::hprintln; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -warning: unused import: `lm3s6965::Interrupt` - --> $DIR/local-cfg-task-local-err.rs:10:5 - | -10 | use lm3s6965::Interrupt; - | ^^^^^^^^^^^^^^^^^^^ diff --git a/ui/local-err.rs b/ui/local-err.rs deleted file mode 100644 index 7ebfc069..00000000 --- a/ui/local-err.rs +++ /dev/null @@ -1,83 +0,0 @@ -//! examples/local_err.rs - -#![deny(unsafe_code)] -#![deny(warnings)] -#![no_main] -#![no_std] - -// errors here, since we cannot bail compilation or generate stubs -// run cargo expand, then you see the root of the problem... -use cortex_m_semihosting::{debug, hprintln}; -use lm3s6965::Interrupt; -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965)] -mod app { - #[resources] - struct Resources { - // An early resource - #[init(0)] - shared: u32, - - // A local (move), early resource - #[task_local] - #[init(1)] - l1: u32, - - // An exclusive, early resource - #[lock_free] - #[init(1)] - e1: u32, - - // A local (move), late resource - #[task_local] - l2: u32, - - // An exclusive, late resource - #[lock_free] - e2: u32, - } - - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - rtic::pend(Interrupt::UART0); - rtic::pend(Interrupt::UART1); - (init::LateResources { e2: 2, l2: 2 }, init::Monotonics()) - } - - // `shared` cannot be accessed from this context - // l1 ok - // l2 rejeceted (not task_local) - // e2 ok - #[idle(resources =[l1, l2, e2])] - fn idle(cx: idle::Context) -> ! { - hprintln!("IDLE:l1 = {}", cx.resources.l1).unwrap(); - hprintln!("IDLE:e2 = {}", cx.resources.e2).unwrap(); - debug::exit(debug::EXIT_SUCCESS); - loop {} - } - - // `shared` can be accessed from this context - // l2 rejected (not task_local) - // e1 rejected (not lock_free) - #[task(priority = 1, binds = UART0, resources = [shared, l2, e1])] - fn uart0(cx: uart0::Context) { - let shared: &mut u32 = cx.resources.shared; - *shared += 1; - *cx.resources.e1 += 10; - hprintln!("UART0: shared = {}", shared).unwrap(); - hprintln!("UART0:l2 = {}", cx.resources.l2).unwrap(); - hprintln!("UART0:e1 = {}", cx.resources.e1).unwrap(); - } - - // l2 rejected (not task_local) - #[task(priority = 2, binds = UART1, resources = [shared, l2, e1])] - fn uart1(cx: uart1::Context) { - let shared: &mut u32 = cx.resources.shared; - *shared += 1; - - hprintln!("UART1: shared = {}", shared).unwrap(); - hprintln!("UART1:l2 = {}", cx.resources.l2).unwrap(); - hprintln!("UART1:e1 = {}", cx.resources.e1).unwrap(); - } -} diff --git a/ui/local-err.stderr b/ui/local-err.stderr deleted file mode 100644 index 88369d8e..00000000 --- a/ui/local-err.stderr +++ /dev/null @@ -1,60 +0,0 @@ -error: task local resource "l2" is used by multiple tasks - --> $DIR/local-err.rs:34:9 - | -34 | l2: u32, - | ^^ - -error: task local resource "l2" is used by task "idle" with priority 0 - --> $DIR/local-err.rs:52:28 - | -52 | #[idle(resources =[l1, l2, e2])] - | ^^ - -error: task local resource "l2" is used by task "uart0" with priority 1 - --> $DIR/local-err.rs:63:62 - | -63 | #[task(priority = 1, binds = UART0, resources = [shared, l2, e1])] - | ^^ - -error: task local resource "l2" is used by task "uart1" with priority 2 - --> $DIR/local-err.rs:74:62 - | -74 | #[task(priority = 2, binds = UART1, resources = [shared, l2, e1])] - | ^^ - -error: Lock free resource "e1" is used by tasks at different priorities - --> $DIR/local-err.rs:30:9 - | -30 | e1: u32, - | ^^ - -error: Resource "e1" is declared lock free but used by tasks at different priorities - --> $DIR/local-err.rs:63:66 - | -63 | #[task(priority = 1, binds = UART0, resources = [shared, l2, e1])] - | ^^ - -error: Resource "e1" is declared lock free but used by tasks at different priorities - --> $DIR/local-err.rs:74:66 - | -74 | #[task(priority = 2, binds = UART1, resources = [shared, l2, e1])] - | ^^ - -error: unused imports: `debug`, `hprintln` - --> $DIR/local-err.rs:10:28 - | -10 | use cortex_m_semihosting::{debug, hprintln}; - | ^^^^^ ^^^^^^^^ - | -note: the lint level is defined here - --> $DIR/local-err.rs:4:9 - | -4 | #![deny(warnings)] - | ^^^^^^^^ - = note: `#[deny(unused_imports)]` implied by `#[deny(warnings)]` - -error: unused import: `lm3s6965::Interrupt` - --> $DIR/local-err.rs:11:5 - | -11 | use lm3s6965::Interrupt; - | ^^^^^^^^^^^^^^^^^^^ diff --git a/ui/locals-cfg.rs b/ui/locals-cfg.rs deleted file mode 100644 index 170d3026..00000000 --- a/ui/locals-cfg.rs +++ /dev/null @@ -1,50 +0,0 @@ -#![no_main] - -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965, dispatchers = [SSI0])] -mod app { - #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - #[cfg(never)] - static mut FOO: u32 = 0; - - FOO; - - (init::LateResources {}, init::Monotonics()) - } - - #[idle] - fn idle(_: idle::Context) -> ! { - #[cfg(never)] - static mut FOO: u32 = 0; - - FOO; - - loop {} - } - - #[task(binds = SVCall)] - fn svcall(_: svcall::Context) { - #[cfg(never)] - static mut FOO: u32 = 0; - - FOO; - } - - #[task(binds = UART0)] - fn uart0(_: uart0::Context) { - #[cfg(never)] - static mut FOO: u32 = 0; - - FOO; - } - - #[task] - fn foo(_: foo::Context) { - #[cfg(never)] - static mut FOO: u32 = 0; - - FOO; - } -} diff --git a/ui/locals-cfg.stderr b/ui/locals-cfg.stderr deleted file mode 100644 index 33a80754..00000000 --- a/ui/locals-cfg.stderr +++ /dev/null @@ -1,29 +0,0 @@ -error[E0425]: cannot find value `FOO` in this scope - --> $DIR/locals-cfg.rs:12:9 - | -12 | FOO; - | ^^^ not found in this scope - -error[E0425]: cannot find value `FOO` in this scope - --> $DIR/locals-cfg.rs:22:9 - | -22 | FOO; - | ^^^ not found in this scope - -error[E0425]: cannot find value `FOO` in this scope - --> $DIR/locals-cfg.rs:32:9 - | -32 | FOO; - | ^^^ not found in this scope - -error[E0425]: cannot find value `FOO` in this scope - --> $DIR/locals-cfg.rs:40:9 - | -40 | FOO; - | ^^^ not found in this scope - -error[E0425]: cannot find value `FOO` in this scope - --> $DIR/locals-cfg.rs:48:9 - | -48 | FOO; - | ^^^ not found in this scope diff --git a/ui/resources-cfg.rs b/ui/resources-cfg.rs deleted file mode 100644 index c802a46f..00000000 --- a/ui/resources-cfg.rs +++ /dev/null @@ -1,80 +0,0 @@ -#![no_main] - -use panic_semihosting as _; - -#[rtic::app(device = lm3s6965)] -mod app { - #[resources] - struct Resources { - #[cfg(never)] - #[init(0)] - o1: u32, // init - - #[cfg(never)] - #[init(0)] - o2: u32, // idle - - #[cfg(never)] - #[init(0)] - o3: u32, // EXTI0 - - #[cfg(never)] - #[init(0)] - o4: u32, // idle - - #[cfg(never)] - #[init(0)] - o5: u32, // EXTI1 - - #[cfg(never)] - #[init(0)] - o6: u32, // init - - #[cfg(never)] - #[init(0)] - s1: u32, // idle & EXTI0 - - #[cfg(never)] - #[init(0)] - s2: u32, // EXTI0 & EXTI1 - - #[cfg(never)] - #[init(0)] - s3: u32, - } - - #[init(resources = [o1, o4, o5, o6, s3])] - fn init(c: init::Context) -> (init::LateResources, init::Monotonics) { - c.resources.o1; - c.resources.o4; - c.resources.o5; - c.resources.o6; - c.resources.s3; - - (init::LateResources {}, init::Monotonics()) - } - - #[idle(resources = [o2, &o4, s1, &s3])] - fn idle(c: idle::Context) -> ! { - c.resources.o2; - c.resources.o4; - c.resources.s1; - c.resources.s3; - - loop {} - } - - #[task(binds = UART0, resources = [o3, s1, s2, &s3])] - fn uart0(c: uart0::Context) { - c.resources.o3; - c.resources.s1; - c.resources.s2; - c.resources.s3; - } - - #[task(binds = UART1, resources = [s2, &o5])] - fn uart1(c: uart1::Context) { - c.resources.s2; - c.resources.o5; - } -} diff --git a/ui/resources-cfg.stderr b/ui/resources-cfg.stderr deleted file mode 100644 index 03612de0..00000000 --- a/ui/resources-cfg.stderr +++ /dev/null @@ -1,119 +0,0 @@ -error[E0609]: no field `o1` on type `__rtic_internal_initResources<'_>` - --> $DIR/resources-cfg.rs:48:21 - | -48 | c.resources.o1; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `o4` on type `__rtic_internal_initResources<'_>` - --> $DIR/resources-cfg.rs:49:21 - | -49 | c.resources.o4; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `o5` on type `__rtic_internal_initResources<'_>` - --> $DIR/resources-cfg.rs:50:21 - | -50 | c.resources.o5; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `o6` on type `__rtic_internal_initResources<'_>` - --> $DIR/resources-cfg.rs:51:21 - | -51 | c.resources.o6; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `s3` on type `__rtic_internal_initResources<'_>` - --> $DIR/resources-cfg.rs:52:21 - | -52 | c.resources.s3; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `o2` on type `__rtic_internal_idleResources<'_>` - --> $DIR/resources-cfg.rs:59:21 - | -59 | c.resources.o2; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `o4` on type `__rtic_internal_idleResources<'_>` - --> $DIR/resources-cfg.rs:60:21 - | -60 | c.resources.o4; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `s1` on type `__rtic_internal_idleResources<'_>` - --> $DIR/resources-cfg.rs:61:21 - | -61 | c.resources.s1; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `s3` on type `__rtic_internal_idleResources<'_>` - --> $DIR/resources-cfg.rs:62:21 - | -62 | c.resources.s3; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `o3` on type `__rtic_internal_uart0Resources<'_>` - --> $DIR/resources-cfg.rs:69:21 - | -69 | c.resources.o3; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `s1` on type `__rtic_internal_uart0Resources<'_>` - --> $DIR/resources-cfg.rs:70:21 - | -70 | c.resources.s1; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `s2` on type `__rtic_internal_uart0Resources<'_>` - --> $DIR/resources-cfg.rs:71:21 - | -71 | c.resources.s2; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `s3` on type `__rtic_internal_uart0Resources<'_>` - --> $DIR/resources-cfg.rs:72:21 - | -72 | c.resources.s3; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `s2` on type `__rtic_internal_uart1Resources<'_>` - --> $DIR/resources-cfg.rs:77:21 - | -77 | c.resources.s2; - | ^^ unknown field - | - = note: available fields are: `__marker__` - -error[E0609]: no field `o5` on type `__rtic_internal_uart1Resources<'_>` - --> $DIR/resources-cfg.rs:78:21 - | -78 | c.resources.o5; - | ^^ unknown field - | - = note: available fields are: `__marker__` diff --git a/ui/task-priority-too-high.rs b/ui/task-priority-too-high.rs index b1cbfa94..0d903d3a 100644 --- a/ui/task-priority-too-high.rs +++ b/ui/task-priority-too-high.rs @@ -2,9 +2,15 @@ #[rtic::app(device = lm3s6965)] mod app { + #[shared] + struct Shared {} + + #[local] + struct Local {} + #[init] - fn init(_: init::Context) -> (init::LateResources, init::Monotonics) { - (init::LateResources {}, init::Monotonics()) + fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) { + (Shared {}, Local {}, init::Monotonics {}) } #[task(binds = GPIOA, priority = 1)] |