Customer Reviews

Computer Architecture a Quantitative Approach

5 star:		(11)
4 star:		(2)
3 star:		(3)
2 star:		(2)
1 star:		(1)

 

 

Need to get inside the hardware, and don't mind a few bumps along the way? Computer Architecture: A Quantitative Approach will take you deeper than you probably ever thought you wanted to go. The focus is on uniprocessor architecture, although it does provide introductory coverage of multiprocessors. This work covers the various designs and alternatives for instruction sets, pipelining, cache, memory, I/O, etc. and provides current examples as well as historical references. The weakness of the book is that the exercises at the end of each chapter go beyond the scope of the material covered. Although certainly worthwhile and complimentary to the material presented in the chapters, the exercises seem to be material for the next level. The authors should either make the exercises more related to the chapter explanations and examples, or they should offer relevant extended references. It would also be helpful if they provided an answer set to a percentage of the exercises. The user of the 2nd edition is well advised to grab the errata file from the publisher, see Preface, as there are many errors in the printing. Overall, I would recommend this book to those who are serious about gaining an advanced understanding of modern computer architecture. Be advised, a good basic understanding is necessary before tackling this work.

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.

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.

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.

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.

This book has a great deal of information in it but the end of chapter questions are often vague. The sample questions dont really apply to the chapter end questions and the solutions manual is currently out of print and not available.

As with the 1st edition, this is a book that is not only packed with information, but it is also presented in an extremely readable way. I read the 1st edition from cover to cover in a weeks time. The same goes for the 2nd edition. The 'Fallacies and Pitfalls' sections are possible the best sections: the drive home serious points, while maintaining a humourous view.

There are times when using this book particularly the exercises that I am glad I am doing research in this field, as details are sometimes left out. However this is not necessarily a bad thing, as it forces students to think about how a problem should be formulated (e.g. what assumptions make sense, what simplifications are reasonable).

On the whole this is a pretty good book but it works best for an audience with some prior exposure to the concepts (of course a reflection of the fact that it is not an introductory text).

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.

This book assumes a solid understanding of computer architecture, and basic techniques for optimising cycle throughput. Therefore, it is not really practical to attempt to read this book without such knowledge. A very good introduction could be gained from another book by the same authors - "Computer Architecture - The Hardware/Software Interface".

I read this book as part of the curriculum of a course called "Advanced Computer Architectures" at the University of Copenhagen. It is a very informative book when it comes to discussing various dynamic (hardware) and static (compiler-based) techniques for improved pipelined behaviour of a CPU.