A Rust Framework for Real-Time Parallel Programming

Real-time systems are a challenging research area with applications ranging from the automotive industry to robotics and the Internet of Things. These systems differ from general-purpose systems due to the importance of time-related non-functional requirements, such as deadlines and bounded execution intervals, usually running in resources constrained environments [21].

The development of real-time systems has faced limitations when relying solely on sequential execution models [7]. The widespread adoption of multi-core processors has become the primary approach for increasing computational performance. However, exploiting these architectures efficiently requires software capable of expressing and managing parallel execution. Sequential programming models do not scale well to multi-core platforms and therefore fail to fully utilize the available processing resources. At the same time, the expansion of real-time systems into domains involving close human–machine interaction introduces even stricter timing requirements, further increasing the need for efficient parallel real-time programming models [1, 15].

Real-time parallel programming has been explored in several programming languages. In C/C++, solutions often rely on extensions or directive-based models such as OpenMP [19], while Ada includes language-level support for concurrency and real-time scheduling. Despite these efforts, the programmability of parallel real-time systems remains an active research topic [1, 15].

Rust [13] is an emerging systems programming language that provides strong guarantees regarding memory safety and concurrency correctness. Its ownership-based memory model allows many classes of errors commonly found in low-level languages to be detected at compile time. These characteristics make Rust an appealing candidate for the development of critical and real-time systems [10]. Rust offers several libraries for parallel programming and there is ongoing work on real-time execution support. However, there is still a lack of frameworks that combine both aspects in a unified programming model.

In previous work [4], we proposed the design of a framework aimed at supporting real-time parallel programming in Rust. In this paper, we present an initial proposal for such framework. The paper is structured as follows. The next section provides some background and related work for parallel programming models in real-time systems. Afterward, Sections 3 and 4 provide the design and architecture of the proposed framework, followed by the programming interface in Section 5 and internal execution and runtime behaviour in Section 6. Finally, Section 7 provides the results of experiments done with the proposed implementation, and Section 8 draws the final conclusion and potential future work.

Programming models for real-time systems typically provide abstractions that capture key elements of the real-time execution model [1]. These abstractions include the notion of time, the specification of real-time tasks and their scheduling properties, mechanisms for communication and synchronization between tasks, and control over how computations are mapped onto the underlying execution platform.

Two main approaches have traditionally been used to support these requirements. The first relies on general-purpose sequential programming languages, where concurrency and real-time behaviour are implemented through libraries, operating system primitives, and runtime support. This approach is commonly used with the C programming language [9] together with real-time operating systems and POSIX real-time extensions [11]. The second approach consists of using programming languages where concurrency and real-time constructs are provided as first-class language features, such as in Ada [2] or in Real-Time Java [6].

When considering both concurrency and parallelism, programming real-time systems must address more challenges. In addition to defining concurrent tasks that represent the structure of the application, the programming model must also support the expression of parallelism within the algorithms executed by these tasks. As a result, the programming model must combine mechanisms for defining concurrent activities with abstractions that enable parallel execution inside these activities.

Furthermore, mechanisms are required to control how parallel computations are mapped onto scheduling entities. Although mapping and scheduling are typically handled by the runtime system or the operating system, programming models for real-time parallel systems must expose sufficient control to allow developers to influence these decisions. This results in an integrated vertical stack where the programming model, runtime, and operating system cooperate to manage the mapping and scheduling of parallel computations, as illustrated in Figure 1 [16]: application code is structured as graphs of tasks, which are mapped and executed by underlying threads, themselves scheduled by the operating system. Such control may be exposed through runtime libraries and system calls, or also integrated into the programming model itself.

Despite research efforts, the programmability of parallel real-time systems is still challenging. Among the existing approaches, two representative solutions are particularly relevant: the use of a restricted OpenMP tasking model for real-time systems and the parallel programming capabilities integrated into the Ada language.

OpenMP [5] is a widely adopted API for shared-memory parallel programming, extensively used in high-performance computing. Its applicability has gradually expanded to embedded and critical computing domains, such as video processing in autonomous driving systems. Although OpenMP already provides mechanisms for expressing parallelism, it does not natively support key real-time scheduling properties such as deadlines or worst-case execution time constraints. Serrano et al. [19] proposed an OpenMP profile targeting critical real-time systems, introducing restrictions and extensions to make the tasking model more suitable for real-time execution. While this work establishes important foundations, further research is still needed, particularly regarding the integration of multiple parallel real-time activities and the specification of real-time scheduling properties.

