Patterns for Parallel Programming

by Beverly A. Sanders, Berna L. Massingill, Timothy G. Mattson, et al.

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... This description may be from another edition of this product.

• Format: Hardcover
• Language: English
• ISBN: 0321228111
• ISBN13: 9780321228116
• Release Date: September 2004
• Publisher: Addison-Wesley Professional
• Length: 355 Pages
• Weight: 1.60 lbs.
• Dimensions: 0.9" x 7.2" x 9.6"

Customer Reviews

Probably one of the best books on this subject

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.

Easy to read and useful content

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.

Read this book

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...

A good start

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

Good book for parallel computing

This is an excellent introduction to parallel computing. It presents patterns for discovering what can be parallized, what data structures can be used, how to choose algorithms. Patterns are demonstrated by good examples showing benefits and trade-offs of different solutions. There is also a brief, but very useful introduction to common implementations: OpenMP, MPI, and regular procedural approach demonstrated with Java. Some caution about what this book is not: this is not a general parallel programming designand patterns book (as I expected from the title). The focus of this book is parallel computing (i.e. scalable _calculations_, often scientific). There is somewhat more to parallel _programming_ than this book covers. Still, I found this book very good and useful, even though I expected broader coverage.