Multicore Basics for Single Core MCU Developers

As a technology journalist I constantly need to educate or re-educate myself on a range of technical topics and often refer to technical books to get a refresher course in key hardware and software technologies.

Until recently, my best resources for multicore hardware and software development have been the Multicore Association’s Programming Practices Guide, a compendium of the collected wisdom of the MCA’s membership for newbie multicore developers, and Software Engineering for Embedded Systems by Robert Oshana and Mark Kraeling, which covers all aspects of systems software design, much of it on multicore development.

These two stand-by references now have been joined by a new resource: Real World Multicore Embedded
Systems (Newnes/Elsevier, 2013) by Bryon Moyer.

Moyer’s book is packed with useful and up-to-date information on almost every aspect of developing applications based on multicore processors: memory architectures; cache coherency; multicore SoC design; operating systems and virtualization; threads and message passing; synchronization; languages; tools for parallelizing, communications, and benchmarking; and partitioning and hardware and software debug.

Moyer’s target audience is developers who use traditional single-core processors in their designs and who have yet to make the transition to multicore.

Until recently, multicore has been confined to such areas as desktop, mobile, and network computing. But for a number of reasons, such as the lowering cost of components and the increasing complexity of the software, the use of multicore MPUs and MCUs is becoming more common in embedded applications. But not without some continued resistance from designers/developers, because, as Moyer points out, designing for multicore is hard. Or it feels hard.

“There’s been a huge energy barrier to cross to feel competent in the multicore world,” he writes. “Some parts of multicore truly are hard, but as it reaches the mainstream, many of the issues that you might have had to resolve yourself have already been taken care of. There are now tools and libraries and even changes to language standards that make embedded multicore programming less of a walk in the wild.

“And that’s where this book comes in. There have been people quietly working for years on solving and simplifying multicore issues for embedded systems. Some of the people involved in those processes or simply with experience in using multicore have contributed from their vast knowledge to help you understand multicore for embedded.”

Moyer authored five of the sixteen chapters. For the rest he lined up experts on
various aspects of embedded multicore development including: Jim Holt and Sanjay R.
Deshpande of Freescale, John Carbone and William Lamie of Express Logic, Max
Domeika of Intel, Neal Stollon of HDL Dynamics, Frank Schirrmeister and Ysinori
Watanabe of Cadence, and Gitu Jain and Frank Schirrmeister of Synopsys.

Moyer and his co-authors have succeeded in providing single core developers a
roadmap of what they need to know to make the transition to multicore. Each of the
chapters provides an excellent up-to-date roundup of key aspects of multicore design and development, not just for generalists like me, but for each of the single-core specialists involved in the team effort most complex processor-based designs require: system hardware architects and designers, application software developers, programmers who are involved in writing drivers or adapting libraries for OSes or
virtualization environments, integration and verification engineers, and system software designers and programmers.

Driven by the belief that everyone can benefit from the topics they’re not specifically involved in, Mayer has structured the book in a way that allows both a linear reading from to start to finish, but nonlinearly as well. Each of the chapters is written as a standalone essay, but includes enough references to other aspects of a design to lead to related areas of interest, his intended goal.

“A hardware designer can design a better platform if he or she understands the real-world issues that software programmers face either when writing an application or building firmware,” Moyer writes. “A programmer writing an application can write better code if he or she understands the nuances and trade-offs involved in the platform that will run the code.”

To get you started, Moyer includes a map of the book with the chapters organized into broad categories that make it easy to navigate to those of particular interest. Then in his introductory chapter he gives the reader particular instructions on which chapters to read first and which to go to next, depending on what they are interested in.

For me, these strategies worked. My first reading was in the “begin at the beginning” way. But several times later when I picked the book up for more information, what I had intended to be a short exploration took me deeper than I expected.

For example, because the topic of system partitioning in multicore designs has come up recently in several technical papers I have read or edited for use as contributed articles, I went back and read Chapter 11 on partitioning programs for multicore systems and the role of concurrency (or the lack of it). The way he has structured the book led me back to Chapter 2 on the promise and challenges of concurrency, as well as several other related chapters.

On the other hand, some chapters were disappointing, particularly Chapter 9 on the various languages available for writing code for use in a multicore design. The chapter discusses the basic features of C, C++, Java, Ada, and several web languages and their general strengths and weaknesses. But because the book was written for single core developers who are familiar with those languages, I expected information about how to use them in a multicore design. But there was little on how to use them in that environment, which was the stated objective of the book.

Fortunately, because of the way Moyer has constructed the book, I was able to find my way easily to discussions in other chapters that compensated for the weaknesses of Chapter 9. So, despite the minor flaws, it is a book I have found useful in gaining the insights I need.

— Bernard Cole, MCU and PCB Designline editor, EE Times is an embedded microsystems technology analyst who writes about hardware/software design and use across the range of consumer, industrial, automotive, networking and Internet of Things applications. He can be contacted via LinkedIn, by email at bccole@techrite-associates.com or at 928-525-9087.

Join over 2,000 technical professionals and embedded systems hardware, software, and firmware developers at ESC Boston May 6-7, 2015 and learn about the latest techniques and tips for reducing time, cost, and complexity in the embedded development process.

Passes for the ESC Boston 2015 Technical Conference are available at the conference’s official site with discounted advance pricing until May 1, 2015. The Embedded Systems Conference and EE Times are
owned by UBM Canon.