mirror/rtic
1
0
Fork 0
mirror of https://github.com/rtic-rs/rtic.git synced 2025-12-19 14:25:18 +01:00
Code Issues Projects Releases Packages Wiki Activity

ui tests added

Browse source
This commit is contained in:
Per Lindgren 2021-10-26 19:35:41 +02:00
parent 6c3d94d73b
commit fbd7fe9a08
17 changed files with 229 additions and 227 deletions
Download patch file Download diff file Expand all files Collapse all files

53
examples/lockall_soundness.rs
View file

@ -1,53 +0,0 @@
//! examples/lockall_soundness.rs
// #![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965, dispatchers = [GPIOA])]
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[shared]
struct Shared {
a: u32,
b: i64,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
foo::spawn().unwrap();
(Shared { a: 1, b: 2 }, Local {}, init::Monotonics())
}
// when omitted priority is assumed to be `1`
#[task(shared = [a, b])]
fn foo(mut c: foo::Context) {
static mut X: Option<&'static mut u32> = None;
static mut Y: u32 = 0;
c.shared.lock(|s| {
hprintln!("s.a = {}, s.b = {}", s.a, s.b).ok();
*s.a += 1;
// soundness check
// c.shared.lock(|s| {}); // borrow error
// c.shared.a.lock(|s| {}); // borrow error
unsafe {
X = Some(&mut Y);
// X = Some(s.a); // lifetime issue
// X = Some(&mut *s.a); // lifetime issue
// X = Some(&'static mut *s.a); // not rust
}
hprintln!("s.a = {}, s.b = {}", s.a, s.b).ok();
});
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
}
}

53
examples/lockall_soundness2.rs
View file

@ -1,53 +0,0 @@
//! examples/lockall_soundness2.rs
// #![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965, dispatchers = [GPIOA])]
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[shared]
struct Shared {
a: u32,
b: i64,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
foo::spawn().unwrap();
(Shared { a: 1, b: 2 }, Local {}, init::Monotonics())
}
// when omitted priority is assumed to be `1`
#[task(shared = [a, b])]
fn foo(mut c: foo::Context) {
static mut X: Option<&'static mut u32> = None;
static mut Y: u32 = 0;
c.shared.lock(|foo::Shared { a, b }| {
hprintln!("s.a = {}, s.b = {}", a, b).ok();
**a += 1;
// soundness check
// c.shared.lock(|s| {}); // borrow error
// c.shared.a.lock(|s| {}); // borrow error
unsafe {
X = Some(&mut Y);
// X = Some(*a); // lifetime issue
// X = Some(&mut **a); // lifetime issue
// X = Some(&'static mut **a); // not rust
}
hprintln!("s.a = {}, s.b = {}", a, b).ok();
});
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
}
}

40
examples/lockall_soundness3.rs
View file

@ -1,40 +0,0 @@
//! examples/lockall_soundness3.rs
#![deny(unsafe_code)]
// #![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965, dispatchers = [GPIOA])]
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[shared]
struct Shared {
a: u32,
b: i64,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
foo::spawn().unwrap();
(Shared { a: 1, b: 2 }, Local {}, init::Monotonics())
}
// when omitted priority is assumed to be `1`
#[task(shared = [a, b])]
fn foo(mut c: foo::Context) {
// let s = c.shared.lock(|s| s); // lifetime error
// hprintln!("a {}", s.a).ok();
// let a = c.shared.lock(|foo::Shared { a, b: _ }| a); // lifetime error
// hprintln!("a {}", a).ok();
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
}
}

79
examples/multilock_problem.rs
View file

@ -1,79 +0,0 @@
//! examples/multilock_vs_lockall.rs
#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965, dispatchers = [GPIOA])]
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[shared]
struct Shared {
shared1: u32,
shared2: u32,
shared3: u32,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
locks::spawn().unwrap();
(
Shared {
shared1: 0,
shared2: 0,
shared3: 0,
},
Local {},
init::Monotonics(),
)
}
// when omitted priority is assumed to be `1`
#[task(shared = [shared1, shared2, shared3])]
fn locks(c: locks::Context) {
// nested multi-lock
let s1 = c.shared.shared1;
let s2 = c.shared.shared2;
let s3 = c.shared.shared3;
(s1, s2, s3).lock(|s1, s2, s3| {
*s1 += 1;
*s2 += 2;
*s3 += 3;
hprintln!("Multiple locks, s1: {}, s2: {}, s3: {}", s1, s2, s3).ok();
});
// re-construct gives error (consumed by above lock)
let s = locks::SharedResources {
shared1: s1,
shared2: s2,
shared3: s3,
};
// nested multi-lock destruct
let locks::SharedResources {
shared1,
shared2,
shared3,
} = s;
(shared1, shared2, shared3).lock(|s1, s2, s3| {
*s1 += 1;
*s2 += 2;
*s3 += 3;
hprintln!("Multiple locks, s1: {}, s2: {}, s3: {}", s1, s2, s3).ok();
});
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
}
}

4
examples/multilock_problem_workaround.rs → examples/multilock_sequence.rs
View file

@ -52,14 +52,14 @@ mod app {
hprintln!("Multiple locks, s1: {}, s2: {}, s3: {}", s1, s2, s3).ok();
});
// re-construct gives error (consumed by above lock)
// re-construct
let s = locks::SharedResources {
shared1: s1,
shared2: s2,
shared3: s3,
};
// nested multi-lock destruct
// second nested multi-lock destruct
let locks::SharedResources {
shared1,
shared2,