深入解析Linux 2.6.8.1内核CPU调度机制

5星 · 超过95%的资源需积分: 15 54 浏览量更新于2024-08-01 收藏 249KB PDF 举报

"这篇文档是理解Linux内核2.6.8.1版本CPU调度机制的详细介绍，由原SGI工程师Josh Aas撰写。文档深入浅出地剖析了Linux内核调度器的设计与实现，适合对Linux内核感兴趣的读者学习。" 在Linux内核中，调度器是一个至关重要的组件，它负责决定哪个进程或线程应该获得CPU的执行时间。在Linux 2.6.8.1版本中，内核调度器的目标包括效率、交互性、公平性、防止饥饿以及适应多处理器系统（SMP）和超线程技术（SMT）等。文档首先介绍了Linux内核源代码的获取和版本管理，帮助读者建立对代码组织结构的基本理解。接着，文档详细阐述了进程和线程的概念，包括程序与进程的区别、线程的定义、调度的基本原理，以及CPU和I/O绑定线程的工作模式。上下文切换是调度过程中的一个重要环节，它涉及到保存和恢复进程状态，以在不同进程间切换执行。在讨论Linux调度目标时，文档提到Linux主要面向的市场及这些市场对调度器的影响，如桌面环境和服务器环境的需求差异。效率是调度器的基本要求，它需要快速有效地分配CPU时间。交互性则关乎用户体验，确保响应速度及时。公平性和防止饥饿确保所有进程都能得到合理的执行机会，避免某些进程长时间独占资源。SMP调度关注多处理器环境下的负载均衡，SMT调度则考虑了超线程技术下的任务调度。此外，NUMA（Non-Uniform Memory Access）调度处理了分布式内存访问的问题，而软实时调度则满足了对时间限制较宽松的实时应用需求。在Linux 2.6.8.1调度器的介绍部分，文档提到了O(1)算法的重要性，即调度器能够在常数时间内完成调度决策，无论系统中有多少个进程。这使得调度器能够高效地处理大量并发进程。文档详细回顾了这个O(1)调度器的起源和设计思路，帮助读者理解其工作原理。这份文档为读者提供了一个深入了解Linux内核调度器的起点，涵盖了从基本概念到具体实现的广泛内容，对于希望深入研究Linux内核机制的开发者来说是一份宝贵的参考资料。

2.3 Code Organization

There are quite a few sub directories within each Linux source code package.

Subdirectories that it would be most helpful to know about while reading this

paper are:

Documentation a directory containing lots of good documentation on kernel

internals and the development process

arch a directory containing architecture-speciﬁc code; it contains one subdirec-

tory for each supported architecture (e.g. i386, ia64, ppc64...)

include a directory containing header ﬁles

kernel a directory containing the main kernel co de

mm a directory containing the kernel’s memory management code

3 Overview of Processes and Threads

It is important to have a decent understanding of both processes and threads

b efore learning about schedulers. Explaining processes and threads in depth

is outside of the scope of this document, thus only a summary of the things

that one must know about them is provided here. Readers of this document are

strongly encouraged to gain an in-depth understanding of processes and threads

from another source. Excellent sources are listed in the bibliography[2, 3, 4, 5].

3.1 Programs and Processes

A program is a combination of instructions and data put together to perform a

task when executed. A process is an instance of a program (what one might call

a “running” program). An analogy is that programs are like classes in languages

like C++ and Java, and processes are like objects (instantiated instances of

classes). Processes are an abstraction created to embody the state of a program

during its execution. This means keeping track of the data that is associated

with a thread or threads of execution, which includes variables, hardware state

(e.g. registers and the program counter, etc...), and the contents of an address

space

[1].

3.2 Threads

A process can have multiple threads of execution that work together to accom-

plish its goals. These threads of execution are aptly named threads. A kernel

must keep track of each thread’s stack and hardware state, or whatever is neces-

sary to track a single ﬂow of execution within a process. Usually threads share

An address space is the set of memory addresses that a process is allowed to read and/or

write to.

address spaces, but they do not have to (often they merely overlap). It is impor-

tant to remember that only one thread may be executing on a CPU at any given

time, which is basically the reason kernels have CPU schedulers. An example of

multiple threads within a process can be found in most web browsers. Usually

at least one thread exists to handle user interface events (like stopping a page

load), one thread exists to handle network transactions, and one thread exists

to render web pages.

3.3 Scheduling

Multitasking kernels (like Linux) allow more than one process to exist at any

given time, and furthermore each process is allowed to run as if it were the

only process on the system. Processes do not need to be aware of any other

processes unless they are explicitly designed to be. This makes programs easier

to develop, maintain, and port [1]. Though each CPU in a system can execute

only one thread within a process at a time, many threads from many processes

appear to be executing at the same time. This is because threads are scheduled

to run for very short periods of time and then other threads are given a chance

to run. A kernel’s scheduler enforces a thread scheduling policy, including when,

for how long, and in some cases where (on Symmetric Multiprocessing (SMP)

systems) threads can execute. Normally the scheduler runs in its own thread,

which is woken up by a timer interrupt. Otherwise it is invoked via a system

call or another kernel thread that wishes to yield the CPU. A thread will be

allowed to execute for a certain amount of time, then a context switch to the

scheduler thread will occur, followed by another context switch to a thread of

the scheduler’s choice. This cycle continues, and in this way a certain policy for

CPU usage is carried out.

3.4 CPU and I/O-bound Threads

Threads of execution tend to be either CPU-bound or I/O-bound (Input/Output

b ound). That is, some threads spend a lot of time using the CPU to do compu-

tations, and others spend a lot of time waiting for relatively slow I/O operations

to complete. For example - a thread that is sequencing DNA will b e CPU bound.

A thread taking input for a word processing program will be I/O-bound as it

sp ends most of its time waiting for a human to type. It is not always clear

whether a thread should be considered CPU or I/O bound. The best a sched-

uler can do is guess, if it cares at all. Many schedulers do care about whether

or not a thread should be considered CPU or I/O bound, and thus techniques

for classifying threads as one or the other are important parts of schedulers.

Schedulers tend to give I/O-bound threads priority access to CPUs. Pro-

grams that accept human input tend to be I/O-bound - even the fastest typist

has a considerable amount of time between each keystroke during which the

program he or she is interacting with is simply waiting. It is important to give

programs that interact with humans priority since a lack of speed and respon-

siveness is more likely to be perceived when a human is expecting an immediate

剩余37页未读，继续阅读

ihiphop

粉丝: 3
资源: 4

深入解析Linux 2.6.8.1内核CPU调度机制

Understanding the Linux 2.6.8.1 CPU Scheduler（中文翻译）

linux_cpu_scheduler-2.6.8.1.rar_Linux 2.6 scheculer_linux_cpu_sc

Understanding the Linux 2.6.8.1 CPU Scheduler

深入解析Linux 2.6.8.1内核调度器

Linux 2.6.8.1内核调度深度解析：目标、策略与实现

深入分析Linux内核源码.chm

Linux2.6内核标准教程（共计8-- 第1个）

Linux2.6内核标准教程（共计8--第8个）

Linux2.6内核标准教程（共计8--第5个）

Linux2.6内核标准教程（共计8--第7个）

最新资源