Designing multicore solutions

14 October, 2008

Multicore processing is having a tremendous impact on the development of embedded systems in the military and elsewhere. While previous multiprocessing solutions involved two or more physical chips, which doubled or more the amount of board space consumed, the introduction of multiple processing cores in a single chip allows operating systems and applications to take advantage of increased computing power. It has also provided access to additional computing resources without noticeably increasing the size or weight of the system.

But as developers delve deeper into the nuts and bolts of designing multicore systems, they’re finding that these advantages come with certain obstacles in the form of additional considerations that must be taken into account during the design process. This impact on software is most immediately felt on the design of your OS, which must support either asymmetric multiprocessing, AMP, or, ideally, the more advanced symmetric multiprocessing, SMP, architecture. There are also considerations to be made when approaching the applications that will run on your multicore system.

Finding the right OS balance

In multicore computing, the functions performed by the operating system become layered and more complex. The operating system design must be capable of handling the complex concurrency issues that arise with multicore architectures. Some of the generic areas of OS design that are affected by the presence of multiple cores are initialisation, interrupt handling, scheduling and locking.

However, in the context of a real time operating system, other key factors such as priority scheduling, determinism and interrupt latency should be preserved in multicore architectures. One such design optimisation, known as processor affinity, may allow applications to request an affinity to a processor core. In this case, the operating system schedules the applications on the preferred processor core, as long as it does not affect overall system scheduling.

A more rigid form of processor affinity is processor binding, where the task is always scheduled on the same processor core. However, this approach in real time operating systems may lead to priority inversions. Operating system design should accommodate considerations such as processor affinity without degrading realtime determinism & responsiveness.

A real time operating system like LynxOS from LynuxWorks, supports SMP and can schedule tasks dynamically and transparently between processors to efficiently balance workloads using available processors. It optimises the support of load balancing on multiple cores along with preserving the key elements of real time latency and determinism.

Optimising multicore applications

Applications written for uni-processor execution are not necessarily optimised for multicore architectures. Any inherent contention for resources that prevents execution parallelism may result in performance bottlenecks in multicore environments.

Applications that are CPU-bound can exploit the full power of multicore architectures, while memory-bound or I/Obound applications may need to be optimised to avoid the bottlenecks that arise due to bus contention in symmetric multiprocessing architectures. Multithreaded applications can implicitly invoke resource contention as they request services from the operating system.

When looking at applications on multicore solutions, embedded developers must determine the allocation of functions within applications and redesign their applications to exploit parallelism.

Developers must consider the design trade-offs of using multi-threading vs nonmulti- threading to harness the power of multiple processor cores. In some instances, applications may perform better on a single core system.