Who Should Attend

This course is designed for experienced developers working in systems or embedded environments, including:

• Embedded Software Engineers
• Systems Programmers
• Linux Kernel and Low-Level Developers
• Engineers working on real-time or multi-core systems
• Technical Leads and Senior Engineers

Prerequisites

Participants should have:

• strong experience in C or C++ programming
• familiarity with Linux development environments
• understanding of basic operating system concepts

Learning Objectives

By the end of this course, participants will be able to:

• understand real-time multitasking concepts and system constraints
• apply concurrent programming techniques on single-core and multi-core systems
• design systems with determinism, preemption, and interrupt handling in mind
• understand processor-level behaviour including cache management and pipeline optimisation
• implement synchronization mechanisms for multi-core environments
• debug complex real-time and concurrent applications
• understand the structure and behaviour of a real-time Linux kernel
• solve classical concurrency problems such as producer-consumer and dining philosophers

Course Content

Day 1 – Introduction to Real-Time and Multi-Core Programming

Participants begin by understanding the foundations of real-time systems and multi-core architectures.

Topics typically include:

• fundamentals of real-time systems and constraints
• multi-tasking and preemptive scheduling
• multi-core architectures and hyperthreading

Development setup and practical work:

• install and configure development and execution environments
• implement a basic context switch routine

Thread-Safe Data Structures

Participants explore how to safely manage shared data in concurrent systems.

Topics typically include:

• linked lists (single and double)
• circular lists, FIFOs, and stacks
• ensuring data integrity using assertions and conditions

Practical exercise:

• implement a thread-safe doubly linked list

Memory Management Strategies

Participants learn how memory behaviour impacts performance and reliability.

Topics typically include:

• allocation strategies (buddy system, best-fit, first-fit, pool management)
• memory layout and optimisation
• detecting and preventing memory errors

Practical exercises:

• implement a thread-safe buddy system memory manager
• enhance memory management to detect leaks and invalid access

Day 2 – Real-Time Components and Multi-Core Interactions

Participants focus on task management, scheduling, and interrupt handling.

Real-Time Task Management

Topics typically include:

• task descriptors, task lists, and context switching
• scheduling models (fixed priority, RMA, EDF, adaptive scheduling)

Practical exercise:

• implement a basic fixed-priority scheduler

Interrupt Handling in Real-Time Systems

Topics typically include:

• time and device interrupts
• edge-triggered vs level-triggered interrupts
• interrupt vectoring and acknowledgement

Practical exercise:

• implement a basic interrupt manager

Multi-Core System Interactions

Topics typically include:

• cache coherence mechanisms (snooping, MOESI protocol)
• memory ordering and memory barriers
• DMA coherency considerations

Practical exercise:

• implement a spinlock for multi-core synchronization

Day 3 – Multi-Core Scheduling and Synchronization

Participants deepen their understanding of scheduling and synchronization mechanisms.

Multi-Core Scheduling

Topics typically include:

• assigning interrupts across processors
• optimising cache usage
• avoiding false sharing and cache contention

Practical exercise:

• analyse and evaluate a multi-core scheduler

Synchronization Mechanisms

Topics typically include:

• semaphores and mutexes
• recursive and non-recursive mutexes
• condition variables and mailboxes

Practical exercises:

• implement a mutex system
• validate proper nesting in recursive locks
• extend mutexes with condition variable support

Priority Inversion and Solutions

Topics typically include:

• priority inversion problem
• priority inheritance vs priority ceiling

Practical exercise:

• implement priority ceiling protocol for mutexes

Day 4 – Concurrency Challenges and POSIX Threads

Participants explore real-world concurrency problems and solutions.

Common Concurrency Problems

Topics typically include:

• producer-consumer problem
• deadlocks, livelocks, and starvation

Practical exercise:

• solve the dining philosophers problem

POSIX Thread Programming (Pthreads)

Topics typically include:

• thread creation and management
• mutexes and condition variables
• POSIX semaphores
• scheduling policies (real-time vs standard)

Practical exercises:

• solve the readers-writers problem using POSIX threads
• implement thread-local storage

Day 5 – Linux Kernel Multi-Tasking and Asymmetric Processing

Participants move into kernel-level programming and advanced system design.

Kernel-Level Multi-Tasking

Topics typically include:

• memory management (buddy and slab allocators)
• task creation and termination

Kernel Synchronization Primitives

Topics typically include:

• atomic operations
• spinlocks and read/write locks
• semaphores and sequential locks

Practical exercise:

• implement a kernel-mode execution barrier

Kernel Timing Mechanisms

Topics typically include:

• hardware clocks and software timers
• high-resolution timing

Practical exercise:

• implement a kernel event synchronization object

Asymmetric Multiprocessing (AMP)

Topics typically include:

• AMP architecture vs SMP
• shared memory challenges
• inter-processor communication (IPC)

Topics include:

• OpenAMP framework
• RemoteProc and rpmsg

Practical exercise:

• implement message passing between AMP cores

Delivery Approach

This is a deep, hands-on engineering programme designed to build advanced capability.

It includes:

• instructor-led technical sessions
• extensive practical exercises
• real-world system-level scenarios
• progressive implementation of real-time components

Duration

5 Days

Delivery Options

This course can be delivered as:

• a public scheduled course
• a private team programme
• virtual delivery (Linux-based lab setup required)
• on-site classroom training

Outcomes

After completing this course, participants will be able to:

• design and implement real-time multi-core applications
• manage concurrency across single-core and multi-core systems
• apply advanced scheduling and synchronization techniques
• debug complex real-time behaviour
• develop kernel-level components and understand Linux internals
• optimise systems for performance, determinism, and scalability

Additional Notes

This programme is particularly valuable for teams developing real-time, embedded, or performance-critical Linux systems, where concurrency and timing behaviour are essential.

It also provides a strong foundation for progression into:

• real-time Linux kernel development
• advanced embedded and RTOS systems
• high-performance computing and systems optimisation

Participants will work extensively with real-world scenarios, ensuring the learning can be applied directly to production environments.