Ada [2] is a high-level programming language designed for safety-critical and real-time systems. It provides built-in support for concurrency through its tasking model, as well as mechanisms for real-time scheduling and synchronization. More recently, Ada has incorporated constructs that support parallel programming [8], allowing developers to express parallel execution within the language while preserving its real-time semantics. As a result, Ada represents a language-driven approach integrating real-time and parallel programming.

Although both OpenMP and Ada adopt fine-grained parallel models, they originate from different communities and design perspectives. OpenMP emerged from the high-performance computing community and provides a comprehensive and flexible parallel programming model. In contrast, Ada was developed primarily for safety-critical and real-time applications and therefore offers extensive support for real-time execution. Consequently, integrating real-time and parallelism follows different directions in these technologies: OpenMP attempts to incorporate real-time properties into an existing parallel programming model, whereas Ada introduces parallel constructs into a language that already supports real-time concurrency [14].

Beyond these two approaches, Maia et al. [12] proposed an approach combining the Java fork/join model with the Real-Time Specification for Java, which was not followed up. Schmid et al. [17] performed a preliminary analysis of real-time execution in frameworks such as Embedded Multicore Building Blocks, Intel Threading Building Blocks, and High Performance ParalleX, concluding that the dynamic nature and limited real-time capabilities of the underlying scheduler in these frameworks makes it a challenge to provide real-time behaviour. A current relevant work is on providing soft real-time behaviour with static memory allocation and probabilistic time bounds, in a manner which is transparent to the programmer [18].

To the best of our knowledge, there is still no framework that integrates structured parallel programming with explicit real-time scheduling control in Rust, with [4] providing some initial ideas.

In order to support the high-level design goals described previously, the internal architecture of the framework is organized around a set of custom Rust structs (Figure 2) that encapsulate both the lifecycle of threads and the associated scheduling logic. Although the user interacts mainly with high-level public abstractions, the library internally coordinates thread creation, job execution, and scheduling through a modular architecture. This separation allows the framework to provide a simple and safe programming interface while still enabling detailed control over execution behaviour.

To achieve this objective, two primary public abstractions are exposed to the programmer: one representing isolated threads and another representing thread pools. This separation allows the framework to maintain internal control over thread management while still providing users with flexible mechanisms to configure and interact with execution entities. Both abstractions are implemented as public structs whose internal state remains private and is managed exclusively by the library. This design ensures that critical thread management data remains encapsulated within the framework, preserving safety guarantees while hiding unnecessary complexity from the user.

The proposed framework builds upon concepts present in existing Rust thread pool libraries, particularly the ThreadPool crate [3], while extending them to address the requirements of real-time systems. The framework introduces mechanisms that provide greater control over scheduling attributes and thread management, while maintaining a simplified programming interface for developers.

Several operations that would normally require direct interaction with low-level system interfaces (typically through libraries such as libc) are encapsulated within safe abstractions. This design allows developers to access system-level functionality without explicitly writing unsafe code, thereby reducing the risk of memory management errors.

The framework is organized into four main modules (Figure 3). The lib module exposes the public interface and contains the methods directly accessible to the user. The remaining modules implement the internal logic of the system.

The thread_manager module contains the data structures and methods responsible for creating and managing threads and thread pools. The thread_runner module implements the execution cycle of the threads, including the mechanisms responsible for executing submitted tasks and enforcing periodic behaviour. Finally, the libc_abstractor module encapsulates all interactions with the external libc library and contains the unsafe code required to access low-level system functionality.

By isolating these operations in a dedicated module, the framework maintains cleaner and safer code across the remaining components. This modular architecture helps organize the framework’s functionality while keeping complex or low-level operations hidden from the user.

This section describes the mechanisms provided by the framework to create and manage threads from the developer’s perspective.

In order to provide the level of simplicity exposed in the programming interface, a significant portion of the complexity involved in thread creation and management is handled internally by the framework. This includes low-level interactions with the libc library, management of scheduling attributes, and coordination of the thread lifecycle.

The lib module contains the public-facing structures ThreadPoolManager and ThreadManager, together with the methods exposed to the user. Internally, this module interacts with the thread_manager module, which contains the internal Thread and ThreadPool structures responsible for storing and managing the data associated with created threads and thread pools. These structures are not accessible to the user and encapsulate the internal state of the runtime.

