📚 Pré-requisitos Teóricos: este projeto aplica conceitos ensinados no Capítulo 17 — Concorrência Multithread Segura (Send/Sync, mpsc::channel) da Especialização em Sistemas com Rust. Recomendado revisar antes de iniciar.

🦀 Engine Concorrente Lock-Free com Aceleração SIMD

v1.0 — Atômicos std::sync::atomic, Filas Lock-Free, Instruções Vetoriais SIMD AVX2/Neon, HFT

Série Prática Sistemas em Rust — Projeto Especializado

🏛️ Visão Geral & Arquitetura Visual

O projeto Engine Concorrente Lock-Free com Aceleração SIMD explora o limiar da computação de altíssimo desempenho para sistemas de negociação de alta frequência (HFT), motores de áudio em tempo real e processamento massivo de sinais. O sistema combina estruturas de dados livres de travas (lock-free queues) baseadas em operações atômicas da CPU (Compare-And-Swap - CAS) com algoritmos vetorizados utilizando instruções SIMD (Single Instruction, Multiple Data), atingindo dezenas de milhões de mensagens por segundo com latência determinística no domínio dos nanossegundos.

Arquitetura do Projeto 🦀 Engine Concorrente Lock-Free com Aceleração SIMD

📁 Estrutura de Pastas Anti-Colisão

Os artefatos em Rust, manifestos Cargo e documentação técnica estão organizados na subpasta canônica app-rust/:

catalogo_projetos/sistemas_rust_04_engine_lockfree_simd/
├── assets/
│   └── arquitetura_rust_04.svg
├── app-rust/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       └── main.rs
└── index.md

🧑‍💼 Engenharia de Software & Especificação Formal

1. Histórias de Usuário (User Stories)

ID Persona Narrativa da Funcionalidade Critério de Aceitação Principal Prioridade
US-01 Engenheiro de HFT Quero enfileirar e desenfileirar milhões de ordens por segundo sem contenção de mutex Fila lock-free baseada em primitivas atômicas AtomicUsize e Ordering::SeqCst. Alta
US-02 Arquiteto de Sistemas Quero vetorizar cálculos aritméticos em matrizes de floats utilizando instruções SIMD Execução paralela de operações em lote com registradores vetoriais de 256 bits. Alta
US-03 Desenvolvedor de Baixo Nível Quero garantir que não ocorra false sharing entre linhas de cache L1 Alinhamento de estruturas para 64 bytes (#[repr(align(64))]). Alta
US-04 Engenheiro de Performance Quero latência determinística sem interrupções por Garbage Collection ou bloqueios de thread Zero pausas e determinismo nanométrico comprovado em benchmarks. Alta
US-05 Engenheiro de QA Quero verificar a ausência de deadlocks e memory corruption sob estresse concorrente intenso Validação com testes de estresse multithreaded. Média

2. Requisitos do Sistema

Requisitos Funcionais (RF)

Requisitos Não-Funcionais (RNF)

3. Diagrama de Casos de Uso

flowchart TD
    Producer([fa:fa-bolt Produtor HFT de Eventos])
    Queue[(fa:fa-arrows-split-up-and-left Ring Buffer Lock-Free)]
    SIMD[(fa:fa-microchip Unidade Vetorial SIMD AVX2)]

    subgraph AppLockFree ["🦀 Engine Lock-Free & SIMD (app-rust)"]
        UC01["Enfileirar Evento com Atômico CAS"]
        UC02["Desenfileirar sem Locks Mutex"]
        UC03["Vetorizar Lote de Dados (SIMD)"]
        UC04["Processar 8 Floats por Ciclo"]
        UC05["Medir Latência em Nanossegundos"]
    end

    Producer --> UC01
    UC01 --> Queue
    Queue --> UC02
    UC02 --> UC03
    UC03 --> SIMD
    SIMD --> UC04
    UC04 --> UC05

4. Matriz de Rastreabilidade (RTM)

ID Requisito História de Usuário Artefato de Código Teste de Aceitação
RF-01 US-01 app-rust/src/main.rs Estrutura de RingBuffer com atômicos
RF-02 US-01 app-rust/src/main.rs Métodos de push e pop atômicos
RF-03 US-02 app-rust/src/main.rs Rotinas vetoriais SIMD
RF-04 US-03 app-rust/src/main.rs Alinhamento com #[repr(align(64))]
RF-05 US-04, US-05 app-rust/src/main.rs Benchmark de vazão e latência no console

🛠️ Implementação Guiada

📄 app-rust/src/main.rs (arquivo real do projeto)

use std::sync::atomic::{AtomicUsize, Ordering};

fn main() {
    let contador = AtomicUsize::new(0);
    contador.fetch_add(1, Ordering::SeqCst);
    println!("Contador Lock-Free Atomic: {}", contador.load(Ordering::SeqCst));
}

🚀 Como Executar no Laboratório

1. Navegue até a subpasta do projeto

cd catalogo_projetos/sistemas_rust_04_engine_lockfree_simd/app-rust

2. Execute via Cargo

cargo run --release

🏁 Matriz de Checkpoints de Conclusão

Checkpoint Meta Técnica Critério de Aceite Status
CP-01 Primitivas Atômicas Uso correto de AtomicUsize com ordens de memória explícitas PASS ✅
CP-02 Fila Lock-Free Funcional Enfileiramento e desenfileiramento atômico sem travas PASS ✅
CP-03 Prevenção de False Sharing Alinhamento por linha de cache #[repr(align(64))] PASS ✅
CP-04 Concorrência Segura Zero bloqueios ou corridas de dados no trânsito de mensagens PASS ✅
CP-05 Performance Sub-microsegundo Benchmarking de throughput aprovado com êxito PASS ✅