对 RTIC 框架的探索

/* ## Sections in FLASH */
/* ### Vector table */
.vector_table ORIGIN(FLASH) :
{ __vector_table = .; /* Initial Stack Pointer (SP) value. * We mask the bottom three bits to force 8-byte alignment. * Despite having an assert for this later, it's possible that a separate * linker script could override _stack_start after the assert is checked. */ LONG(_stack_start & 0xFFFFFFF8); /* Reset vector */ KEEP(*(.vector_table.reset_vector)); /* this is the `__RESET_VECTOR` symbol */ /* Exceptions */ __exceptions = .; /* start of exceptions */ KEEP(*(.vector_table.exceptions)); /* this is the `__EXCEPTIONS` symbol */ __eexceptions = .; /* end of exceptions */ /* Device specific interrupts */ KEEP(*(.vector_table.interrupts)); /* this is the `__INTERRUPTS` symbol */
} > FLASH

PROVIDE(NonMaskableInt = DefaultHandler);
PROVIDE(MemoryManagement = DefaultHandler);
PROVIDE(BusFault = DefaultHandler);
PROVIDE(UsageFault = DefaultHandler);
PROVIDE(SecureFault = DefaultHandler);
PROVIDE(SVCall = DefaultHandler);
PROVIDE(DebugMonitor = DefaultHandler);
PROVIDE(PendSV = DefaultHandler);
PROVIDE(SysTick = DefaultHandler);

