This is an important book, written for experts by an expert, that explains the nature of software performance and how to make software-intensive systems work faster. Its focus is on the dynamic behavior of software in its execution environment. The book seems to be based on Zhang’s PhD thesis, and is aimed at software performance professionals and academics. Although thoughtful and insightful, it is a hard read. In fact, this book is encyclopedic. It provides a solid foundation for understanding the software execution domain, and is an exciting approach to understanding software performance. However, it is definitely not light reading. It could be used as a textbook for a very advanced software engineering graduate course.
The book contains seven chapters, 14 tables, and 54 wonderful figures. It is worth buying for the data and analysis alone. Code segments are sprinkled throughout the text to illustrate various points.
The explanation of profiling is wonderful, and the graphs provide great insight. The author writes in the first line of the preface: “Today’s software systems are becoming more and more complex.” But I never found a definition or explanation of software complexity, except for the problem and complexity of finding reference affinity described in chapter 2.
Chapter 1 defines the dynamic nature of program execution and the tools needed for analysis. Chapter 2 is about the technology of reference affinity, including definitions, theorems, and their proofs. Section 2.6.2 shows how sampling analysis can uncover the location of binary code segments used for matrix multiplication. Chapter 3 gives a component-based definition for spatial locality. Here, the use of “component” differs from most system engineering books. Even though the author uses a unique definition of a component, chapter 3 shows how one can locate the resource hogging code segments. Here, it is not the source code, but the executable code. The author writes: “The new model is based on components, which are groups of memory accesses that have similar reuse distances.” This is a strange use of the term “component.”
Chapter 4 suggests ways to find data layouts that improve performance by trial and error. Equation 4.1 introduces the concept of temperature, and I wonder how temperature is related to data layout unless the author means that given a specific layout, performance degrades as the processor runs at higher utilization levels. The higher the utilization, the hotter the computer. Chapter 5, on resource-based memory management, is a must-read. Chapter 6 encourages performance profiling beyond function or loop boundaries and describes how to do it. A profound finding buried in the text in Section 6.3 is that “in general one cannot guarantee a program to be free of memory leaks.”
The best way to read this book is to start with the summary and think about items 3, 4, 6, 7, and 9, listed in Section 7. Next, read chapter 2, skip the theorems, and then go on to the chapters dealing with the performance problem that you are facing. The use of profiling data is profound, and Section 1.3.1 on reference affinity is the best explanation of the classic space/time tradeoff facing software engineers that I have ever read. The explanation of the technology of memory management in Section 1.4.3 is excellent. Most of chapter 2 could be made into an appendix. The book lacks an index, so finding specific topics is hard.
The book would profit from a rewrite with attention to English, style, grammar, and more common software engineering terms. I needed a glossary. For example, I never found the definition of TLB. A gifted technical writer should work with Zhang to produce what could become a seminal work. The book deals exhaustively with its subject, but it is a chore to read. For it to become a viable textbook, problems need to be added to each chapter.
There is no other treatment of software performance that is as complete and as deep as this book.
