Skip to content

Computer Organization and Design MIPS Edition The Hardware/Software Interface

Best in textbook rentals since 2012!

ISBN-10: 0124077269

ISBN-13: 9780124077263

Edition: 5th 2014

Authors: David A. Patterson, John L. Hennessy

List price: $89.95
Blue ribbon 30 day, 100% satisfaction guarantee!
what's this?
Rush Rewards U
Members Receive:
Carrot Coin icon
XP icon
You have reached 400 XP and carrot coins. That is the daily max!


The 5th edition of Computer Organization and Design moves forward into the post-PC era with new examples, exercises, and material highlighting the emergence of mobile computing and the cloud. This generational change is emphasized and explored with updated content featuring tablet computers, cloud infrastructure, and the ARM (mobile computing devices) and x86 (cloud computing) architectures. Because an understanding of modern hardware is essential to achieving good performance and energy efficiency, this edition adds a new concrete example, "Going Faster," used throughout the text to demonstrate extremely effective optimization techniques. Also new to this edition is discussion of the…    
Customers also bought

Book details

List price: $89.95
Edition: 5th
Copyright year: 2014
Publisher: Elsevier Science & Technology
Publication date: 10/10/2013
Binding: Paperback
Pages: 800
Size: 7.50" wide x 9.21" long x 1.00" tall
Weight: 3.168

David A. Patterson was the first in his family to graduate from college (1969 A.B UCLA), and he enjoyed it so much that he didn't stop until a PhD, (1976 UCLA). After 4 years developing a wafer-scale computer at Hughes Aircraft, he joined U.C. Berkeley in 1977. He spent 1979 at DEC working on the VAX minicomputer. He and colleagues later developed the Reduced Instruction Set Computer (RISC). By joining forces with IBM's 801 and Stanford's MIPS projects, RISC became widespread. In 1984 Sun Microsystems recruited him to start the SPARC architecture. In 1987, Patterson and colleagues wondered if tried building dependable storage systems from the new PC disks. This led to the popular Redundant…    

John L. Hennessy is the president of Stanford University, where he has been a member of the faculty since 1977 in the departments of electrical engineering and computer science. Hennessy is a fellow of the IEEE and the ACM, a member of the National Academy of Engineering, the National Academy of Science, the American Academy of Arts and Sciences, and the Spanish Royal Academy of Engineering. He received the 2001 Eckert-Mauchly Award for his contributions to RISC technology, the 2001 Seymour Cray Computer Engineering Award, and shared the John von Neumann award in 2000 with David Patterson. After completing the project in 1984, he took a one-year leave from the university to co-found MIPS…    

