Book Review: Intel’s Multicore Programming Book

The book “Multicore Programming – Increasing Performance through Software Multithreading” by Shameem Akhter and Jason Roberts is part of a series of books put out by Intel in their multicore software push. In case you have not noticed, Intel has a huge market push currently where they give seminars, publish articles and books, and give curricula to universities in order to get more parallel software in place. I read this book recently, and here is a short review.
First a short note about the Intel multicore education push: the end goal is to make sure that the average computer user will perceive value (more features and higher performance) from buying multicore Intel processors for their home or business PC. In the process, they do provide a useful community service, and presumably lots of jobs for PhDs in parallel programming and computing. This focus on the desktop computing arena has implications for the contents of books like this.

The authors are experienced parallel software writers working at Intel, and who wrote this book for Intel as part of the multicore push.

The book covers the obvious topics for any introduction book to parallel programming:

• Application patterns for parallel programs: various ways to structure computations to extract or expose parallelism.
• Programming APIs.
• Common problems in parallel code.
• Debugging parallel code.
• Performance tuning parallel code.
• Fundamental computer architecture.

In my mind, the best part of the book is the application patterns and programming APIs section. The most interesting aspect of the book was the weight given to the programming APIs and debug tools for Windows. In comparison, most other texts that I have seen focus on the portable and generally available pthreads/Posix threads API or OpenMP. The Windows APIs are actually pretty cool and powerful. Note that the .net managed code (CLR) environment has its own set of APIs similar to but distinct from the general old Win32 API.

The authors clearly have a weak spot for OpenMP, and more time is spent on OpenMP than any other API. I remain unconvinced about its generality, but it certainly has some interesting properties. But it is far from automatic parallelization. MPI gets a very strange treatment, being tucked away in a late part of the debugging chapter. Why it was not considered a full programming API is beyond me.

A section on memory consistency is pretty well written and is one of the best expositions on how that actually works on x86 and Itanium architectures.

The worst part of the book is the strangely confused and forced section on hardware architecture. Being an Intel (trademark) book about Intel (trademark) processors and programming them, the chapter on Pentium (r) and Core (r) and Itanium (trademark) processors was probably mandatory. But to someone with prior knowledge of computer architecture it is all very confused, trying to press ILP together with SMT (HyperThreading) and multicore into some joint thread concept that just does not work as a pedagogical concept.  Also, Itanium takes up an inordinate amount of space for what is basically a moribund architecture. But I guess that Intel (trademark) cannot acknowledge that Itanium (trademark) is a titanic disaster. At least not yet.  This chapter is also full of little (r) and ™ markers and various Intel product names that really makes it harder to read.

There is a good description of Intel multithreaded programming tools, not surprisingly.

Overall, the book offers a good read, but it suffers from also being Intel PR material. I do not recommend against reading it, especially not if you are programming in an x86 desktop environment. But if you are attacking an embedded Power Architecture problem, I think there are better sources.

Note for publicity thinkers: I bought this book after reading a technical article at Embedded.com “Technical Insights”. Submitting book chapters or excerpts as technical articles there could drive readers and buyers to your books. Worked on me at least, at least this one time.