Real-time systems in industrial automation are being asked to do more than execute control logic on a predictable cycle. Machine vision, machine learning, advanced robotics, and model-predictive control can add substantial computational demand, while control and safety functions must continue to meet strict deadlines. Heterogeneous multicore platforms offer more processing capacity, but using that capacity without undermining timing guarantees is a central engineering challenge.
The issue is not simply whether a processor can deliver high average throughput. Industrial applications also need confidence in worst-case behavior: whether a task will complete on time when other cores, accelerators, operating-system services, and memory traffic are active.
Why industrial real-time systems are changing
Programmable logic controllers (PLCs) remain central to industrial automation. Their established programming environments, libraries, and support for fast control cycles make them a practical foundation for machine and process control. At the same time, automation applications are expanding to include workloads such as image processing, AI inference, and more computationally intensive planning.
These functions do not all have the same timing needs. A vision or learning workload may benefit from parallel execution and specialized hardware, while a control task may have a strict response-time deadline tied to a physical process. Combining them on one controller can reduce the need for separate computing units, but it also introduces shared-resource dependencies that must be managed.
Across embedded computing, the hardware response has been to combine general-purpose CPU cores with GPUs, programmable logic, and dedicated accelerators. These heterogeneous systems can run different types of work on engines suited to those workloads. However, the processors and accelerators often share memory systems and interconnects, creating opportunities for one task to affect another’s execution time.
The predictability challenge in heterogeneous multicore systems
Real-time timing analysis traditionally separates two questions: how long a task may execute, and whether the task set can meet its deadlines under a scheduling policy. On a single-core system, estimating a task’s worst-case execution time (WCET) and then analyzing scheduling interference can provide a path to timing guarantees.
That separation becomes more difficult when multiple cores operate concurrently. Tasks may compete for shared caches, memory banks, buses, input/output paths, or other resources. A task’s completion time can depend not only on its own instructions, but also on what other cores are doing and when they access shared hardware.
Memory is a particularly important source of interference. A CPU core or accelerator may have to wait while other agents use shared memory resources. As a result, execution time measured in isolation may not represent execution time under system-wide load. More cores can raise parallel throughput, but can also increase contention and make worst-case timing harder to establish.
This creates a practical tension for system designers:
- Performance-oriented workloads often favor parallelism, flexible software stacks, and optimization for average throughput.
- Predictability-oriented workloads require bounded response times, controlled interference, and evidence that deadlines can be met in worst-case conditions.
Safety-related functions add another constraint. When a system must demonstrate freedom from interference between components with different criticality levels, testing alone may not be enough to provide the necessary assurance. Timing and schedulability evidence must account for how components share the platform.
Modeling parallel work for real-time scheduling
Many traditional real-time task models treat a recurring task as sequential. That assumption does not describe applications that divide work across several processors or use conditional execution paths. Directed acyclic graph (DAG) models can represent parallel tasks and the precedence relationships between their components. More expressive models can also capture conditional branches and alternative execution choices, such as running a computation on a CPU or an accelerator.
These models matter because scheduling decisions affect more than processor assignment. A system may need to consider which engine runs each task, how tasks interact, how preemption is handled, and how shared memory is allocated. For automation engineers, end-to-end latency also matters: the time from sensing a condition through computation to a control action can be more important than the execution time of an individual software task.
Memory-aware execution and resource isolation
One approach to reducing unpredictable memory contention is to coordinate memory access with computation rather than allowing all tasks to compete freely at once. The Predictable Execution Model (PREM), described in the source material, divides task execution into memory and computation phases. During a memory phase, required instructions and data are brought into local memory; during the computation phase, the task runs without competing for the shared memory path in the same way.
A co-scheduler can coordinate access to memory and processor resources. In systems that support this approach, task chunks can be scheduled so memory transfers and computation are managed as parts of a wider timing plan. The details depend on the platform and software stack; the principle is to make resource use more explicit and analyzable.
Other techniques can contribute to isolation. Cache partitioning, memory-bandwidth reservation, and hypervisor-level controls can limit the effects of one workload on another. A partitioning hypervisor can also help separate software with different timing or safety requirements. These mechanisms do not remove the need for system-level analysis, but they can provide a more controlled basis for it.
What automation teams should consider
When evaluating a multicore controller or embedded platform, engineering teams should look beyond core count and peak performance. Useful questions include:
- Which control functions have hard deadlines, and what are their end-to-end latency requirements?
- Which tasks share caches, memory, interconnects, or accelerator resources?
- Can workloads be partitioned or scheduled to limit interference?
- Does the timing analysis reflect the intended hardware configuration and concurrent workload?
- Can the compiler, operating system, or hypervisor provide the information and controls needed for predictable execution?
These questions are relevant whether the system is built around a PLC, a domain controller, or a custom embedded platform. They are also important when integrating vision and AI functions into an existing control architecture, where new workloads may change the timing behavior of established tasks.
Conclusion: Treat predictability as a system property
Heterogeneous multicore hardware can support demanding industrial applications, but added compute capacity does not automatically translate into dependable real-time performance. Shared-memory interference, parallel task behavior, and mixed-criticality requirements all affect whether deadlines can be guaranteed.
For industrial automation teams, the practical implication is to treat predictability as a whole-system design concern. Task models, scheduling, memory management, software partitioning, and timing analysis need to reflect how the platform will actually operate under load. Managing these factors is essential to combining data-intensive workloads with the reliable, deadline-driven control that industrial processes require.