Computer Organization and Design: The Hardware/Software Interface / Edition 5

by David A. Patterson

Overview

The performance of software systems is dramatically affected by how well software designers understand the basic hardware technologies at work in a system. Similarly, hardware designers must understand the far-reaching effects their design decisions have on software applications. For readers in either category, this classic introduction to the field provides a look deep into the computer. It demonstrates the relationships between the software and hardware and focuses on the foundational concepts that are the basis for current computer design.

As with previous editions, a MIPS processor is the core used to present the fundamentals of hardware technologies at work in a computer system. The book presents an entire MIPS instruction set-instruction by instruction-the fundamentals of assembly language, computer arithmetic, pipelining, memory hierarchies, and I/O, and introduces the essentials of network and multiprocessor architectures.

A new aspect of the third edition is the explicit connection between program performance and CPU performance. The authors show how hardware and software components-such as the specific algorithm, programming language, compiler, instruction set architecture, and processor implementation-impact program performance. This edition also digs deeper into related hardware and software issues, offering specific material on the CD for readers with a hardware or software focus. A CD provides a toolkit of simulators and compilers along with tutorials for using them.

Revised Printing Features: Appendix A now in the text; corrections throughout the text; updated links on the CD: Uses standard 32-bit MIPS 32 as the primary teaching ISA: Highlights the latestdevelopments in architecture, Intel IA-32, Power PC 604, Pentium P4, Google's PC cluster, SPEC CPU2000 benchmark suite for processors, vSPEC Web99 benchmark for web, EEMBC benchmark for embedded systems, AMD Opteron memory hierarchy, AMD vs. 1A-64, Intrinsity's FastMATH processor servers: New material for a Hardware Focus, Using logic design conventions, Designing with hardware description languages, Advanced pipelining, Designing with FPGAs, HDL simulators and tutorials, Xilinx CAD tools: New material for a Software Focus, How compilers work, How to optimize compilers, How to implement object oriented languages, History sections on programming languages, compilers, operating systems, and databases: A search engine for both the printed text and CD-only content.

Product Details

ISBN-13:	2900124077262
Publisher:	Elsevier Science
Publication date:	10/10/2013
Series:	Morgan Kaufmann Series in Computer Architecture and Design Series
Edition description:	Older Edition
Pages:	800
Product dimensions:	7.40(w) x 9.10(h) x 1.30(d)

About the Author

ACM named John L. Hennessy a recipient of the 2017 ACM A.M. Turing Award for pioneering a systematic, quantitative approach to the design and evaluation of computer architectures with enduring impact on the microprocessor industry. John L. Hennessy is a Professor of Electrical Engineering and Computer Science at Stanford University, where he has been a member of the faculty since 1977 and was, from 2000 to 2016, its tenth President. Prof. Hennessy is a Fellow of the IEEE and ACM; a member of the National Academy of Engineering, the National Academy of Science, and the American Philosophical Society; and a Fellow of the American Academy of Arts and Sciences. Among his many awards are the 2001 Eckert-Mauchly Award for his contributions to RISC technology, the 2001 Seymour Cray Computer Engineering Award, and the 2000 John von Neumann Award, which he shared with David Patterson. He has also received seven honorary doctorates.

ACM named David A. Patterson a recipient of the 2017 ACM A.M. Turing Award for pioneering a systematic, quantitative approach to the design and evaluation of computer architectures with enduring impact on the microprocessor industry. David A. Patterson is the Pardee Chair of Computer Science, Emeritus at the University of California Berkeley. His teaching has been honored by the Distinguished Teaching Award from the University of California, the Karlstrom Award from ACM, and the Mulligan Education Medal and Undergraduate Teaching Award from IEEE. Patterson received the IEEE Technical Achievement Award and the ACM Eckert-Mauchly Award for contributions to RISC, and he shared the IEEE Johnson Information Storage Award for contributions to RAID. He also shared the IEEE John von Neumann Medal and the C & C Prize with John Hennessy. Like his co-author, Patterson is a Fellow of the American Academy of Arts and Sciences, the Computer History Museum, ACM, and IEEE, and he was elected to the National Academy of Engineering, the National Academy of Sciences, and the Silicon Valley Engineering Hall of Fame. He served on the Information Technology Advisory Committee to the U.S. President, as chair of the CS division in the Berkeley EECS department, as chair of the Computing Research Association, and as President of ACM. This record led to Distinguished Service Awards from ACM, CRA, and SIGARCH.

Table of Contents