#[inline(always)]
pub fn run<F>(priority: u8, f: F)
where F: FnOnce(),
{ if priority == 1 { // If the priority of this interrupt is `1` then BASEPRI can only be `0` f(); unsafe { basepri::write(0) } } else { let initial = basepri::read(); f(); unsafe { basepri::write(initial) } }
}

#[task(binds = SPI3)]
fn hw_task(_cx: hw_task::Context) { print!("hello world");
}

#[no_mangle]
unsafe fn SPI3() { const PRIORITY: u8 = 1u8; rtic::export::run(PRIORITY, || hw_task(hw_task::Context::new()));
}
fn hw_task(_cx: hw_task::Context) { print!("hello world");
}

/// Executor for an async task.
pub struct AsyncTaskExecutor<F: Future> { // `task` is protected by the `running` flag. task: UnsafeCell<MaybeUninit<F>>, running: AtomicBool, pending: AtomicBool,
}

impl<F: Future> AsyncTaskExecutor<F> { /// Poll the future in the executor. #[inline(always)] pub fn poll(&self, wake: fn()) { if self.is_running() && self.check_and_clear_pending() { let waker = unsafe { Waker::from_raw(RawWaker::new(wake as *const (), &WAKER_VTABLE)) }; let mut cx = Context::from_waker(&waker); let future = unsafe { Pin::new_unchecked(&mut *(self.task.get() as *mut F)) }; match future.poll(&mut cx) { Poll::Ready(_) => { self.running.store(false, Ordering::Release); } Poll::Pending => {} } } }
}

/// Pointer to executor holder.
pub struct AsyncTaskExecutorPtr { // Void pointer. ptr: AtomicPtr<()>,
}
impl AsyncTaskExecutorPtr { pub const fn new() -> Self { Self { ptr: AtomicPtr::new(core::ptr::null_mut()), } }
}

// Generate executor definition and priority in global scope
for (name, _) in app.software_tasks.iter() { let exec_name = util::internal_task_ident(name, "EXEC"); items.push(quote!( #[allow(non_upper_case_globals)] static #exec_name: rtic::export::executor::AsyncTaskExecutorPtr = rtic::export::executor::AsyncTaskExecutorPtr::new(); ));
}

impl AsyncTaskExecutorPtr { #[inline(always)] pub fn set_in_main<F: Future>(&self, executor: &ManuallyDrop<AsyncTaskExecutor<F>>) { self.ptr.store(executor as *const _ as _, Ordering::Relaxed); }
}

for (name, _) in app.software_tasks.iter() { let exec_name = util::internal_task_ident(name, "EXEC"); let new_n_args = util::new_n_args_ident(app.software_tasks[name].inputs.len()); executor_allocations.push(quote!( let executor = ::core::mem::ManuallyDrop::new(rtic::export::executor::AsyncTaskExecutor::#new_n_args(#name)); executors_size += ::core::mem::size_of_val(&executor); #exec_name.set_in_main(&executor); ));
}

#[no_mangle]
unsafe extern "C" fn main() -> ! { /* ... */}

quote!( #(#extra_mods_stmts)* #[doc(hidden)] #[no_mangle] unsafe extern "C" fn #main() -> ! { #(#assertion_stmts)* #(#pre_init_stmts)* #[inline(never)] fn __rtic_init_resources<F>(f: F) where F: FnOnce() { f(); } // Generate allocations for async executors. let mut executors_size = 0; #(#executor_allocations)* #(#msp_check)* // Wrap late_init_stmts in a function to ensure that stack space is reclaimed. __rtic_init_resources(||{ let (shared_resources, local_resources) = #init_name(#init_name::Context::new(#init_args)); #(#post_init_stmts)* }); #call_idle }
)

// check that dispatchers are not used as hardware tasks
for task in app.hardware_tasks.values() { let binds = &task.args.binds; if app.args.dispatchers.contains_key(binds) { return Err(parse::Error::new( binds.span(), "dispatcher interrupts can't be used as hardware tasks", )); }
}

let mut channels = Channels::new();
for (name, spawnee) in &app.software_tasks { let spawnee_prio = spawnee.args.priority; let channel = channels.entry(spawnee_prio).or_default(); channel.tasks.insert(name.clone()); // All inputs are send as we do not know from where they may be spawned. spawnee.inputs.iter().for_each(|input| { send_types.insert(input.ty.clone()); });
}

let doc = format!("Interrupt handler to dispatch async tasks at priority {level}");
let attribute = &interrupts.get(&level).expect("UNREACHABLE").1.attrs;
let config = handler_config(app, analysis, dispatcher_name.clone());
items.push(quote!( #[allow(non_snake_case)] #[doc = #doc] #[no_mangle] #(#attribute)* #(#config)* unsafe fn #dispatcher_name() { /// The priority of this interrupt handler const PRIORITY: u8 = #level; rtic::export::run(PRIORITY, || { #(#stmts)* }); }
));

for name in channel.tasks.iter() { let exec_name = util::internal_task_ident(name, "EXEC"); let from_ptr_n_args = util::from_ptr_n_args_ident(app.software_tasks[name].inputs.len()); stmts.push(quote!( let exec = rtic::export::executor::AsyncTaskExecutor::#from_ptr_n_args(#name, &#exec_name); exec.poll(|| { let exec = rtic::export::executor::AsyncTaskExecutor::#from_ptr_n_args(#name, &#exec_name); exec.set_pending(); #pend_interrupt }); ));
}

let pend_interrupt = if level > 0 { let int_mod = interrupt_mod(app); quote!(rtic::export::pend(#int_mod::#dispatcher_name);)
} else { // For 0 priority tasks we don't need to pend anything quote!()
};

/// Sets the given `interrupt` as pending
///
/// This is a convenience function around
/// [`NVIC::pend`](../cortex_m/peripheral/struct.NVIC.html#method.pend)
pub fn pend<I>(interrupt: I)
where I: InterruptNumber,
{ NVIC::pend(interrupt);
}

// Check 0-priority async software tasks and idle dependency
for (name, task) in &app.software_tasks { if task.args.priority == 0 { // If there is a 0-priority task, there must be no idle if app.idle.is_some() { error.push(syn::Error::new( name.span(), format!( "Async task {:?} has priority 0, but `#[idle]` is defined. 0-priority async tasks are only allowed if there is no `#[idle]`.", name.to_string(), ) )); } }
}

let call_idle = if let Some(idle) = &app.idle { let name = &idle.name; quote!(#name(#name::Context::new()))
} else if analysis.channels.get(&0).is_some() { let dispatcher = util::zero_prio_dispatcher_ident(); quote!(#dispatcher();)
} else { quote!(loop {})
};

if level > 0 { // generate code for non-zero dispatcher
} else { items.push(quote!( #[allow(non_snake_case)] unsafe fn #dispatcher_name() -> ! { loop { #(#stmts)* } } ));
}

#[shared]
struct Shared { shared1: u32, shared2: u32,
} #[local]
struct Local { foo_local_res_1: u32, bar_local_res_1: u32,
}

// Check that lock_free resources are correct
for lf_res in lock_free.iter() { for (task, tr, _, priority) in task_resources_list.iter() { for r in tr { // Get all uses of resources annotated lock_free if lf_res == r { // Check so async tasks do not use lock free resources if app.software_tasks.get(task).is_some() { error.push(syn::Error::new( r.span(), format!( "Lock free shared resource {:?} is used by an async tasks, which is forbidden", r.to_string(), ), )); } // HashMap returns the previous existing object if old.key == new.key if let Some(lf_res) = lf_hash.insert( r.to_string(), (task, r, priority) ) { // Check if priority differ, if it does, append to // list of resources which will be annotated with errors if priority != lf_res.2 { lf_res_with_error.push(lf_res.1); lf_res_with_error.push(r); } // If the resource already violates lock free properties if lf_res_with_error.contains(&r) { lf_res_with_error.push(lf_res.1); lf_res_with_error.push(r); } } } } }
}

#[inline(always)]
pub unsafe fn lock<T, R>( ptr: *mut T, ceiling: u8, nvic_prio_bits: u8, f: impl FnOnce(&mut T) -> R,
) -> R { if ceiling == (1 << nvic_prio_bits) { critical_section::with(|_| f(&mut *ptr)) } else { let current = basepri::read(); basepri_max::write(cortex_logical2hw(ceiling, nvic_prio_bits)); let r = f(&mut *ptr); basepri::write(current); r }
}

 /// Generates a `Mutex` implementation #[allow(clippy::too_many_arguments)] pub fn impl_mutex( app: &App, _analysis: &CodegenAnalysis, cfgs: &[Attribute], resources_prefix: bool, name: &Ident, ty: &TokenStream2, ceiling: u8, ptr: &TokenStream2, ) -> TokenStream2 { let path = if resources_prefix { quote!(shared_resources::#name) } else { quote!(#name) }; let device = &app.args.device; quote!( #(#cfgs)* impl<'a> rtic::Mutex for #path<'a> { type T = #ty; #[inline(always)] fn lock<RTIC_INTERNAL_R>(&mut self, f: impl FnOnce(&mut #ty) -> RTIC_INTERNAL_R) -> RTIC_INTERNAL_R { /// Priority ceiling const CEILING: u8 = #ceiling; unsafe { rtic::export::lock( #ptr, CEILING, #device::NVIC_PRIO_BITS, f, ) } } } ) }

#[proc_macro_attribute]
pub fn app(_args: TokenStream, _input: TokenStream) -> TokenStream { let (mut app, analysis) = match syntax::parse(_args, _input) { Err(e) => return e.to_compile_error().into(), Ok(x) => x, }; // Modify app based on backend before continuing if let Err(e) = preprocess::app(&mut app, &analysis) { return e.to_compile_error().into(); } let app = app; // App is not mutable after this point if let Err(e) = check::app(&app, &analysis) { return e.to_compile_error().into(); } let analysis = analyze::app(analysis, &app); let ts = codegen::app(&app, &analysis); // write to disk ...
}

pub struct App { /// The arguments to the `#[app]` attribute pub args: AppArgs, /// The name of the `const` item on which the `#[app]` attribute has been placed pub name: Ident, /// The `#[init]` function pub init: Init, /// The `#[idle]` function pub idle: Option<Idle>, /// Resources shared between tasks defined in `#[shared]` pub shared_resources: Map<SharedResource>, pub shared_resources_vis: syn::Visibility, /// Task local resources defined in `#[local]` pub local_resources: Map<LocalResource>, pub local_resources_vis: syn::Visibility, /// User imports pub user_imports: Vec<ItemUse>, /// User code pub user_code: Vec<Item>, /// Hardware tasks: `#[task(binds = ..)]`s pub hardware_tasks: Map<HardwareTask>, /// Async software tasks: `#[task]` pub software_tasks: Map<SoftwareTask>,
}

pub enum Access { /// `[x]`, a mutable resource Exclusive, /// `[&x]`, a static non-mutable resource Shared,
}

let (access, path) = match e { Expr::Path(e) => (Access::Exclusive, e.path), Expr::Reference(ref r) if r.mutability.is_none() => match &*r.expr { Expr::Path(e) => (Access::Shared, e.path.clone()), _ => return err, }, _ => return err,
};

pub enum Ownership { /// Owned by a single task Owned { /// Priority of the task that owns this resource priority: u8, }, /// "Co-owned" by more than one task; all of them have the same priority CoOwned { /// Priority of the tasks that co-own this resource priority: u8, }, /// Contended by more than one task; the tasks have different priorities Contended { /// Priority ceiling ceiling: u8, },
}

let mut used_shared_resource = IndexSet::new();
let mut ownerships = Ownerships::new();
let mut sync_types = SyncTypes::new();
for (prio, name, access) in app.shared_resource_accesses() { let res = app.shared_resources.get(name).expect("UNREACHABLE"); // This shared resource is used used_shared_resource.insert(name.clone()); if let Some(priority) = prio { if let Some(ownership) = ownerships.get_mut(name) { match *ownership { Ownership::Owned { priority: ceiling } | Ownership::CoOwned { priority: ceiling } | Ownership::Contended { ceiling } if priority != ceiling => { *ownership = Ownership::Contended { ceiling: cmp::max(ceiling, priority), }; if access.is_shared() { sync_types.insert(res.ty.clone()); } } Ownership::Owned { priority: ceil } if ceil == priority => { *ownership = Ownership::CoOwned { priority }; } _ => {} } } else { ownerships.insert(name.clone(), Ownership::Owned { priority }); } }
}

for (&priority, name) in interrupt_ids.chain(app.hardware_tasks.values().filter_map(|task| { if is_exception(&task.args.binds) { // We do exceptions in another pass None } else { Some((&task.args.priority, &task.args.binds)) } })) { stmts.push(quote!( core.NVIC.set_priority( #rt_err::#interrupt::#name, rtic::export::cortex_logical2hw(#priority, #nvic_prio_bits), ); )); // NOTE unmask the interrupt *after* setting its priority: changing the priority of a pended // interrupt is implementation defined stmts.push(quote!(rtic::export::NVIC::unmask(#rt_err::#interrupt::#name);)); }

// Set exception priorities
for (name, priority) in app.hardware_tasks.values().filter_map(|task| { if is_exception(&task.args.binds) { Some((&task.args.binds, task.args.priority)) } else { None }
}) { stmts.push(quote!(core.SCB.set_priority( rtic::export::SystemHandler::#name, rtic::export::cortex_logical2hw(#priority, #nvic_prio_bits), );));
}

for (name, _) in app.software_tasks.iter() { let exec_name = util::internal_task_ident(name, "EXEC"); let new_n_args = util::new_n_args_ident(app.software_tasks[name].inputs.len()); executor_allocations.push(quote!( let executor = ::core::mem::ManuallyDrop::new(rtic::export::executor::AsyncTaskExecutor::#new_n_args(#name)); executors_size += ::core::mem::size_of_val(&executor); #exec_name.set_in_main(&executor); ));
}

#[inline(never)]
fn __rtic_init_resources<F>(f: F) where F: FnOnce() { f();
}
// Wrap late_init_stmts in a function to ensure that stack space is reclaimed.
__rtic_init_resources(||{ let (shared_resources, local_resources) = #init_name(#init_name::Context::new(#init_args)); #(#post_init_stmts)*
});

/// Generates code that runs after `#[init]` returns
pub fn codegen(app: &App, analysis: &Analysis) -> Vec<TokenStream2> { let mut stmts = vec![]; // Initialize shared resources for (name, res) in &app.shared_resources { let mangled_name = util::static_shared_resource_ident(name); // If it's live let cfgs = res.cfgs.clone(); if analysis.shared_resources.get(name).is_some() { stmts.push(quote!( // We include the cfgs #(#cfgs)* // Resource is a RacyCell<MaybeUninit<T>> // - `get_mut` to obtain a raw pointer to `MaybeUninit<T>` // - `write` the defined value for the late resource T #mangled_name.get_mut().write(core::mem::MaybeUninit::new(shared_resources.#name)); )); } } // Initialize local resources for (name, res) in &app.local_resources { let mangled_name = util::static_local_resource_ident(name); // If it's live let cfgs = res.cfgs.clone(); if analysis.local_resources.get(name).is_some() { stmts.push(quote!( // We include the cfgs #(#cfgs)* // Resource is a RacyCell<MaybeUninit<T>> // - `get_mut` to obtain a raw pointer to `MaybeUninit<T>` // - `write` the defined value for the late resource T #mangled_name.get_mut().write(core::mem::MaybeUninit::new(local_resources.#name)); )); } } // Enable the interrupts -- this completes the `init`-ialization phase stmts.push(quote!(rtic::export::interrupt::enable();)); stmts
}