Thank you for sending your enquiry! One of our team members will contact you shortly.
Thank you for sending your booking! One of our team members will contact you shortly.
Course Outline
RISC-V Architecture Fundamentals and Ecosystem Overview
RISC-V ISA Landscape and Industry Adoption
- The philosophy of open ISAs and the standardization landscape managed by RISC-V International.
- Mental models of RISC-V: Load-Store architecture, register file structures, and byte ordering conventions.
- Comparative analysis with ARM, x86, and POWER architectures: Evaluating trade-offs for heterogeneous computing systems.
- Assessment of ecosystem maturity, including contributions from SiFive, T-Head, Western Digital, and the expanding open-source silicon community.
- Standardized interfaces: RISC-V Privileged ISA and the Machine Software Abstraction Layer (MSBL).
Memory Models and ABI Compliance
- Unprivileged Architecture specifications: Control and Status Registers (CSR) mapping, exception handling mechanisms, and memory hierarchies.
- RV32I and RV64I instruction sets, along with ABI compliance ensuring cross-platform binary portability.
- Memory ordering conventions and barrier instructions essential for multiprocessor systems.
RISC-V Assembly Programming and Compiler Toolchain
Low-Level Instruction Programming
- Base integer instructions (I), Multiply/Divide (M), and Atomic operations (A) extensions.
- Bitness-aware programming strategies tailored for 32-bit and 64-bit RISC-V targets.
- Calling conventions and stack frame management techniques for embedded and real-time software systems.
Compiler Toolchain Proficiency
- LLVM-based compiler toolchains: Utilizing Clang, LLVM, and Binutils for RISC-V cross-compilation.
- Linker scripts, section management, and memory layout configuration for bare-metal and RTOS environments.
- Leveraging compiler intrinsics, optimization levels, and profiling-driven code tuning.
- Workflows for developing open-source toolchains: Building, testing, and packaging custom GCC/Clang toolchains.
Embedded Systems Development and Real-Time Operating Systems
Bare-Metal and RTOS Programming
- Rust systems programming for RISC-V: Utilizing zero-cost abstractions, unsafe memory management, and bare-metal development techniques.
- Developing in No-Std environments: Custom linkers, device driver creation, and memory-mapped I/O handling.
- Utilizing Zephyr RTOS and Buildroot BSPs for RISC-V target platforms.
- Peripheral interfacing: Programming GPIO, I2C, SPI, UART, and DMA controllers.
Power and Performance Optimization
- Clock gating, power domain management, and optimization of low-power modes.
- Cycle-accurate performance analysis using simulation profilers and hardware performance counters.
- Tuning real-time interrupt latency for safety-critical applications.
Linux Kernel and Bootloader Development for RISC-V
Boot Firmware and Bootloader Ecosystem
- OpenSBI implementation: Developing bootloader firmware based on the SBI specification.
- Implementing UEFI/EDK II on RISC-V for modern firmware boot stack development.
- Porting Coreboot and U-Boot to RISC-V single-board computers.
Linux Kernel Integration
- Contributing to the RISC-V mainline kernel: Device tree overlays, CPU topology management, and AIA interrupt controller driver development.
- Developing Vendor BSPs and configuring kernels for custom SoC platforms.
- Ensuring file system support, networking stack functionality, and containerization capabilities (Docker, Kubernetes) on RISC-V host systems.
RISC-V SoC Design and FPGA Prototyping
Multicore SoC Architecture and Integration
- Network-on-Chip (NoC) design methodologies for RISC-V multi-core processors.
- Implementing Axi4/CHI cache coherence protocols and inter-processor communication standards.
- Integrating open-source IP: Leveraging OpenCores, the ChIPS Framework, and vendor RTL components.
- Designing bus matrices and integrating memory controllers (DDR, SRAM, eMMC, PCIe).
FPGA-Based Processor Prototyping
- Synthesizing and implementing RISC-V cores on FPGA platforms (e.g., BOOM, VexRiscv, PULP).
- Applying SystemVerilog Assertions (SVA) and UVM-based functional verification methodologies.
- Utilizing formal verification tools and property-based testing for RISC-V core validation.
RISC-V Vector Extensions and Domain-Specific Acceleration
RVV (RISC-V Vector) Extension Deep Dive
- Vector load/store operations, vector-fused multiply-add (VFMA), and matrix computation acceleration techniques.
- Variable-length vector operations (VL, VLEN) enabling workload-optimized SIMD execution.
- Utilizing vector mask operations, segment control, and data type flexibility for DSP and ML workloads.
Custom DSP and Domain-Specific Instruction Design
- Designing domain-specific accelerators through custom extensions and CBAR-based operand interfaces.
- Modifying compiler frontends to support custom instruction generation and code emission.
- Strategies for hardware-software partitioning to integrate accelerators into production SoCs.
AI Acceleration and Edge Machine Learning on RISC-V
NPU Design and Integration for RISC-V Processors
- Neural Processing Unit architectures: Utilizing systolic arrays, tensor cores, and weight compression for on-chip AI acceleration.
- Applying model quantization techniques (INT8, INT4, FP8) for edge deployment on RISC-V devices.
- Ensuring framework compatibility with TensorFlow Lite Micro, ONNX Runtime, and PyTorch Edge on RISC-V targets.
Heterogeneous Computing for AI Workloads
- Co-designing RISC-V host CPUs with AI accelerator NPUs to support real-time inference pipelines.
- Optimizing the memory subsystem: Managing HBM/DDR bandwidth for ML model weights and activations.
- Addressing thermal and power budgeting challenges in edge AI inference systems.
Hardware Security and Confidential Computing on RISC-V
Physical Memory Protection and Trusted Execution
- Implementing Physical Memory Protection (PMP) and Page Table walker security mechanisms.
- Developing Secure Enclave/TEE architectures for RISC-V: Integrating OP-TEE and SEV-class trusted execution environments.
- Securing the boot chain: Establishing roots of trust, secure boot processes, and measured launch attestation.
Cryptographic Acceleration
- Utilizing RISC-V cryptographic extensions (Zk, Zkr, K) for accelerating SHA, AES, RSA, RSA-PSS, and ECC operations.
- Integrating post-quantum cryptography (PQC) into next-generation RISC-V processors.
- Mitigating side-channel attacks through constant-time programming, masking techniques, and hardware random number generators.
Advanced Custom Architecture and ISA Extension Design
Domain-Specific Architecture and Custom Instruction Extensions
- Methodology for ISA extension design: Encoding, encoding tables, ABI impact analysis, and the submission process to RISC-V International.
- Designing custom register files using CBAR (Custom Base Address Registers) for efficient operand dispatch.
- Optimizing instruction pipelining, hazard detection, and pipeline modifications for custom extensions.
Verification and Signoff of Custom Architecture Modifications
- Designing testbenches for custom extensions: Generating directed versus constraint-random stimuli.
- Establishing regression testing frameworks and coverage-driven verification processes for architectural modifications.
- Conducting interoperability testing to ensure custom instructions operate correctly within established ABI constraints.
Safety-Critical and Automotive RISC-V Applications
Functional Safety and Automotive Standards Compliance
- Achieving ISO 26262 functional safety compliance for automotive processors based on RISC-V.
- Determining ASIL-Q classifications and developing safety manuals for RISC-V silicon IP.
- Implementing deterministic interrupt handling, lockstep core pairs, and memory protection measures for safety-critical RISC-V systems.
Industrial Real-Time and Edge Computing Applications
- Ensuring IEC 61508 SIL compliance and deterministic scheduling on RISC-V multicore platforms.
- Developing Industrial IoT gateways using RISC-V: Managing connectivity, edge analytics, and OTA firmware update systems.
Capstone Project: End-to-End RISC-V System Development
Full Lifecycle Project
- Architecture specification: Designing ISA extensions and core configurations for a defined use case.
- RTL implementation in SystemVerilog, accompanied by UVM testbenches and formal verification coverage.
- FPGA prototyping, boot firmware development, and integration of bare-metal driver stacks.
- Customizing Linux BSPs and toolchains for the custom RISC-V core.
- Deploying AI workloads: Integrating NPUs, applying model quantization, and performing performance benchmarking.
- Validating security: Enforcing PMP, implementing secure boot, and benchmarking cryptographic acceleration.
- Producing technical architecture documentation, analyzing IP strategies, and presenting findings to cross-functional teams.
Requirements
None.
21 Hours
Testimonials (2)
The explanations and interactivity of the trainer, he really brought the subject well; and even-though I was probably not experienced enough, I did learn a lot from it!
Pieter Bruynseels - Spot Buy Center BV
Course - Design Patterns
I liked the platform we used. It was really nice and easy to use. I liked the typescript section, the part about namespaces and modules.
