Parallel Programming with Microsoft .NET: Design Patterns for Decomposition and Coordination on Multicore Architectures (Patterns & Practices) [Paperback]

Colin Campbell (Author), Ralph Johnson (Author), Ade Miller (Author), Stephen Toub (Author)

Book Description

Publication Date: September 10, 2010 | Series: Patterns & Practices

The CPU meter shows the problem. One core is running at 100 percent, but all the other cores are idle. Your application is CPU-bound, but you are using only a fraction of the computing power of your multicore system. What next?

The answer, in a nutshell, is parallel programming. Where you once would have written the kind of sequential code that is familiar to all programmers, you now find that this no longer meets your performance goals. To use your system’s CPU resources efficiently, you need to split your application into pieces that can run at the same time. This is easier said than done. Parallel programming has a reputation for being the domain of experts and a minefield of subtle, hard-to-reproduce software defects.

Everyone seems to have a favorite story about a parallel program that did not behave as expected because of a mysterious bug. These stories should inspire a healthy respect for the difficulty of the problems you face in writing your own parallel programs. Fortunately, help has arrived. Microsoft Visual Studio® 2010 introduces a new programming model for parallelism that significantly simplifies the job. Behind the scenes are supporting libraries with sophisticated algorithms that dynamically distribute computations on multicore architectures. Proven design patterns are another source of help. A Guide to Parallel Programming introduces you to the most important and frequently used patterns of parallel programming and gives executable code samples for them, using the Task Parallel Library (TPL) and Parallel LINQ (PLINQ).

Editorial Reviews

About the Author

Colin Campbell is a coauthor of Model-Based Software Testing and Analysis in C# and he has written several academic papers on mathematically rigorous approaches to software analysis. He is a founder and principal at Modeled Computation LLC, in Seattle.

Ralph Johnson is a research associate professor at the University of Illinois. He was one of the four co-authors of Design Patterns, and the leader of the group that developed the first automated refactoring tool, the Smalltalk Refactoring Browser. For the past few years, he has been working on documenting patterns of parallel programming.

Ade Miller works as a Development Lead with Microsoft’s patterns & practices group, where he manages several agile teams who deliver applied engineering  guidance to Microsoft’s customers. His primary interests are in parallel computing and agile software development practices.

Stephen Toub works on the Parallel Computing Platform team at Microsoft. He spends his days designing and developing the next generation of concurrent and parallel programming models for .NET and Visual Studio. His team's blog can be found at http://blogs.msdn.com/pfxteamhttp://blogs.msdn.com/pfxteam.

Product Details

• Paperback: 224 pages
• Publisher: Microsoft Press; 1 edition (September 10, 2010)
• Language: English
• ISBN-10: 0735651590
• ISBN-13: 978-0735651593
• Product Dimensions: 9.1 x 7.4 x 0.6 inches
• Shipping Weight: 11.2 ounces (View shipping rates and policies)
• Average Customer Review: 4.8 out of 5 stars  See all reviews (4 customer reviews)
• Amazon Best Sellers Rank: #194,651 in Books (See Top 100 in Books)
  • #39 in Books > Computers & Technology > Hardware > Parallel Processing Computers
  • #68 in Books > Computers & Technology > Computer Science > Software Engineering > Design Tools & Techniques

More About the Author

Ade Miller is currently a Principal Program Manager for Dryad and DryadLINQ a set of technologies that support data-intensive computing applications running on a Windows HPC Server 2008 R2 cluster. Previously he was the Development Lead for Microsoft's patterns & practices group (p&p) where he managed p&p's agile development teams. His primary interests are parallel computing and in engineering leadership to improve the way people develop software.

He is one of the authors of Parallel Programming with Microsoft .NET and Parallel Programming with Microsoft Visual C++. Ade also writes and speaks about parallel computing and his experiences with agile software development at Microsoft and elsewhere.

