RTOS Performance Report (2024) – Now Available

In today’s fast-changing world of embedded systems and IoT, devices are becoming more interconnected and taking on increasingly complex tasks, especially at the edge. This shift has created a growing need for precise, predictable timing, where even small delays can have serious consequences. With the rise of advanced technologies like sensor arrays, human-machine interfaces (HMIs), communication protocols, encryption algorithms, and artificial intelligence (AI), RTOS performance has gone from being a useful advantage to an absolute necessity.

The market offers over a hundred RTOS options, ranging from simple, open-source schedulers to highly specialized, safety-critical, certified commercial solutions. However, despite the wide selection, not all RTOS solutions are created equal, and the choice of an RTOS can significantly impact the performance and success of your application, not to mention the hardware you select.

Consider a low-power IoT sensor node running on a battery. The device must strike a balance between power consumption and performance to stay operational for months or even years without needing a battery replacement. In this context, an efficient RTOS plays a critical role: it manages the device’s sleep cycles, wakes the processor only when necessary, and executes tasks with minimal energy use. On the other hand, an inefficient RTOS might keep the processor awake longer than required, quickly draining the battery and shortening the device’s lifespan. The efficiency of the RTOS can ultimately decide whether an IoT deployment succeeds or fails.

What Does the RTOS Performance Report Cover?

The RTOS Performance Report (2024) represents an in-depth benchmarking analysis of three popular open-source RTOSes and one commercially available RTOS. We will examine their performance across key areas that are vital to the functioning of embedded systems, including:

• Cooperative Scheduling
• Preemptive Scheduling
• Memory Allocation
• Synchronization Processing
• Message Processing

While performance is just one of many factors to consider when selecting an RTOS, (see 7 Characteristics to Consider when Selecting an RTOS), it is a critical metric that directly influences your system’s reliability and efficiency. As the industry continues to trend toward more complex and interconnected systems, understanding the performance characteristics of an RTOS becomes essential for ensuring that your embedded applications can meet the increasingly demanding requirements of today’s technological landscape.

In the future, we plan to expand this study to include additional RTOSes and delve into the impact of POSIX APIs on performance. Until then, enjoy the results we’ve found so far, and think carefully about how they may or may not impact how you design your real-time applications.

To download the full report, click here, or you can click the image below:

The RTOS Performance Test Methodology

Our RTOS benchmark analysis was based on a series of tests from the Thread Metric benchmark suite, formerly offered by Microsoft and now offered by the Eclipse Foundation. The Thread Metric benchmark suite is under MIT license and can be found on GitHub here: Thread Metric Benchmark Suite.

The Thread Metric benchmark suite consists of eight tests, one of which is a calibration test to ensure the platform’s operation is similar.  For this study, we have selected the following five Thread Metric RTOS performance tests:

• Cooperative Scheduling
• Preemptive Scheduling
• Memory Allocation
• Synchronization Processing
• Message Passing

Each test is based on total throughput within a 30-second time interval, with higher throughput indicating a more efficient RTOS.

How the RTOS was Configured and Tested

We conducted the analysis on the ST STM32L4 IoT Discovery Node (B-L475E-IOT01A), equipped with an 80MHz Cortex-M4 processor. Results were consistent across multiple boards, with variations within a 1% margin. The repeatability of the tests easily fell within this margin, and in most cases, it was much better. (Which is what you’d expect from a deterministic RTOS).

The original intent was to compile each RTOS in IAR EWARM and run the tests. We discovered that Zephyr RTOS was tightly coupled to its build system, and the time required to set it up with IAR Embedded Workbench for Arm was prohibitive. That forced us to make some adjustments.

The RTOS and Thread Metric benchmark code were compiled using GCC version 12.3 (or similar). All RTOS C code was optimized for speed with uniform compilation flags across all RTOS versions. The specific versions used in this analysis are:

• FreeRTOS 11.1.0
• PX5 RTOS 5.1.0
• Eclipse ThreadX 6.1.1
• Zephyr 3.7

The RTOSes were left in their default configuration for the STM32L475. The configuration matters because, for your application, you might use different configuration settings that affect how the RTOS performs. The defaults were used because they are the most likely settings most embedded system teams use. Some configurations were adjusted to ensure that the comparisons were as close to “apples to apples” as possible.

For example, not all RTOSes support argument checking, assertions, or might have additional checks that are performed in debug builds. We disabled these features since they would typically be disabled in production, allowing for the most reliable comparison between RTOSes.

It’s always possible something was overlooked. I’ve provided the configuration settings for each RTOS in the appendices so you can easily see the test conditions. This is important for transparency and for anyone to reproduce the results.

Next Steps

RTOS performance is essential for applications that require high performance and for applications that need to minimize processor cost and power consumption. These considerations should apply to all embedded applications. There is no reason to unnecessarily increase the device BOM cost because of poor RTOS performance.

In time, I want to add other RTOSes to this study to provide a fuller picture of RTOS performance and the state of the industry. There are several additional RTOSes that we are looking to add to this study in the future, including:

• RT-Thread
• SEGGERs embOS
• NuttX

With the push to leverage POSIX APIs in embedded applications, we hope also to perform these tests using POSIX APIs in addition to the native RTOS APIs.

Download the RTOS Performance Report Now to see how these RTOSes compare.