Rent
$19.76
Buy
$40.83

Deliver to your Kindle or other device

Flip to back Flip to front
Audible Narration Playing... Paused   You are listening to a sample of the Audible narration for this Kindle book.
Learn more

The Art of Multiprocessor Programming Kindle Edition

4.1 out of 5 stars 27 customer reviews

Rent from
Price
New from Used from
Kindle
"Please retry"
$19.76
$40.83
Hardcover
"Please retry"
$261.85
Paperback
"Please retry"
$15.00 $10.00

Length: 528 pages Optimized for larger screens
  • Due to its large file size, this book may take longer to download

Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.

  • Apple
  • Android
  • Windows Phone
  • Android

To get the free app, enter your email address or mobile phone number.


Editorial Reviews

About the Author

Maurice Herlihy received an A.B. in Mathematics from Harvard University, and a Ph.D. in Computer Science from M.I.T. He has served on the faculty of Carnegie Mellon University, on the staff of DEC Cambridge Research Lab, and is currently a Professor in the Computer Science Department at Brown University. Maurice Herlihy is an ACM Fellow, and is the recipient of the 2003 Dijkstra Prize in Distributed Computing. He shared the 2004 Gödel Prize with Nir Shavit, the highest award in theoretical computer science. In 2012 he shared the Edsger W. Dijkstra Prize In Distributed Computing with Nir Shavit.

Nir Shavit received a B.A. and M.Sc. from the Technion and a Ph.D. from the Hebrew University, all in Computer Science. From 1999 to 2011 he served as a member of technical staff at Sun Labs and Oracle Labs. He shared the 2004 Gödel Prize with Maurice Herlihy, the highest award in theoretical computer science. He is a Professor in the Electrical Engineering and Computer Science Department at M.I.T. and the Computer Science Department at Tel-Aviv University. In 2012 he shared the Edsger W. Dijkstra Prize In Distributed Computing with Maurice Herlihy.

Product Details

  • File Size: 10556 KB
  • Print Length: 528 pages
  • Publisher: Morgan Kaufmann; 1 edition (August 29, 2011)
  • Publication Date: August 29, 2011
  • Sold by: Amazon Digital Services LLC
  • Language: English
  • ASIN: B00245A4U0
  • Text-to-Speech: Enabled
  • X-Ray:
  • Word Wise: Not Enabled
  • Lending: Not Enabled
  • Enhanced Typesetting: Not Enabled
  • Amazon Best Sellers Rank: #1,038,697 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
  •  Would you like to give feedback on images or tell us about a lower price?


More About the Authors

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Top Customer Reviews

Format: Paperback Verified Purchase
The Art of Multiprocessor Programming is an outstanding text that will soon become a classic. I give a chapter by chapter review of it below.

Practitioners that are already well versed in parallel programming can jump directly to Chapter 7, however, I would suggest at least skimming Chapters 2, 3 and 4. Even those programmers who understand shared memory and locking may be shocked at how relaxed memory models or compiler optimizations can reorder operations causing innocent looking code to break.

----------------------------------------

Chapter 1 - Introduction

Why is this book called "The Art of Multiprocessor Programming" and not "The Art of Parallel Programming?" It is not by accident. There is a directed effort to explain parallel programming concepts as they relate to multi-core (or many-core) architectures. In particular, shared-memory multiprocessors have specific implementation details, such as cache coherence policies, that directly affect parallel software run on such architectures. The introduction gives a brief overview of the direction of the text: principles and practice.

----------------------------------------

Part 1 - Principles

Chapter 2 - Mutual Exclusion

Mutual exclusion is a key concept to multi-threaded programming, and this chapter is rightly placed at the beginning of the text. This chapter presents some of the foundational concepts in parallel computing, such as, understanding time related to operation interleavings, pessimistic critical sections, forward progress, deadlocks and fairness. In addition, some of the classic algorithms are presented here, such as Lamport's Ticket Locking and Peterson's 2-Threaded Lock.
Read more ›
2 Comments 111 of 115 people found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
Format: Paperback
The content is perfect and deserves 5 stars and I agree with the 5 stars comments, but the code deserves the only 3 stars as there are a lot of flaws in it - the code even contradicts its description( both in the book and in the code downloaded from a site ). For example, at chapter 8.3.1 the Readers-Writers ( i.e. multiple-readers-multiple-writers as the name suggests ) implementation is actually a multiple-readers-single-writer as the WriteLock.lock() method doesn't protect from multiple writers( there is a mention about a single writer in the text but the paragraph name suggests multiple writers ). The code at 8.3.2 is just misleading and doesn't match the description - again the WriteLock.lock() is flawed - it frees the lock if readAcquires != readReleases thus allowing the ReadLock.lock() method to acquire the lock and increment the readAcquires counter which results in the writer starvation and lost of fairness( should be FIFO ) and again there is no protection from multiple writers but the "Readers-Writers lock" name suggests that it should be. And as the last blow the code in 8.3.2 suffers from the lost-wakeup problem described two pages before - the WriterLock.unlock() method doesn't wake up the readers waiting in condition.await(). But there is a rehabilitation for the authors - the description for the code doesn't contain the flaws mentioned above - it is absolutely correct! The Chapter 8 drove me mad by its discrepancy between the text and the code!
So, I got suspicious about the code in the book but not about the description.
I rated the book 4 stars as the content and description( including pictures )is brilliant but the code is sometimes wrong and misleading ( I think it was copy-pasted from the old authors's works ), if the code had not contained such bizarre flaws I would have rated 5 stars as the content is really perfect and shows the authors expertise in the field.
2 Comments 80 of 84 people found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
Format: Paperback Verified Purchase
This book gives programmers the practical and theoretical tools they need to adapt to the proliferation of multi-core machines. It opens with six chapters on theoretical subjects. These chapters are fascinating in their own right as well as directly applicable to my daily work. I thought the most important subjects were wait-free synchronization (every method completes in a finite number of steps), lock-free synchronization (some method completes in a finite number of steps), and some computability proofs. The authors use computability to demonstrate the equivalence of several types of synchronization primitives. They also present some impossibility proofs that show you how to avoid trying to solve unsolvable problems. The computability results and synchronization guarantees combine to give you the tools to determine whether one concurrent algorithm is "better" than another.

The remainder of the book is devoted to practical subjects. These chapters cover locks, a variety of data structures, work scheduling, and some miscellaneous topics. Java's java.util.concurrent package provides production-quality implementations of most of these data structures. The authors know this, and they use the data structures chapters to demonstrate generally applicable techniques while avoiding unnecessary implementation details. The work scheduling chapter is a sobering reminder of the difficulty inherent in fully exploiting highly parallel architectures. The authors show how to use recurrences to analyze the relative speedup an algorithm gains by running on P processors instead of a single processor. Combining this with the discussion of Ahmdal's Law earlier in the book we see that the essential math behind parallelism severely penalizes you for seemingly small sequential portions of your code.
Read more ›
Comment 32 of 32 people found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse

Most Recent Customer Reviews


Forums

There are no discussions about this product yet.
Be the first to discuss this product with the community.
Start a new discussion
Topic:
First post:
Prompts for sign-in
 


What Other Items Do Customers Buy After Viewing This Item?