《程序员视角的计算机系统》第二版：深入解析计算机结构

5星 · 超过95%的资源需积分: 9 104 浏览量更新于2024-07-24 收藏 6.78MB PDF 举报

"Computer Systems：A Programmer's Perspective 2nd" 是一本由Randal E. Bryant和David R. O'Hallaron合著的计算机科学经典教材，主要探讨了计算机的结构和组成原理，适合程序员和计算机科学学生阅读。本书旨在帮助读者理解计算机系统的工作方式，从程序员的角度出发，深入浅出地解释了底层硬件与高级编程语言之间的联系。书中涵盖了多个关键知识点： 1. **计算机体系结构**：介绍了计算机的基本组成部分，包括处理器、内存、I/O设备等。读者将学习到CPU如何执行指令、内存层次结构以及存储器的工作原理。 2. **数据表示**：讨论了二进制、十六进制和八进制数制，位操作，浮点数表示，以及如何在计算机中表示字符和字符串。 3. **指令集架构**：涵盖了不同类型的指令，如数据处理指令、控制流指令，以及它们在处理器中的执行过程。此外，还涉及汇编语言和机器码的概念。 4. **程序的执行**：深入解析了编译器和解释器的作用，以及它们如何将高级语言转化为机器可执行的代码。讨论了程序的加载、链接和执行过程。 5. **存储器管理**：涵盖了虚拟内存、分页和分段技术，以及内存分配和回收策略，强调了内存效率和空间管理的重要性。 6. **并发与多线程**：讨论了在多处理器和多核系统中的并发执行，包括线程同步、互斥锁、死锁和活锁等概念。 7. **输入/输出（I/O）系统**：介绍了I/O设备的分类、中断、DMA（直接内存访问）以及设备控制器的工作机制。 8. **计算机安全与性能分析**：探讨了系统安全的威胁，如缓冲区溢出和指针错误，以及如何通过优化技术提升程序性能。 9. **计算机网络与分布式系统**：简要介绍了网络基础知识，如TCP/IP协议栈，以及分布式系统中的通信和协调问题。通过这本教材，读者不仅能掌握计算机系统的基础知识，还能了解到如何利用这些知识来编写更高效、更安全的程序。书中的实例和练习题有助于巩固理论知识，并将其应用于实际编程场景。 "Computer Systems：A Programmer's Perspective 2nd" 是一本全面而深入的教材，对于想要深入理解计算机系统工作的程序员和学生来说，是一份宝贵的参考资料。

xx Preface

Windows and have an environment very close to that provided by Linux. Not all

features of Linux are available under Cygwin, however.

We also assume that you have some familiarity with C or C++. If your only

prior experience is with Java, the transition will require more effort on your part,

but we will help you. Java and C share similar syntax and control statements.

However, there are aspects of C, particularly pointers, explicit dynamic memory

allocation, and formatted I/O, that do not exist in Java. Fortunately, C is a small

language, and it is clearly and beautifully described in the classic “K&R” text

by Brian Kernighan and Dennis Ritchie [58]. Regardless of your programming

background, consider K&R an essential part of your personal systems library.

Several of the early chapters in the book explore the interactions between

C programs and their machine-language counterparts. The machine-language

examples were all generated by the GNU gcc compiler running on IA32 and x86-

64 processors. We do not assume any prior experience with hardware, machine

language, or assembly-language programming.

New to C? Advice on the C programming language

To help readers whose background in C programming is weak (or nonexistent), we have also included

these special notes to highlight features that are especially important in C. We assume you are familiar

with C++ or Java.

How to Read the Book

Learning how computer systems work from a programmer’s perspective is great

fun, mainly because you can do it actively. Whenever you learn something new,

you can try it out right away and see the result ﬁrst hand. In fact, we believe that

the only way to learn systems is to do systems, either working concrete problems

or writing and running programs on real systems.

This theme pervades the entire book. When a new concept is introduced, it

is followed in the text by one or more practice problems that you should work

immediately to test your understanding. Solutions to the practice problems are

at the end of each chapter. As you read, try to solve each problem on your own,

and then check the solution to make sure you are on the right track. Each chapter

is followed by a set of homework problems of varying difﬁculty. Your instructor

has the solutions to the homework problems in an Instructor’s Manual. For each

homework problem, we show a rating of the amount of effort we feel it will require:

◆ Should require just a few minutes. Little or no programming required.

◆◆ Might require up to 20 minutes. Often involves writing and testing some code.

Many of these are derived from problems we have given on exams.

◆◆◆ Requires a signiﬁcant effort, perhaps 1–2 hours. Generally involves writing

and testing a signiﬁcant amount of code.

◆◆◆◆ A lab assignment, requiring up to 10 hours of effort.

Preface xxi

code/intro/hello.c

1 #include <stdio.h>

int main()

4 {

5 printf("hello, world\n");

6 return 0;

7 }

code/intro/hello.c

Figure 1 A typical code example.

Each code example in the text was formatted directly, without any manual

intervention, from a C program compiled with gcc and tested on a Linux system.

Of course, your system may have a different version of gcc, or a different compiler