Prior to leading the p&p development team Ade lead the development of the p&p Web Services Software Factory. He was a developer and then a Development Lead on Visual Studio Tools for Office 2005 and 2008. Before joining Microsoft Ade worked on a variety of interesting projects including a web start-up, embedded languages, and High Performance Computing (HPC). Ade received his BSc and PhD in Physics from the University of Southampton, UK.

You can find out more about Ade at www.ademiller.com where he blogs about software and climbing mountains.

Customer Reviews

Most Helpful Customer Reviews

1 of 1 people found the following review helpful:

5.0 out of 5 stars Awesome Book!!!!, June 28, 2011

By 

T. Anderson (PA USA) - See all my reviews
(VINE VOICE)    (TOP 1000 REVIEWER)    (REAL NAME)   

Amazon Verified Purchase

This review is from: Parallel Programming with Microsoft .NET: Design Patterns for Decomposition and Coordination on Multicore Architectures (Patterns & Practices) (Paperback)

This is a book of patterns that achieve potential parallelism. It is very important concept that all developers should have a decent grasp on. The patterns teach you how to write programs that run faster when parallel hardware is available and about the same as an equivalent sequential program when it is not.

The book starts with an introduction to potential parallelism, tasks, coordinating tasks, shared data, and the limits of parallelism. It then has a chapter on each pattern which include Parallel Loops, Parallel Tasks, Parallel Aggregation, Futures, Dynamic Task Parallelism, and Pipelines.

It continues with some awesome appendices- Adapting Object-Oriented Patterns, Debugging and Profiling Parallel Applications, and Technology Overview. It ends with a nice glossary, references, and indexes.

The book does a nice job of giving examples in PLINQ (Parallel LINQ) and TPL (Task Parallel Library).

There is a great companion site located on CodePlex. You can download Answers to end of chapter questions, C#, F#, and VB code samples, Appendix B Color Figures, and a nice demo application.

The book is very well written and the authors do a great job of making what would seem like a complex topic easy to understand.

The thing I like most about this book is that there is no fluff. The book is all about getting you up and running, but up and running the right way with the right tools.

This book is a must read for anyone considering moving into parallel programming with the .NET framework.

1 of 1 people found the following review helpful:

5.0 out of 5 stars Great, practical overview of parallel patterns in .NET 4.0..., May 13, 2011

By 

Big Chief (Laguna Niguel, CA) - See all my reviews

This review is from: Parallel Programming with Microsoft .NET: Design Patterns for Decomposition and Coordination on Multicore Architectures (Patterns & Practices) (Paperback)

This was a relatively short read, and packed with best practices, examples, and further reading. It's hard to imagine a quicker way to get up to speed on the basics of parallel programming using the .NET 4.0 features. This book was so good I thought I'd check out another "patterns and practices" book from MS; their Prism 4 book. The advice on AgggregateException handling alone is worth the read, but there is so much more. I've been writing software since the 80s, and I'll rate this as "Highly Recommended".

4.0 out of 5 stars Good introduction to PLINQ and PCL, February 12, 2012

By 

J. Sandberg - See all my reviews
(REAL NAME)   

Amazon Verified Purchase

This review is from: Parallel Programming with Microsoft .NET: Design Patterns for Decomposition and Coordination on Multicore Architectures (Patterns & Practices) (Paperback)

I have to admit that I was disappointed in the book not covering .NET multi-threading outside of of the PCL library. It would have been nice to have some notion how to do parellel programming outside of the .NET 4.0 framework (which was why I bought the book). There were no design patterns to speak of that did not deal with PCL or PLINQ. It was, however, useful in understanding what is possible in .NET 4.0 and what the general layout should be used for various situations for parellism. I initially had troubles digesting the functional programming associated with PLINQ. It took me a bit to grasp what was going on. I must admit, however, that once I got an idea of the syntax of LINQ and PLINQ, the utility of PCL became clear, not just in the book's limited context but for parellism in .NET in general. Once I got over the hurdles, this quickly became a 4-star book. Once I get to .NET 4.0, I look forward to using PCL and PLINQ, and this book is a great introduction.