Rust Language

Rust para embarcadores

Cecília Carneiro e Silva

(@ceciliacsilva)

Sobre mim

  •  Graduação em engenheria Elétrica com ênfase em computação (UFU).
  • Mestrado (UFU) - Rust em sistemas embarcados (estratégias e modelos de programação).
  • Doutoranda (pesquisadora em um projeto de P&D) (UFU) - Sistemas de dados (+ Rust).
  • Interesses: linguagens, programação de sistemas (e suas diversões).

Agenda

  • Introdução.
  • O que Rust?
  • Rust strikes back...
  • Rust em sistemas embarcados.

Problema

https://msrc-blog.microsoft.com/2019/07/16/a-proactive-approach-to-more-secure-code/

  • Necessidade de linguagens mais seguras.

  • Segurança/determinismo - no Undefined Behavior.

  • Memória em estado consistentes sem coletor de lixo.

https://www.youtube.com/watch?v=9ev3xTDEhtw

Controle x Segurança

  • Mozilla, para "systems programming" *.
  • Rust v1.0.0 foi liberada em Maio/2015 👶🏽.
  • Confiável, rápida, produtiva. *
  • Community-driven (RFC) e código aberto.
 

https://leftoversalad.com/c/015_programmingpeople/

Como?

  • Type System.
  • Zero cost abstractions.
  • Ownership + Borrow checker + lifetime.
  • Ferramentas (Construção, teste, documentação).
  • Multiparadigma (OO + funcional).
  • Enuns.
  • Tratamento de erro explícito (sem exceptions).
  • Sem NULL.

  • Pattern matching.
  • Macros.
  • Erros de compilação amigáveis.
  • Boa parte dos bugs encotrados em programas concorrentes são impossíveis em Rust!("Fearless concurrency")

Por que  amar Rust?

Type System

e genéricos (trait bound)

Sistema de tipos estático e inferido (onde possível).

 

Lógica de négocio nos tipos.

 

Traits (interface) - compartilhamento de comportamento.

 

Traits ~ Haskell Typeclasses.

Type System

e genéricos (trait bound)

Traits são a base do sistema de polimorfismo.

 

Genéricos - monomorfismo (compilação).

 

Aceita qualquer tipo que implemente a interface necessária.

code

Rust Ownership

Para um tipo (T) você tem:

T, &mut T, &T


     T é owned, &mut T é exclusive,

&T é shared.

 

Recursos estão atrelados a um "dono". Quando termina o escopo do dono, o compilador se encarrega de liberar o recurso (Drop - Free).

code

Borrow checker

  • múltiplas &T. ✔️
  • múltiplas &mut T. ✖️
  • &mut T e &T. ✖️

 

Você precisa convencer o compilador que não há race-conditions no seu programa.

 

Compilador garante que elas (&) não "vivem" mais do que o T.

e lifetime.

code

Embedded Rust

microcontroladores

Bare metal

Embedded Rust Wg

Working group

  • Objetivo: experiência próxima ao desenvolvimento de aplicações para PC em Rust.
  • Segurança, eficiência e produtividade.
  • Definição conjunta das interfaces/contratos (embedded-hal) - reuso e portabilidade.
  • Design patterns.
  • Documentação e tutoriais.

https://rust-embedded.github.io/book/portability/index.html by Embedded Rust WG is licensed under CC BY.

https://rust-embedded.github.io/book/start/registers.html by Embedded Rust WG is licensed under CC BY.

Organização (crates)

Demos
stm32f4xx_hal
cortex-m/cortex-m-rt
stm32f4
STM32F4

demo1 - ligando um led.

  • #[entry], peripherals, configurações.

#![no_std]

  • Rust = core + stdlib.
  • stdlib -> Sistema Operacional.
  • Estruturas de dados (heapless).
  • #![no_main] = não procure pela 'fn main()'.
  • #[entry] = função que será chamada após a inicialização da RAM.
  • #[panic] = implementação do 'panic!'.

demo2 - Concorrência

#[interrupt], Mutex...

Misc

Cross compilation

$ rustup target add thumbv7em-none-eabihf
  • Todas as otimizações desenvolvidas para tal plataforma.

Linker

  • Transparente (responsabilidade do cortex-m-rt)
  • App contém apenas o "memory.x":
MEMORY
{
/* NOTE K = KiBi = 1024 bytes */
FLASH : ORIGIN = 0x08000000, LENGTH = 64K 
RAM : ORIGIN = 0x20000000, LENGTH = 32K
}

/* This is where the call stack will be allocated. */
/* The stack is of the full descending type. */
/* NOTE Do NOT modify `_stack_start` unless you */
/* know what you are doing */
_stack_start = ORIGIN(RAM) + LENGTH(RAM);

Build

  • Cargo.
  • config: linker e target (cross target).
$ cat .cargo/config 
[target.thumbv7em-none-eabihf]
rustflags = [
  "-C", "link-arg=-Tlink.x",
]

[build]
target = "thumbv7em-none-eabihf"

$ cargo build

Mais...

  • Outros periféricos e abstrações.
  • Outros μC e μP.
  • Ferramentas e conceitos padrões que pode não ser o ideal para uma aplicação particular.
  • Bibliotecas e ferramentas auxiliares. (Várias!)
  • Concorrência... (Async, RTIC)
  • Sistemas operacionais de tempo real (TockOS).

Conclusões

  • Rust é pequeno, rápido e seguro; pode realmente ser uma opção para o restrito mercado dos sistemas embarcados.
  • Experiência diferente, focado no reuso de código.
  • Ainda é recente, uso em produção requer uma série de cuidados.
  • Ecossistema não é maduro como C/C++.
  • Curva de aprendizado da linguagem.
  • Ainda falta suporte dos fabricantes.

Obrigada.

Made with Slides.com