A different angle on multicore

Multicore is a hot topic at the moment. The subject crops up in numerous articles and I have written about it before. Surveys suggest that, before long, more than half of embedded designs will be implemented using multiple CPUs.

There are broadly two hardware architectures: homogeneous multicore, where there are numerous identical cores, and heterogeneous multicore, where the cores differ in architecture. Then, as I have described in a previous post, there are generally two software architectures: SMP [Symmetrical Multi-Processing], where a single operating system instance executes across a number of cores, and AMP [Asymmetrical Multi-Processing], where each core runs its own operating system instance [each of which may be different]. But I recently learned that this is not the whole story …

There are various reasons for adopting a multicore approach to an embedded design, but, broadly speaking, the objective is to provide sufficient computing power to deliver the required performance from the application, while minimizing power consumption. Commonly a collection of lower power cores can deliver the performance, while consuming less power than a single, more powerful processor. The challenge is to reap the full benefits of this architectural advantage and that is the role of software.

If the design is heterogeneous, specialist cores may have been chosen to perform some of the application functionality and an AMP approach is the only viable approach. This may also be the case if the application is multi-functional, with a diverse range of requirements, but is running on a homogeneous multicore platform. The opportunity to select the optimal operating system for each core may be attractive.

However, if the application is conceptually simple and just requires plenty of CPU power, and a homogeneous multicore platform is in use, SMP would seem the obvious choice. Indeed, it will be the best option for many applications, but, at least for networking systems, there is an alternative.

Mentor Embedded recently established a partnership with a company called 6WIND, who offer another approach. Their product, 6WINDGate, is high-performance packet processing software optimized for multicore platforms and represents a “drop-in” replacement for standard networking stacks. Instead of using SMP, which, even if well implemented, carries a significant system-wide overhead, they run a conventional OS [like Mentor Embedded Linux] on one CPU, together with the control plane and networking stack. All the other CPUs run the packet processing data plane in a fast path environment, leveraging a multicore executive to execute on “bare metal” [i.e. no underlying OS] for ultimate runtime efficiency.

Although this product is specifically designed for packet processing systems, I wonder if the approach might be used elsewhere. In any case, it is a creative way to extract the maximum possible throughput from a multicore system.