altogether, and so your compiler might generate different machine code, but the

overall behavior should be the same. All of the source code is available from the

CS:APP Web page at csapp.cs.cmu.edu. In the text, the ﬁle names of the source

programs are documented in horizontal bars that surround the formatted code.

For example, the program in Figure 1 can be found in the ﬁle hello.c in directory

code/intro/. We encourage you to try running the example programs on your

system as you encounter them.

To avoid having a book that is overwhelming, both in bulk and in content,

we have created a number of Web asides containing material that supplements

the main presentation of the book. These asides are referenced within the book

with a notation of the form CHAP:TOP, where CHAP is a short encoding of the

chapter subject, and TOP is short code for the topic that is covered. For example,

Web Aside data:bool contains supplementary material on Boolean algebra for

the presentation on data representations in Chapter 2, while Web Aside arch:vlog

contains material describing processor designs using the Verilog hardware descrip-

tion language, supplementing the presentation of processor design in Chapter 4.

All of these Web asides are available from the CS:APP Web page.

Aside What is an aside?

You will encounter asides of this form throughout the text. Asides are parenthetical remarks that give

you some additional insight into the current topic. Asides serve a number of purposes. Some are little

history lessons. For example, where did C, Linux, and the Internet come from? Other asides are meant

to clarify ideas that students often ﬁnd confusing. For example, what is the difference between a cache

line, set, and block? Other asides give real-world examples. For example, how a ﬂoating-point error

crashed a French rocket, or what the geometry of an actual Seagate disk drive looks like. Finally, some

asides are just fun stuff. For example, what is a “hoinky”?

xxii Preface

Book Overview

The CS:APP book consists of 12 chapters designed to capture the core ideas in

computer systems:

Chapter 1: A Tour of Computer Systems. This chapter introduces the major

ideas and themes in computer systems by tracing the life cycle of a simple

“hello, world” program.

Chapter 2: Representing and Manipulating Information. We cover computer

arithmetic, emphasizing the properties of unsigned and two’s-complement

number representations that affect programmers. We consider how numbers

are represented and therefore what range of values can be encoded for a given

word size. We consider the effect of casting between signed and unsigned num-

bers. We cover the mathematical properties of arithmetic operations. Novice

programmers are often surprised to learn that the (two’s-complement) sum

or product of two positive numbers can be negative. On the other hand, two’s-

complement arithmetic satisﬁes the algebraic properties of a ring, and hence a

compiler can safely transform multiplication by a constant into a sequence of

shifts and adds. We use the bit-level operations of C to demonstrate the prin-

ciples and applications of Boolean algebra. We cover the IEEE ﬂoating-point

format in terms of how it represents values and the mathematical properties

of ﬂoating-point operations.

Having a solid understanding of computer arithmetic is critical to writing

reliable programs. For example, programmers and compilers cannot replace

the expression (x<y) with (x-y < 0), due to the possibility of overﬂow. They

cannot even replace it with the expression (-y < -x), due to the asymmetric

range of negative and positive numbers in the two’s-complement represen-

tation. Arithmetic overﬂow is a common source of programming errors and

security vulnerabilities, yet few other books cover the properties of computer

arithmetic from a programmer’s perspective.

Chapter 3: Machine-Level Representation of Programs. We teach you how to

read the IA32 and x86-64 assembly language generated by a C compiler. We

cover the basic instruction patterns generated for different control constructs,

such as conditionals, loops, and switch statements. We cover the implemen-

tation of procedures, including stack allocation, register usage conventions,

and parameter passing. We cover the way different data structures such as

structures, unions, and arrays are allocated and accessed. We also use the

machine-level view of programs as a way to understand common code se-

curity vulnerabilities, such as buffer overﬂow, and steps that the programmer,

the compiler, and the operating system can take to mitigate these threats.

Learning the concepts in this chapter helps you become a better programmer,

because you will understand how programs are represented on a machine.

One certain beneﬁt is that you will develop a thorough and concrete under-

standing of pointers.

Chapter 4: Processor Architecture. This chapter covers basic combinational

and sequential logic elements, and then shows how these elements can be

Preface xxiii

combined in a datapath that executes a simpliﬁed subset of the IA32 instruc-

tion set called “Y86.” We begin with the design of a single-cycle datapath. This

design is conceptually very simple, but it would not be very fast. We then intro-

duce pipelining , where the different steps required to process an instruction

are implemented as separate stages. At any given time, each stage can work

on a different instruction. Our ﬁve-stage processor pipeline is much more re-

alistic. The control logic for the processor designs is described using a simple

hardware description language called HCL. Hardware designs written in HCL

can be compiled and linked into simulators provided with the textbook, and

they can be used to generate Verilog descriptions suitable for synthesis into

working hardware.

Chapter 5: Optimizing Program Performance.This chapter introduces a num-

ber of techniques for improving code performance, with the idea being that

programmers learn to write their C code in such a way that a compiler can

then generate efﬁcient machine code. We start with transformations that re-

duce the work to be done by a program and hence should be standard practice

when writing any program for any machine. We then progress to transforma-

