当前: 首页 - 图书专区 - 深入理解计算机系统(英文版·第3版)
深入理解计算机系统(英文版·第3版)


  在线购买
[美] 兰德尔 E.布莱恩特(Randal E. Bryant)大卫 R. 奥哈拉伦(David R. O'Hallaron) 著
978-7-111-56127-9
239.00
1088
2017年04月07日

计算机 > 计算机科学理论与基础知识
Pearson Education Inc.
339
英文
16
Computer Systems: A Programmer's Perspective, Third Edition
教材
经典原版书库







本书目的是解释所有计算机系统的本质概念,并展示这些概念是如何实实在在地影响应用程序的正确性、性能和实用性的。本书从程序员的角度来讲述应用程序员如何能够利用系统知识来写出更好的程序。
本书是一本将计算机软件和硬件理论结合讲述的经典教材,内容涵盖计算机导论、体系结构和处理器设计等多门课程。本书最大的特点是为程序员描述计算机系统的实现细节,通过描述程序是如何映射到系统上,以及程序是如何执行的,使读者更好地理解程序的行为,找到程序效率低下的原因。
和第2版相比,本版内容上最大的变化是,从以IA32和x86-64为基础转变为完全以x86-64为基础。主要更新如下:
· 基于x86-64,大量地重写代码,首次介绍对处理浮点数据的程序的机器级支持。
· 处理器体系结构修改为支持64位字和操作的设计。
· 引入更多的功能单元和更复杂的控制逻辑,使基于程序数据流表示的程序性能模型预测更加可靠。
· 扩充关于用GOT和PLT创建与位置无关代码的讨论,描述了更加强大的链接技术(比如库打桩)。
· 增加了对信号处理程序更细致的描述,包括异步信号安全的函数等。
· 采用最新函数,更新了与协议无关和线程安全的网络编程。

作者简介
Randal E. Bryant  1981年于麻省理工学院获得计算机博士学位,1984年至今任教于卡内基-梅隆大学。现任卡内基-梅隆大学计算机科学学院院长、教授,同时还受邀任教于电子和计算机工程系。他从事本科生和研究生计算机系统方面课程的教学近40年,和O’Hallaron教授一起在卡内基-梅隆大学开设了15-213课程“计算机系统导论”,那便是本书的基础。他还是ACM院士、IEEE院士、美国国家工程院院士和美国人文与科学研究院院士。其研究成果被Intel、IBM、Fujitsu和Microsoft等主要计算机制造商使用,他还因研究获得过Semiconductor Research Corporation、ACM、IEEE颁发的多项大奖。
David R. O’Hallaron 卡内基-梅隆大学电子和计算机工程系教授。在弗吉尼亚大学获得计算机科学的博士学位,2007年-2010年为Intel匹兹堡实验室主任。他教授本科生和研究生的计算机系统方面的课程已有20余年,并和Bryant教授一起教授“计算机系统导论”课程。曾获得卡内基-梅隆大学计算机学院颁发的Herbert Simon杰出教学奖。他主要从事计算机系统领域的研究,与Quake项目成员一起获得过高性能计算领域中的最高国际奖项——Gordon Bell奖。他目前的工作重点是研究自动分级(autograding)概念,即评价其他程序质量的程序。
本书(简称CS:APP)的主要读者是计算机科学家、计算机工程师,以及那些想通过学习计算机系统的内在运作而能够写出更好程序的人。
我们的目的是解释所有计算机系统的本质概念,并向你展示这些概念是如何实实在在地影响应用程序的正确性、性能和实用性的。其他的系统类书籍都是从构建者的角度来写的,讲述如何实现硬件或系统软件,包括操作系统、编译器和网络接口。而本书是从程序员的角度来写的,讲述应用程序员如何能够利用系统知识来编写出更好的程序。当然,学习一个计算机系统应该做些什么,是学习如何构建一个计算机系统的很好的出发点,所以,对于希望继续学习系统软硬件实现的人来说,本书也是一本很有价值的介绍性读物。大多数系统书籍还倾向于重点关注系统的某一个方面,比如:硬件架构、操作系统、编译器或者网络。本书则以程序员的视角统一覆盖了上述所有方面的内容。
如果你研究和领会了这本书里的概念,你将开始成为极少数的“牛人”,这些“牛人”知道事情是如何运作的,也知道当事情出现故障时如何修复。你写的程序将能够更好地利用操作系统和系统软件提供的功能,对各种操作条件和运行时参数都能正确操作,运行起来更快,并能避免出现使程序容易受到网络攻击的缺陷。同时,你也要做好更深入探究的准备,研究像编译器、计算机体系结构、操作系统、嵌入式系统、网络互联和网络安全这样的高级题目。
读者应具备的背景知识
本书的重点是执行x86-64机器代码的系统。对英特尔及其竞争对手而言,x86-64是他们自1978年起,以8086微处理器为代表,不断进化的最新成果。按照英特尔微处理器产品线的命名规则,这类微处理器俗称为“x86”。随着半导体技术的演进,单芯片上集成了更多的晶体管,这些处理器的计算能力和内存容量有了很大的增长。在这个过程中,它们从处理16位字,发展到引入IA32处理器处理32位字,再到最近的x86-64处理64位字。
我们考虑的是这些机器如何在Linux操作系统上运行C语言程序。Linux是众多继承自最初由贝尔实验室开发的Unix的操作系统中的一种。这类操作系统的其他成员包括Solaris、FreeBSD和MacOS X。近年来,由于Posix和标准Unix规范的标准化努力,这些操作系统保持了高度兼容性。因此,本书内容几乎直接适用于这些“类Unix”操作系统。
文中包含大量已在Linux系统上编译和运行过的程序示例。我们假设你能访问一台这样的机器,并且能够登录,做一些诸如切换目录之类的简单操作。如果你的计算机运行的是Microsoft Windows系统,我们建议你选择安装一个虚拟机环境(例如VirtualBox或者VMWare),以便为一种操作系统(客户OS)编写的程序能在另一种系统(宿主OS)上运行。
我们还假设你对C和C++有一定的了解。如果你以前只有Java经验,那么你需要付出更多的努力来完成这种转换,不过我们也会帮助你。Java和C有相似的语法和控制语句。不过,有一些C语言的特性(特别是指针、显式的动态内存分配和格式化I/O)在Java中都是没有的。所幸的是,C是一个较小的语言,在Brian Kernighan和Dennis Ritchie经典的“K&R”文献中得到了清晰优美的描述[61]。无论你的编程背景如何,都应该考虑将K&R作为个人系统藏书的一部分。如果你只有使用解释性语言的经验,如Python、Ruby或Perl,那么在使用本书之前,需要花费一些时间来学习C。
本书的前几章揭示了C语言程序和它们相对应的机器语言程序之间的交互作用。机器语言示例都是用运行在x86-64处理器上的GNU GCC编译器生成的。我们不需要你以前有任何硬件、机器语言或是汇编语言编程的经验。
给C语言初学者 关于C编程语言的建议
为了帮助C语言编程背景薄弱(或全无背景)的读者,我们在书中加入了这样一些专门的注释来突出C中一些特别重要的特性。我们假设你熟悉C++或Java。
如何阅读此书
从程序员的角度学习计算机系统是如何工作的会非常有趣,主要是因为你可以主动地做这件事情。无论何时你学到一些新的东西,都可以马上试验并且直接看到运行结果。事实上,我们相信学习系统的唯一方法就是做(do)系统,即在真正的系统上解决具体的问题,或是编写和运行程序。
这个主题观念贯穿全书。当引入一个新概念时,将会有一个或多个练习题紧随其后,你应该马上做一做来检验你的理解。这些练习题的解答在每章的末尾。当你阅读时,尝试自己来解答每个问题,然后再查阅答案,看自己的答案是否正确。除第1章外,每章后面都有难度不同的家庭作业。对每个家庭作业题,我们标注了难度级别:
*只需要几分钟。几乎或完全不需要编程。
**可能需要将近20分钟。通常包括编写和测试一些代码。(许多都源自我们在考试中出的题目。)
需要很大的努力,也许是1~2个小时。一般包括编写和测试大量的代码。
一个实验作业,需要将近10个小时。
文中每段代码示例都是由经过GCC编译的C程序直接生成并在Linux系统上进行了测试,没有任何人为的改动。当然,你的系统上GCC的版本可能不同,或者根本就是另外一种编译器,那么可能生成不一样的机器代码,但是整体行为表现应该是一样的。所有的源程序代码都可以从csapp.cs.cmu.edu上的CS:APP主页上获取。在本书中,源程序的文件名列在两条水平线的右边,水平线之间是格式化的代码。比如,图1中的程序能在code/intro/目录下的hello.c文件中找到。当遇到这些示例程序时,我们鼓励你在自己的系统上试着运行它们。


图1 一个典型的代码示例
为了避免本书体积过大、内容过多,我们添加了许多网络旁注(Web aside),包括一些对本书主要内容的补充资料。本书中用CHAP:TOP这样的标记形式来引用这些旁注,这里CHAP是该章主题的缩写编码,而TOP是涉及的话题的缩写编码。例如,网络旁注DATA:BOOL包含对第2章中数据表示里面有关布尔代数内容的补充资料;而网络旁注ARCH:VLOG包含的是用Verilog硬件描述语言进行处理器设计的资料,是对第4章中处理器设计部分的补充。所有的网络旁注都可以从CS:APP的主页上获取。
旁注 什么是旁注
在整本书中,你将会遇到很多以这种形式出现的旁注。旁注是附加说明,能使你对当前讨论的主题多一些了解。旁注可以有很多用处。一些是小的历史故事。例如,C语言、Linux和Internet是从何而来的?有些旁注则是用来澄清学生们经常感到疑惑的问题。例如,高速缓存的行、组和块有什么区别?还有些旁注给出了一些现实世界的例子。例如,一个浮点错误怎么毁掉了法国的一枚火箭,或是给出市面上出售的一个磁盘驱动器的几何和运行参数。最后,还有一些旁注仅仅就是一些有趣的内容,例如,什么是“hoinky”?
本书概述
本书由12章组成,旨在阐述计算机系统的核心概念。内容概述如下:
第1章:计算机系统漫游。这一章通过研究“hello,world”这个简单程序的生命周期,介绍计算机系统的主要概念和主题。
第2章:信息的表示和处理。我们讲述了计算机的算术运算,重点描述了会对程序员有影响的无符号数和数的补码表示的特性。我们考虑数字是如何表示的,以及由此确定对于一个给定的字长,其可能编码值的范围。我们探讨有符号和无符号数字之间类型转换的效果,还阐述算术运算的数学特性。菜鸟级程序员经常很惊奇地了解到(用补码表示的)两个正数的和或者积可能为负。另一方面,补码的算术运算满足很多整数运算的代数特性,因此,编译器可以很安全地把一个常量乘法转化为一系列的移位和加法。我们用C语言的位级操作来说明布尔代数的原理和应用。我们从两个方面讲述了IEEE标准的浮点格式:一是如何用它来表示数值,一是浮点运算的数学属性。
对计算机的算术运算有深刻的理解是写出可靠程序的关键。比如,程序员和编译器不能用表达式(x-y<0)来替代(x第3章:程序的机器级表示。我们教读者如何阅读由C编译器生成的x86-64机器代码。我们说明为不同控制结构(比如条件、循环和开关语句)生成的基本指令模式。我们还讲述过程的实现,包括栈分配、寄存器使用惯例和参数传递。我们讨论不同数据结构(如结构、联合和数组)的分配和访问方式。我们还说明实现整数和浮点数算术运算的指令。我们还以分析程序在机器级的样子作为途径,来理解常见的代码安全漏洞(例如缓冲区溢出),以及理解程序员、编译器和操作系统可以采取的减轻这些威胁的措施。学习本章的概念能够帮助读者成为更好的程序员,因为你们懂得程序在机器上是如何表示的。另外一个好处就在于读者会对指针有非常全面而具体的理解。
第4章:处理器体系结构。这一章讲述基本的组合和时序逻辑元素,并展示这些元素如何在数据通路中组合到一起,来执行x86-64指令集的一个称为“Y86-64”的简化子集。我们从设计单时钟周期数据通路开始。这个设计概念上非常简单,但是运行速度不会太快。然后我们引入流水线的思想,将处理一条指令所需要的不同步骤实现为独立的阶段。这个设计中,在任何时刻,每个阶段都可以处理不同的指令。我们的五阶段处理器流水线更加实用。本章中处理器设计的控制逻辑是用一种称为HCL的简单硬件描述语言来描述的。用HCL写的硬件设计能够编译和链接到本书提供的模拟器中,还可以根据这些设计生成Verilog描述,它适合合成到实际可以运行的硬件上去。
第5章:优化程序性能。在这一章里,我们介绍了许多提高代码性能的技术,主要思想就是让程序员通过使编译器能够生成更有效的机器代码来学习编写C代码。我们一开始介绍的是减少程序需要做的工作的变换,这些是在任何机器上写任何程序时都应该遵循的。然后讲的是增加生成的机器代码中指令级并行度的变换,因而提高了程序在现代“超标量”处理器上的性能。为了解释这些变换行之有效的原理,我们介绍了一个简单的操作模型,它描述了现代乱序处理器是如何工作的,然后给出了如何根据一个程序的图形化表示中的关键路径来测量一个程序可能的性能。你会惊讶于对C代码做一些简单的变换能给程序带来多大的速度提升。
第6章:存储器层次结构。对应用程序员来说,存储器系统是计算机系统中最直接可见的部分之一。到目前为止,读者一直认同这样一个存储器系统概念模型,认为它是一个有一致访问时间的线性数组。实际上,存储器系统是一个由不同容量、造价和访问时间的存储设备组成的层次结构。我们讲述不同类型的随机存取存储器(RAM)和只读存储器(ROM),以及磁盘和固态硬盘的几何形状和组织构造。我们描述这些存储设备是如何放置在层次结构中的,讲述访问局部性是如何使这种层次结构成为可能的。我们通过一个独特的观点使这些理论具体化,那就是将存储器系统视为一个“存储器山”,山脊是时间局部性,而斜坡是空间局部性。最后,我们向读者阐述如何通过改善程序的时间局部性和空间局部性来提高应用程序的性能。
第7章:链接。本章讲述静态和动态链接,包括的概念有可重定位的和可执行的目标文件、符号解析、重定位、静态库、共享目标库、位置无关代码,以及库打桩。大多数讲述系统的书中都不讲链接,我们要讲述它是出于以下原因。第一,程序员遇到的最令人迷惑的问题中,有一些和链接时的小故障有关,尤其是对那些大型软件包来说。第二,链接器生成的目标文件是与一些像加载、虚拟内存和内存映射这样的概念相关的。
第8章:异常控制流。在本书的这个部分,我们通过介绍异常控制流(即除正常分支和过程调用以外的控制流的变化)的一般概念,打破单一程序的模型。我们给出存在于系统所有层次的异常控制流的例子,从底层的硬件异常和中断,到并发进程的上下文切换,到由于接收Linux信号引起的控制流突变,到C语言中破坏栈原则的非本地跳转。
在这一章,我们介绍进程的基本概念,进程是对一个正在执行的程序的一种抽象。读者会学习进程是如何工作的,以及如何在应用程序中创建和操纵进程。我们会展示应用程序员如何通过Linux系统调用来使用多个进程。学完本章之后,读者就能够编写带作业控制的Linux shell了。同时,这里也会向读者初步展示程序的并发执行会引起不确定的行为。
第9章:虚拟内存。我们讲述虚拟内存系统是希望读者对它是如何工作的以及它的特性有所了解。我们想让读者了解为什么不同的并发进程各自都有一个完全相同的地址范围,能共享某些页,而又独占另外一些页。我们还讲了一些管理和操纵虚拟内存的问题。特别地,我们讨论了存储分配操作,就像标准库的malloc和free操作。阐述这些内容是出于下面几个目的。它加强了这样一个概念,那就是虚拟内存空间只是一个字节数组,程序可以把它划分成不同的存储单元。它可以帮助读者理解当程序包含存储泄漏和非法指针引用等内存引用错误时的后果。最后,许多应用程序员编写自己的优化了的存储分配操作来满足应用程序的需要和特性。这一章比其他任何一章都更能展现将计算机系统中的硬件和软件结合起来阐述的优点。而传统的计算机体系结构和操作系统书籍都只讲述虚拟内存的某一方面。
第10章:系统级I/O。我们讲述Unix I/O的基本概念,例如文件和描述符。我们描述如何共享文件,I/O重定向是如何工作的,还有如何访问文件的元数据。我们还开发了一个健壮的带缓冲区的I/O包,可以正确处理一种称为short counts的奇特行为,也就是库函数只读取一部分的输入数据。我们阐述C的标准I/O库,以及它与Linux I/O的关系,重点谈到标准I/O的局限性,这些局限性使之不适合网络编程。总的来说,本章的主题是后面两章—网络和并发编程的基础。
第11章:网络编程。对编程而言,网络是非常有趣的I/O设备,它将许多我们前面文中学习的概念(比如进程、信号、字节顺序、内存映射和动态内存分配)联系在一起。网络程序还为下一章的主题—并发,提供了一个很令人信服的上下文。本章只是网络编程的一个很小的部分,使读者能够编写一个简单的Web服务器。我们还讲述位于所有网络程序底层的客户端服务器模型。我们展现了一个程序员对Internet的观点,并且教读者如何用套接字接口来编写Internet客户端和服务器。最后,我们介绍超文本传输协议(HTTP),并开发了一个简单的迭代式Web服务器。
第12章:并发编程。这一章以Internet服务器设计为例介绍了并发编程。我们比较对照了三种编写并发程序的基本机制(进程、I/O多路复用和线程),并且展示如何用它们来建造并发Internet服务器。我们探讨了用P、V信号量操作来实现同步、线程安全和可重入、竞争条件以及死锁等的基本原则。对大多数服务器应用来说,写并发代码都是很关键的。我们还讲述了线程级编程的使用方法,用这种方法来表达应用程序中的并行性,使得程序在多核处理器上能执行得更快。使用所有的核解决同一个计算问题需要很小心谨慎地协调并发线程,既要保证正确性,又要争取获得高性能。
本版新增内容
本书的第1版于2003年出版,第2版在2011年出版。考虑到计算机技术发展如此迅速,这本书的内容还算是保持得很好。事实证明Intel x86的机器上运行Linux(以及相关操作系统),加上采用C语言编程,是一种能够涵盖当今许多系统的组合。然而,硬件技术、编译器和程序库接口的变化,以及很多教师教授这些内容的经验,都促使我们做了大量的修改。
第2版以来的最大整体变化是,我们的介绍从以IA32和x86-64为基础,转变为完全以x86-64为基础。这种重心的转移影响了很多章节的内容。下面列出一些明显的变化:
第1章。我们将第5章对Amdahl定理的讨论移到了本章。
第2章。读者和评论家的反馈是一致的,本章的一些内容有点令人不知所措。因此,我们澄清了一些知识点,用更加数学的方式来描述,使得这些内容更容易理解。这使得读者能先略过数学细节,获得高层次的总体概念,然后回过头来进行更细致深入的阅读。
第3章。我们将之前基于IA32和x86-64的表现形式转换为完全基于x86-64,还更新了近期版本GCC产生的代码。其结果是大量的重写工作,包括修改了一些概念提出的顺序。同时,我们还首次介绍了对处理浮点数据的程序的机器级支持。由于历史原因,我们给出了一个网络旁注描述IA32机器码。
第4章。我们将之前基于32位架构的处理器设计修改为支持64位字和操作的设计。
第5章。我们更新了内容以反映最近几代x86-64处理器的性能。通过引入更多的功能单元和更复杂的控制逻辑,我们开发的基于程序数据流表示的程序性能模型,其性能预测变得比之前更加可靠。
第6章。我们对内容进行了更新,以反映更多的近期技术。
第7章。针对x86-64,我们重写了本章,扩充了关于用GOT和PLT创建位置无关代码的讨论,新增了一节描述更加强大的链接技术,比如库打桩。
第8章。我们增加了对信号处理程序更细致的描述,包括异步信号安全的函数,编写信号处理程序的具体指导原则,以及用sigsuspend等待处理程序。
第9章。本章变化不大。
第10章。我们新增了一节说明文件和文件的层次结构,除此之外,本章的变化不大。
第11章。我们介绍了采用最新getaddrinfo和getnameinfo函数的、与协议无关和线程安全的网络编程,取代过时的、不可重入的gethostbyname和gethostbyaddr函数。
第12章。我们扩充了利用线程级并行性使得程序在多核机器上更快运行的内容。
此外,我们还增加和修改了很多练习题和家庭作业。
本书的起源
本书起源于1998年秋季,我们在卡内基–梅隆(CMU)大学开设的一门编号为15-213的介绍性课程:计算机系统导论(Introduction to Computer System,ICS)[14]。从那以后,每学期都开设了ICS这门课程,每学期有超过400名学生上课,这些学生从本科二年级到硕士研究生都有,所学专业也很广泛。这门课程是卡内基–梅隆大学计算机科学系(CS)以及电子和计算机工程系(ECE)所有本科生的必修课,也是CS和ECE大多数高级系统课程的先行必修课。
ICS这门课程的宗旨是用一种不同的方式向学生介绍计算机。因为,我们的学生中几乎没有人有机会亲自去构造一个计算机系统。另一方面,大多数学生,甚至包括所有的计算机科学家和计算机工程师,也需要日常使用计算机和编写计算机程序。所以我们决定从程序员的角度来讲解系统,并采用这样的原则过滤要讲述的内容:我们只讨论那些影响用户级C语言程序的性能、正确性或实用性的主题。
比如,我们排除了诸如硬件加法器和总线设计这样的主题。虽然我们谈及了机器语言,但是重点并不在于如何手工编写汇编语言,而是关注C语言编译器是如何将C语言的结构翻译成机器代码的,包括编译器是如何翻译指针、循环、过程调用以及开关(switch)语句的。更进一步地,我们将更广泛和全盘地看待系统,包括硬件和系统软件,涵盖了包括链接、加载、进程、信号、性能优化、虚拟内存、I/O以及网络与并发编程等在内的主题。
这种做法使得我们讲授ICS课程的方式对学生来讲既实用、具体,还能动手操作,同时也非常能调动学生的积极性。很快地,我们收到来自学生和教职工非常热烈而积极的反响,我们意识到卡内基梅隆大学以外的其他人也可以从我们的方法中获益。因此,这本书从ICS课程的笔记中应运而生了,而现在我们对它做了修改,使之能够反映科学技术以及计算机系统实现中的变化和进步。
通过本书的多个版本和多种语言译本,ICS和许多相似课程已经成为世界范围内数百所高校的计算机科学和计算机工程课程的一部分。
写给指导教师们:可以基于本书的课程
指导教师可以使用本书来讲授五种不同类型的系统课程(见图2)。具体每门课程则有赖于课程大纲的要求、个人喜好、学生的背景和能力。图中的课程从左往右越来越强调以程序员的角度来看待系统。以下是简单的描述。
ORG:一门以非传统风格讲述传统主题的计算机组成原理课程。传统的主题包括逻辑设计、处理器体系结构、汇编语言和存储器系统,然而这里更多地强调了对程序员的影响。例如,要反过来考虑数据表示对C语言程序的数据类型和操作的影响。又例如,对汇编代码的讲解是基于C语言编译器产生的机器代码,而不是手工编写的汇编代码。
ORG+:一门特别强调硬件对应用程序性能影响的ORG课程。和ORG课程相比,学生要更多地学习代码优化和改进C语言程序的内存性能。
ICS:基本的ICS课程,旨在培养一类程序员,他们能够理解硬件、操作系统和编译系统对应用程序的性能和正确性的影响。和ORG+课程的一个显著不同是,本课程不涉及低层次的处理器体系结构。相反,程序员只同现代乱序处理器的高级模型打交道。ICS课程非常适合安排到一个10周的小学期,如果期望步调更从容一些,也可以延长到一个15周的学期。
ICS+:在基本的ICS课程基础上,额外论述一些系统编程的问题,比如系统级I/O、网络编程和并发编程。这是卡内基–梅隆大学的一门一学期时长的课程,会讲述本书中除了低级处理器体系结构以外的所有章。
SP:一门系统编程课程。和ICS+课程相似,但是剔除了浮点和性能优化的内容,更加强调系统编程,包括进程控制、动态链接、系统级I/O、网络编程和并发编程。指导教师可能会想从其他渠道对某些高级主题做些补充,比如守护进程(daemon)、终端控制和Unix IPC(进程间通信)。

图2 五类基于本书的课程
注: 符号⊙表示覆盖部分章节,其中:(a)只有硬件;(b)无动态存储分配;(c)无动态链接;(d)无浮点数。ICS+是卡内基–梅隆的15-213课程。
图2要表达的主要信息是本书给了学生和指导教师多种选择。如果你希望学生更多地了解低层次的处理器体系结构,那么通过ORG和ORG+课程可以达到目的。另一方面,如果你想将当前的计算机组成原理课程转换成ICS或者ICS+课程,但是又对突然做这样剧烈的变化感到担心,那么你可以逐步递增转向ICS课程。你可以从OGR课程开始,它以一种非传统的方式教授传统的问题。一旦你对这些内容感到驾轻就熟了,就可以转到ORG+,最终转到ICS。如果学生没有C语言的经验(比如他们只用Java编写过程序),你可以花几周的时间在C语言上,然后再讲述ORG或者ICS课程的内容。
最后,我们认为ORG+和SP课程适合安排为两期(两个小学期或者两个学期)。或者你可以考虑按照一期ICS和一期SP的方式来教授ICS+课程。
写给指导教师们:经过课堂验证的实验练习
ICS+课程在卡内基–梅隆大学得到了学生很高的评价。学生对这门课程的评价,中值分数一般为5.0/5.0,平均分数一般为4.6/5.0。学生们说这门课非常有趣,令人兴奋,主要就是因为相关的实验练习。这些实验练习可以从CS:APP的主页上获得。下面是本书提供的一些实验的示例。
数据实验。这个实验要求学生实现简单的逻辑和算术运算函数,但是只能使用一个非常有限的C语言子集。比如,只能用位级操作来计算一个数字的绝对值。这个实验可帮助学生了解C语言数据类型的位级表示,以及数据操作的位级行为。
二进制炸弹实验。二进制炸弹是一个作为目标代码文件提供给学生的程序。运行时,它提示用户输入6个不同的字符串。如果其中的任何一个不正确,炸弹就会“爆炸”,打印出一条错误消息,并且在一个打分服务器上记录事件日志。学生必须通过对程序反汇编和逆向工程来测定应该是哪6个串,从而解除各自炸弹的雷管。该实验能教会学生理解汇编语言,并且强制他们学习怎样使用调试器。
缓冲区溢出实验。它要求学生通过利用一个缓冲区溢出漏洞,来修改一个二进制可执行文件的运行时行为。这个实验可教会学生栈的原理,并让他们了解写那种易于遭受缓冲区溢出攻击的代码的危险性。
体系结构实验。第4章的几个家庭作业能够组合成一个实验作业,在实验中,学生修改处理器的HCL描述,增加新的指令,修改分支预测策略,或者增加、删除旁路路径和寄存器端口。修改后的处理器能够被模拟,并通过运行自动化测试检测出大多数可能的错误。这个实验使学生能够体验处理器设计中令人激动的部分,而不需要掌握逻辑设计和硬件描述语言的完整知识。
性能实验。学生必须优化应用程序的核心函数(比如卷积积分或矩阵转置)的性能。这个实验可非常清晰地表明高速缓存的特性,并带给学生低级程序优化的经验。
cache实验。这个实验类似于性能实验,学生编写一个通用高速缓存模拟器,并优化小型矩阵转置核心函数,以最小化对模拟的高速缓存的不命中次数。我们使用Valgrind为矩阵转置核心函数生成真实的地址访问记录。
shell实验。学生实现他们自己的带有作业控制的Unix shell程序,包括Ctrl+C和Ctrl+Z按键,fg、bg和jobs命令。这是学生第一次接触并发,并且让他们对Unix的进程控制、信号和信号处理有清晰的了解。
malloc实验。学生实现他们自己的malloc、free和realloc(可选)版本。这个实验可让学生们清晰地理解数据的布局和组织,并且要求他们评估时间和空间效率的各种权衡及折中。
代理实验。实现一个位于浏览器和万维网其他部分之间的并行Web代理。这个实验向学生们揭示了Web客户端和服务器这样的主题,并且把课程中的许多概念联系起来,比如字节排序、文件I/O、进程控制、信号、信号处理、内存映射、套接字和并发。学生很高兴能够看到他们的程序在真实的Web浏览器和Web服务器之间起到的作用。
CS:APP的教师手册中有对实验的详细讨论,还有关于下载支持软件的说明。
第3版的致谢
很荣幸在此感谢那些帮助我们完成本书第3版的人们。
我们要感谢卡内基–梅隆大学的同事们,他们已经教授了ICS课程多年,并提供了富有见解的反馈意见,给了我们极大的鼓励:Guy Blelloch、Roger Dannenberg、David Eckhardt、Franz Franchetti、Greg Ganger、Seth Goldstein、Khaled Harras、Greg Kesden、Bruce Maggs、Todd Mowry、Andreas Nowatzyk、Frank Pfenning、 Markus Pueschel和Anthony Rowe。David Winters在安装和配置参考Linux机器方面给予了我们很大的帮助。
Jason Fritts(圣路易斯大学,St.Louis University)和Cindy Norris(阿帕拉契州立大学,Appalachian State)对第2版提供了细致周密的评论。龚奕利(武汉大学,Wuhan University)翻译了中文版,并为其维护勘误,同时还贡献了一些错误报告。Godmar Back(弗吉尼亚理工大学,Virginia Tech)向我们介绍了异步信号安全以及与协议无关的网络编程,帮助我们显著提升了本书质量。
非常感谢目光敏锐的读者们,他们报告了第2版中的错误:Rami Ammari、Paul Anagnostopoulos、Lucas Brenfnger、Godmar Back、Ji Bin、Sharbel Bousemaan、Richard Callahan、 Seth Chaiken、Cheng Chen、Libo Chen、Tao Du、Pascal Garcia、Yili Gong、Ronald Greenberg、Dorukhan Gül鰖、Dong Han、Dominik Helm、Ronald Jones、Mustafa Kazdagli、Gordon Kindlmann、Sankar Krishnan、Kanak Kshetri、Junlin Lu、Qiangqiang Luo、Sebastian Luy、Lei Ma、Ashwin Nanjappa、Gregoire Paradis、Jonas Pfenninger、Karl Pichotta、David Ramsey、Kaustabh Roy、David Selvaraj、Sankar Shanmugam、Dominique Smulkowska、Dag Srb、Michael Spear、Yu Tanaka、Steven Tricanowicz、Scott Wright、Waiki Wright、Han Xu、Zhengshan Yan、Firo Yang、Shuang Yang、John Ye、Taketo Yoshida、Yan Zhu和Michael Zink。
还要感谢对实验做出贡献的读者,他们是:Godmar Back(弗吉尼亚理工大学,Virginia Tech)、Taymon Beal(伍斯特理工学院,Worcester Polytechnic Institute)、Aran Clauson(西华盛顿大学,Western Washington University)、Cary Gray(威顿学院,Wheaton College)、Paul Haiduk(德州农机大学,West Texas A&M University)、Len Hamey(麦考瑞大学,Macquarie University)、Eddie Kohler(哈佛大学,Harvard)、Hugh Lauer(伍斯特理工学院,Worcester Polytechnic Institute)、Robert Marmorstein(朗沃德大学,Longwood University)和James Riely(德保罗大学,DePaul University)。
再次感谢Windfall软件公司的Paul Anagnostopoulos在本书排版和先进的制作过程中所做的精湛工作。非常感谢Paul和他的优秀团队:Richard Camp(文字编辑)、Jennifer McClain(校对)、Laurel Muller(美术制作)以及Ted Laux(索引制作)。Paul甚至找出了我们对缩写BSS的起源描述中的一个错误,这个错误从第1版起一直没有被发现!
最后,我们要感谢Prentice Hall出版社的朋友们。Marcia Horton和我们的编辑Matt Goldstein一直坚定不移地给予我们支持和鼓励,非常感谢他们。
第2版的致谢
我们深深地感谢那些帮助我们写出CS:APP第2版的人们。
首先,我们要感谢在卡内基–梅隆大学教授ICS课程的同事们,感谢你们见解深刻的反馈意见和鼓励:Guy Blelloch、Roger Dannenberg、David Eckhardt、Greg Ganger、Seth Goldstein、Greg Kesden、Bruce Maggs、Todd Mowry、Andreas Nowatzyk、Frank Pfenning和Markus Pueschel。
还要感谢报告第1版勘误的目光敏锐的读者们:Daniel Amelang、Rui Baptista、Quarup Barreirinhas、Michael Bombyk、J鰎g Brauer、Jordan Brough、Yixin Cao、James Caroll、Rui Carvalho、Hyoung-Kee Choi、Al Davis、Grant Davis、Christian Dufour、Mao Fan、Tim Freeman、Inge Frick、Max Gebhardt、Jeff Goldblat、Thomas Gross、Anita Gupta、John Hampton、Hiep Hong、Greg Israelsen、Ronald Jones、Haudy Kazemi、Brian Kell、Constantine Kousoulis、Sacha Krakowiak、Arun Krishnaswamy、Martin Kulas、Michael Li、Zeyang Li、Ricky Liu、Mario Lo Conte、Dirk Maas、Devon Macey、Carl Marcinik、Will Marrero、Simone Martins、Tao Men、Mark Morrissey、Venkata Naidu、Bhas Nalabothula、Thomas Niemann、Eric Peskin、David Po、Anne Rogers、John Ross、Michael Scott、Seiki、Ray Shih、Darren Shultz、Erik Silkensen、Suryanto、Emil Tarazi、Nawanan Theera-Ampornpunt、Joe Trdinich、Michael Trigoboff、James Troup、Martin Vopatek、Alan West、Betsy Wolff、Tim Wong、James Woodruff、Scott Wright、Jackie Xiao、Guanpeng Xu、Qing Xu、Caren Yang、Yin Yongsheng、Wang Yuanxuan、Steven Zhang和Day Zhong。特别感谢Inge Frick,他发现了我们加锁复制(lock-and-copy)例子中一个极不明显但很深刻的错误,还要特别感谢Ricky Liu,他的校对水平真的很高。
我们Intel实验室的同事Andrew Chien和Limor Fix在本书的写作过程中一直非常支持。非常感谢Steve Schlosser提供了一些关于磁盘驱动器的总结描述,Casey Helfrich和Michael Ryan安装并维护了新的Core i7机器。Michael Kozuch、Babu Pillai和Jason Campbell对存储器系统性能、多核系统和能量墙问题提出了很有价值的见解。Phil Gibbons和Shimin Chen跟我们分享了大量关于固态硬盘设计的专业知识。
我们还有机会邀请了Wen-Mei Hwu、Markus Pueschel和Jiri Simsa这样的高人给予了一些针对具体问题的意见和高层次的建议。James Hoe帮助我们写了Y86处理器的Verilog描述,还完成了所有将设计合成到可运行的硬件上的工作。
非常感谢审阅本书草稿的同事们:James Archibald(百翰杨大学,Brigham Young University)、Richard Carver(乔治梅森大学,George Mason University)、Mirela Damian(维拉诺瓦大学,Villanova University)、Peter Dinda(西北大学)、John Fiore(坦普尔大学,Temple University)、Jason Fritts(圣路易斯大学,St.Louis University)、John Greiner(莱斯大学)、 Brian Harvey(加州大学伯克利分校)、Don Heller(宾夕法利亚州立大学)、Wei Chung Hsu(明尼苏达大学)、Michelle Hugue(马里兰大学)、Jeremy Johnson(德雷克塞尔大学,Drexel University)、Geoff Kuenning(哈维马德学院,Harvey Mudd College)、Ricky Liu、Sam Madden(麻省理工学院)、Fred Martin(马萨诸塞大学洛厄尔分校,University of Massachusetts, Lowell)、Abraham Matta(波士顿大学)、Markus Pueschel(卡内基–梅隆大学)、Norman Ramsey(塔夫茨大学,Tufts University)、Glenn Reinmann(加州大学洛杉矶分校)、Michela Taufer(特拉华大学,University of Delaware)和Craig Zilles(伊利诺伊大学香槟分校)。
Windfall软件公司的Paul Anagnostopoulos出色地完成了本书的排版,并领导了制作团队。非常感谢Paul和他超棒的团队:Rick Camp(文字编辑)、Joe Snowden(排版)、MaryEllen N.Oliver(校对)、Laurel Muller(美术)和Ted Laux(索引制作)。
最后,我们要感谢Prentice Hall出版社的朋友们。Marcia Horton总是支持着我们。我们的编辑Matt Goldstein由始至终表现出了一流的领导才能。我们由衷地感谢他们的帮助、鼓励和真知灼见。
第1版的致谢
我们衷心地感谢那些给了我们中肯批评和鼓励的众多朋友及同事。特别感谢我们15-213课程的学生们,他们充满感染力的精力和热情鞭策我们前行。Nick Carter和Vinny Furia无私地提供了他们的malloc程序包。
Guy Blelloch、Greg Kesden、Bruce Maggs和Todd Mowry已教授此课多个学期,他们给了我们鼓励并帮助改进课程内容。Herb Derby提供了早期的精神指导和鼓励。Allan Fisher、Garth Gibson、Thomas Gross、Satya、Peter Steenkiste和Hui Zhang从一开始就鼓励我们开设这门课程。Garth早期给的建议促使本书的工作得以开展,并且在Allan Fisher 领导的小组的帮助下又细化和修订了本书的工作。Mark Stehlik 和 Peter Lee 提供了极大的支持,使得这些内容成为本科生课程的一部分。Greg Kesden 针对ICS在操作系统课程上的影响提供了有益的反馈意见。Greg Ganger和Jiri Schindler提供了一些磁盘驱动的描述说明,并回答了我们关于现代磁盘的疑问。Tom Striker 向我们展示了存储器山的比喻。James Hoe 在处理器体系结构方面提出了很多有用的建议和反馈。
有一群特殊的学生极大地帮助我们发展了这门课程的内容,他们是Khalil Amiri、Angela Demke Brown、Chris Colohan、Jason Crawford、Peter Dinda、Julio Lopez、Bruce Lowekamp、Jeff Pierce、Sanjay Rao、Balaji Sarpeshkar、Blake Scholl、Sanjit Seshia、Greg Steffan、Tiankai Tu、Kip Walker和Yinglian Xie。尤其是Chris Colohan 建立了愉悦的氛围并持续到今天,还发明了传奇般的“二进制炸弹”,这是一个对教授机器语言代码和调试概念非常有用的工具。
Chris Bauer、Alan Cox、Peter Dinda、Sandhya Dwarkadis、John Greiner、Bruce Jacob、Barry Johnson、Don Heller、Bruce Lowekamp、Greg Morrisett、Brian Noble、Bobbie Othmer、Bill Pugh、Michael Scott、Mark Smotherman、Greg Steffan和Bob Wier 花费了大量时间阅读此书的早期草稿,并给予我们建议。特别感谢Peter Dinda(西北大学)、John Greiner(莱茨大学)、Wei Hsu(明尼苏达大学)、Bruce Lowekamp(威廉&玛丽大学)、Bobbie Othmer(明尼苏达大学)、Michael Scott(罗彻斯特大学)和Bob Wier(落基山学院)在教学中测试此书的试用版。同样特别感谢他们的学生们!
我们还要感谢Prentice Hall出版社的同事。感谢Marcia Horton、Eric Frank和Harold Stone不懈的支持和远见。Harold还帮我们提供了对RISC和CISC处理器体系结构准确的历史观点。Jerry Ralya有惊人的见识,并教会了我们很多如何写作的知识。
最后,我们衷心感谢伟大的技术作家Brian Kernighan以及后来的W.Richard Stevens,他们向我们证明了技术书籍也能写得如此优美。
谢谢你们所有的人。

Randal E.Bryant
David R.O'Hallaron
于匹兹堡,宾夕法尼亚州
Contents

Preface xix About the Authors xxxv
1
A Tour of Computer Systems 1
1.1 Information Is Bits + Context 3
1.2 Programs Are Translated by Other Programs into Different Forms 4
1.3 It Pays to Understand How Compilation Systems Work 6
1.4 Processors Read and Interpret Instructions Stored in Memory 7
1.4.1 Hardware Organization of a System 8
1.4.2 Running the helloProgram 10
1.5 Caches Matter 11
1.6 Storage Devices Form a Hierarchy 14
1.7 The Operating System Manages the Hardware 14
1.7.1 Processes 15
1.7.2 Threads 17
1.7.3 Virtual Memory 18
1.7.4 Files 19
1.8 Systems Communicate with Other Systems Using Networks 19
1.9 Important Themes 22
1.9.1 Amdahl’s Law 22
1.9.2 Concurrency and Parallelism 24
1.9.3 The Importance of Abstractions in Computer Systems 26
1.10 Summary 27 Bibliographic Notes 28 Solutions to Practice Problems 28
Part I Program Structure and Execution
2
Representing and Manipulating Information 31
2.1 Information Storage 34
2.1.1 Hexadecimal Notation 36
2.1.2 Data Sizes 39
2.1.3 Addressing and Byte Ordering 42 
2.1.4 Representing Strings 49 
2.1.5 Representing Code 49 
2.1.6 Introduction to Boolean Algebra 50 
2.1.7 Bit-Level Operations in C 54 
2.1.8 Logical Operations in C 56 
2.1.9 Shift Operations in C 57 
2.2 Integer Representations 59 
2.2.1 Integral Data Types 60 
2.2.2 Unsigned Encodings 62 
2.2.3 Two’s-Complement Encodings 64 
2.2.4 Conversions between Signed and Unsigned 70 
2.2.5 Signed versus Unsigned in C 74 
2.2.6 Expanding the Bit Representation of a Number 76 
2.2.7 Truncating Numbers 81 
2.2.8 Advice on Signed versus Unsigned 83 
2.3 Integer Arithmetic 84 
2.3.1 Unsigned Addition 84 
2.3.2 Two’s-Complement Addition 90 
2.3.3 Two’s-Complement Negation 95 
2.3.4 Unsigned Multiplication 96 
2.3.5 Two’s-Complement Multiplication 97 
2.3.6 Multiplying by Constants 101 
2.3.7 Dividing by Powers of 2 103 
2.3.8 Final Thoughts on Integer Arithmetic 107 
2.4 Floating Point 108 
2.4.1 Fractional Binary Numbers 109 
2.4.2 IEEE Floating-Point Representation 112 
2.4.3 Example Numbers 115 
2.4.4 Rounding 120 
2.4.5 Floating-Point Operations 122 
2.4.6 Floating Point in C 124 
2.5 Summary 126 
Bibliographic Notes 127 
Homework Problems 128 
Solutions to Practice Problems 143 
3 
Machine-Level Representation of Programs 163 
3.1 A Historical Perspective 166 
3.2 Program Encodings 169
3.2.1 Machine-Level Code 170
3.2.2 Code Examples 172
3.2.3 Notes on Formatting 175
3.3 Data Formats 177
3.4 Accessing Information 179
3.4.1 Operand Speci.ers 180
3.4.2 Data Movement Instructions 182
3.4.3 Data Movement Example 186
3.4.4 Pushing and Popping Stack Data 189
3.5 Arithmetic and Logical Operations 191
3.5.1 Load Effective Address 191
3.5.2 Unary and Binary Operations 194
3.5.3 Shift Operations 194
3.5.4 Discussion 196
3.5.5 Special Arithmetic Operations 197
3.6 Control 200
3.6.1 Condition Codes 201
3.6.2 Accessing the Condition Codes 202
3.6.3 Jump Instructions 205
3.6.4 Jump Instruction Encodings 207
3.6.5 Implementing Conditional Branches withConditional Control 209
3.6.6 Implementing Conditional Branches withConditional Moves 214
3.6.7 Loops 220
3.6.8 Switch Statements 232
3.7 Procedures 238
3.7.1 The Run-Time Stack 239
3.7.2 Control Transfer 241
3.7.3 Data Transfer 245
3.7.4 Local Storage on the Stack 248
3.7.5 Local Storage in Registers 251
3.7.6 Recursive Procedures 253
3.8 Array Allocation and Access 255
3.8.1 Basic Principles 255
3.8.2 Pointer Arithmetic 257
3.8.3 Nested Arrays 258
3.8.4 Fixed-Size Arrays 260
3.8.5 Variable-Size Arrays 262
3.9 Heterogeneous Data Structures 265 
3.9.1 Structures 265 
3.9.2 Unions 269 
3.9.3 Data Alignment 273 
3.10 Combining Control and Data in Machine-Level Programs 276 
3.10.1 Understanding Pointers 277 
3.10.2 Life in the Real World: Using the gdbDebugger 279 
3.10.3 Out-of-Bounds Memory References and Buffer Over.ow 279 
3.10.4 Thwarting Buffer Over.ow Attacks 284 
3.10.5 Supporting Variable-Size Stack Frames 290 
3.11 Floating-Point Code 293 
3.11.1 Floating-Point Movement and Conversion Operations 296 
3.11.2 Floating-Point Code in Procedures 301 
3.11.3 Floating-Point Arithmetic Operations 302 
3.11.4 De.ning and Using Floating-Point Constants 304 
3.11.5 Using Bitwise Operations in Floating-Point Code 305 
3.11.6 Floating-Point Comparison Operations 306 
3.11.7 Observations about Floating-Point Code 309 
3.12 Summary 309 
Bibliographic Notes 310 
Homework Problems 311 
Solutions to Practice Problems 325 
4 
Processor Architecture 351
4.1 The Y86-64 Instruction Set Architecture 355
4.1.1 Programmer-Visible State 355
4.1.2 Y86-64 Instructions 356
4.1.3 Instruction Encoding 358
4.1.4 Y86-64 Exceptions 363
4.1.5 Y86-64 Programs 364
4.1.6 Some Y86-64 Instruction Details 370
4.2 Logic Design and the Hardware Control Language HCL 372
4.2.1 Logic Gates 373
4.2.2 Combinational Circuits and HCL Boolean Expressions 374
4.2.3 Word-Level Combinational Circuits and HCLInteger Expressions 376
4.2.4 Set Membership 380
4.2.5 Memory and Clocking 381
4.3 Sequential Y86-64 Implementations 384
4.3.1 Organizing Processing into Stages 384
4.3.2 SEQ Hardware Structure 396 
4.3.3 SEQ Timing 400 
4.3.4 SEQ Stage Implementations 404 
4.4 General Principles of Pipelining 412 
4.4.1 Computational Pipelines 412 
4.4.2 A Detailed Look at Pipeline Operation 414 
4.4.3 Limitations of Pipelining 416 
4.4.4 Pipelining a System with Feedback 419 
4.5 Pipelined Y86-64 Implementations 421 
4.5.1 SEQ+: Rearranging the Computation Stages 421 
4.5.2 Inserting Pipeline Registers 422 
4.5.3 Rearranging and Relabeling Signals 426 
4.5.4 Next PC Prediction 427 
4.5.5 Pipeline Hazards 429 
4.5.6 Exception Handling 444 
4.5.7 PIPE Stage Implementations 447 
4.5.8 Pipeline Control Logic 455 
4.5.9 Performance Analysis 464 
4.5.10 Un.nished Business 468 
4.6 Summary 470 
4.6.1 Y86-64 Simulators 472 
Bibliographic Notes 473 
Homework Problems 473 
Solutions to Practice Problems 480 
5 
Optimizing Program Performance 495
5.1 Capabilities and Limitations of Optimizing Compilers 498
5.2 Expressing Program Performance 502
5.3 Program Example 504
5.4 Eliminating Loop Inef.ciencies 508
5.5 Reducing Procedure Calls 512
5.6 Eliminating Unneeded Memory References 514
5.7 Understanding Modern Processors 517
5.7.1 Overall Operation 518
5.7.2 Functional Unit Performance 523
5.7.3 An Abstract Model of Processor Operation 525
5.8 Loop Unrolling 531
5.9 Enhancing Parallelism 536
5.9.1 Multiple Accumulators 536
5.9.2 Reassociation Transformation 541
5.10 Summary of Results for Optimizing Combining Code 547 
5.11 Some Limiting Factors 548 
5.11.1 Register Spilling 548 
5.11.2 Branch Prediction and Misprediction Penalties 549 
5.12 Understanding Memory Performance 553 
5.12.1 Load Performance 554 
5.12.2 Store Performance 555 
5.13 Life in the Real World: Performance Improvement Techniques 561 
5.14 Identifying and Eliminating Performance Bottlenecks 562 
5.14.1 Program Pro.ling 562 
5.14.2 Using a Pro.ler to Guide Optimization 565 
5.15 Summary 568 
Bibliographic Notes 569 
Homework Problems 570 
Solutions to Practice Problems 573 
6 
The Memory Hierarchy 579
6.1 Storage Technologies 581
6.1.1 Random Access Memory 581
6.1.2 Disk Storage 589
6.1.3 Solid State Disks 600
6.1.4 Storage Technology Trends 602
6.2 Locality 604
6.2.1 Locality of References to Program Data 606
6.2.2 Locality of Instruction Fetches 607
6.2.3 Summary of Locality 608
6.3 The Memory Hierarchy 609
6.3.1 Caching in the Memory Hierarchy 610
6.3.2 Summary of Memory Hierarchy Concepts 614
6.4 Cache Memories 614
6.4.1 Generic Cache Memory Organization 615
6.4.2 Direct-Mapped Caches 617
6.4.3 Set Associative Caches 624
6.4.4 Fully Associative Caches 626
6.4.5 Issues with Writes 630
6.4.6 Anatomy of a Real Cache Hierarchy 631
6.4.7 Performance Impact of Cache Parameters 631
6.5 Writing Cache-Friendly Code 633
6.6 Putting It Together: The Impact of Caches on Program Performance 639
6.6.1 The Memory Mountain 639
6.6.2 Rearranging Loops to Increase Spatial Locality 643
6.6.3 Exploiting Locality in Your Programs 647
6.7 Summary 648
Bibliographic Notes 648
Homework Problems 649
Solutions to Practice Problems 660
Part II Running Programs on a System
7
Linking 669
7.1 Compiler Drivers 671
7.2 Static Linking 672
7.3 Object Files 673
7.4 Relocatable Object Files 674
7.5 Symbols and Symbol Tables 675
7.6 Symbol Resolution 679
7.6.1 How Linkers Resolve Duplicate Symbol Names 680
7.6.2 Linking with Static Libraries 684
7.6.3 How Linkers Use Static Libraries to Resolve References 688
7.7 Relocation 689
7.7.1 Relocation Entries 690
7.7.2 Relocating Symbol References 691
7.8 Executable Object Files 695
7.9 Loading Executable Object Files 697
7.10 Dynamic Linking with Shared Libraries 698
7.11 Loading and Linking Shared Libraries from Applications 701
7.12 Position-Independent Code (PIC) 704
7.13 Library Interpositioning 707
7.13.1 Compile-Time Interpositioning 708
7.13.2 Link-Time Interpositioning 708
7.13.3 Run-Time Interpositioning 710
7.14 Tools for Manipulating Object Files 713
7.15 Summary 713
Bibliographic Notes 714
Homework Problems 714
Solutions to Practice Problems 717
8
Exceptional Control Flow 721
8.1 Exceptions 723
8.1.1 Exception Handling 724
8.1.2 Classes of Exceptions 726
8.1.3 Exceptions in Linux/x86-64 Systems 729
8.2 Processes 732
8.2.1 Logical Control Flow 732
8.2.2 Concurrent Flows 733
8.2.3 Private Address Space 734
8.2.4 User and Kernel Modes 734
8.2.5 Context Switches 736
8.3 System Call Error Handling 737
8.4 Process Control 738
8.4.1 Obtaining Process IDs 739
8.4.2 Creating and Terminating Processes 739
8.4.3 Reaping Child Processes 743
8.4.4 Putting Processes to Sleep 749
8.4.5 Loading and Running Programs 750
8.4.6 Using forkand execveto Run Programs 753
8.5 Signals 756
8.5.1 Signal Terminology 758
8.5.2 Sending Signals 759
8.5.3 Receiving Signals 762
8.5.4 Blocking and Unblocking Signals 764
8.5.5 Writing Signal Handlers 766
8.5.6 Synchronizing Flows to Avoid Nasty Concurrency Bugs 776
8.5.7 Explicitly Waiting for Signals 778
8.6 Nonlocal Jumps 781
8.7 Tools for Manipulating Processes 786
8.8 Summary 787
Bibliographic Notes 787
Homework Problems 788
Solutions to Practice Problems 795
9
Virtual Memory 801
9.1 Physical and Virtual Addressing 803
9.2 Address Spaces 804
9.3 VM as a Tool for Caching 805 
9.3.1 DRAM Cache Organization 806 
9.3.2 Page Tables 806 
9.3.3 Page Hits 808 
9.3.4 Page Faults 808 
9.3.5 Allocating Pages 810 
9.3.6 Locality to the Rescue Again 810 
9.4 VM as a Tool for Memory Management 811 
9.5 VM as a Tool for Memory Protection 812 
9.6 Address Translation 813 
9.6.1 Integrating Caches and VM 817 
9.6.2 Speeding Up Address Translation with a TLB 817 
9.6.3 Multi-Level Page Tables 819 
9.6.4 Putting It Together: End-to-End Address Translation 821 
9.7 Case Study: The Intel Core i7/Linux Memory System 825 
9.7.1 Core i7 Address Translation 826 
9.7.2 Linux Virtual Memory System 828 
9.8 Memory Mapping 833 
9.8.1 Shared Objects Revisited 833 
9.8.2 The forkFunction Revisited 836 
9.8.3 The execveFunction Revisited 836 
9.8.4 User-Level Memory Mapping with the mmapFunction 837 
9.9 Dynamic Memory Allocation 839 
9.9.1 The mallocand freeFunctions 840 
9.9.2 Why Dynamic Memory Allocation? 843 
9.9.3 Allocator Requirements and Goals 844 
9.9.4 Fragmentation 846 
9.9.5 Implementation Issues 846 
9.9.6 Implicit Free Lists 847 
9.9.7 Placing Allocated Blocks 849 
9.9.8 Splitting Free Blocks 849 
9.9.9 Getting Additional Heap Memory 850 
9.9.10 Coalescing Free Blocks 850 
9.9.11 Coalescing with Boundary Tags 851 
9.9.12 Putting It Together: Implementing a Simple Allocator 854 
9.9.13 Explicit Free Lists 862 
9.9.14 Segregated Free Lists 863 
9.10 Garbage Collection 865 
9.10.1 Garbage Collector Basics 866 
9.10.2 Mark&Sweep Garbage Collectors 867 
9.10.3 Conservative Mark&Sweep for C Programs 869 
9.11 Common Memory-Related Bugs in C Programs 870
9.11.1 Dereferencing Bad Pointers 870
9.11.2 Reading Uninitialized Memory 871
9.11.3 Allowing Stack Buffer Over.ows 871
9.11.4 Assuming That Pointers and the Objects They Point to Are the Same Size 872
9.11.5 Making Off-by-One Errors 872
9.11.6 Referencing a Pointer Instead of the Object It Points To 873
9.11.7 Misunderstanding Pointer Arithmetic 873
9.11.8 Referencing Nonexistent Variables 874
9.11.9 Referencing Data in Free Heap Blocks 874
9.11.10 Introducing Memory Leaks 875
9.12 Summary 875
Bibliographic Notes 876
Homework Problems 876
Solutions to Practice Problems 880
Part III Interaction and Communication between Programs
10
System-Level I/O 889
10.1 Unix I/O 890
10.2 Files 891
10.3 Opening and Closing Files 893
10.4 Reading and Writing Files 895
10.5 Robust Reading and Writing with the RioPackage 897
10.5.1 Rio Unbuffered Input and Output Functions 897
10.5.2 Rio Buffered Input Functions 898
10.6 Reading File Metadata 903
10.7 Reading Directory Contents 905
10.8 Sharing Files 906
10.9 I/O Redirection 909
10.10 Standard I/O 911
10.11 Putting It Together: Which I/O Functions Should I Use? 911
10.12 Summary 913
Bibliographic Notes 914
Homework Problems 914
Solutions to Practice Problems 915
11
Network Programming 917
11.1 The Client-Server Programming Model 918
11.2 Networks 919
11.3 The Global IP Internet 924
11.3.1 IP Addresses 925
11.3.2 Internet Domain Names 927
11.3.3 Internet Connections 929
11.4 The Sockets Interface 932
11.4.1 Socket Address Structures 933
11.4.2 The socketFunction 934
11.4.3 The connectFunction 934
11.4.4 The bindFunction 935
11.4.5 The listenFunction 935
11.4.6 The acceptFunction 936
11.4.7 Host and Service Conversion 937
11.4.8 Helper Functions for the Sockets Interface 942
11.4.9 Example Echo Client and Server 944
11.5 Web Servers 948
11.5.1 Web Basics 948
11.5.2 Web Content 949
11.5.3 HTTP Transactions 950
11.5.4 Serving Dynamic Content 953
11.6 Putting It Together: The TinyWeb Server 956
11.7 Summary 964
Bibliographic Notes 965
Homework Problems 965
Solutions to Practice Problems 966
12
Concurrent Programming 971
12.1 Concurrent Programming with Processes 973
12.1.1 A Concurrent Server Based on Processes 974
12.1.2 Pros and Cons of Processes 975
12.2 Concurrent Programming with I/O Multiplexing 977
12.2.1 A Concurrent Event-Driven Server Based on I/O Multiplexing 980
12.2.2 Pros and Cons of I/O Multiplexing 985
12.3 Concurrent Programming with Threads 985
12.3.1 Thread Execution Model 986
12.3.2 Posix Threads 987 
12.3.3 Creating Threads 988 
12.3.4 Terminating Threads 988 
12.3.5 Reaping Terminated Threads 989 
12.3.6 Detaching Threads 989 
12.3.7 Initializing Threads 990 
12.3.8 A Concurrent Server Based on Threads 991 
12.4 Shared Variables in Threaded Programs 992 
12.4.1 Threads Memory Model 993 
12.4.2 Mapping Variables to Memory 994 
12.4.3 Shared Variables 995 
12.5 Synchronizing Threads with Semaphores 995 
12.5.1 Progress Graphs 999 
12.5.2 Semaphores 1001 
12.5.3 Using Semaphores for Mutual Exclusion 1002 
12.5.4 Using Semaphores to Schedule Shared Resources 1004 
12.5.5 Putting It Together: A Concurrent Server Based on 
Prethreading 1008 
12.6 Using Threads for Parallelism 1013 
12.7 Other Concurrency Issues 1020 
12.7.1 Thread Safety 1020 
12.7.2 Reentrancy 1023 
12.7.3 Using Existing Library Functions in Threaded Programs 1024 
12.7.4 Races 1025 
12.7.5 Deadlocks 1027 
12.8 Summary 1030 
Bibliographic Notes 1030 
Homework Problems 1031 
Solutions to Practice Problems 1036 
A 
Error Handling 1041
A.1 Error Handling in Unix Systems 1042
A.2 Error-Handling Wrappers 1043
References 1047 Index 1053





出版者的话
推荐序一
推荐序二
前言
关于作者
第1章 计算机系统漫游 1
1.1 信息就是位+上下文 3
1.2 程序被其他程序翻译成不同的格式 4
1.3 了解编译系统如何工作是大有益处的 6
1.4 处理器读并解释储存在内存中的指令 7
1.4.1 系统的硬件组成 8
1.4.2 运行hello程序 10
1.5 高速缓存至关重要 11
1.6 存储设备形成层次结构 14
1.7 操作系统管理硬件 14
1.7.1 进程 15
1.7.2 线程 17
1.7.3 虚拟内存 18
1.7.4 文件 19
1.8 系统之间利用网络通信 19
1.9 重要主题 22
1.9.1 Amdahl定律 22
1.9.2 并发和并行 24
1.9.3 计算机系统中抽象的重要性 26
1.10 小结 27
参考文献说明 28
练习题答案 28
第一部分
程序结构和执行
第2章 信息的表示和处理 31
2.1 信息存储 34
2.1.1 十六进制表示法 36
2.1.2 字数据大小 39
2.1.3 寻址和字节顺序 42
2.1.4 表示字符串 49
2.1.5 表示代码 49
2.1.6 布尔代数简介 50
2.1.7 C语言中的位级运算 54
2.1.8 C语言中的逻辑运算 56
2.1.9 C语言中的移位运算 57
2.2 整数表示 59
2.2.1 整型数据类型 60
2.2.2 无符号数的编码 62
2.2.3 补码编码 64
2.2.4 有符号数和无符号数之间的转换 70
2.2.5 C语言中的有符号数与无符号数 74
2.2.6 扩展一个数字的位表示 76
2.2.7 截断数字 81
2.2.8 关于有符号数与无符号数的建议 83
2.3 整数运算 84
2.3.1 无符号加法 84
2.3.2 补码加法 90
2.3.3 补码的非 95
2.3.4 无符号乘法 96
2.3.5 补码乘法 97
2.3.6 乘以常数 101
2.3.7 除以2的幂 103
2.3.8 关于整数运算的最后思考 107
2.4 浮点数 108
2.4.1 二进制小数 109
2.4.2 IEEE浮点表示 112
2.4.3 数字示例 115
2.4.4 舍入 120
2.4.5 浮点运算 122
2.4.6 C语言中的浮点数 124
2.5 小结 126
参考文献说明 127
家庭作业 128
练习题答案 143
第3章 程序的机器级表示 163
3.1 历史观点 166
3.2 程序编码 169
3.2.1 机器级代码 170
3.2.2 代码示例 172
3.2.3 关于格式的注解 175
3.3 数据格式 177
3.4 访问信息 179
3.4.1 操作数指示符 180
3.4.2 数据传送指令 182
3.4.3 数据传送示例 186
3.4.4 压入和弹出栈数据 189
3.5 算术和逻辑操作 191
3.5.1 加载有效地址 191
3.5.2 一元和二元操作 194
3.5.3 移位操作 194
3.5.4 讨论 196
3.5.5 特殊的算术操作 197
3.6 控制 200
3.6.1 条件码 201
3.6.2 访问条件码 202
3.6.3 跳转指令 205
3.6.4 跳转指令的编码 207
3.6.5 用条件控制来实现条件分支 209
3.6.6 用条件传送来实现条件分支 214
3.6.7 循环 220
3.6.8 switch语句 232
3.7 过程 238
3.7.1 运行时栈 239
3.7.2 转移控制 241
3.7.3 数据传送 245
3.7.4 栈上的局部存储 248
3.7.5 寄存器中的局部存储空间 251
3.7.6 递归过程 253
3.8 数组分配和访问 255
3.8.1 基本原则 255
3.8.2 指针运算 257
3.8.3 嵌套的数组 258
3.8.4 定长数组 260
3.8.5 变长数组 262
3.9 异质的数据结构 265
3.9.1 结构 265
3.9.2 联合 269
3.9.3 数据对齐 273
3.10 在机器级程序中将控制与数据结合起来 276
3.10.1 理解指针 277
3.10.2 应用:使用GDB调试器 279
3.10.3 内存越界引用和缓冲区溢出 279
3.10.4 对抗缓冲区溢出攻击 284
3.10.5 支持变长栈帧 290
3.11 浮点代码 293
3.11.1 浮点传送和转换操作 296
3.11.2 过程中的浮点代码 301
3.11.3 浮点运算操作 302
3.11.4 定义和使用浮点常数 304
3.11.5 在浮点代码中使用位级操作 305
3.11.6 浮点比较操作 306
3.11.7 对浮点代码的观察结论 309
3.12 小结 309
参考文献说明 310
家庭作业 311
练习题答案 325
第4章 处理器体系结构 351
4.1 Y86-64指令集体系结构 355
4.1.1 程序员可见的状态 355
4.1.2 Y86-64指令 356
4.1.3 指令编码 358
4.1.4 Y86-64异常 363
4.1.5 Y86-64程序 364
4.1.6 一些Y86-64指令的详情 370
4.2 逻辑设计和硬件控制语言HCL 372
4.2.1 逻辑门 373
4.2.2 组合电路和HCL布尔表达式 374
4.2.3 字级的组合电路和HCL整数表达式 376
4.2.4 集合关系 380
4.2.5 存储器和时钟 381
4.3 Y86-64的顺序实现 384
4.3.1 将处理组织成阶段 384
4.3.2 SEQ硬件结构 396
4.3.3 SEQ的时序 400
4.3.4 SEQ阶段的实现 404
4.4 流水线的通用原理 412
4.4.1 计算流水线 412
4.4.2 流水线操作的详细说明 414
4.4.3 流水线的局限性 416
4.4.4 带反馈的流水线系统 419
4.5 Y86-64的流水线实现 421
4.5.1 SEQ+:重新安排计算阶段 421
4.5.2 插入流水线寄存器 422
4.5.3 对信号进行重新排列和标号 426
4.5.4 预测下一个PC 427
4.5.5 流水线冒险 429
4.5.6 异常处理 444
4.5.7 PIPE各阶段的实现 447
4.5.8 流水线控制逻辑 455
4.5.9 性能分析 464
4.5.10 未完成的工作 468
4.6 小结 470
参考文献说明 473
家庭作业 473
练习题答案 480
第5章 优化程序性能 495
5.1 优化编译器的能力和局限性 498
5.2 表示程序性能 502
5.3 程序示例 504
5.4 消除循环的低效率 508
5.5 减少过程调用 512
5.6 消除不必要的内存引用 514
5.7 理解现代处理器 517
5.7.1 整体操作 518
5.7.2 功能单元的性能 523
5.7.3 处理器操作的抽象模型 525
5.8 循环展开 531
5.9 提高并行性 536
5.9.1 多个累积变量 536
5.9.2 重新结合变换 541
5.10 优化合并代码的结果小结 547
5.11 一些限制因素 548
5.11.1 寄存器溢出 548
5.11.2 分支预测和预测错误处罚 549
5.12 理解内存性能 553
5.12.1 加载的性能 554
5.12.2 存储的性能 555
5.13 应用:性能提高技术 561
5.14 确认和消除性能瓶颈 562
5.14.1 程序剖析 562
5.14.2 使用剖析程序来指导优化 565
5.15 小结 568
参考文献说明 569
家庭作业 570
练习题答案 573
第6章 存储器层次结构 579
6.1 存储技术 581
6.1.1 随机访问存储器 581
6.1.2 磁盘存储 589
6.1.3 固态硬盘 600
6.1.4 存储技术趋势 602
6.2 局部性 604
6.2.1 对程序数据引用的局部性 606
6.2.2 取指令的局部性 607
6.2.3 局部性小结 608
6.3 存储器层次结构 609
6.3.1 存储器层次结构中的缓存 610
6.3.2 存储器层次结构概念小结 614
6.4 高速缓存存储器 614
6.4.1 通用的高速缓存存储器组织结构 615
6.4.2 直接映射高速缓存 617
6.4.3 组相联高速缓存 624
6.4.4 全相联高速缓存 626
6.4.5 有关写的问题 630
6.4.6 一个真实的高速缓存层次结构的解剖 631
6.4.7 高速缓存参数的性能影响 631
6.5 编写高速缓存友好的代码 633
6.6 综合:高速缓存对程序性能的影响 639
6.6.1 存储器山 639
6.6.2 重新排列循环以提高空间局部性 643
6.6.3 在程序中利用局部性 647
6.7 小结 648
参考文献说明 648
家庭作业 649
练习题答案 660
第二部分
在系统上运行程序
第7章 链接 669
7.1 编译器驱动程序 671
7.2 静态链接 672
7.3 目标文件 673
7.4 可重定位目标文件 674
7.5 符号和符号表 675
7.6 符号解析 679
7.6.1 链接器如何解析多重定义的全局符号 680
7.6.2 与静态库链接 684
7.6.3 链接器如何使用静态库来解析引用 688
7.7 重定位 689
7.7.1 重定位条目 690
7.7.2 重定位符号引用 691
7.8 可执行目标文件 695
7.9 加载可执行目标文件 697
7.10 动态链接共享库 698
7.11 从应用程序中加载和链接共享库 701
7.12 位置无关代码 704
7.13 库打桩机制 707
7.13.1 编译时打桩 708
7.13.2 链接时打桩 708
7.13.3 运行时打桩 710
7.14 处理目标文件的工具 713
7.15 小结 713
参考文献说明 714
家庭作业 714
练习题答案 717
第8章 异常控制流 721
8.1 异常 723
8.1.1 异常处理 724
8.1.2 异常的类别 726
8.1.3 Linux/x86-64系统中的异常 729
8.2 进程 732
8.2.1 逻辑控制流 732
8.2.2 并发流 733
8.2.3 私有地址空间 734
8.2.4 用户模式和内核模式 734
8.2.5 上下文切换 736
8.3 系统调用错误处理 737
8.4 进程控制 738
8.4.1 获取进程ID 739
8.4.2 创建和终止进程 739
8.4.3 回收子进程 743
8.4.4 让进程休眠 749
8.4.5 加载并运行程序 750
8.4.6 利用fork和execve运行程序 753
8.5 信号 756
8.5.1 信号术语 758
8.5.2 发送信号 759
8.5.3 接收信号 762
8.5.4 阻塞和解除阻塞信号 764
8.5.5 编写信号处理程序 766
8.5.6 同步流以避免讨厌的并发错误 776
8.5.7 显式地等待信号 778
8.6 非本地跳转 781
8.7 操作进程的工具 786
8.8 小结 787
参考文献说明 787
家庭作业 788
练习题答案 795
第9章 虚拟内存 801
9.1 物理和虚拟寻址 803
9.2 地址空间 804
9.3 虚拟内存作为缓存的工具 805
9.3.1 DRAM缓存的组织结构 806
9.3.2 页表 806
9.3.3 页命中 808
9.3.4 缺页 808
9.3.5 分配页面 810
9.3.6 又是局部性救了我们 810
9.4 虚拟内存作为内存管理的工具 811
9.5 虚拟内存作为内存保护的工具 812
9.6 地址翻译 813
9.6.1 结合高速缓存和虚拟内存 817
9.6.2 利用TLB加速地址翻译 817
9.6.3 多级页表 819
9.6.4 综合:端到端的地址翻译 821
9.7 案例研究:Intel Core i7/Linux内存系统 825
9.7.1 Core i7地址翻译 826
9.7.2 Linux虚拟内存系统 828
9.8 内存映射 833
9.8.1 再看共享对象 833
9.8.2 再看fork函数 836
9.8.3 再看execve函数 836
9.8.4 使用mmap函数的用户级内存映射 837
9.9 动态内存分配 839
9.9.1 malloc和free函数 840
9.9.2 为什么要使用动态内存分配 843
9.9.3 分配器的要求和目标 844
9.9.4 碎片 846
9.9.5 实现问题 846
9.9.6 隐式空闲链表 847
9.9.7 放置已分配的块 849
9.9.8 分割空闲块 849
9.9.9 获取额外的堆内存 850
9.9.10 合并空闲块 850
9.9.11 带边界标记的合并 851
9.9.12 综合:实现一个简单的分配器 854
9.9.13 显式空闲链表 862
9.9.14 分离的空闲链表 863
9.10 垃圾收集 865
9.10.1 垃圾收集器的基本知识 866
9.10.2 Mark&Sweep垃圾收集器 867
9.10.3 C程序的保守Mark&Sweep 869
9.11 C程序中常见的与内存有关的错误 870
9.11.1 间接引用坏指针 870
9.11.2 读未初始化的内存 871
9.11.3 允许栈缓冲区溢出 871
9.11.4 假设指针和它们指向的对象是相同大小的 872
9.11.5 造成错位错误 872
9.11.6 引用指针,而不是它所指向的对象 873
9.11.7 误解指针运算 873
9.11.8 引用不存在的变量 874
9.11.9 引用空闲堆块中的数据 874
9.11.10 引起内存泄漏 875
9.12 小结 875
参考文献说明 876
家庭作业 876
练习题答案 880
第三部分
程序间的交互和通信
第10章 系统级I/O 889
10.1 Unix I/O 890
10.2 文件 891
10.3 打开和关闭文件 893
10.4 读和写文件 895
10.5 用RIO包健壮地读写 897
10.5.1 RIO的无缓冲的输入输出函数 897
10.5.2 RIO的带缓冲的输入函数 898
10.6 读取文件元数据 903
10.7 读取目录内容 905
10.8 共享文件 906
10.9 I/O重定向 909
10.10 标准I/O 911
10.11 综合:我该使用哪些I/O函数? 911
10.12 小结 913
参考文献说明 914
家庭作业 914
练习题答案 915
第11章 网络编程 917
11.1 客户端–服务器编程模型 918
11.2 网络 919
11.3 全球IP因特网 924
11.3.1 IP地址 925
11.3.2 因特网域名 927
11.3.3 因特网连接 929
11.4 套接字接口 932
11.4.1 套接字地址结构 933
11.4.2 socket函数 934
11.4.3 connect函数 934
11.4.4 bind函数 935
11.4.5 listen函数 935
11.4.6 accept函数 936
11.4.7 主机和服务的转换 937
11.4.8 套接字接口的辅助函数 942
11.4.9 echo客户端和服务器的示例 944
11.5 Web服务器 948
11.5.1 Web基础 948
11.5.2 Web内容 949
11.5.3 HTTP事务 950
11.5.4 服务动态内容 953
11.6 综合:TINY Web服务器 956
11.7 小结 964
参考文献说明 965
家庭作业 965
练习题答案 966
第12章 并发编程 971
12.1 基于进程的并发编程 973
12.1.1 基于进程的并发服务器 974
12.1.2 进程的优劣 975
12.2 基于I/O多路复用的并发编程 977
12.2.1 基于I/O多路复用的并发事件驱动服务器 980
12.2.2 I/O多路复用技术的优劣 985
12.3 基于线程的并发编程 985
12.3.1 线程执行模型 986
12.3.2 Posix线程 987
12.3.3 创建线程 988
12.3.4 终止线程 988
12.3.5 回收已终止线程的资源 989
12.3.6 分离线程 989
12.3.7 初始化线程 990
12.3.8 基于线程的并发服务器 991
12.4 多线程程序中的共享变量 992
12.4.1 线程内存模型 993
12.4.2 将变量映射到内存 994
12.4.3 共享变量 995
12.5 用信号量同步线程 995
12.5.1 进度图 999
12.5.2 信号量 1001
12.5.3 使用信号量来实现互斥 1002
12.5.4 利用信号量来调度共享资源 1004
12.5.5 综合:基于预线程化的并发服务器 1008
12.6 使用线程提高并行性 1013
12.7 其他并发问题 1020
12.7.1 线程安全 1020
12.7.2 可重入性 1023
12.7.3 在线程化的程序中使用已存在的库函数 1024
12.7.4 竞争 1025
12.7.5 死锁 1027
12.8 小结 1030
参考文献说明 1030
家庭作业 1031
练习题答案 1036
附录A 错误处理 1041
参考文献 1047
计算机\基础
读者书评
发表评论



高级搜索
白话大数据与机器学习
计算机科学概论(原书第5版)
计算机科学导论(原书第3版)


版权所有© 2017  北京华章图文信息有限公司 京ICP备08102525号 京公网安备110102004606号
通信地址:北京市百万庄南街1号 邮编:100037
电话:(010)68318309, 88378998 传真:(010)68311602, 68995260
高校教师服务
华章教育微信
诚聘英才
诚聘英才