As software-defined vehicles continue to evolve, automotive teams are increasingly looking beyond traditional MCU-based architectures. Modern operating systems such as QNX SDP 8.0 provide compelling advantages for next-generation vehicle platforms, enabling service-oriented architectures, simplified software deployment, and more flexible application updates. Yet one critical challenge remains: How can one achieve the same deterministic timing behavior when porting applications from Classic AUTOSAR microcontrollers to microprocessors? This is supported by MotionWise Schedule as it provides deterministic scheduling mechanisms, using the same task semantics that developers are used to from Classic AUTOSAR.
The Migration Dilemma: Modern Platforms vs. Deterministic Timing
OEMs and Tier-1 suppliers are transitioning from domain specific and signal-based architectures to centralized, service-oriented computing platforms based on QNX SDP 8.0. These platforms provide powerful capabilities that are difficult to achieve on classic MCU environments:
- Independent application deployment and updates
- Automatic process isolation by MMU
- Improved scalability for future vehicle functions
These benefits make POSIX-based platforms attractive for next-generation vehicle architectures. However, migrating existing, legacy software is often far more complicated than simply recompiling the code, due to – among others – the difference between execution models.
Why Classic AUTOSAR Applications Behave Differently
Classic AUTOSAR applications are built around the concept of periodic tasks and control loops. Software Components (SWCs) contain runnables that are triggered by the AUTOSAR Runtime Environment (RTE) according to well-defined timing constraints.
Developers rely on characteristics such as:
- Low activation jitter
- Predictable periodic execution
- Deterministic task activation
- Well-defined execution order
- Short deadlines for safety-critical workloads
Over many years, applications have been carefully optimized and validated based on these assumptions.
When these applications are migrated to a QNX-based environment, developers quickly discover that it behaves differently.
Example of init and periodic runnables used in Classic AUTOSAR RTE
Example of the Init and Main functions of VehicleStateEstimation
(they will be reused in the QNX process)
The Scheduling Challenge
QNX SDP 8.0 was never designed to replicate Classic AUTOSAR execution semantics.
Although the operating system provides the necessary real-time scheduling capabilities, it executes threads and processes rather than AUTOSAR-style runnables.
With having many individual threads, it is challenging to enforce optimal, deterministic execution patterns across individual applications, to provide proper isolation with the standard OS schedulers, and it can only be approximated with additional synchronization mechanisms.
Development teams often encounter:
- Increased execution jitter
- Less deterministic activation patterns
- Different prioritization behavior
- Challenges with fast cyclic workloads with deadlines
- Loss of timing assumptions embedded in existing software
The consequence is often extensive application rework
Engineering teams may need to redesign software architectures, rewrite timing-critical logic, or introduce additional synchronization mechanisms. For large vehicle programs containing millions of lines of proven software, this effort can become a significant barrier to migration.
In some projects, the challenge even leads to the opposite decision: moving existing applications back to powerful MCU platforms because Classic AUTOSAR environments provide a better match for the desired timing behavior.
Bridging the Gap with MotionWise Schedule
MotionWise Schedule enables software teams to obtain the benefits of QNX SDP 8.0 while providing the deterministic execution characteristics traditionally associated with Classic AUTOSAR. In a Classic AUTOSAR environment, runnables are the fundamental execution units inside Software Components. The AUTOSAR Runtime Environment is responsible for activating these runnables according to configured events and timing constraints.
Instead of forcing applications to adapt to a “thread-oriented” execution model and rework the Software Components into multi-threaded processes, MotionWise Schedule introduces a time-aware execution concept that coordinates activities according to timing requirements and it supports runnable semantics: MotionWise Schedule can execute workloads using a familiar runnable-based model. This model enables a more deterministic scheduling and coordination of the workload executions.
What This Means for Developers
MotionWise Schedule offers features that are traditionally provided by the Classic AUTOSAR Runtime Environment, including:
- Periodic activation of runnables
- Time-aware execution coordination
- Deterministic scheduling behavior
- Management of execution timing constraints
- Consistent runtime triggering of software functions
As a result, software teams can reuse substantial portions of their existing application logic while gaining access to the benefits of QNX SDP 8.0. The existing application design can be largely preserved.
This approach allows migrated workloads to retain predictable activation and execution patterns.
Executing the same runnables with MotionWise Schedule on QNX, without the need of thread- and time management in the code
MotionWise Schedule provides tools to achieve the desired runnable timing. Based on user input configuration it generates a correct-by-design embedded schedule configuration for the MotionWise Schedule runtime, which is described in another article: MotionWise Global Scheduler: Tackling the Challenges of Modern SDVs. This enables flexible updates and quick deployment of newly added components, as the process considers all timing requirements (from existing and newly added components) upon changes.
Users can easily configure the runnable by period, budget, allowed CPU cores and many others (jitter, deadlines etc.) in MotionWise Schedule. The parameters can be changed by an integrator without any code change.
Furthermore, once having the runnables up and running, precedence and ordering constraints can be easily achieved without any (manual) embedded code change. This is supported by the so-called Computation Chain scheduling feature of MotionWise Schedule. The exact sequences of runnables are considered during the offline schedule configuration process, while not just the order of the runnables, but also end-to-end latency budgets can be specified. As a result, the execution follows the requested sequence during runtime, independently if the sequence is on the same CPU core or includes multiple ones.
Example Computation Chain with MotionWise Schedule on QNX
Unlocking the Benefits of QNX Without Sacrificing Determinism
The ability to preserve timing behavior has a direct impact on project economics. MotionWise Schedule reduces the engineering effort significantly and reduces risk during architectural transitions.
This lowers migration barriers and helps organizations confidently move toward the next generation of software-defined vehicles. Instead of focusing engineering resources on reimplementing scheduling logic, teams can concentrate on delivering vehicle functionality and innovation.
For automotive organizations adopting QNX, the objective is clear: leverage the flexibility and scalability of a modern operating system while maintaining the deterministic execution behavior required by real-time vehicle applications.
MotionWise Schedule enables exactly that.
Conclusion
The transition from Classic AUTOSAR platforms to QNX-based architectures offers enormous opportunities for scalability, maintainability, and software deployment flexibility. However, differences in scheduling behavior frequently create a major obstacle for migration projects.
MotionWise Schedule addresses this challenge by introducing deterministic, time-aware execution on QNX platforms and by supporting runnable-based execution models familiar to AUTOSAR developers.
The result is a practical migration path that preserves predictable timing behavior, minimizes software rework, and enables automotive teams to modernize their architecture without compromising real-time performance.
Want to learn how MotionWise Schedule can simplify your migration from Classic AUTOSAR to QNX? Contact the TrustMotion team and discover how MotionWise Schedule can accelerate your transition to next-generation vehicle platforms.
This article was co-written by Tamas Liszbauer, Product Manager at TrustMotion, and Anerudh Athrey, Senior Technical Product Manager at QNX.