Computer Abstractions and Technology
Eight Great Ideas in Computer Architecture
Below Your Program
Under the Covers
Technologies for Building Processors and Memory
The Power Wall
The Sea Change: The Switch from Uniprocessors to Multiprocessors
Real Stuff: Benchmarking the Intel Core i7
Fallacies and Pitfalls
Concluding Remarks
Historical Perspective and Further Reading
Instructions: Language of the Computer
Operations of the Computer Hardware
Operands of the Computer Hardware
Signed and Unsigned Numbers
Representing Instructions in the Computer
Logical Operations
Instructions for Making Decisions
Supporting Procedures in Computer Hardware
Communicating with People
MIPS Addressing for 32-Bit Immediates and Addresses
Parallelism and Instructions: Synchronization
Translating and Starting a Program
AC Sort Example to Put It All Together
Arrays versus Pointers
Advanced Material: Compiling C and Interpreting Java
Real Stuff: ARMv7 (32-bit) Instructions
Real Stuff: x86 Instructions
Real Stuff: ARMv8 (64-bit) Instructions
Fallacies and Pitfalls
Concluding Remarks
Historical Perspective and Further Reading
Arithmetic for Computers
Addition and Subtraction
Floating Point
Parallelism and Computer Arithmetic: Subword Parallelism
Real Stuff: Streaming SIMD Extensions and Advanced Vector Extensions in x86
Going Faster: Subword Parallelism and Matrix Multiply
Fallacies and Pitfalls
Concluding Remarks
Historical Perspective and Further Reading
The Processor
Logic Design Conventions
Building a Datapath
A Simple Implementation Scheme
An Overview of Pipelining
Pipelined Datapath and Control
Data Hazards: Forwarding versus Stalling
Control Hazards
Parallelism via Instructions
Real Stuff: The ARM Cortex-A8 and Intel Core i7 Pipelines
Going Faster: Instruction-Level Parallelism and Matrix Multiply
Advanced Topic: An Introduction to Digital Design Using a Hardware Design Language to Describe and Model a Pipeline and More Pipelining Illustrations
Fallacies and Pitfalls
Concluding Remarks
Historical Perspective and Further Reading
Large and Fast: Exploiting Memory Hierarchy
Memory Technologies
The Basics of Caches
Measuring and Improving Cache Performance
Dependable Memory Hierarchy
Virtual Machines
Virtual Memory
A Common Framework for Memory Hierarchy
Using a Finite-State Machine to Control a Simple Cache
Parallelism and Memory Hierarchies: Cache Coherence
Parallelism and Memory Hierarchy: Redundant Arrays of Inexpensive Disks
Advanced Material: Implementing Cache Controllers
Real Stuff: The ARM Cortex-A8 and Intel Core i7 Memory Hierarchies
Going Faster: Cache Blocking and Matrix Multiply
Fallacies and Pitfalls
Concluding Remarks
Historical Perspective and Further Reading
Parallel Processors from Client to Cloud
The Difficulty of Creating Parallel Processing Programs
Hardware Multithreading
Multicore and Other Shared Memory Multiprocessors
Introduction to Graphics Processing Units
Clusters, Warehouse Scale Computers, and Other Message-Passing Multiprocessors
Introduction to Multiprocessor Network Topologies
Communicating to the Outside World: Cluster Networking
Multiprocessor Benchmarks and Performance Models
Real Stuff: Benchmarking Intel Core 17 versus NVIDIA Tesla GPU
Going Faster: Multiple Processors and Matrix Multiply
Fallacies and Pitfalls
Concluding Remarks
Historical Perspective and Further Reading
Assemblers, Linkers, and the SPIM Simulator
Memory Usage
Procedure Call Convention
Exceptions and Interrupts
Input and Output
MIPS R2000 Assembly Language
Concluding Remarks
The Basics of Logic Design
Gates, Truth Tables, and Logic Equations
Combinational Logic
Using a Hardware Description Language
Constructing a Basic Arithmetic Logic Unit
Faster Addition: Carry Lookahead
Memory Elements: Flip-Flops, Latches, and Registers
Memory Elements: SRAMs and DRAMs
Finite-State Machines
Timing Methodologies
Field Programmable Devices
Concluding Remarks
Graphics and Computing GPUs
GPU System Architectures
Programming GPUs
Multithreaded Multiprocessor Architecture
Parallel Memory System
Floating Point Arithmetic
Real Stuff: The NVIDIA GeForce 8800
Real Stuff: Mapping Applications to GPUs
Fallacies and Pitfalls
Concluding Remarks
Historical Perspective and Further Reading
Mapping Control to Hardware
Implementing Combinational Control Units
Implementing Finite-State Machine Control
Implementing the Next-State Function with a Sequencer
Translating a Microprogram to Hardware
Concluding Remarks
A Survey of RISC Architectures for Desktop, Server, and Embedded Computers
Addressing Modes and Instruction Formats
Instructions: The MIPS Core Subset
Instructions: Multimedia Extensions of the Desktop/Server RISCs
Instructions: Digital Signal-Processing Extensions of the Embedded RISCs
Instructions: Common Extensions to MIPS Core
Instructions Unique to MIPS-64
Instructions Unique to Alpha
Instructions Unique to SPARC v9
Instructions Unique to PowerPC
instructions Unique to PA-RISC 2.0
Instructions Unique to ARM
Instructions Unique to Thumb
Instructions Unique to SuperH
Instructions Unique to M32R
Instructions Unique to MIPS-16
Concluding Remarks
Further Reading