Preface     xi
Computer Abstractions and Technology     2
Introduction     3
Below Your Program     11
Under the Covers     15
Real Stuff: Manufacturing Pentium 4 Chips     28
Fallacies and Pitfalls     33
Concluding Remarks     35
Historical Perspective and Further Reading     36
Exercises     36
Computers in the Real World: Information Technology for the 4 Billion without IT     44
Instructions: Language of the Computer     46
Introduction     48
Operations of the Computer Hardware     49
Operands of the Computer Hardware     52
Representing Instructions in the Computer     60
Logical Operations     68
Instructions for Making Decisions     72
Supporting Procedures in Computer Hardware     79
Communicating with People     90
MIPS Addressing for 32-Bit Immediates and Addresses     95
Translating and Starting a Program     106
How Compilers Optimize     116
How Compilers Work: An Introduction     121
A C Sort Example to Put It All Together     121
Implementing an Object-Oriented Language     130
Arrays versus Pointers     130
Real Stuff: IA-32 Instructions     134
Fallacies and Pitfalls     143
Concluding Remarks     145
Historical Perspective and Further Reading     147
Exercises     147
Computers in the Real World: Helping Save Our Environment with Data     156
Arithmetic for Computers     158
Introduction     160
Signed and Unsigned Numbers     160
Addition and Subtraction     170
Multiplication     176
Division     183
Floating Point     189
Real Stuff: Floating Point in the IA-32     217
Fallacies and Pitfalls     220
Concluding Remarks     225
Historical Perspective and Further Reading     229
Exercises     229
Computers in the Real World: Reconstructing the Ancient World     236
Assessing and Understanding Performance     238
Introduction     240
CPU Performance and Its Factors     246
Evaluating Performance     254
Real Stuff: Two SPEC Benchmarks and the Performance of Recent Intel Processors     259
Fallacies and Pitfalls     266
Concluding Remarks     270
Historical Perspective and Further Reading     272
Exercises     272
Computers in the Real World: Moving People Faster and More Safely     280
The Processor: Datapath and Control     282
Introduction     284
Logic Design Conventions     289
Building a Datapath     292
A Simple Implementation Scheme     300
A Multicycle Implementation     318
Exceptions     340
Microprogramming: Simplifying Control Design     346
An Introduction to Digital Design Using a Hardware Design Language     346
Real Stuff: The Organization of Recent Pentium Implementations     347
Fallacies and Pitfalls     350
Concluding Remarks     352
Historical Perspective and Further Reading     353
Exercises     354
Computers in the Real World: Empowering the Disabled     366
Enhancing Performance with Pipelining     368
An Overview of Pipelining     370
A Pipelined Datapath     384
Pipelined Control     399
Data Hazards and Forwarding     402
Data Hazards and Stalls     413
Control Hazards     416
Using a Hardware Description Language to Describe and Model a Pipeline     426
Exceptions     427
Advanced Pipelining: Extracting More Performance     432
Real Stuff: The Pentium 4 Pipeline     448
Fallacies and Pitfalls     451
Concluding Remarks     452
Historical Perspective and Further Reading     454
Exercises     454
Computers in the Real World: Mass Communication without Gatekeepers     464
Large and Fast: Exploiting Memory Hierarchy     466
Introduction     468
The Basics of Caches     473
Measuring and Improving Cache Performance     492
Virtual Memory     511
A Common Framework for Memory Hierarchies     538
Real Stuff: The Pentium P4 and the AMD Opteron Memory Hierarchies     546
Fallacies and Pitfalls     550
Concluding Remarks     552
Historical Perspective and Further Reading     555
Exercises     555
Computers in the Real World: Saving the World's Art Treasures     562
Storage, Networks, and Other Peripherals     564
Introduction     566
Disk Storage and Dependability     569
Networks     580
Buses and Other Connections between Processors, Memory, and I/O Devices     581
Interfacing I/O Devices to the Processor, Memory, and Operating System     588
I/O Performance Measures: Examples from Disk and File Systems     597
Designing an I/O System     600
Real Stuff: A Digital Camera     603
Fallacies and Pitfalls     606
Concluding Remarks     609
Historical Perspective and Further Reading     611
Exercises     611
Computers in the Real World: Saving Lives through Better Diagnosis     622
Multiprocessors and Clusters     2
Introduction     4
Programming Multiprocessors     8
Multiprocessors Connected by a Single Bus     11
Multiprocessors Connected by a Network     21
Clusters     25
Network Topologies     27
Multiprocessors Inside a Chip and Multithreading     30
Real Stuff: The Google Cluster of PCs     34
Fallacies and Pitfalls     39
Concluding Remarks     42
Historical Perspective and Further Reading     47
Exercises     55
Appendices
Assemblers, Linkers, and the SPIM Simulator     2
Introduction      3
Assemblers     10
Linkers     18
Loading     19
Memory Usage     20
Procedure Call Convention     22
Exceptions and Interrupts     33
Input and Output     37
SPIM     40
MIPS R2000 Assembly Language     44
Concluding Remarks     79
Exercises     80
The Basics of Logic Design     2
Introduction     3
Gates, Truth Tables, and Logic Equations     4
Combinational Logic     8
Using a Hardware Description Language     20
Constructing a Basic Arithmetic Logic Unit     26
Faster Addition: Carry Lookahead     38
Clocks     47
Memory Elements: Flip-Flops, Latches, and Registers     49
Memory Elements: SRAMs and DRAMs     57
Finite-State Machines     67
Timing Methodologies     72
Field Programmable Devices     77
Concluding Remarks     78
Exercises     79
Mapping Control to Hardware     2
Introduction     3
Implementing Combinational Control Units     4
Implementing Finite-State Machine Control      8
Implementing the Next-State Function with a Sequencer     21
Translating a Microprogram to Hardware     27
Concluding Remarks     31
Exercises     32
A Survey of RISC Architectures for Desktop, Server, and Embedded Computers     2
Introduction     3
Addressing Modes and Instruction Formats     5
Instructions: The MIPS Core Subset     9
Instructions: Multimedia Extensions of the Desktop/Server RISCs     16
Instructions: Digital Signal-Processing Extensions of the Embedded RISCs     19
Instructions: Common Extensions to MIPS Core     20
Instructions Unique to MIPS-64     25
Instructions Unique to Alpha     27
Instructions Unique to SPARC v.9     29
Instructions Unique to PowerPC     32
Instructions Unique to PA-RISC 2.0     34
Instructions Unique to ARM     36
Instructions Unique to Thumb     38
Instructions Unique to SuperH     39
Instructions Unique to M32R     40
Instructions Unique to MIPS-16     41
Concluding Remarks     43
Index     I-1
Glossary     G-1
Further Reading     FR-1

