This is a Ph.D. dissertation in book form. It is also the ACM Distinguished Dissertation of 1986. It is therefore necessary to state that this book will not be useful as a textbook for undergraduates. But it should be required reading for graduate students studying computer architecture, recommended reading for graduate students in computer science, and a must for practitioners in computer architecture and design.
The book is a delight to read, and David Ungar, the author, should be commended for the clarity with which he describes the research work. It was a surprise to find, in a Ph.D. dissertation, not only descriptions of achievements but also of failures, missed opportunities, and what the author calls “architect’s traps.”
The research reported in this book is related to the design and performance evaluation of a RISC (reduced instruction set computer) system designed to run the Smalltalk-80 exploratory programming environment (EPE). EPE provides a rapid program development cycle for programmers. Smalltalk systems are object-oriented programming systems that provide program abstraction and reduction in written code. Unfortunately, such systems so far have been large, expensive (exceeding $80,000), and slow. The author has taken Smalltalk-80 EPE and has tried to design a language-specific RISC system that he calls SOAR (Smalltalk on a RISC). SOAR is a mix of VLSI technology and intelligent software routines that gets a better performance at a lower cost compared to existing systems. The author and his colleagues have built VLSI implementations of SOAR and a Smalltalk interpreter and have tested the design and performance of SOAR. The book presents all these in amazing detail.
The book has seven chapters and a bibliography, followed by two appendices. appendix A (containing 55 tables) details the performance evaluation of SOAR, and Appendix B (containing 16 tables) details the raw data and benchmarks used in the evaluation. Appendices A and B occupy 40 percent of the text; the remainder is devoted to the actual description of the design.
The book opens with a preface summarizing the conclusions of the dissertation. Chapter 1 is introductory and is a pointer to the next five chapters. Chapter 2 is a synopsis of past work. It explains the drawbacks of existing Smalltalk EPEs and the reasons behind the work undertaken. It explains, briefly but distinctly, the issues involved and presents a brief description of seven computer architectures that have influenced the SOAR architecture. I found this chapter enlightening. Chapter 3 describes SOAR architecture. Here one can clearly see how to make choices and compromises in choosing the architecture. The author makes the whole architecture evolve in light of the goals he has set out to achieve. The instruction set, the interpretation of instructions, the interrupts, the storage management, the pipelining, and other interaction issues of SOAR are clearly described with appropriate diagrams. Two interesting ideas about data-tags and register-windows, which help speed up the execution of instructions, are carefully explained. The author also explains how some design decisions proved to be of limited benefit. All the conclusions are supported by experimental results, although one occasionally reads a conclusion like “extra time needed to compile to SOAR instructions does not seem to pose a problem” (p. 41).
Chapter 4 describes the Smalltalk-80 benchmarks for testing the overall performance of SOAR. The author draws conclusions about the contribution and noncontribution of SOAR features to the goals set. The evaluation of SOAR and a comparison of SOAR with other systems are described in six tables. The author also acknowledges some decisions as errors (the architects’ traps).
Chapter 5, like chapter 3, is a well-written chapter. It describes a new garbage-collection method called generation scavenging. The synopsis of past work is nicely done indeed. The new algorithm and its code in pidgin C are described in detail. With appropriate diagrams, the author explains how objects are created, saved, and removed from the memory (memory-reclamation) and also compares the algorithm with some existing ones. The performance evaluation and advantages of the suggested algorithm are detailed in the text and tables. Some disadvantages are also mentioned. The above algorithm allocates a “tenure” status to objects surviving garbage collection. What if such objects are not needed just after being tenured? Moreover, at what point can an object be tenured? These issues are the subject of chapter 6. This chapter describes the analysis and evaluation of the issues mentioned. The experiments were done on Berkeley Smalltalk. The chapter makes some proposals. In my opinion this chapter shows some weakness because the testing was not done on SOAR. Chapter 7 summarizes the whole project and suggests future work to be done on SOAR.
The book is excellently printed and I found only one typo, in figure 4.1, where the initials “pnh” are used in a figure but the text below uses “phn” for the same initials. I would have preferred that the bibliography be placed at the end instead of in the middle of the book. Although the latter method is appropriate for a dissertation, it may not be proper for a book. I would also like to comment on the way the bibliography is arranged. It is time-consuming to find a reference here because there seems to be no order in the arrangement of the references. For example, BGH 82 comes before Bay 84. One has to go back and forth to search the required reference.
Despite these easily correctable problems, I have no hesitation in highly recommending the book. I hope readers of this book will enjoy it as much as I did. The price of the book is stiff, and a paperback version would be able to reach a wider audience.
