Browse Books

Reviewer: Robert Ballance

Data and control dependencies are the constraints among program statements that influence or dictate execution order. Dependence analysis extracts dependence information from a program in order to guide optimization and to expose potential parallelism. Data dependence analysis is particularly important in optimizing programs for parallel execution. In this book, Allen and Kennedy have managed to summarize 20 years of academic theory and industrial practice in designing dependence-based optimizations for high-performance parallel computing. The authors start with data dependence analysis. Starting with dependence analysis, they then present analysis methods and optimizations for loops, fine- and coarse-grained parallelism, and other control constructs. As the book unfolds, the reader is brought closer to machine architectural issues such as register management, cache management, and instruction scheduling. Interprocedural analysis and optimization are introduced. The book concludes with several case studies in optimization: C, hardware design languages, array assignments, and compiling high-performance Fortran. Each chapter concludes with both practical and theoretical exercises. Allen and Kennedy have not really written a compiler book, but rather an excellent introduction and guide to implementing optimizations for high-performance computing. It could be used as a graduate-level text on the applications of dependence analysis, or as an advanced compiler construction text. It would be an excellent follow-on text to a more general compiler construction book, such as Muchnick’s Advanced compiler design and implementation [1]. The publisher provides a Web site where one can find supporting materials, answers to sample exercises, prepared lectures, and errata. Overall, dependence-analysis and optimization are hard topics, which the authors handle well. This is to be expected, given their experience in the field, and their roles in developing the subject. As computer architectures and high performance applications continue to evolve, the techniques presented here will continue to be relevant to compiler writers. A good example is the problem of vectorization, which is again becoming an issue for the most advanced current architectures. The book is intended for academic instruction, and as a reference for industrial practitioner. Practicing programmers who are developing high-performance numerical codes would also benefit from reading the book. Online Computing Reviews Service

Reviewer: Olivier Louis Marie Lecarme

I have a very high opinion of the Morgan Kaufmann series of books in computer science. They are generally very well presented, and bound in handy and pleasant volumes. Thus, I was expecting the same for this new book. The book is almost 800 pages, with 36 pages of index, 289 entries in the reference section, a very pleasant presentation and layout, and a beautiful cover: these are the first things that are visible. The reputation of the authors is also impressive, especially Kennedy, who can be considered to be an authority in the subject area. As the preface explains, this book is the product of a 20-year research project at Rice University. Some aspects of the book are disappointing, however. First of all, as soon as you open the book, a leaflet of errata falls out (two leaflets, in fact). The first leaflet corrects a systematic error made by an overzealous copy editor, who added a comma in the number 1000 wherever it occurred in Fortran programs. The second leaflet corrects and replaces page 46, where there is some confusion in comparison operators in a definition. This is not the end: when you go to the Web site for the book (http://www.mkp.com/ocma/), you discover a 105 KB PDF file of errata, completely different from the previous ones. Another disappointment, however, is that it seems impossible to find the PowerPoint presentations, used in classes based on the book, on this Web site, contrary to what is stated in the preface. Despite this impressing lot of errata, lets consider the preface, table of contents, and first chapters. One rapidly discovers that the title of the book has been chosen by the editor, but not by the authors. Reading only the title, you could imagine that the book addresses the topic of building optimizing compilers for any general-purpose language. In fact, the book addresses the optimization of loops in Fortran programs, using the theory of dependence. Almost all the program examples in the book and there are plenty of examples are in Fortran. Im not saying this is not an important and interesting subject, but the book title is somewhat misleading. Fortunately, the book is very well written and organized. The authors are true specialists, both in the practice of compiler writing, and in the teaching of it. They are the authors of the main part of the theory they are explaining, as demonstrated by the enormous number of times their names occur in the large bibliography. The chapters in the book are as follows: This book by can be used as support for an advanced undergraduate course, or, better, for a graduate course. It should also have a place in the library of anybody seriously working on implementing optimizing compilers for modern architectures. Online Computing Reviews Service