Mitigating the multicore factorStory
July 25, 2011
Soon most hardware processing platforms will be based on multicore architectures. But what does this mean for legacy software applications?
Multicore platforms are capable of delivering higher performance, lower power consumption, a smaller physical footprint, and even a lower bill of material costs as compared to single-core platforms. However, none of those benefits will come unless legacy single-core optimized software applications are successfully moved onto multicore architectures. This does not necessarily mean that lots of software refactoring work needs to be done. But it does mean that developers need to have the right knowledge and tools to assess their options and select the right one.
The consolidation play
The most straightforward approach to legacy software migration is to consider the multicore platform as the same collection of single-core processing engines in use today, except that the cores are now all in one physical package. In other words, for each processor, developers will select the appropriate OS and application to run on it. Virtualization is a popular method to achieve this and is sometimes seen as the first step in the multicore journey. This approach consolidates discrete processing functionality onto a multicore platform and requires limited new knowledge and software refactoring, although it will only deliver a fraction of the performance, power, size, and cost benefits mentioned earlier because it does not utilize the inherent parallel processing available.
Balance, optimization, and opportunity
Most developers know that the way to exploit the fundamental benefits of multicore platforms is to unlock whatever concurrency exists in their software applications so that a reasonably balanced loading can be achieved across the available processors. The challenge is that some new concepts, such as threading, data dependencies, and data races, need to be understood to implement an efficient migration to a multicore platform. The military systems market, while having its own idiosyncrasies, is certainly also governed by one of the fundamental rules of business: Companies that master a new technique or technology faster than their competition give themselves a real differentiating edge.
Afraid to jump?
To become a multicore-ready software development organization, a few things need to be added to the armory of skills, methods, and tools available to engineers. These are imperative in satisfying the fundamental question at the heart of all multicore migration projects: How much concurrency is there in the applications, and how easy is it to unlock it? Traditionally, the answer to this question has been hard to find. Usually it is necessary to do all the trial-and-error engineering work to answer it. Therefore, it is not surprising that many development teams resist taking this step. This reluctance is because they do not know how to evaluate the benefits of multicore adoption and they do not know how to implement such a concurrency analysis project. Therefore, they do nothing.
Guidance through the darkness
In recent years, CriticalBlue has helped many different types of organizations to migrate towards and optimize their use of multicore platforms. The Prism tool was developed after extensive consultations with experienced multicore software developers to establish the capabilities needed to address the aforementioned challenges. One small example of the output of those discussions is that CriticalBlue’s Prism has a what-if exploration capability that allows developers, without first having to modify their code, to investigate the impact of different parallelization approaches, multicore platforms, and data dependency management methods. The tool, coupled with a range of training courses and methodology services, provides a framework to help developers migrate legacy systems efficiently and effectively.
Putting the right foot forward
Mitigating performance, power, size, and cost constraints while delivering leading-edge functionality based on existing legacy software is the key to profitable embedded systems. While multicore hardware is rapidly becoming the norm, knowledge of how to best utilize such platforms while running legacy application software is limited. Programming multicore systems is not a brand new science; it is a question of adding a few new ideas and techniques to existing and well-established skills. Therefore, managing the complexity of migrating legacy software onto multicore platforms can be turned into a real business differentiator. So why not get there ahead of the competition?
David Stewart is the cofounder and CEO of CriticalBlue. He has 30 years’ experience in the software and silicon industries and is also the chairman of the Multicore Association’s working group on Multicore Programming Best Practices. He can be contacted at [email protected]