tions that enhance the degree of instruction-level parallelism in the generated

machine code, thereby improving their performance on modern “superscalar”

processors. To motivate these transformations, we introduce a simple opera-

tional model of how modern out-of-order processors work, and show how to

measure the potential performance of a program in terms of the critical paths

through a graphical representation of a program. You will be surprised how

much you can speed up a program by simple transformations of the C code.

Chapter 6: The Memory Hierarchy.The memory system is one of the most visi-

ble parts of a computer system to application programmers. To this point, you

have relied on a conceptual model of the memory system as a linear array with

uniform access times. In practice, a memory system is a hierarchy of storage

devices with different capacities, costs, and access times. We cover the differ-

ent types of RAM and ROM memories and the geometry and organization of

magnetic-disk and solid-state drives. We describe how these storage devices

are arranged in a hierarchy. We show how this hierarchy is made possible by

locality of reference. We make these ideas concrete by introducing a unique

view of a memory system as a “memory mountain” with ridges of temporal

locality and slopes of spatial locality. Finally, we show you how to improve the

performance of application programs by improving their temporal and spatial

locality.

Chapter 7: Linking. This chapter covers both static and dynamic linking, in-

cluding the ideas of relocatable and executable object ﬁles, symbol resolution,

relocation, static libraries, shared object libraries, and position-independent

code. Linking is not covered in most systems texts, but we cover it for sev-

eral reasons. First, some of the most confusing errors that programmers can

encounter are related to glitches during linking, especially for large software

packages. Second, the object ﬁles produced by linkers are tied to concepts

such as loading, virtual memory, and memory mapping.

xxiv Preface

Chapter 8: Exceptional Control Flow. In this part of the presentation, we

step beyond the single-program model by introducing the general concept

of exceptional control ﬂow (i.e., changes in control ﬂow that are outside the

normal branches and procedure calls). We cover examples of exceptional

control ﬂow that exist at all levels of the system, from low-level hardware

exceptions and interrupts, to context switches between concurrent processes,

to abrupt changes in control ﬂow caused by the delivery of Unix signals, to

the nonlocal jumps in C that break the stack discipline.

This is the part of the book where we introduce the fundamental idea of

a process, an abstraction of an executing program. You will learn how pro-

cesses work and how they can be created and manipulated from application

programs. We show how application programmers can make use of multiple

processes via Unix system calls. When you ﬁnish this chapter, you will be able

to write a Unix shell with job control. It is also your ﬁrst introduction to the

nondeterministic behavior that arises with concurrent program execution.

Chapter 9: Virtual Memory. Our presentation of the virtual memory system

seeks to give some understanding of how it works and its characteristics. We

want you to know how it is that the different simultaneous processes can each

use an identical range of addresses, sharing some pages but having individual

copies of others. We also cover issues involved in managing and manipulating

virtual memory. In particular, we cover the operation of storage allocators

such as the Unix malloc and free operations. Covering this material serves

several purposes. It reinforces the concept that the virtual memory space is

just an array of bytes that the program can subdivide into different storage

units. It helps you understand the effects of programs containing memory ref-

erencing errors such as storage leaks and invalid pointer references. Finally,

many application programmers write their own storage allocators optimized

toward the needs and characteristics of the application. This chapter, more

than any other, demonstrates the beneﬁt of covering both the hardware and

the software aspects of computer systems in a uniﬁed way. Traditional com-

puter architecture and operating systems texts present only part of the virtual

memory story.

Chapter 10: System-Level I/O. We cover the basic concepts of Unix I/O such

as ﬁles and descriptors. We describe how ﬁles are shared, how I/O redirection

works, and how to access ﬁle metadata. We also develop a robust buffered I/O

package that deals correctly with a curious behavior known as short counts,

where the library function reads only part of the input data. We cover the C

standard I/O library and its relationship to Unix I/O, focusing on limitations

of standard I/O that make it unsuitable for network programming. In general,

the topics covered in this chapter are building blocks for the next two chapters

on network and concurrent programming.

Chapter 11: Network Programming. Networks are interesting I/O devices to

program, tying together many of the ideas that we have studied earlier in the

text, such as processes, signals, byte ordering, memory mapping, and dynamic

剩余998页未读，继续阅读

TOUTOU1994

粉丝: 1
资源: 3

《程序员视角的计算机系统》第二版：深入解析计算机结构

《Computer Systems: A Programmer's Perspective》3rd Edition -英文版

Computer Systems: Programmer's Perspective课后答案解析

Computer Systems: A Programmer's Perspective

Computer Systems: A Programmer's Perspective (2nd Edition)

Computer Systems A Programmer’s Perspective 2nd Edition

Computer Systems A Programmer's Perspective(2nd) 无水印pdf

Computer Systems - A Programmer's Perspective (2nd Edition

Computer Systems A Programmer's perspective

Computer Systems- A Programmer’s Perspective, 1st,2nd,3rd, Global Edition.rar

Computer Systems_A Programmer's Perspective_2nd(深入理解计算机系统英文第二版)(带目录书签彩色)

最新资源