Finally, the thread_runner module contains the execution logic that runs within each thread created by the framework. This module implements the runtime behaviour of isolated threads, worker threads in thread pools, load-balancing threads, and periodic task handlers. The following sections describe the behaviour of these components in greater detail.

The proposed framework was designed with real-time programming requirements in mind, where timing guarantees, responsiveness, and predictability are critical for system correctness. Therefore, evaluating the performance of the framework is essential to determine its suitability for time-sensitive applications.

A set of experiments was conducted to analyse the behaviour of the framework under different execution scenarios (full description can be found in [20]). The evaluation focused on key metrics such as thread creation time, task execution duration, scheduling latency, and task distribution across worker threads. To collect these measurements, the experimental examples were instrumented with timestamp collection using the Rust std library, namely the Instant type, which allows precise measurement of elapsed time. Synchronization primitives such as Mutex were used to safely propagate timing information from worker threads to the main program. Basic statistical metrics including minimum, maximum, mean, and standard deviation were computed using a Rust statistics library.

Each experiment was executed one hundred times in order to obtain a sufficiently large sample set for analysis. The experiments were conducted on a virtual machine running Ubuntu with four CPU cores and 8 GB of RAM, hosted on a desktop machine equipped with an Intel Core i7-9700K processor and 16 GB of RAM. Although the use of virtualization may introduce additional scheduling variability due to resource sharing, it also provides reproducibility and isolation. Consequently, the results presented here should be interpreted as conservative estimates of performance; improved timing behaviour is expected when executing on dedicated hardware.

Several scenarios were evaluated. The first experiment measured the overhead of creating isolated threads and executing simple tasks. Results showed that thread creation times were consistently below one millisecond on average, while task execution durations closely matched the expected workload timing. Some variability was observed due to the virtualized environment, but most executions remained within predictable bounds.

The second experiment evaluated hierarchical thread creation, where a parent thread dynamically spawned multiple child threads executing periodic tasks. The results showed that child thread creation overhead was very small, and although the coordination performed by the parent thread introduced additional execution time, the framework handled hierarchical thread management efficiently.

A third experiment focused on the thread pool implementation. The results demonstrated that thread pool initialization incurs slightly higher overhead due to the creation of multiple worker threads and internal queues. However, once the pool is created, job dispatch latency becomes extremely small, typically measured in microseconds, indicating that the framework can efficiently reuse worker threads to execute tasks.

A further experiment evaluated task distribution across worker threads when tasks are submitted without explicitly specifying a target thread. The load balancing mechanism showed a relatively even distribution of tasks across available worker threads, confirming the effectiveness of the internal queueing and load balancing strategy. Execution times remained stable even under increased workload.

Finally, a scenario was evaluated in which thread pools were created dynamically from within already running threads using inherited scheduling parameters. While this configuration introduces additional initialization overhead, the results indicate that such dynamic creation remains feasible and reasonably efficient for runtime task management.

Overall, the experimental results indicate that the framework introduces very low overhead for thread creation and task dispatching, while maintaining predictable execution behaviour in most scenarios. Although some timing variability was observed due to the virtualized execution environment, the median values across all experiments remained stable and consistent with the requirements of real-time systems.

Real-time systems increasingly require the ability to exploit parallel hardware while maintaining strict control over timing and scheduling behaviour. Although Rust has gained significant attention as a systems programming language due to its strong safety guarantees and modern concurrency model, support for structured real-time parallel programming remains limited.

This paper presented the design and prototype implementation of a framework for real-time parallel programming in Rust. The framework introduces abstractions for creating and managing real-time threads with configurable scheduling parameters, as well as thread pools that support structured parallel task execution. The design aims to provide developers with explicit control over priorities, processor affinity, and task placement while preserving the safety guarantees offered by Rust.

The prototype implementation demonstrates that it is feasible to combine real-time scheduling mechanisms with parallel programming constructs within the Rust ecosystem. The presented architecture hides low-level complexity from the user while still exposing the necessary controls required for real-time applications. Experimental results indicate that the framework introduces low overhead for thread creation and task dispatch, suggesting that the approach is suitable for time-sensitive environments.

This work represents an initial step toward providing practical support for real-time parallel programming in Rust. Future work will focus on extending the framework with additional programming abstractions, scheduling mechanisms and synchronization primitives. Furthermore, integration with existing real-time operating systems, such as Zephyr, will be explored to allow to further evaluate the overheads and predictability of the framework implementation.