Computer Organization and Design, Fourth Edition: The Hardware/Software Interface (The Morgan Kaufmann Series in Computer Architecture and Design)
The classic textbook for computer systems analysis and design, Computer Organization and Design, has been thoroughly updated to provide a new focus on the revolutionary change taking place in industry today: the switch from uniprocessor to multicore
Rating: 
(out of 98 reviews)
List Price: $ 89.95
Price: $ 47.15
Review by David A. Lessnau for Computer Organization and Design, Fourth Edition: The Hardware/Software Interface (The Morgan Kaufmann Series in Computer Architecture and Design)
Rating:
This is a tough book to review. On one hand, it’s got an amazing amount of information in it. On the other, it’s got a lot of editing problems. It also suffers from a lack of focus on who its audience is. So, splitting the difference, I’m rating this book at 4 stars out of 5.
Regarding the book’s audience, it’s vital that you pay attention to the chart on page xiii of the Preface. It maps your path through the book based on whether you’re a software-type or a hardware-type. Assuming I was so brilliant that I could ignore such trivia, I attempted to plow my way through the whole book. Software-type that I am, I had some tough times in a couple of sections and then utterly failed to understand anything when I hit the core of Chapter 5. If I had paid attention to that chart, I would have known to skip that part of the book. However, even for the material that’s within the path laid out for you by that chart, a lot of the work seems to assume knowledge on the part of the reader. For instance:
– Chapter 2 is about the MIPS assembly language. In the exercises, you’re supposed to write various code snippets. Many of these snippets assume far more familiarity with writing entire assembly programs than is presented.
– The exercises at the end of each chapter are broken into three types: regular, “For More Practice,” and “In More Depth.” Those last two types require far more knowledge than is presented. It looks like the authors culled them from previous editions and, instead of trashing them, just stuck them on the CD and referenced them.
– Exercise 3.9 is annotated as requiring Section 3.2. But, unless you’re very familiar with the implementation of MIPS assembly language, there’s no way that someone using the material in that section alone could do the problem.
– Exercise 3.13 is annotated as requiring Section 3.3. Yet, the question is completely undoable unless you’ve at least read Appendix B. Of course, Appendix B, itself, is practically indecipherable unless you’ve had previous experience/knowledge with Logic Design.
– Exercises 7.21, 7.22 and 7.38 talk about “the first 1 million references in a trace of gcc.” The book contains no definition of what that means. Those questions also mention the cache simulator “dinero” and say, “see the Preface of this book for information on how to obtain them.” There’s no such information in the Preface or on the CD. The CD does have MipsIt software which includes a cache simulator, but it doesn’t seem to work reliably on my XP SP2 system (it also doesn’t seem to accept those “traces” as input). That could be operator error, though. Doing a Google search pointed me to max.stanford.edu as a source of the software and traces. But, it seems you have to have a Linux system (or be smarter than me) to use them.
– Exercise 7.35 gives a C code snippet and asks you to calculate the expected cache miss rate. There’s nothing in the book about calculating expected miss rates from algorithms. Also, the exercise is assigned partially against section 7.4. Section 7.4 covers virtual memory, not caches.
– Most of the Chapter 8 exercises are mis-referenced (i.e., they’re labeled as being associated with certain sections of the chapter which have nothing to do with the question). Along with the standard problem of assuming knowledge that’s not covered in the book, many of them teach new information instead of testing/re-enforcing comprehension of the provided material.
There are many incorrect page number and section number references in the book. This is especially bad in the exercises where it becomes impossible to do certain ones since the code and data they’re referencing isn’t findable (at least easily). This problem does seem to get better as you get to the later chapters. There are also problems with basic typography. Some examples:
– Exercise 3.29 wants the reader to come up with a non-restoring division algorithm based on the restoring division algorithm in Figure 3.11 on page 185. The figure and page numbers are right, but the text of the question refers to “step 3b” and “restoring the Remainder” that aren’t present there. So, there’s no way to figure out what the authors are doing or what they want the reader to do in the exercise.
– Many of the tables and diagrams in the book use “color” to help indicate something important. Unfortunately, the color used is dark blue. Unless you look very carefully, there’s no difference between the regular text/line color (black) and the “emphasized” version.
– The text description of Figure 7.31 on page 544 mentions labeled sections that show differences in performance based on cache associativity. The labels are missing.
– Exercise 7.45 gives you a C snippet that you’re supposed to document. It contains “!!” as an operator. C has no such operator. My guess is it’s either a logical AND, “&&”, or a logical OR, “||”.
Also, the chapters are WAY too long and there are no exercises following the sections. For instance, Chapter 2 is 100 pages long over 20 sections. All the exercises (59 of them) are clumped together in the back of the chapter. The authors note the necessary section numbers with these exercises, but each section needs its own set of exercises immediately following it. This would also alleviate the problem where the authors have the wrong section numbers assigned to exercises. If these exercises were at the end of a section instead of clumped with 60 other exercises at the back of the chapter, they’d stand out more if they didn’t belong.
And, finally, the book needs answers to the questions.
As an aside, this book is used in Florida State University’s (FSU) CDA 3101: Computer Organization course.
Review by Ramon Kranzkuper for Computer Organization and Design, Fourth Edition: The Hardware/Software Interface (The Morgan Kaufmann Series in Computer Architecture and Design)
Rating:
This book is one of the standard textbooks for Computer Organization. However the approach of instruction taken by the authors is unconventional, and a reader might or might not find it useful. Here are the points that will be useful to prospective buyers: 1. If this book was ASSIGNED as a course requirement, have no fear. With a good instructor in class as your primary source, the book is fairly easy to understand. Besides, the exercises are well ranked in order of difficulty, and sufficiently varied across levels of difficulty. And they are usually interesting. 2. If you wish to use this as a reference work, be warned. The style is strange, and upside down in places. For example, “examples” are given with wrong usage of Assembly “instructions”, because the book has not “got there yet”. Later, you are given the “correct version”. Some people might like this, some may not. 3. If you are a professional and want a refresher, be warned again. The book labours through pages and pages of simple worked exercises, involving nothing more complicated than a times b divided by c, and then jumps into implementational details. 4. One thing the book must be praised for is its thoroughness. 5. Essentially, the authors have intended that ANYONE not even remotely familiar with the subject should be able to tackle it from the ground up. Thus you have concepts introduced in an EXTREMELY step by step fashion, and no one will complain that the book is “difficult to read”, per se. But the authors carry it a little too far, and those readers used to traditional textbook techniques of explanation, will be lost in many places. Those who have no problems with this might complain that the book is too long in places. The most satisfied reader will be one who has no idea of what computers are, and was thrown into this course all of a sudden, and who has a lot of free time, and who has an instructor to guide him through the book and the course.
Review by Andrew McCaffrey for Computer Organization and Design, Fourth Edition: The Hardware/Software Interface (The Morgan Kaufmann Series in Computer Architecture and Design)
Rating:
Rather than being a boring, bland and dry text, COMPUTER ORGANIZATION & DESIGN is a well-written and very informative introduction to many hardware and software fundamentals that should be known by anyone with interest in this field. It’s a little wordier than it probably could be, but I found the style of the writing to be a great help at teaching myself these sometimes obscure topics. It succeeds at being both a teacher and a reference book.The authors had the clever idea of introducing many of the concepts from a historical perspective, tracing the beginnings of ideas up to their current implementations. This makes the narrative much less dry than it could have been (let’s face it, hardware design isn’t exactly riveting material) but makes for a great introduction. The reader gets to see the concepts develop from simpler ideas into the more complicated set-ups of today. Putting the models into that context makes the more difficult concepts easier to grasp.Some discussion concerning this text has revolved around its wordiness. Certainly the book goes into more detail than it probably needs to, and takes longer than necessary to explain certain topics. But to the student or reader encountering these details for the first time, this approach can be extremely rewarding. I found this book to be an excellent teacher. While it took a little bit of time for me to read, it was quite up to the task of clearly and simply explaining the concepts at hand. Each chapter has a section on Fallacies and Pitfalls, which I found particularly helpful. They take a number of the most commonly held misconceptions about the material in that chapter, and clearly and carefully explain why such things aren’t true. I found that a lot of what they covered were things that I had either misconstrued or was unclear about so this section was invaluable for me.As reference material, the book covers Processor Performance, Microinstructions, Arithmetic (covers binary and floating-point operations done on the MIPS processor), Processor Pipelining, I/O Interfaces, Multiprocessing, and various other MIPS related subjects. If you looking for something that’s primarily reference material, you could probably find a text out there that’s a bit more concise. But if you’re a little rusty on some of these concepts or are encountering them for the first time, then you could do a lot worse than to teach yourself from this book.
Review by Christopher D. Smith for Computer Organization and Design, Fourth Edition: The Hardware/Software Interface (The Morgan Kaufmann Series in Computer Architecture and Design)
Rating:
The information contained in this book is sound, and the coverage of a variety of topics is relatively thorough. It is, however, difficult to appreciate these strengths given the numerous flaws in the text. Minor flaws include numerous misleading typographical errors, and too little attention to the flow of information.
The big mistake, though, is the failure to publish a complete book. If you want to learn from this book, then you will need to spend a good bit of time either sitting at a computer reading, or printing out the PDF files on the accompanying CD. The appendices (which are not extraneous, but rather a fundamental part of the text which contain information that’s referred to throughout the book) are included ONLY on the accompanying CD. For more than 50% of the review exercises are just references to PDF files. The contents of the CD are not available from the publisher’s web site. Do NOT buy a used copy of this book that’s missing the accompanying CD. If you like taking books with you to read away from the office, don’t buy this book at all. You’ll spend too much effort wondering why the printer felt the need to offload a good bit of the printing work onto you. All of this is made even less tolerable by the poor information flow, which will leave you needing to make reference to the appendices many times throughout virtually all other chapters of the book.
It’s possible that a future edition may fix these issues. Until then, there have to be better ways to learn.
Review by Bookaneer for Computer Organization and Design, Fourth Edition: The Hardware/Software Interface (The Morgan Kaufmann Series in Computer Architecture and Design)
Rating:
Some may wonder why so many teachers, in Universities, Colleges and elsewhere, have selected this textbook among so many other choices. First, this book presents an authoritative introduction on a popular type of architecture: the MIPS architecture. As the basis for the Pentium class of systems, one can hardly avoid a good coverage of MIPS in a Computer Architecture and Design class. Secondly, the authors have taken great pains to indicate common fallacies and pitfalls as well as “real-world” examples (even though they may be slightly outdated since the writing of this book in 1995). Thirdly the book is fairly comprehensive in breadth, if not always in depth. This brings us to the real reason this textbook enjoys popularity among teachers: flexibility. Teachers often use a textbook not as a reference, but as an aide in teaching. Usually this means that the exercises, presentation and diagrams are helpful in covering a particular topic. Patterson and Hennessy provide the essentials of MIPS architecture while leaving enough room for teachers to use their own methods of presentation and emphasis. Since the book makes use of logic design but does not require it as a prerequisite (while giving a very good high-level overview in Appendix B), students from a variety of background (hardware or software) can make use of this book without being held back. A teacher may choose to cover logic design in parallel, or seperately, put more emphasis on pipelining or glossing over it, and either offer an extensive coverage of MIPS assembly or ignore it altogether This effectively allows for a wide berth in teaching possibilities.What’s in it for the student? Pay careful attention to your teacher’s lecture! (But you know this already) Use this book for its excellent diagrams and for its explanations if you need to understand a particular concept in more details. Use it to do the exercises of course. In the rare event that you understood completely the lecture the first time, do not hesitate to skip ahead to find “Final” diagrams and summary tables. A note on P&H’s incremental method: while it may initially present some difficulty for a reader accustomed to receiving ready-made answers, it is an excellent way of understanding the design process which is inherently incremental in scope and functionality. When studying a series of diagrams (such as 5.19-5.24 or 6.31-6.35), visualize the intermediary figures as stills of a picture. The entire sequence of figures may be played in “fast-forward” to see the evolution of a design or the activities along the instruction datapath. The last figure in such a sequence may then better understood and appreciated. Last but not least, do not hesitate to read and consult other references such as Tanenbaum’s Structured Computer Organization, MIPS reference docs available online and MIPS design companies websites. Do not forget what a Computer Architecture and Design class is all about: learning to design your own architecture one day in the real world!