深入解析Linux 2.6.8.1内核调度器

需积分: 9 170 浏览量更新于2024-07-19 收藏 251KB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

"这篇文档是Josh Aas于2005年撰写的关于理解Linux 2.6.8.1版CPU调度器的文章，旨在深入解析Linux操作系统的内核和调度机制。文中涵盖Linux内核源码、进程与线程的概念、调度目标以及Linux 2.6.8.1版调度器的起源和特点。" 在Linux操作系统中，CPU调度器扮演着至关重要的角色，它决定了哪个进程或线程可以占用CPU资源进行执行。Linux 2.6.8.1版本的调度器是一个关键组件，它直接影响到系统性能、交互性和公平性。该文档首先介绍了文章的概述，指出Linux内核相关的文献资料，并定义了文档中使用的排版约定。获取Linux内核源代码是学习其调度器的第一步，可以通过特定的途径下载。内核版本管理保证了代码的更新和兼容性。源代码的组织结构复杂，但有规律可循，包括进程管理和调度策略的相关模块。文档接着讨论了进程和线程的概念，区分了程序与进程的区别，解释了线程如何共享进程资源，以及CPU和I/O绑定线程的不同。上下文切换是调度过程中的一个重要环节，当一个进程或线程让出CPU时，操作系统会保存其状态并恢复另一个进程或线程的状态，使得它们能无缝地继续执行。 Linux调度的目标多元化，包括提高效率、提升交互性、保证公平性和防止饥饿现象。这些目标适应了不同场景的需求，例如单一处理器系统（SMP）和多线程系统（SMT）的调度策略，以及非均匀内存访问（NUMA）架构下的优化。此外，还考虑了软实时调度，确保某些任务能在规定时间内完成。 Linux 2.6.8.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页未读，继续阅读

iammatlab

粉丝: 4
资源: 12

深入解析Linux 2.6.8.1内核调度器

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

linux_cpu_scheduler-2.6.8.1.rar_Linux 2.6 scheculer_linux_cpu_sc

linux-2.6.21.5源代码

reactor.core.scheduler.Scheduler 是什么？可以做什么用？举个java的例子？

spark.yarn.scheduler.exclude.nodes不生效

scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau

Correct the classpath of your application so that it contains a single, compatible version of org.quartz.Scheduler

optim.lr_scheduler的使用方法是什么

torch.optim.lr_scheduler.StepLR

torch.optim.lr_scheduler.ReduceLROnPlateau

torch.optim.lr_scheduler.lambdalr

torch.optim.lr_scheduler.MultiStepLR

torch.optim.lr_scheduler.MultiStepLRd的具体用法

org.quartz.Scheduler 加锁只保证一个定时任务执行

org.quartz.scheduler

torch.optim.lr_scheduler.MultiStepLR(opt, milestones=[75, 150, 200], gamma=0.1)

我希望使用torch.optim.lr_scheduler()

torch.optim.lr_scheduler.MultiStepLR的具体用法，据个例子

torch.optim.lr_scheduler.StepLR怎么使用

optim.lr_scheduler.StepLR

最新资源