<< 1 >>
Rating: 
Summary: A little outdated...but still a great book
Review: Anyone who is interested in computer architecture or computer performance benchmarking should have a copy of this book. It is well organized, packed full of information, and has many challenging exercises at the end of each chapter that reinforce and extend the concepts outlined. Also, the inside jacket gives a list of useful formula for quick reference. For those interested in vector processors, the authors have included an overview of these in the appendix. Do to new hardware and updated versions of operating systems, the book is of course somewhat out-of-date since it first appeared. It takes a long time to get through the book, but the time spent is well worth it. My interest in the book was mostly in performance aspects of computer architecture, and how to relate the material in the book to the SPEC benchmarking studies. For this reason, and for lack of space, my comments will briefly summarize the parts of the book that I found exceptionally well-written in this area. The discussion on the measuring and reporting of computer performance begins early in the book, wherein the authors attempt to quantify what it means for one computer to be faster than then another. They take the position that the best measure of performance is the execution time of real programs. They of course mention benchmarks as a way of doing this, and discuss briefly the SPEC92 benchmark suites. The SPEC standards have changed considerably since this book was written however. After a discussion of the methods to calculate performance, and their drawbacks, the authors discuss Amdahl's Law and how to use it correctly. This is followed by a discussion of the CPU performance equation with several interesting examples given. There is a "fallacies and pitfalls" section at the end of chapter one, as there is at the end of every chapter, that discusses the problems with approaches taken in benchmarking performance. These arguments are considerably important if one is to step away from marketing claims when developing commercial software packages, especially for scientific applications. Customer satisfaction in using these packages is dictated by the actual performance, not what might be accomplished in an isolated test environment. The author's honest approach to these issues is extremely helpful to those involved in developing these kinds of programs and applications. One of the more common fallacies that they discuss in this regard are: The MIPS value as being indicative of performance among computers. They argue that this is not the case since MIPS is dependent on the instruction set, the program being run, and it can vary inversely to performance. For the later, they give the well-known example of machines with optional floating-point hardware. The MIPS rating can be misleading since floating-point programs using the hardware take less time but have a lower MIPS rating. If software floating point routines are used, they result in a higher MIPS rating but the execution time is longer. The issues with instruction sets are given a very detailed treatment by the authors, along with the role of compilers in designing an efficient instruction set. They discuss how variables are allocated and addressed and how many registers are needed to allocate the variables appropriately. They use a hypothetical load-store architecture, which they call DLX to illustrate the points they are attempting to make. The DLX is generic enough so as to be convincing in its didactic quality, based as it is on the computer hardware that was available at the time of writing. The authors give a thorough discussion of pipelining, including performance issues and potential pitfalls in using it. They also describe the use of dynamic scheduling to avoid stalling when data dependencies are present. The scoreboard and Tomasulo approaches to dynamic scheduling are discussed. In addition, the authors spend a lot of time discussing cache memory design and cache optimization, and virtual memory. The chapter on storage media is excellent and the authors employ some queuing theory to estimate the reponse time and throughput of an I/O system, assuming that the system is in equilibrium. The authors then discuss in detail different ways to benchmark I/O performance. This discussion is extremely important for those involved in Web server performance modeling and benchmarking. An excellent example is given dealing with the performance of a UNIX file system. Chapter 7 is very important for those who need to study the performance of networked computers. The authors begin by considering a simple network consisting of two machines containing FIFO queues. They then design a simple protocol, similar to UDP for transferring data between these machines, and calculate the total latency of this network. Interconnection media are considered, although the presentation is somewhat out-of-date due to improvements and costs since the book was written. Performance issues with switched (ATM) versus shared medium (Ethernet) are discussed. The authors also treat connectionless networks with a brief overview of the TCP/IP protocol, and mention the role of the Internet, but do not discuss, disappointingly, performance issues with TCP/IP over the Internet, which is a formidable mathematical problem. The treatment of multiprocessor architectures is excellent and the authors discuss two application kernels that are frequently used in scientific applications: the Fast Fourier Transform and the LU factorization from linear algebra. The parallel implementation of these algorithms is extremely important in scientific programming. They consider the Barnes-Hut n-body algorithm and the Ocean application to study scaling and performance issues in parallel programs. Some excellent appendices appear in the book, particularly the ones on vector architectures. For those interested in scientific applications, vector processing is a popular methodology for performance enhancement. But the authors point out that the popularity of vector processing seems to becoming to an end, due to advances in microprocessor technology. Scientific progammers have realized this, and have devoted much of their time in writing code that will run on these processors, which is frequently a challenging proposition.
Rating: 
Summary: If this is the best there is, God help us.
Review: For one thing, if you are interested in this book, chances are that you are taking a class in computer architecture and are required to buy it. If that is the case, all of the high-brow comments won't do you any good. You are forced to suffer through this monstrosity. That was my position. Fortunately you will be able to get a more modern edition with all the thousands of typos and errata fixed, or so you hope. Problems at the end of the chapter, you ask? Get that blade ready to cut your wrists. Yea, it's simple math. You'll never use anything more than multiplication and division here, but I submit that it is almost impossible to answer some of these questions without first knowing what the answer is. The examples in the chapter do next to nothing to prepare you for the exercises, and later in the book, the questions get so complex that there must be 25 variables to consider. If the author was trying to trick you, he could throw all sorts of extra things just to trip you up. You would dutifully find something to do with them. A professor that tries to teach this entire book in a semester is a maniac, but they all try. Also they may try to go out of order on you with the chapters. Beware. Worse still is trying to go in order. Chapter 4 alone will stop you cold. I honestly think you can devote an entire semester just to some of these individual chapters. The book assumes you are very smart. You need to be someone with both a degree in EE, CS, and who has work experience dealing with hardware. My bottom line is that I am trying to warn you about what you are getting yourself into with this book. It is no easy read, no quick fix, no Bible of computer architeture that would allow you to use it as reference material in your job. If you were to look something up, it would take you a day and a half just to remember back to what the hell they were talking about. Somebody needs to do a better job than these geniuses.
Rating: 
Summary: wordy and rambling
Review: Hennessy and Patterson put heavy emphasis on conceptual understanding of how modern computer work and how the performance is measured by benchmarking technique. I think this book should be a good wrap for college student. The thing that is pitiful is the exercises behind each chapter which is astronomically much more difficult to grasp and to comprehend. They might be too wordy and not suitable for someone who just learn computer architecture. The 'virtual' DLX ISA, although functions as a simple architecture, should be carefully revised to support or channel various issues in modern processor (like superscalar or VLIW). Students are stuck with DLX for the whole semester without the opportunity to explore other ISA like MIPS, VAX, or Intel x86.
Rating:
Summary: wordy and rambling
Review: It is true that this is _the_ reference book for computer architecture. However, that has nothing to do with it being a well-written book. Its popularity may be attributed
to the lack of books on the same topic which allowed it to become
the standard textbook in many universities. This is how I came to have to suffer through it in a college graduate course. Contrary to what some of the previous reviews described, this book is not conceptual at all. One of Patterson's main points is, to put it bluntly, why bother theorizing when you can benchmark with a set of most heavily used real programs for the intended application? The computations involved don't go beyond what one needs to balance a checkbook. And the few "laws" such as Amdahl's Law, is so common sense that it's sad that a name is attached to it. All of these are minor complaints, however, compared to the terrible writing style. I don't expect a technical writer to be polished or even engaging. But at the very least s/he must be coherent and to-the-point. In several chapters especially in the second half of the book, the authors would ramble on for pages without getting anywhere. Phrases or even paragraphs could have been taken out to clarify the content. It almost seemed that the authors were trying to fill enough pages just to get paid. In short, this book does not live up to its reputation but anyone interested in computer architecture will probably have to endure it until a better book comes out.
Rating: 
Summary: 20
Review: my name is abduallah alhammadi from yemen Iam student at computer engineering in yemen
Rating:
Summary: Not for introduction, this is an advanced book !
Review: The complaints of one of the reviewer are perfectly justified in the sense that using this book as your first one in "computer architecture" will probably make you leave the subject very soon. This is an advanced book discussing the problems of computer architecture but with the "instruction set" point of view. The intent of this book is not to teach you basics in computer architecture! For introductory textbooks, rather go to the other one from Hennessy and Patterson "Computer organization and design : The hardware/software interface" or Tanenbaum's "Structured Computer Organization". However, with considerations about the scope of the book, it is excellent even if not easy. I don't think there something better on the market in the subject.
Rating: 
Summary: disappointed
Review: The complaints of one of the reviewer are perfectly justified in the sense that using this book as your first one in "computer architecture" will probably make you leave the subject very soon. This is an advanced book discussing the problems of computer architecture but with the "instruction set" point of view. The intent of this book is not to teach you basics in computer architecture! For introductory textbooks, rather go to the other one from Hennessy and Patterson "Computer organization and design : The hardware/software interface" or Tanenbaum's "Structured Computer Organization". However, with considerations about the scope of the book, it is excellent even if not easy. I don't think there something better on the market in the subject.
Rating:
Summary: PhD. In a box
Review: This book is one of the few books out there that manages to have a huge page count but remain packed with the same fluedity and comprehension, and ciriculum, that makes you feel as though you wasted your money on graduate school, and could have just spent 80 some odd for this book. If you have ever been frustrated with the level of incompetance and stupidity in the reatail computer book market, where everone and their dogs sisters brother's uncle sallys, cosins sister is either a for dummies author, or some fool writing about thier experience with Windows, than this is the book for you, This book will take you to new levels of understanding of computers, the authors cover things like what Pipelining really is, and things like why MIPS is not a good mesure for performance, etc. At the end of each chapter the authors have a section called Fallicies and Pitfalls, which give you inside perspective from the Experts as to why some things are bad mesuremnts and or Engineering philospies, that exist today. Rest assured also that this book is not written by no name Professors. The first Author D. Patterson, along with Carlo Sequin coined the name RISC for there newly fashiond RISC chip, the second J. Hennesey invented the what he called the MIPS chip, both higly important chips to Companys like Sun and SGI and both authors have numorus awards for Engineering and Education and hail from highly acreddited universities, namely UC Berkly and Stanford. This book will not leave you waxing and waining for more, but rather fill you with the understanding and knowledge that are key to making a good engineer. Put simply, this book will not teach you the basics, this book will teach you the "advanced" and I really do mean the adVANced.
Rating:
Summary: Well founded book
Review: This is by far the best book in the subject, as one can see surfing through the sites of CA courses in several universities around the world. The most important feature of the book is the well founded exposition. With the book it is possible to understand why the designers of modern computers take the decisions that we read in the processor reports. Every decision is based in performance measures and good cost-benefit relation. The book emphasizes this point of view. Every thing must be measured in order to take the right decision. Also this is the reason because several more recent books are not bestsellers as this book in a field where the time is very important, the principles remains. However I hope a new edition sonner. Please Mr. Henessy and Mr. Patterson!
Rating:
Summary: Only for the serious student
Review: To address some of the cocerns others have raised, let me start by saying this is absolutely *the* reference book used in all of Computer Science and Computer Engineering. This is the book they use to teach the very basic and the most advanced classes. So bear that in mind. If you are not a serious student, this book will be difficult to work through. If you are lazy and unwilling to really sit down and think about the material here, you won't be able to comprehend it well enough to solve the problems. But, if you have a desire to learn this material and approach it with an open mind, you'll be delighted with the content. I wish it went more in-depth into modern processor design issues, but it lays the groundwork for understanding not only where we have all come from, but leads to where we're going, and why. No other single book covers such a huge and complex topic so clearly and simply. But if you're unwilling to work at it, be prepared to hate the book. This book walks you through the evolution of the computer architecture, touching on all the core concepts: basic operation in an ALU, cache systems, memory management, branch prediction, multiprocessor interconnects, specific processor designs, pipelining, and so much more. There's no better book to put on your desk.
<< 1 >>
| 
