mirror of
https://github.com/rtic-rs/rtic.git
synced 2024-11-26 05:29:38 +01:00
656 lines
34 KiB
HTML
656 lines
34 KiB
HTML
<!DOCTYPE HTML>
|
|
<html lang="en" class="light" dir="ltr">
|
|
<head>
|
|
<!-- Book generated using mdBook -->
|
|
<meta charset="UTF-8">
|
|
<title>Resources - Real-Time Interrupt-driven Concurrency</title>
|
|
|
|
|
|
<!-- Custom HTML head -->
|
|
|
|
<meta name="description" content="">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1">
|
|
<meta name="theme-color" content="#ffffff">
|
|
|
|
<link rel="icon" href="../favicon.svg">
|
|
<link rel="shortcut icon" href="../favicon.png">
|
|
<link rel="stylesheet" href="../css/variables.css">
|
|
<link rel="stylesheet" href="../css/general.css">
|
|
<link rel="stylesheet" href="../css/chrome.css">
|
|
<link rel="stylesheet" href="../css/print.css" media="print">
|
|
|
|
<!-- Fonts -->
|
|
<link rel="stylesheet" href="../FontAwesome/css/font-awesome.css">
|
|
<link rel="stylesheet" href="../fonts/fonts.css">
|
|
|
|
<!-- Highlight.js Stylesheets -->
|
|
<link rel="stylesheet" href="../highlight.css">
|
|
<link rel="stylesheet" href="../tomorrow-night.css">
|
|
<link rel="stylesheet" href="../ayu-highlight.css">
|
|
|
|
<!-- Custom theme stylesheets -->
|
|
|
|
</head>
|
|
<body class="sidebar-visible no-js">
|
|
<div id="body-container">
|
|
<!-- Provide site root to javascript -->
|
|
<script>
|
|
var path_to_root = "../";
|
|
var default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "navy" : "light";
|
|
</script>
|
|
|
|
<!-- Work around some values being stored in localStorage wrapped in quotes -->
|
|
<script>
|
|
try {
|
|
var theme = localStorage.getItem('mdbook-theme');
|
|
var sidebar = localStorage.getItem('mdbook-sidebar');
|
|
|
|
if (theme.startsWith('"') && theme.endsWith('"')) {
|
|
localStorage.setItem('mdbook-theme', theme.slice(1, theme.length - 1));
|
|
}
|
|
|
|
if (sidebar.startsWith('"') && sidebar.endsWith('"')) {
|
|
localStorage.setItem('mdbook-sidebar', sidebar.slice(1, sidebar.length - 1));
|
|
}
|
|
} catch (e) { }
|
|
</script>
|
|
|
|
<!-- Set the theme before any content is loaded, prevents flash -->
|
|
<script>
|
|
var theme;
|
|
try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
|
|
if (theme === null || theme === undefined) { theme = default_theme; }
|
|
var html = document.querySelector('html');
|
|
html.classList.remove('light')
|
|
html.classList.add(theme);
|
|
var body = document.querySelector('body');
|
|
body.classList.remove('no-js')
|
|
body.classList.add('js');
|
|
</script>
|
|
|
|
<input type="checkbox" id="sidebar-toggle-anchor" class="hidden">
|
|
|
|
<!-- Hide / unhide sidebar before it is displayed -->
|
|
<script>
|
|
var body = document.querySelector('body');
|
|
var sidebar = null;
|
|
var sidebar_toggle = document.getElementById("sidebar-toggle-anchor");
|
|
if (document.body.clientWidth >= 1080) {
|
|
try { sidebar = localStorage.getItem('mdbook-sidebar'); } catch(e) { }
|
|
sidebar = sidebar || 'visible';
|
|
} else {
|
|
sidebar = 'hidden';
|
|
}
|
|
sidebar_toggle.checked = sidebar === 'visible';
|
|
body.classList.remove('sidebar-visible');
|
|
body.classList.add("sidebar-" + sidebar);
|
|
</script>
|
|
|
|
<nav id="sidebar" class="sidebar" aria-label="Table of contents">
|
|
<div class="sidebar-scrollbox">
|
|
<ol class="chapter"><li class="chapter-item expanded affix "><a href="../preface.html">Preface</a></li><li class="chapter-item expanded affix "><li class="spacer"></li><li class="chapter-item expanded "><a href="../starting_a_project.html"><strong aria-hidden="true">1.</strong> Starting a new project</a></li><li class="chapter-item expanded "><a href="../by-example.html"><strong aria-hidden="true">2.</strong> RTIC by example</a></li><li><ol class="section"><li class="chapter-item expanded "><a href="../by-example/app.html"><strong aria-hidden="true">2.1.</strong> The app</a></li><li class="chapter-item expanded "><a href="../by-example/hardware_tasks.html"><strong aria-hidden="true">2.2.</strong> Hardware tasks</a></li><li class="chapter-item expanded "><a href="../by-example/software_tasks.html"><strong aria-hidden="true">2.3.</strong> Software tasks & spawn</a></li><li class="chapter-item expanded "><a href="../by-example/resources.html" class="active"><strong aria-hidden="true">2.4.</strong> Resources</a></li><li class="chapter-item expanded "><a href="../by-example/app_init.html"><strong aria-hidden="true">2.5.</strong> The init task</a></li><li class="chapter-item expanded "><a href="../by-example/app_idle.html"><strong aria-hidden="true">2.6.</strong> The idle task</a></li><li class="chapter-item expanded "><a href="../by-example/channel.html"><strong aria-hidden="true">2.7.</strong> Channel based communication</a></li><li class="chapter-item expanded "><a href="../by-example/delay.html"><strong aria-hidden="true">2.8.</strong> Delay and Timeout using Monotonics</a></li><li class="chapter-item expanded "><a href="../by-example/app_minimal.html"><strong aria-hidden="true">2.9.</strong> The minimal app</a></li><li class="chapter-item expanded "><a href="../by-example/tips/index.html"><strong aria-hidden="true">2.10.</strong> Tips & Tricks</a></li><li><ol class="section"><li class="chapter-item expanded "><a href="../by-example/tips/destructureing.html"><strong aria-hidden="true">2.10.1.</strong> Resource de-structure-ing</a></li><li class="chapter-item expanded "><a href="../by-example/tips/indirection.html"><strong aria-hidden="true">2.10.2.</strong> Avoid copies when message passing</a></li><li class="chapter-item expanded "><a href="../by-example/tips/static_lifetimes.html"><strong aria-hidden="true">2.10.3.</strong> 'static super-powers</a></li><li class="chapter-item expanded "><a href="../by-example/tips/view_code.html"><strong aria-hidden="true">2.10.4.</strong> Inspecting generated code</a></li></ol></li></ol></li><li class="chapter-item expanded "><a href="../monotonic_impl.html"><strong aria-hidden="true">3.</strong> Monotonics & the Timer Queue</a></li><li class="chapter-item expanded "><a href="../rtic_vs.html"><strong aria-hidden="true">4.</strong> RTIC vs. the world</a></li><li class="chapter-item expanded "><a href="../rtic_and_embassy.html"><strong aria-hidden="true">5.</strong> RTIC and Embassy</a></li><li class="chapter-item expanded "><a href="../awesome_rtic.html"><strong aria-hidden="true">6.</strong> Awesome RTIC examples</a></li><li class="chapter-item expanded affix "><li class="spacer"></li><li class="chapter-item expanded "><a href="../migration_v1_v2.html"><strong aria-hidden="true">7.</strong> Migrating from v1.0.x to v2.0.0</a></li><li><ol class="section"><li class="chapter-item expanded "><a href="../migration_v1_v2/monotonics.html"><strong aria-hidden="true">7.1.</strong> Migrating to rtic-monotonics</a></li><li class="chapter-item expanded "><a href="../migration_v1_v2/async_tasks.html"><strong aria-hidden="true">7.2.</strong> Software tasks must now be async</a></li><li class="chapter-item expanded "><a href="../migration_v1_v2/rtic-sync.html"><strong aria-hidden="true">7.3.</strong> Using and understanding rtic-sync</a></li><li class="chapter-item expanded "><a href="../migration_v1_v2/complete_example.html"><strong aria-hidden="true">7.4.</strong> A code example on migration</a></li></ol></li><li class="chapter-item expanded "><li class="spacer"></li><li class="chapter-item expanded "><a href="../internals.html"><strong aria-hidden="true">8.</strong> Under the hood</a></li><li><ol class="section"><li class="chapter-item expanded "><a href="../internals/targets.html"><strong aria-hidden="true">8.1.</strong> Cortex-M architectures</a></li></ol></li></ol>
|
|
</div>
|
|
<div id="sidebar-resize-handle" class="sidebar-resize-handle">
|
|
<div class="sidebar-resize-indicator"></div>
|
|
</div>
|
|
</nav>
|
|
|
|
<!-- Track and set sidebar scroll position -->
|
|
<script>
|
|
var sidebarScrollbox = document.querySelector('#sidebar .sidebar-scrollbox');
|
|
sidebarScrollbox.addEventListener('click', function(e) {
|
|
if (e.target.tagName === 'A') {
|
|
sessionStorage.setItem('sidebar-scroll', sidebarScrollbox.scrollTop);
|
|
}
|
|
}, { passive: true });
|
|
var sidebarScrollTop = sessionStorage.getItem('sidebar-scroll');
|
|
sessionStorage.removeItem('sidebar-scroll');
|
|
if (sidebarScrollTop) {
|
|
// preserve sidebar scroll position when navigating via links within sidebar
|
|
sidebarScrollbox.scrollTop = sidebarScrollTop;
|
|
} else {
|
|
// scroll sidebar to current active section when navigating via "next/previous chapter" buttons
|
|
var activeSection = document.querySelector('#sidebar .active');
|
|
if (activeSection) {
|
|
activeSection.scrollIntoView({ block: 'center' });
|
|
}
|
|
}
|
|
</script>
|
|
|
|
<div id="page-wrapper" class="page-wrapper">
|
|
|
|
<div class="page">
|
|
<div id="menu-bar-hover-placeholder"></div>
|
|
<div id="menu-bar" class="menu-bar sticky">
|
|
<div class="left-buttons">
|
|
<label id="sidebar-toggle" class="icon-button" for="sidebar-toggle-anchor" title="Toggle Table of Contents" aria-label="Toggle Table of Contents" aria-controls="sidebar">
|
|
<i class="fa fa-bars"></i>
|
|
</label>
|
|
<button id="theme-toggle" class="icon-button" type="button" title="Change theme" aria-label="Change theme" aria-haspopup="true" aria-expanded="false" aria-controls="theme-list">
|
|
<i class="fa fa-paint-brush"></i>
|
|
</button>
|
|
<ul id="theme-list" class="theme-popup" aria-label="Themes" role="menu">
|
|
<li role="none"><button role="menuitem" class="theme" id="light">Light</button></li>
|
|
<li role="none"><button role="menuitem" class="theme" id="rust">Rust</button></li>
|
|
<li role="none"><button role="menuitem" class="theme" id="coal">Coal</button></li>
|
|
<li role="none"><button role="menuitem" class="theme" id="navy">Navy</button></li>
|
|
<li role="none"><button role="menuitem" class="theme" id="ayu">Ayu</button></li>
|
|
</ul>
|
|
<button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
|
|
<i class="fa fa-search"></i>
|
|
</button>
|
|
</div>
|
|
|
|
<h1 class="menu-title">Real-Time Interrupt-driven Concurrency</h1>
|
|
|
|
<div class="right-buttons">
|
|
<a href="../print.html" title="Print this book" aria-label="Print this book">
|
|
<i id="print-button" class="fa fa-print"></i>
|
|
</a>
|
|
<a href="https://github.com/rtic-rs/rtic" title="Git repository" aria-label="Git repository">
|
|
<i id="git-repository-button" class="fa fa-github"></i>
|
|
</a>
|
|
|
|
</div>
|
|
</div>
|
|
|
|
<div id="search-wrapper" class="hidden">
|
|
<form id="searchbar-outer" class="searchbar-outer">
|
|
<input type="search" id="searchbar" name="searchbar" placeholder="Search this book ..." aria-controls="searchresults-outer" aria-describedby="searchresults-header">
|
|
</form>
|
|
<div id="searchresults-outer" class="searchresults-outer hidden">
|
|
<div id="searchresults-header" class="searchresults-header"></div>
|
|
<ul id="searchresults">
|
|
</ul>
|
|
</div>
|
|
</div>
|
|
|
|
<!-- Apply ARIA attributes after the sidebar and the sidebar toggle button are added to the DOM -->
|
|
<script>
|
|
document.getElementById('sidebar-toggle').setAttribute('aria-expanded', sidebar === 'visible');
|
|
document.getElementById('sidebar').setAttribute('aria-hidden', sidebar !== 'visible');
|
|
Array.from(document.querySelectorAll('#sidebar a')).forEach(function(link) {
|
|
link.setAttribute('tabIndex', sidebar === 'visible' ? 0 : -1);
|
|
});
|
|
</script>
|
|
|
|
<div id="content" class="content">
|
|
<main>
|
|
<h1 id="resource-usage"><a class="header" href="#resource-usage">Resource usage</a></h1>
|
|
<p>The RTIC framework manages shared and task local resources allowing persistent data storage and safe accesses without the use of <code>unsafe</code> code.</p>
|
|
<p>RTIC resources are visible only to functions declared within the <code>#[app]</code> module and the framework gives the user complete control (on a per-task basis) over resource accessibility.</p>
|
|
<p>Declaration of system-wide resources is done by annotating <strong>two</strong> <code>struct</code>s within the <code>#[app]</code> module with the attribute <code>#[local]</code> and <code>#[shared]</code>. Each field in these structures corresponds to a different resource (identified by field name). The difference between these two sets of resources will be covered below.</p>
|
|
<p>Each task must declare the resources it intends to access in its corresponding metadata attribute using the <code>local</code> and <code>shared</code> arguments. Each argument takes a list of resource identifiers. The listed resources are made available to the context under the <code>local</code> and <code>shared</code> fields of the <code>Context</code> structure.</p>
|
|
<p>The <code>init</code> task returns the initial values for the system-wide (<code>#[shared]</code> and <code>#[local]</code>) resources.</p>
|
|
<!-- and the set of initialized timers used by the application. The monotonic timers will be
|
|
further discussed in [Monotonic & `spawn_{at/after}`](./monotonic.md). -->
|
|
<h2 id="local-resources"><a class="header" href="#local-resources"><code>#[local]</code> resources</a></h2>
|
|
<p><code>#[local]</code> resources are locally accessible to a specific task, meaning that only that task can access the resource and does so without locks or critical sections. This allows for the resources, commonly drivers or large objects, to be initialized in <code>#[init]</code> and then be passed to a specific task.</p>
|
|
<p>Thus, a task <code>#[local]</code> resource can only be accessed by one singular task. Attempting to assign the same <code>#[local]</code> resource to more than one task is a compile-time error.</p>
|
|
<p>Types of <code>#[local]</code> resources must implement a <a href="https://doc.rust-lang.org/stable/core/marker/trait.Send.html"><code>Send</code></a> trait as they are being sent from <code>init</code> to a target task, crossing a thread boundary.</p>
|
|
<p>The example application shown below contains three tasks <code>foo</code>, <code>bar</code> and <code>idle</code>, each having access to its own <code>#[local]</code> resource.</p>
|
|
<pre><code class="language-rust noplayground">//! examples/locals.rs
|
|
|
|
#![no_main]
|
|
#![no_std]
|
|
#![deny(warnings)]
|
|
#![deny(unsafe_code)]
|
|
#![deny(missing_docs)]
|
|
|
|
use panic_semihosting as _;
|
|
|
|
#[rtic::app(device = lm3s6965, dispatchers = [UART0, UART1])]
|
|
mod app {
|
|
use cortex_m_semihosting::{debug, hprintln};
|
|
|
|
#[shared]
|
|
struct Shared {}
|
|
|
|
#[local]
|
|
struct Local {
|
|
local_to_foo: i64,
|
|
local_to_bar: i64,
|
|
local_to_idle: i64,
|
|
}
|
|
|
|
// `#[init]` cannot access locals from the `#[local]` struct as they are initialized here.
|
|
#[init]
|
|
fn init(_: init::Context) -> (Shared, Local) {
|
|
foo::spawn().unwrap();
|
|
bar::spawn().unwrap();
|
|
|
|
(
|
|
Shared {},
|
|
// initial values for the `#[local]` resources
|
|
Local {
|
|
local_to_foo: 0,
|
|
local_to_bar: 0,
|
|
local_to_idle: 0,
|
|
},
|
|
)
|
|
}
|
|
|
|
// `local_to_idle` can only be accessed from this context
|
|
#[idle(local = [local_to_idle])]
|
|
fn idle(cx: idle::Context) -> ! {
|
|
let local_to_idle = cx.local.local_to_idle;
|
|
*local_to_idle += 1;
|
|
|
|
hprintln!("idle: local_to_idle = {}", local_to_idle);
|
|
|
|
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
|
|
|
|
// error: no `local_to_foo` field in `idle::LocalResources`
|
|
// _cx.local.local_to_foo += 1;
|
|
|
|
// error: no `local_to_bar` field in `idle::LocalResources`
|
|
// _cx.local.local_to_bar += 1;
|
|
|
|
loop {
|
|
cortex_m::asm::nop();
|
|
}
|
|
}
|
|
|
|
// `local_to_foo` can only be accessed from this context
|
|
#[task(local = [local_to_foo], priority = 1)]
|
|
async fn foo(cx: foo::Context) {
|
|
let local_to_foo = cx.local.local_to_foo;
|
|
*local_to_foo += 1;
|
|
|
|
// error: no `local_to_bar` field in `foo::LocalResources`
|
|
// cx.local.local_to_bar += 1;
|
|
|
|
hprintln!("foo: local_to_foo = {}", local_to_foo);
|
|
}
|
|
|
|
// `local_to_bar` can only be accessed from this context
|
|
#[task(local = [local_to_bar], priority = 1)]
|
|
async fn bar(cx: bar::Context) {
|
|
let local_to_bar = cx.local.local_to_bar;
|
|
*local_to_bar += 1;
|
|
|
|
// error: no `local_to_foo` field in `bar::LocalResources`
|
|
// cx.local.local_to_foo += 1;
|
|
|
|
hprintln!("bar: local_to_bar = {}", local_to_bar);
|
|
}
|
|
}</code></pre>
|
|
<p>Running the example:</p>
|
|
<pre><code class="language-console">$ cargo xtask qemu --verbose --example locals
|
|
</code></pre>
|
|
<pre><code class="language-console">bar: local_to_bar = 1
|
|
foo: local_to_foo = 1
|
|
idle: local_to_idle = 1
|
|
</code></pre>
|
|
<p>Local resources in <code>#[init]</code> and <code>#[idle]</code> have <code>'static</code> lifetimes. This is safe since both tasks are not re-entrant.</p>
|
|
<h3 id="task-local-initialized-resources"><a class="header" href="#task-local-initialized-resources">Task local initialized resources</a></h3>
|
|
<p>Local resources can also be specified directly in the resource claim like so: <code>#[task(local = [my_var: TYPE = INITIAL_VALUE, ...])]</code>; this allows for creating locals which do no need to be initialized in <code>#[init]</code>.</p>
|
|
<p>Types of <code>#[task(local = [..])]</code> resources have to be neither <a href="https://doc.rust-lang.org/stable/core/marker/trait.Send.html"><code>Send</code></a> nor <a href="https://doc.rust-lang.org/stable/core/marker/trait.Sync.html"><code>Sync</code></a> as they are not crossing any thread boundary.</p>
|
|
<p>In the example below the different uses and lifetimes are shown:</p>
|
|
<pre><code class="language-rust noplayground">//! examples/declared_locals.rs
|
|
|
|
#![no_main]
|
|
#![no_std]
|
|
#![deny(warnings)]
|
|
#![deny(unsafe_code)]
|
|
#![deny(missing_docs)]
|
|
|
|
use panic_semihosting as _;
|
|
|
|
#[rtic::app(device = lm3s6965)]
|
|
mod app {
|
|
use cortex_m_semihosting::debug;
|
|
|
|
#[shared]
|
|
struct Shared {}
|
|
|
|
#[local]
|
|
struct Local {}
|
|
|
|
#[init(local = [a: u32 = 0])]
|
|
fn init(cx: init::Context) -> (Shared, Local) {
|
|
// Locals in `#[init]` have 'static lifetime
|
|
let _a: &'static mut u32 = cx.local.a;
|
|
|
|
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
|
|
|
|
(Shared {}, Local {})
|
|
}
|
|
|
|
#[idle(local = [a: u32 = 0])]
|
|
fn idle(cx: idle::Context) -> ! {
|
|
// Locals in `#[idle]` have 'static lifetime
|
|
let _a: &'static mut u32 = cx.local.a;
|
|
|
|
loop {}
|
|
}
|
|
|
|
#[task(binds = UART0, local = [a: u32 = 0])]
|
|
fn foo(cx: foo::Context) {
|
|
// Locals in `#[task]`s have a local lifetime
|
|
let _a: &mut u32 = cx.local.a;
|
|
|
|
// error: explicit lifetime required in the type of `cx`
|
|
// let _a: &'static mut u32 = cx.local.a;
|
|
}
|
|
}</code></pre>
|
|
<p>You can run the application, but as the example is designed merely to showcase the lifetime properties there is no output (it suffices to build the application).</p>
|
|
<pre><code class="language-console">$ cargo build --target thumbv7m-none-eabi --example declared_locals
|
|
</code></pre>
|
|
<!-- -->
|
|
<h2 id="shared-resources-and-lock"><a class="header" href="#shared-resources-and-lock"><code>#[shared]</code> resources and <code>lock</code></a></h2>
|
|
<p>Critical sections are required to access <code>#[shared]</code> resources in a data race-free manner and to achieve this the <code>shared</code> field of the passed <code>Context</code> implements the <a href="../../../api/rtic/trait.Mutex.html"><code>Mutex</code></a> trait for each shared resource accessible to the task. This trait has only one method, <a href="../../../api/rtic/trait.Mutex.html#method.lock"><code>lock</code></a>, which runs its closure argument in a critical section.</p>
|
|
<p>The critical section created by the <code>lock</code> API is based on dynamic priorities: it temporarily raises the dynamic priority of the context to a <em>ceiling</em> priority that prevents other tasks from preempting the critical section. This synchronization protocol is known as the <a href="https://en.wikipedia.org/wiki/Priority_ceiling_protocol">Immediate Ceiling Priority Protocol (ICPP)</a>, and complies with <a href="https://en.wikipedia.org/wiki/Stack_Resource_Policy">Stack Resource Policy (SRP)</a> based scheduling of RTIC.</p>
|
|
<p>In the example below we have three interrupt handlers with priorities ranging from one to three. The two handlers with the lower priorities contend for a <code>shared</code> resource and need to succeed in locking the resource in order to access its data. The highest priority handler, which does not access the <code>shared</code> resource, is free to preempt a critical section created by the lowest priority handler.</p>
|
|
<pre><code class="language-rust noplayground">//! examples/lock.rs
|
|
|
|
#![no_main]
|
|
#![no_std]
|
|
#![deny(warnings)]
|
|
#![deny(unsafe_code)]
|
|
#![deny(missing_docs)]
|
|
|
|
use panic_semihosting as _;
|
|
|
|
#[rtic::app(device = lm3s6965, dispatchers = [GPIOA, GPIOB, GPIOC])]
|
|
mod app {
|
|
use cortex_m_semihosting::{debug, hprintln};
|
|
|
|
#[shared]
|
|
struct Shared {
|
|
shared: u32,
|
|
}
|
|
|
|
#[local]
|
|
struct Local {}
|
|
|
|
#[init]
|
|
fn init(_: init::Context) -> (Shared, Local) {
|
|
foo::spawn().unwrap();
|
|
|
|
(Shared { shared: 0 }, Local {})
|
|
}
|
|
|
|
// when omitted priority is assumed to be `1`
|
|
#[task(shared = [shared])]
|
|
async fn foo(mut c: foo::Context) {
|
|
hprintln!("A");
|
|
|
|
// the lower priority task requires a critical section to access the data
|
|
c.shared.shared.lock(|shared| {
|
|
// data can only be modified within this critical section (closure)
|
|
*shared += 1;
|
|
|
|
// bar will *not* run right now due to the critical section
|
|
bar::spawn().unwrap();
|
|
|
|
hprintln!("B - shared = {}", *shared);
|
|
|
|
// baz does not contend for `shared` so it's allowed to run now
|
|
baz::spawn().unwrap();
|
|
});
|
|
|
|
// critical section is over: bar can now start
|
|
|
|
hprintln!("E");
|
|
|
|
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
|
|
}
|
|
|
|
#[task(priority = 2, shared = [shared])]
|
|
async fn bar(mut c: bar::Context) {
|
|
// the higher priority task does still need a critical section
|
|
let shared = c.shared.shared.lock(|shared| {
|
|
*shared += 1;
|
|
|
|
*shared
|
|
});
|
|
|
|
hprintln!("D - shared = {}", shared);
|
|
}
|
|
|
|
#[task(priority = 3)]
|
|
async fn baz(_: baz::Context) {
|
|
hprintln!("C");
|
|
}
|
|
}</code></pre>
|
|
<pre><code class="language-console">$ cargo xtask qemu --verbose --example lock
|
|
</code></pre>
|
|
<pre><code class="language-console">A
|
|
B - shared = 1
|
|
C
|
|
D - shared = 2
|
|
E
|
|
</code></pre>
|
|
<p>Types of <code>#[shared]</code> resources have to be <a href="https://doc.rust-lang.org/stable/core/marker/trait.Send.html"><code>Send</code></a>.</p>
|
|
<h2 id="multi-lock"><a class="header" href="#multi-lock">Multi-lock</a></h2>
|
|
<p>As an extension to <code>lock</code>, and to reduce rightward drift, locks can be taken as tuples. The following examples show this in use:</p>
|
|
<pre><code class="language-rust noplayground">//! examples/mutlilock.rs
|
|
|
|
#![no_main]
|
|
#![no_std]
|
|
#![deny(warnings)]
|
|
#![deny(unsafe_code)]
|
|
#![deny(missing_docs)]
|
|
|
|
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) {
|
|
locks::spawn().unwrap();
|
|
|
|
(
|
|
Shared {
|
|
shared1: 0,
|
|
shared2: 0,
|
|
shared3: 0,
|
|
},
|
|
Local {},
|
|
)
|
|
}
|
|
|
|
// when omitted priority is assumed to be `1`
|
|
#[task(shared = [shared1, shared2, shared3])]
|
|
async fn locks(c: locks::Context) {
|
|
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 += 1;
|
|
*s3 += 1;
|
|
|
|
hprintln!("Multiple locks, s1: {}, s2: {}, s3: {}", *s1, *s2, *s3);
|
|
});
|
|
|
|
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
|
|
}
|
|
}</code></pre>
|
|
<pre><code class="language-console">$ cargo xtask qemu --verbose --example multilock
|
|
</code></pre>
|
|
<pre><code class="language-console">Multiple locks, s1: 1, s2: 1, s3: 1
|
|
</code></pre>
|
|
<h2 id="only-shared---access"><a class="header" href="#only-shared---access">Only shared (<code>&-</code>) access</a></h2>
|
|
<p>By default, the framework assumes that all tasks require exclusive mutable access (<code>&mut-</code>) to resources, but it is possible to specify that a task only requires shared access (<code>&-</code>) to a resource using the <code>&resource_name</code> syntax in the <code>shared</code> list.</p>
|
|
<p>The advantage of specifying shared access (<code>&-</code>) to a resource is that no locks are required to access the resource even if the resource is contended by more than one task running at different priorities. The downside is that the task only gets a shared reference (<code>&-</code>) to the resource, limiting the operations it can perform on it, but where a shared reference is enough this approach reduces the number of required locks. In addition to simple immutable data, this shared access can be useful where the resource type safely implements interior mutability, with appropriate locking or atomic operations of its own.</p>
|
|
<p>Note that in this release of RTIC it is not possible to request both exclusive access (<code>&mut-</code>) and shared access (<code>&-</code>) to the <em>same</em> resource from different tasks. Attempting to do so will result in a compile error.</p>
|
|
<p>In the example below a key (e.g. a cryptographic key) is loaded (or created) at runtime (returned by <code>init</code>) and then used from two tasks that run at different priorities without any kind of lock.</p>
|
|
<pre><code class="language-rust noplayground">//! examples/only-shared-access.rs
|
|
|
|
#![no_main]
|
|
#![no_std]
|
|
#![deny(warnings)]
|
|
#![deny(unsafe_code)]
|
|
#![deny(missing_docs)]
|
|
|
|
use panic_semihosting as _;
|
|
|
|
#[rtic::app(device = lm3s6965, dispatchers = [UART0, UART1])]
|
|
mod app {
|
|
use cortex_m_semihosting::{debug, hprintln};
|
|
|
|
#[shared]
|
|
struct Shared {
|
|
key: u32,
|
|
}
|
|
|
|
#[local]
|
|
struct Local {}
|
|
|
|
#[init]
|
|
fn init(_: init::Context) -> (Shared, Local) {
|
|
foo::spawn().unwrap();
|
|
bar::spawn().unwrap();
|
|
|
|
(Shared { key: 0xdeadbeef }, Local {})
|
|
}
|
|
|
|
#[task(shared = [&key])]
|
|
async fn foo(cx: foo::Context) {
|
|
let key: &u32 = cx.shared.key;
|
|
hprintln!("foo(key = {:#x})", key);
|
|
|
|
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
|
|
}
|
|
|
|
#[task(priority = 2, shared = [&key])]
|
|
async fn bar(cx: bar::Context) {
|
|
hprintln!("bar(key = {:#x})", cx.shared.key);
|
|
}
|
|
}</code></pre>
|
|
<pre><code class="language-console">$ cargo xtask qemu --verbose --example only-shared-access
|
|
</code></pre>
|
|
<pre><code class="language-console">bar(key = 0xdeadbeef)
|
|
foo(key = 0xdeadbeef)
|
|
</code></pre>
|
|
<h2 id="lock-free-access-of-shared-resources"><a class="header" href="#lock-free-access-of-shared-resources">Lock-free access of shared resources</a></h2>
|
|
<p>A critical section is <em>not</em> required to access a <code>#[shared]</code> resource that's only accessed by tasks running at the <em>same</em> priority. In this case, you can opt out of the <code>lock</code> API by adding the <code>#[lock_free]</code> field-level attribute to the resource declaration (see example below).</p>
|
|
<!-- Note that this is merely a convenience to reduce needless resource locking code, because even if the
|
|
`lock` API is used, at runtime the framework will **not** produce a critical section due to how
|
|
the underlying resource-ceiling preemption works. -->
|
|
<p>To adhere to the Rust <a href="https://doc.rust-lang.org/nomicon/aliasing.html">aliasing</a> rule, a resource may be either accessed through multiple immutable references or a singe mutable reference (but not both at the same time).</p>
|
|
<p>Using <code>#[lock_free]</code> on resources shared by tasks running at different priorities will result in a <em>compile-time</em> error -- not using the <code>lock</code> API would violate the aforementioned alias rule. Similarly, for each priority there can be only a single <em>software</em> task accessing a shared resource (as an <code>async</code> task may yield execution to other <em>software</em> or <em>hardware</em> tasks running at the same priority). However, under this single-task restriction, we make the observation that the resource is in effect no longer <code>shared</code> but rather <code>local</code>. Thus, using a <code>#[lock_free]</code> shared resource will result in a <em>compile-time</em> error -- where applicable, use a <code>#[local]</code> resource instead.</p>
|
|
<pre><code class="language-rust noplayground">//! examples/lock-free.rs
|
|
|
|
#![no_main]
|
|
#![no_std]
|
|
#![deny(warnings)]
|
|
#![deny(unsafe_code)]
|
|
#![deny(missing_docs)]
|
|
|
|
use panic_semihosting as _;
|
|
|
|
#[rtic::app(device = lm3s6965)]
|
|
mod app {
|
|
use cortex_m_semihosting::{debug, hprintln};
|
|
use lm3s6965::Interrupt;
|
|
|
|
#[shared]
|
|
struct Shared {
|
|
#[lock_free] // <- lock-free shared resource
|
|
counter: u64,
|
|
}
|
|
|
|
#[local]
|
|
struct Local {}
|
|
|
|
#[init]
|
|
fn init(_: init::Context) -> (Shared, Local) {
|
|
rtic::pend(Interrupt::UART0);
|
|
|
|
(Shared { counter: 0 }, Local {})
|
|
}
|
|
|
|
#[task(binds = UART0, shared = [counter])] // <- same priority
|
|
fn foo(c: foo::Context) {
|
|
rtic::pend(Interrupt::UART1);
|
|
|
|
*c.shared.counter += 1; // <- no lock API required
|
|
let counter = *c.shared.counter;
|
|
hprintln!(" foo = {}", counter);
|
|
}
|
|
|
|
#[task(binds = UART1, shared = [counter])] // <- same priority
|
|
fn bar(c: bar::Context) {
|
|
rtic::pend(Interrupt::UART0);
|
|
*c.shared.counter += 1; // <- no lock API required
|
|
let counter = *c.shared.counter;
|
|
hprintln!(" bar = {}", counter);
|
|
|
|
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
|
|
}
|
|
}</code></pre>
|
|
<pre><code class="language-console">$ cargo xtask qemu --verbose --example lock-free
|
|
</code></pre>
|
|
<pre><code class="language-console"> foo = 1
|
|
bar = 2
|
|
</code></pre>
|
|
|
|
</main>
|
|
|
|
<nav class="nav-wrapper" aria-label="Page navigation">
|
|
<!-- Mobile navigation buttons -->
|
|
<a rel="prev" href="../by-example/software_tasks.html" class="mobile-nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
|
|
<i class="fa fa-angle-left"></i>
|
|
</a>
|
|
|
|
<a rel="next prefetch" href="../by-example/app_init.html" class="mobile-nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
|
|
<i class="fa fa-angle-right"></i>
|
|
</a>
|
|
|
|
<div style="clear: both"></div>
|
|
</nav>
|
|
</div>
|
|
</div>
|
|
|
|
<nav class="nav-wide-wrapper" aria-label="Page navigation">
|
|
<a rel="prev" href="../by-example/software_tasks.html" class="nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
|
|
<i class="fa fa-angle-left"></i>
|
|
</a>
|
|
|
|
<a rel="next prefetch" href="../by-example/app_init.html" class="nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
|
|
<i class="fa fa-angle-right"></i>
|
|
</a>
|
|
</nav>
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
<script>
|
|
window.playground_copyable = true;
|
|
</script>
|
|
|
|
|
|
<script src="../elasticlunr.min.js"></script>
|
|
<script src="../mark.min.js"></script>
|
|
<script src="../searcher.js"></script>
|
|
|
|
<script src="../clipboard.min.js"></script>
|
|
<script src="../highlight.js"></script>
|
|
<script src="../book.js"></script>
|
|
|
|
<!-- Custom JS scripts -->
|
|
<script src="../mermaid.min.js"></script>
|
|
<script src="../mermaid-init.js"></script>
|
|
|
|
|
|
</div>
|
|
</body>
|
|
</html>
|