 |
GetTextbooks.co.uk
Compare Prices & Save up to 90% |
|
|
|
| Login | Sign up | My Wish List |
 | | High-Performance Compilers for Parallel Computing by Michael Wolfe ISBN-10: 9780805327304 ISBN-10: 0-8053-2730-4 ISBN-13: 9780805327304 ISBN-13: 978-0-8053-2730-4 Hardcover 1995-06-16 Addison Wesley Find Lowest Price |
Reviews | ||
A Practitioners Guide This book covers a lot of ground. Wolfe starts off with a chapter on machine architecture, then moves into language features that can be parallelized. Then there are chapters on graphs and linear algebra then he dives into an encyclopedia of data dependence, data flow, and control flow algorithms. I only made it about 1/3 of the way thru the book as it is oriented toward people actually implementing high performance compilers ie it's a practitioners guide. I gave the book four stars because the type setting (previously mentioned lack of periods) is appalling. Especially in this day and age. | ||
It's the de-facto bible for parallel compiler optimizations If you want to get into data dependency analysis of compilers, this book is absolutely the best. Many compiler book authors do not have the experience of writing a compiler of industrial strength, but Michael Wolfe does. | ||
Essential reference for compiler writers This is a modern classic. If you develop compilers for high performance computing (HPC), this must be on your shelves. It has a heavy emphasis on Fortran, the workhorse of HPC, but is widely applicable to other languages as well. The majority of the book's content reflects the large majority of processors that carry today's HPC load: sequential, von Neumann engines, even the computing ensemble as a whole has lots of them. This book's real contribution is in its analysis of the loops that process arrays. Wolfe presents a number of ways to characterize dependencies, using quantitive techniques that go well beyond the graph-based presentations elsewhere. By casting the dependency problem in terms of integer programming or linear algebra, Wolfe make huge bodies of problem-solving knowledge available to the compiler developer. He also uses these quantitative terms to give new insight into loop transformations that the reader may already understand. Despite the irreplaceable value of this book, I found it maddening to read. For some reason, the periods dropped off of nearly every sentence in the text. Then, just when I got used to that quirk, the periods appeared again. Their coming and going was so irregular throughout the book that I never really got into a steady reading rhythm. A much worse problem appeared throughout the first chapter, though. It's an exceptional discussion of matrix multiplication, a staple of performance computing. The chapter presents it again and again, to demonstrate differences in looping constructs and the organization of memory access. That part of the discussion was great. The problem is that it's wrong - a systematic error, in seemingly every example, replaced the scalar multiplication at the core of the algorithm with addition. It's hard enough trying to understand the interactions of loops nested five deep, language features, and memory hierarchies. Doing all that while mentally correcting the text's blunders is simply infuriating. Perhaps those problems were fixed after the 1996 edition that I read - for the reader's sake, I hope so. As it was, that first chapter left me wary of everything else in the book. If you need it, though, you need it. Grit your teeth, brace yourself, and dive in. This is a valuable complement to the Allen&Kennedy text, and essential for anyone creating compilers for HPC architectures. //wiredweird | ||