Computer Systems: A Programmer’s Perspective (3rd Edition)

Description

For courses in Computer Organization and Architecture

This book (known as CS:APP) is for computer scientists, computer engineers, and others who want to be able to write better programs by learning what is going on “under the hood” of a computer system. The aim of the text is to explain the enduring concepts underlying all computer systems, and to show the concrete ways that these ideas affect the correctness, performance, and utility of application programs. Many systems books are written from a builder’s perspective, describing how to implement the hardware or the systems software, including the operating system, compiler, and network interface.

This book is written from a programmer’s perspective, describing how application programmers can use their knowledge of a system to write better programs. Of course, learning what a system is supposed to do provides a good first step in learning how to build one, so this book also serves as a valuable introduction to those who go on to implement systems hardware and software. Most systems books also tend to focus on just one aspect of the system, for example, the hardware architecture, the operating system, the compiler, or the network. This book spans all of these aspects, with the unifying theme of a programmer’s perspective.

Key Features

Computer Systems: A Programmer’s Perspective uses the following features to facilitate learning:

• NEW! The book now exclusively bases its presentation on x86-64
• A carefully planned 12 chapter layout that covers all of the core topics of computer programming
• Chapter 1 uses a simple “hello world” program to introduce the major concepts and themes of computer programming.
• Chapter 2 dives into the topic of computer arithmetic, considering how numbers are represented in computer programs and how they affect value coding. The chapter places a special emphasis on the properties of unsigned and two’s-compliment number representations. It gives students necessary insight into arithmetic from the programmers perspective and why it’s so important.
• Chapter 3 teaches students how to read the x86-64 code generated by a C compiler, covering the basic instruction patterns for different control constructs, implementation procedures, and the allocation of different data structures. This chapter also discusses the implementation of integer and floating point arithmetic and takes a machine-level view of programs to understand certain code vulnerabilities.
• Chapter 4 introduces students to basic combinational and sequential logic elements and shows how they can be used in a simplified subset of the x86-64 instruction set called Y86-64. It starts with a single-cycle datapath and moves onto a discussion of pipelining.
• Chapter 5 gives students techniques for improving code performance with transformations that reduce work and enhance instruction-level parallelism.
• Chapter 6 covers different types of RAM and ROM memory systems, describing their hierarchical arrangement. The chapter makes the abstract concept tangible by using the analogy of a “memory mountain” with ridges of temporal locality and slopes of spatial locality. Students learn that improving temporal and spatial locality improves performance.
• Chapter 7 discusses both static and dynamic linking, areas included in most systems text where programmers make their most confusing errors.
• Chapter 8 explains exceptional control flow at all levels of the system, from simple hardware interrupts to nonlocal jumps in C that break the stack discipline. This chapter introduces the fundamental idea of a process by teaching students how it works and how it is created and manipulated from application programs.
• Chapter 9 shows students key characteristics of the virtual memory system and how it works, addressing issues such as managing and manipulating. This chapter shows the benefits of covering the hardware and software aspects of computer systems in a unified way, which most books do not.
• Chapter 10 covers the basic concepts of Unix I/O, such as files and descriptors. It explains how files are shared, how I/O redirection works, and how to access file metadata.
• Chapter 11 discusses networks, I/O devices that tie together many of the ideas presented earlier in the text. It describes the client-server model that underlies all network applications and presents a programmer’s view of the internet.
• Chapter 12 uses internet design as an example that introduces students to concurrent programming. By comparing and contrasting the three basic mechanisms for writing concurrent programs (processes, I/O multiplexing, and threads) students learn how to build concurrent internet servers.

Changes in each chapter make the text flow easier for students to understand

• UPDATED! Chapter 1 now includes adiscussion of Amdahl’s law, originally in chapter 5.
• UPDATED! Chapter 2 has been rewritten to simplify mathematical presentations and give students easier access to its major concepts.
• UPDATED! Chapter 3 has been rewritten heavily based on the book’s conversion from using a mix of IA32 and x86-64 software to one that solely uses the latter. This includes reorganization of major concepts and a new presentation of machine-level support for programs operating on floating-point data.
• REVISED! Chapter 4’s earlier processor design has been revised to support 64-bit words and operations.
• UPDATED! Chapter 5 contains new material on the performance capabilities of recent generations of x86-64 processors, which is a more reliable predictor of performance.
• UPDATED! Chapter 6 now reflects more recent technology.
• NEW and UPDATED! Chapter 7 has been rewritten to support x86-64. The discussion of using the GOT and PLT to create position-independent code has been expanded. There is also a new section about library interpositioning.
• UPDATED! Chapter 8 has more in-depth information about signal handlers, including asynic-signal-safe functions, specific guidelines for writing signal handlers, and using sigsuspend to wait for handlers.
• NEW! Chapter 10 now includes a section on files and the file hierarchy.
• NEW! Chapter 11 introduces techniques for protocol-independent and thread-safe network programming using the modern getaddrinfo and getnameinfo functions to replace older, obsolete functions.
• UPDATED! Chapter 12 includes greater coverage of using thread-level parallelism to make programs run faster on multi-core machines.

