The Art of Multiprocessor Programming | 
 enlarge | Authors: Maurice Herlihy, Nir Shavit
Publisher: Morgan Kaufmann
Category: Book
List Price: $69.95
Buy New: $55.81
You Save: $14.14 (20%)
New (25) Used (10) from $52.91
Avg. Customer Rating:  5 reviews
Sales Rank: 11803
Media: Paperback
Number Of Items: 1
Pages: 528
Shipping Weight (lbs): 2
Dimensions (in): 9.1 x 7.5 x 1.1
ISBN: 0123705916
Dewey Decimal Number: 004
EAN: 9780123705914
ASIN: 0123705916
Publication Date: March 3, 2008
Availability: Usually ships in 1-2 business days
Shipping: International shipping available
Condition: Brand New, Perfect Condition, Please allow 4-14 business days for delivery. 100% Money Back Guarantee, Over 1,000,000 customers served.
|
| Similar Items:
|
| Editorial Reviews:
Product Description
This book is the first comprehensive presentation of the principles and tools available for programming multiprocessor machines. It is of immediate use to programmers working with the new architectures. For example, the next generation of computer game consoles will all be multiprocessor-based, and the game industry is currently struggling to understand how to address the programming challenges presented by these machines.
This change in the industry is so fundamental that it is certain to require a significant response by universities, and courses on multicore programming will become a staple of computer science curriculums.
The authors are well known and respected in this community and both teach and conduct research in this area. Prof. Maurice Herlihy is on the faculty of Brown University. He is the recipient of the 2003 Dijkstra Prize in distributed computing. Prof. Nir Shavit is on the faculty of Tel-Aviv University and a member of the technical staff at Sun Microsystems Laboratories. In 2004 they shared the Goedel Prize, the highest award in theoretical computer science.
* THE book on multicore programming, the new paradigm of computer science
* Written by the world's most revered experts in multiprocessor programming and performance
* Includes examples, models, exercises, PowerPoint slides, and sample Java programs
|
| Customer Reviews:
Everything I expected it to be, and then some June 16, 2008
If you've already gotten your feet wet with multi-threaded programming, but you haven't been able to maximize concurrency yet, this is the book you need. It includes thorough explanations of all the latest approaches and algorithms. And with multi-core processors becoming ubiquitous, this book will remain of lasting value.
An invaluable resource for contemporary programmers May 30, 2008
9 out of 9 found this review helpful
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. I also found the counting networks chapter fascinating, as I had never encountered that material before.
The book also provides appendices aimed at bringing inexperienced readers up to speed. That said, I wouldn't recommend this book for inexperienced programmers. The material is challenging. If you are looking for a gentler introduction to this subject, consider Java Concurrency in Practice. Each chapter ends with a note describing the history of the material and providing pointers to the bibliography. These demonstrate that the authors have been significant contributors to this field. I do agree with the review from Vyacheslav Imameyev - some of the code samples are wrong. I think they missed "volatile" keywords in several places. I don't see this as a cookbook, so I'm still giving the book five stars.
Highly parallel machines are here to stay. Programmers need to adapt to this or suffer competitive disadvantage. This is the book to read in order to meet that challenge.
 The content is brilliant, the code is sometimes misleading May 28, 2008
8 out of 8 found this review helpful
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.
Excellent book April 1, 2008
6 out of 7 found this review helpful
Took the class from Herlihy that goes with this book. He's an extremely intelligent and knowledgeable man, and the book is invaluable. I will be using it many times in my future computer science career. Lots of valuable reference information, algorithms, proofs of correctness (critical for parallel systems!), and key core concepts that help you think about multiprocessor problems in new ways.
A great book on concurrent programming! March 17, 2008
11 out of 13 found this review helpful
This is a great, lucid - and PRACTICAL book on concurrent programming in general. It's equally applicable if you're programming for a multi-core CPU ... or if you're simply programming threads ... or even if you're programming a cluster.
Half the book is about "theory" (written in a thoroughly engaging, easy-to-follow style), the remaining half about "practice": various tips and tricks obviously learned from hard-earned experience.
There's also a great discussion of "transactional memory", which I'm sure is going to become increasingly important - and increasingly mainstream.
This book is a welcome addition to any practitioner's bookshelf!
|
|
|
