深入理解计算机系统(英文版·第3版)

语音

编辑

锁定

讨论

上传视频

《深入理解计算机系统(英文版·第3版)》是2017年机械工业出版社出版图书，作者[美] 兰德尔 E.布莱恩特(Randal E. Bryant)大卫 R. 奥哈拉伦(David R. O'Hallaron)。[1]

书    名

深入理解计算机系统(英文版·第3版)

作    者

[美]　兰德尔 E.布莱恩特(Randal E. Bryant)大卫 R. 奥哈拉伦(David R. O'Hallaron)

ISBN

978-7-111-56127-9定    价

￥239.00

出版社

机械工业出版社[2]

出版时间

2017年4月

开    本

16

深入理解计算机系统(英文版·第3版)内容简介

编辑

语音

本书是一本将计算机软件和硬件理论结合讲述的经典教材，内容涵盖计算机导论、体系结构和处理器设计等多门课程。本书最大的特点是为程序员描述计算机系统的实现细节，通过描述程序是如何映射到系统上，以及程序是如何执行的，使读者更好地理解程序的行为，找到程序效率低下的原因。

和第2版相比，本版内容上最大的变化是，从以IA32和x86-64为基础转变为完全以x86-64为基础。主要更新如下：

· 基于x86-64，大量地重写代码，首次介绍对处理浮点数据的程序的机器级支持。

· 处理器体系结构修改为支持64位字和操作的设计。

· 引入更多的功能单元和更复杂的控制逻辑，使基于程序数据流表示的程序性能模型预测更加可靠。

· 扩充关于用GOT和PLT创建与位置无关代码的讨论，描述了更加强大的链接技术(比如库打桩)。

· 增加了对信号处理程序更细致的描述，包括异步信号安全的函数等。

· 采用最新函数，更新了与协议无关和线程安全的网络编程。[1]

深入理解计算机系统(英文版·第3版)图书目录

编辑

语音

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[1]

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[1]

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[1]

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[1]

第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[1]

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[1]

第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[1]

词条图册

更多图册

参考资料

1.

深入理解计算机系统(英文版·第3版)

．机械工业出版社[引用日期2017-04-14]

2.

深入理解计算机系统(英文版·第3版)

．豆瓣[引用日期2019-07-30]