The Parallel Programming Guide for Every Software Developer

From grids and clusters to next-generation game consoles, parallel computing is going mainstream. Innovations such as Hyper-Threading Technology, HyperTransport Technology, and multicore microprocessors from IBM, Intel, and Sun are accelerating the movement's growth. Only one thing is missing: programmers with the skills to meet the soaring demand for parallel software.

That's where Patterns for Parallel Programming comes in. It's the first parallel programming guide written specifically to serve working software developers, not just computer scientists. The authors introduce a complete, highly accessible pattern language that will help any experienced developer "think parallel"-and start writing effective parallel code almost immediately. Instead of formal theory, they deliver proven solutions to the challenges faced by parallel programmers, and pragmatic guidance for using today's parallel APIs in the real world. Coverage includes:

• Understanding the parallel computing landscape and the challenges faced by parallel developers

• Finding the concurrency in a software design problem and decomposing it into concurrent tasks

• Managing the use of data across tasks

• Creating an algorithm structure that effectively exploits the concurrency you've identified

• Connecting your algorithmic structures to the APIs needed to implement them

• Specific software constructs for implementing parallel programs

• Working with today's leading parallel programming environments: OpenMP, MPI, and Java

Patterns have helped thousands of programmers master object-oriented development and other complex programming technologies. With this book, you will learn that they're the best way to master parallel programming too.

0321228111B08232004

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 6 Ratings

A good start - 2006-10-08
Reviewer Rating:
Parallel programming has been around for years, in many different forms. It has usually been a specialty for supercomputing number crunchers and for the occasional OS geek. Now that traditional, single-processor solutions are hitting the wall, Moore's Law must grow in new directions: multithreaded processos, multi-cores, multi-processors, and wilder exotica. The hardware is entering the market now, and the software community is scrambling to develop the necessry skills for parallel program development. This book gives a fair introduction to a large range of the techniques available.

After getting the reader oriented to the basics of parallel programming, the authors lay out four "design spaces," or families of related patterns. Within each space, the authors present a handful of patterns using a common and reasonably familiar format: name, problem addressed, context, forces acting on the design, the solution, and examples of the pattern's usage. They identify spaces named Finding Concurrency, Algorithm Structure, Supporting Structures, and Implementation Mechanisms. Of course, these topics overlap to some extend, especially in the interplay of algorithm design and explitable parallelism, or in langauge and API primitives that blur support mechanisms available with the implemenation choices available to the programmer. The authors show how the pieces come together in familiar applications, including molecular dynamics and medical imaging applications. Appendices sketch the basic programming constructs available in three of the major parallelism toolkits around: OpenMP, MPI, and Java.

Although valuable, this book has a number of weaknesses. For example, they cite the Cooley-Tukey FFT algorithm as a winning example of "Divide and Conquer." It's a great example, but perhaps not the one most useful for didactic purposes. The FFT algortithm is brilliant, and based on deep insight combined with total fluency in handling combinations of trig functions. Programmers writing parallel code will always benefit in proportion to their understanding of the algorithms, but I would find it discouraging to think that mastery and creativity at Cooley and Tukey's level were requisite. The authors skip over the kinds of fine-grained parallelism and communication available in emerging platforms, such as FPGA- and GPU-based accelerators. At the opposite end of the spectrum, they also gloss over many of the management issues in grid computing, where parallelism is extremely coarse-grained. I also have reservations about some of the system primitives they identify as patterns - one may as well say that a "for" loop is a pattern, even though it's a primitive in nearly all programming languages.

Despite flaws, the authors do reasonably well at introducing a wide range of basics for writing parallel programs. The interested beginner will need a lot more information to put the ideas to use, but this is a fair start.

//wiredweird

Easy to read and useful content - 2007-10-21
Reviewer Rating:
Normally design pattern books are things that you dip into rather than read end to end, simply because they can be very dry reading. Not this one - as long as you have an interest in parallel programming, reading this end to end should be easy. But that's not to say that you couldn't just dip in to the bits that are most applicable to your work - I'm sure you could.

Many of the examples given of where each pattern is used are in industry sectors other than where I work, but with such good descriptions of each pattern it is easy to picture where they are used other than the examples given and to identify where you have used them yourself without previously knowing that you were using a "named" pattern even if you have been doing it that way for years.

Much of the material in this book is stuff that is hard to find elsewhere. I've heard bits of it at Intel seminars or touched on in Intel books (e.g. the Threading Building Blocks book), but otherwise have not seen this stuff in print, even though many people (possibly unknowingly) are implementing the same ideas in code.

Excellent book. I've knocked one star off though, simply because the authors work on the premise that almost everyone is using one of OpenMP, MPI or Java. In practice, there are still an awful lot of people implementing such systems using C++ with either native threading APIs or third party libraries wrapping those threading APIs.

A total waste of money - 2009-09-21
Reviewer Rating:
When I bought this book, I was hoping that the word 'patterns' in its title is only there to make it buzzword compliant. But sadly not. It is one of those completely useless pattern books, that long-windedly explain what should you do, without telling the how, and the why. Moreover all that explanations are about things, that you find out during the first day, when you actually sit down, and try to do some parallel programming.

Probably one of the best books on this subject - 2008-01-14
Reviewer Rating:
A little dry and a little repetitive but only to a small degree. The subject is (necessarily) approached from several different 'points of view' so some repetition is to be expected, but this should not discourage you from buying and reading this book, it is one of the most readable and affordable books on this topic. I highly recommend this book.

Read this book - 2007-10-07
Reviewer Rating:
This is a very good book: It will start teaching you how to think about parallel programming and will help you get started in this area.

Why only four stars you may ask? The trouble is that after over 40 years knowledge about parallel programming is still weak. The scientific computation folks have their (often heavy duty) tricks of the trade, but, as another reviewer pointed out, parallel computing is much more and is starting to address much broader areas.

This book will help you wade through the maze of confusion and will help you get oriented - that is of a huge help. Then you need to practice...

Browse Similar Topics

Top Level Categories:
Software Engineering

Sub-Categories:
Software Engineering > OOP