The Art of Concurrency: A Thread Monkey's Guide to Writing Parallel Applications [Paperback]

This book assumes the reader has some knowledge of threading already and attempts to provide that elusive next level of information that people want after learning the mechanics of a particular threading API. That is - how best to write code that scales well, that works reliably etc.

The first half of the book is general information about that next step, the second half of the book is mostly a collection of algorithms and how their serial equivalents can be converted to make use of multiple processors/cores, together with some information about how successful the conversion is.

The code examples are mostly C, but with the odd snippet of C++ where required by the threading API being used at the time. The threading APIs used are Intel TBB, OpenMP, PThreads and Windows threads. Some examples are presented using more than one API.

All in all, this book sounds promising. However, having just read it, it really didn't work for me. You know when you are asked a question by another developer who you assume knows his/her stuff, so you answer the question correctly but without giving all of the detail that you would give to somebody more junior (as you assume the person asking the question will already know those bits of detail)? You then see the glazed look in the person's eyes, realise they actually needed the detail, so you explain again but with all the extra detail added this time. Well, to me, this book felt like that - as if it was a brain-dump that is correct, but not necessarily in enough detail to satisfy the needs of the reader. To feel definitive it needs the fuzziness removed, the conversational feel removed, and more detail added. It might become drier as a result, but I think it would be more useful.

As mentioned above, the book uses four different APIs, but doesn't provide enough information on any of them for somebody who doesn't already know them (thankfully, I do) - it certainly doesn't attempt to teach any of them. It presents examples in C (and sometimes C++), but that are not all complete (missing #includes, missing supporting functions etc), or that will build on a slack C compiler but not on a stricter one (a C++ compiler will not build some of this code as C++, mainly due to missing return values - call me fussy, but I expect newly written C to build as C++). Code examples where presented using more than one API contain little inconsistencies that break the feeling of comparing like with like. Coding standards vary between examples, making typing the examples in a tad annoying as you have to switch mentally between naming conventions.

The section on algorithms really should have been the golden nugget in this book. Indeed, the book will remain on my shelf for me to use that section as a memory aid. However, the presentation of that section, like the first half of the book, is too fuzzy and rambling. So, I'll use it to remind myself of the various algorithms, but probably then go elsewhere to find a definitive description that I can re-implement myself, possibly using this book for some suggestions.

So, a book that showed a lot of promise, but that just didn't live up to expectations. It's not a tutorial on any of the APIs (it doesn't claim to be), but it doesn't feel definitive on the algorithms either. For people with either no multi-threading experience, or people with significant multi-threading experience, I suspect this isn't the book for you. If you're in the middle, with some experience but not a huge amount, then you might find it useful.

Treatment of the various threading libraries is inconsistent, with scant
coverage of pThreads and Windows Threading relative to OpenMP or Intel
Thread Building Blocks. Thread-local storage is mentioned, but no
example code is given, so there is insufficient information to actually
use it -- the same is true for many other indexed items. (TLS has four
entries in the index, but the most useful paragraph is on p43 which is
not in the index at all).

If you already know enough to use the libraries, then the only useful
thing from this book is going to be the hints, tips and experiences.
Unlike a previous good reviewer, these are what I think should provide the
golden core of the book (there are plenty of better books on parallel
algorithms). But like the previous reviewer, I was left extremely
disappointed by an opportunity lost. With hints and tips associated
with arbitrary algorithms and scorecards throughout the book, most
of their potential benefit is lost.

If you are a relative beginner, then this book provides a happily
patronising and sloppily-coded "taster" introduction to the field.

Debugging tools are summarily dealt with on pages 258 and 259, and
profiling tools take up the following three pages. Verification and
correctness do not make it to the index, although there is a single
entry for "testing for correctness", which refers to design step 3 on
page 10, which says that you should do this, but simply refers you to
the six pages of the tools chapter above. Step 3 exits reality with:
"With a good solid design, you should be able to keep the number of
threading or logic errors to a minimum, so not much verbiage is spent
on finding or correcting errors in [concurrent] code".

Sample sentences that give you a flavour for the author's style:
"While I've never written one or seen an implementation of one,
creating a barrier that could work with a different number of threads
each time it was used sounds like such a complex and daunting task",
"I recommend reading the chapters from Ben-Ari's text (See if you can
get it out of the library..", "I've not had the chance to work with
the task constructs in OpenMP, so there may be other details...", "I
won't create a threaded version of this code, but you're welcome to
give it a try on your own..".

The book does not give any examples of the simplifications in TBB use
from lambda functions. It assumes all parallel algorithms derive from
serial algorithms. There are a number of academic references, but they
are not suitable for beginners.

Sixty pages in, Chapter Three "Proving Correctness and Measuring
Performance" has this to say about measuring performance: "For serial
applications, you can measure an application's speed using a
stopwatch. Simply time the run from start to finish." The author then
explains how you can measure performance improvement by comparing the
time taken for the first version with that of subsequent versions.
"It is the same with concurrent programs." The earlier part of the
chapter is four pages on verification/correctness mainly refering
to Ben-Ari, preparing for scattered comments later on.

The author is a course architect for Intel specializing in
multithreaded progamming and training.

I was expecting *much* more from this book by its title (the art) and its author (Intel's course architect) and reviews in other sites. If you never heard of threading, it might work for you, otherwise, skip this one.

The subtitle is "A (...) guide to writing parallel application". Well, it's not. In any level. This is not a guide, this does not concern parallel application and mainly talks about one type of parallelism: threading.

As was already said, half of the book is wasted to explain concurrency and show some threading models, while the other half has random algorithms using random threading libraries.

There is little mention of anything else. No message passing examples, no multi-process/producer-consumer examples, no distributed architectures, no GPGPU, no lazy-functional approach, nothing.

The algorithms are ok, but the analysis are very poor. The "score cards" at the end of each algorithm is meant to give you an idea on how it performs against the single-threaded version (or other parallel ones), but it has no data whatsoever. Just some random "words of wisdom" about the general idea. The connection between the algorithms is also poor. The author follows a path that makes sense only to himself, choosing problems that are easy to solve.

In comparison to other books on algorithms, this is pathetic. In comparison to other books on parallelism, it's on the shade.

The icing on the cake is that the author seems oblivious to simple concepts, like module arithmetic...