What People are Saying About This

From the Publisher

The classic introduction to computer organization now updated for mobile computing and the cloud!

Editorial Reviews

Patterson and Hennessy's Computer Organization and Design has long been recognized as an exceptionally thorough and reliable introduction to computer design. Now they've fully updated their classic and linked it even more systematically to real-world practice.

You'll now find "Real Stuff" sections in every chapter: from Google clusters to advanced pipelining, AMD's Opteron memory hierarchy to recent innovations in Intel's Pentium line. You'll find new hardware coverage: FPGAs, HDL simulators, logic design conventions, and more. Plenty of new software coverage, too, from optimizing compilers to implementing object-oriented languages.

The meat of the book remains as good as ever: detailed, accessible introductions to modern instruction sets, memory, storage, networking, multiprocessing, clustering, and more. How it all fits. Why it works as it does. Whether you're primarily interested in hardware or software, this is the rock-solid grounding you'll need to succeed. Bill Camarda, from the October 2007 Read Only

The Barnes & Noble Review
Even today, to write great software, it helps to understand the underlying hardware. And if you’re a hardware architect, you’d better understand how your choices will impact developers. Computer Organization and Design, Third Edition will help software and hardware folks understand each other. The authors even provide separate learning paths for each audience.

Using the actual MIPS 32 architecture to ground their discussions in reality, David Patterson and John Hennessy illuminate computer arithmetic, pipelining, memory hierarchies, I/O, multiprocessing, clustering, and much more. Throughout, welcome “Fallacies and Pitfalls” sections clear up much of the misinformation that bedevils the field.

This edition’s been heavily updated, both for clarity and content. Especially worth noting: a stronger focus on the relationship between hardware and program performance, and a comparison of the Pentium 4 with AMD’s influential new Opteron. Bill Camarda

Bill Camarda is a consultant, writer, and web/multimedia content developer. His 15 books include Special Edition Using Word 2003 and Upgrading & Fixing Networks for Dummies, Second Edition.

bn.com

"The new coverage of multiprocessors and parallelism lives up to the standards of this well-written classic. It provides well-motivated, gentle introductions to the new topics, as well as many details and examples drawn from curent hardware." — John Greiner, Rice University

"Patterson and Hennessy not only improve the pedagogy of the traditional material on pipelined processors and memory hierarchies, but also greatly expand the multiprocessor coverage to include emerging multicore processors and GPUs. Computer Organization and Design sets a new benchmark against which all other architecture books must be compared." -- David A. Wood, University of Wisconsin-Madison

"Intended for computer science students and programmers of varied experience levels, this textbook on computer design and engineering provides a firm foundation in hardware engineering and computer architecture that will aid readers not only in working with hardware design and assembly language programming, but inform software engineers as to the underlying technologies and principles at work in machines they program for. Topics discussed include computer abstractions and technologies, instructions as to the language of computer hardware, arithmetic for computers, processors, memory hierarchies, storage and I/O, and multicores and multiprocessors. A series of appendices offers detailed information on graphics and GPU processes. Chapters include numerous illustrations and code examples and an accompanying CD-ROM provides additional chapters and other resources. This fourth edition is updated to account for the latest technological improvements."—Reference and Research Book News, Inc.

"This book, now in its fourth edition, is a comprehensive introduction to modern computer architecture and is aimed at a variety of audiences with backgrounds in either hardware or software…While there is a great deal of technical content, concepts are lucidly described and always given meaningful context. I found this book to be an interesting read and certainly a book I'd plan to read again." —BCS.org

From the Publisher