并行操作系统的理论与实践：第二版

需积分: 9 66 浏览量更新于2024-07-19 收藏 4.31MB PDF 举报

《操作系统：原理与实践第二卷》（Operating Systems: Principles and Practice, Second Edition, Volume II: Concurrency）是由托马斯·安德森（Thomas Anderson）和迈克尔·达林（Michael Dahlin）合著的一本深入讲解并发原理的高级教材。该书是操作系统经典系列的第二卷，全面涵盖了操作系统设计中的并发控制、线程管理、同步、死锁、调度策略以及分布式系统中的并发模型等核心内容。作者们在书中以第二版的形式更新了理论和技术，将读者带入一个现代操作系统的世界，强调了并发技术在处理多任务和并行计算中的重要性。他们结合实际案例和实践经验，使读者能够理解并发编程的复杂性和挑战，并掌握如何构建高效、可扩展的并发系统。《操作系统：原理与实践第二卷》不仅包含了深入的理论分析，还提供了丰富的实践指导。它采用了一种递归式的教学方法，引导读者通过逐步分解问题，来理解和解决并发领域的难题。书中配有Cameron Neat绘制的插图，帮助读者形象地理解抽象概念，同时，由桑迪·卡普兰（Sandy Kaplan）和惠特尼·施密特（Whitney Schmidt）进行的精心校对，确保了内容的准确无误。此外，该书还强调了版权保护，所有内容未经出版商RecursiveBooks Ltd.的书面许可，不得以任何形式复制、存储或传输。对于任何建议、评论或发现的错误，读者可以通过电子邮件suggestions@recursivebooks.com向作者和出版社反馈，以便于持续改进和更新。《操作系统：原理与实践第二卷》是一本不可或缺的参考书，对于计算机科学专业的学生、操作系统研究人员和工程师，以及希望深入了解并发系统设计的专业人士来说，这本书提供了坚实的基础理论和实用的技巧，是他们在实践中应对现代多核处理器和分布式计算环境挑战的重要工具。

Power tools. We introduce students to a number of abstractions that

they can apply in their work in industry immediately after graduation,

and that we expect will continue to be useful for decades such as

sandboxing, protected procedure calls, threads, locks, condition

variables, caching, checkpointing, and transactions.

Details of specific operating systems. We include numerous examples

of how different operating systems work in practice. However, this

material changes rapidly, and there is an order of magnitude more

material than can be covered in a single semester-length course. The

purpose of these examples is to illustrate how to use the operating

systems principles and power tools to solve concrete problems. We do

not attempt to provide a comprehensive description of Linux, OS X, or

any other particular operating system.

The book is divided into five parts: an introduction (Chapter 1), kernels and

processes (Chapters 2-3), concurrency, synchronization, and scheduling

(Chapters 4-7), memory management (Chapters 8-10), and persistent storage

(Chapters 11-14).

Introduction. The goal of Chapter 1 is to introduce the recurring themes

found in the later chapters. We define some common terms, and we

provide a bit of the history of the development of operating systems.

The Kernel Abstraction. Chapter 2 covers kernel-based process

protection — the concept and implementation of executing a user

program with restricted privileges. Given the increasing importance of

computer security issues, we believe protected execution and safe

transfer across privilege levels are worth treating in depth. We have

broken the description into sections, to allow instructors to choose either

a quick introduction to the concepts (up through Section 2.3), or a full

treatment of the kernel implementation details down to the level of

interrupt handlers. Some instructors start with concurrency, and cover

kernels and kernel protection afterwards. While our textbook can be

used that way, we have found that students benefit from a basic

understanding of the role of operating systems in executing user

programs, before introducing concurrency.

The Programming Interface. Chapter 3 is intended as an impedance

match for students of differing backgrounds. Depending on student

background, it can be skipped or covered in depth. The chapter covers

the operating system from a programmer’s perspective: process creation

and management, device-independent input/output, interprocess

communication, and network sockets. Our goal is that students should

understand at a detailed level what happens when a user clicks a link in

a web browser, as the request is transferred through operating system

kernels and user space processes at the client, server, and back again.

This chapter also covers the organization of the operating system itself:

how device drivers and the hardware abstraction layer work in a modern

operating system; the difference between a monolithic and a microkernel

operating system; and how policy and mechanism are separated in

modern operating systems.

Concurrency and Threads. Chapter 4 motivates and explains the

concept of threads. Because of the increasing importance of concurrent

programming, and its integration with modern programming languages

like Java, many students have been introduced to multi-threaded

programming in an earlier class. This is a bit dangerous, as students at

this stage are prone to writing programs with race conditions, problems

that may or may not be discovered with testing. Thus, the goal of this

chapter is to provide a solid conceptual framework for understanding the

semantics of concurrency, as well as how concurrent threads are

implemented in both the operating system kernel and in user-level

libraries. Instructors needing to go more quickly can omit these

implementation details.

Synchronization. Chapter 5 discusses the synchronization of multi-

threaded programs, a central part of all operating systems and

increasingly important in many other contexts. Our approach is to

describe one effective method for structuring concurrent programs

(based on Mesa monitors), rather than to attempt to cover several

different approaches. In our view, it is more important for students to

master one methodology. Monitors are a particularly robust and simple

one, capable of implementing most concurrent programs efficiently. The

implementation of synchronization primitives should be included if

there is time, so students see that there is no magic.

Multi-Object Synchronization. Chapter 6 discusses advanced topics in

concurrency — specifically, the twin challenges of multiprocessor lock

contention and deadlock. This material is increasingly important for

students working on multicore systems, but some courses may not have

time to cover it in detail.

Scheduling. This chapter covers the concepts of resource allocation in

the specific context of processor scheduling. With the advent of data

center computing and multicore architectures, the principles and practice

of resource allocation have renewed importance. After a quick tour

through the tradeoffs between response time and throughput for

uniprocessor scheduling, the chapter covers a set of more advanced

topics in affinity and multiprocessor scheduling, power-aware and

deadline scheduling, as well as basic queueing theory and overload

management. We conclude these topics by walking students through a

case study of server-side load management.

Address Translation. Chapter 8 explains mechanisms for hardware and

software address translation. The first part of the chapter covers how

hardware and operating systems cooperate to provide flexible, sparse

address spaces through multi-level segmentation and paging. We then

describe how to make memory management efficient with translation

lookaside buffers (TLBs) and virtually addressed caches. We consider

how to keep TLBs consistent when the operating system makes changes

to its page tables. We conclude with a discussion of modern software-

based protection mechanisms such as those found in the Microsoft

Common Language Runtime and Google’s Native Client.

Caching and Virtual Memory. Caches are central to many different

types of computer systems. Most students will have seen the concept of

a cache in an earlier class on machine structures. Thus, our goal is to

cover the theory and implementation of caches: when they work and

when they do not, as well as how they are implemented in hardware and

software. We then show how these ideas are applied in the context of

memory-mapped files and demand-paged virtual memory.

剩余408页未读，继续阅读

Tank-Knat

粉丝: 0
资源: 4

并行操作系统的理论与实践：第二版

Operating Systems Principles and Practice V1

Operating system Principles and practice

Operating Systems Principles and Practice(2nd)

操作系统：内存管理原理与实践（第二版）第三卷

操作系统原理与实践：内核与进程第二版

操作系统原理与实践 第三卷：内存管理

操作系统原理与实践：并发篇（第二版）

操作系统原理与实践：内核与进程（第二版）

操作系统原理与实践：内存管理第二版

《操作系统原理与实践V1》：内核与进程篇详解

最新资源

操作系统原理与实践第三卷：内存管理