Table of Contents

1. Part I: Program Structure and Execution
   1. Chapter 1: A Tour of Computer Systems
   2. Chapter 2: Representing and Manipulating Information
   3. Chapter 3: Machine-Level Representation of Programs
   4. Chapter 4: Processor Architecture
   5. Chapter 5: Optimizing Program Performance
   6. Chapter 6: The Memory Hierarchy
2. Part II: Running Programs on a System
   1. Chapter 7: Linking
   2. Chapter 8: Exceptional Control Flow
   3. Chapter 9: Virtual Memory
3. Part III: Interaction and Communication Between Programs
   1. Chapter 10: System-Level I/O
   2. Chapter 11: Network Programming
   3. Chapter 12: Concurrent Programming
4. Appendix
5. Error Handling

Authors Biography

Randal E. Bryant received his bachelor’s degree from the University of Michigan in 1973 and then attended graduate school at the Massachusetts Institute of Technology, receiving his PhD degree in computer science in 1981. He spent three years as an assistant professor at the California Institute of Technology, and has been on the faculty at Carnegie Mellon since 1984. For five of those years he served as head of the Computer Science Department, and for ten of them he served as Dean of the School of Computer Science. He is currently a university professor of computer science. He also holds a courtesy appointment with the Department of Electrical and Computer Engineering.

Professor Bryant has taught courses in computer systems at both the undergraduate and graduate level for around 40 years. Over many years of teaching computer architecture courses, he began shifting the focus from how computers are designed to how programmers can write more efficient and reliable programs if they understand the system better. Together with Professor O’Hallaron, he developed the course 15-213, Introduction to Computer Systems, at Carnegie Mellon that is the basis for this book. He has also taught courses in algorithms, programming, computer networking, distributed systems, and VLSI design

Most of Professor Bryant’s research concerns the design of software tools to help software and hardware designers verify the correctness of their systems. These include several types of simulators, as well as formal verification tools that prove the correctness of a design using mathematical methods. He has published over 150 technical papers. His research results are used by major computer manufacturers, including Intel, IBM, Fujitsu, and Microsoft. He has won several major awards for his research. These include two inventor recognition awards and a technical achievement award from the Semiconductor Research Corporation, the Kanellakis Theory and Practice Award from the Association for Computer Machinery (ACM), and the W. R. G. Baker Award, the Emmanuel Piore Award, the Phil Kaufman Award, and the A. Richard Newton Award from the Institute of Electrical and Electronics Engineers (IEEE). He is a fellow of both the ACM and the IEEE and a member of both the US National Academy of Engineering and the American Academy of Arts and Sciences.

David R. O’Hallaron is a professor of computer science and electrical and computer engineering at Carnegie Mellon University. He received his PhD from the University of Virginia. He served as the director of Intel Labs, Pittsburgh, from 2007 to 2010.

He has taught computer systems courses at the undergraduate and graduate levels for 20 years on such topics as computer architecture, introductory  computer systems, parallel processor design, and Internet services. Together with Professor Bryant, he developed the course at Carnegie Mellon that led to this book. In 2004, he was awarded the Herbert Simon Award for Teaching Excellence by the CMU School of Computer Science, an award for which the winner is chosen based on a poll of the students.

Professor O’Hallaron works in the area of computer systems, with specific interests in software systems for scientific computing, data-intensive computing, and virtualization. The best-known example of his work is the Quake project, an endeavor involving a group of computer scientists, civil engineers, and seismologists who have developed the ability to predict the motion of the ground during strong earthquakes. In 2003, Professor O’Hallaron and the other members of the Quake team won the Gordon Bell Prize, the top international prize in high-performance computing. His current work focuses on the notion of autograding, that is, programs that evaluate the quality of other programs.