Know your Scheduler

This week I will present some basic concepts about the Linux scheduler

and its operation mode.

The scheduler (or dispatcher) is a kernel component responsible for

coordinating process and thread execution (collectively referred to as

tasks). The scheduler affects the system's overall performance, perhaps

more than any other kernel component, by assigning each task a fair

amount of CPU time based upon the tasks priority and class process.

However, the scheduler also guarantees the lowest priority tasks aren't

starved of CPU time.

Linux implements the preemptive multitasking model, whereby the

scheduler removes a task from the CPU once its allocated time quantum

has expired. Of course, a task may voluntarily surrender -- technically

speaking, yield -- its CPU time if it's waiting for another process to

release a resource. Furthermore, the scheduler reprioritizes tasks. If

a task has already received some CPU time, then it will have lower

priority compared to tasks with identical priority that have not. Under

Linux, a task's priority can range between 20 and -20; the default

priority is 0, and the highest priority is -20. In other words, the

lower the value, the higher the priority (a common source of confusion

for novices). A user can set a priority lower than 0 using the "renice"

command, but the user must have an administrator's privilege.

Linux supports real time tasks as well. A real-time task always takes

priority over all non real-time tasks. In essence, a scheduler sets a

process's state into one of the following modes:

* Running -- A process is the current system process and is

utilizing the system's CPU.

* Running, ready to run -- The process is in the run queue, waiting

for the CPU to become available.

* Waiting, interruptible -- The process is waiting for a lock or an

event. It hasn't disabled incoming signals, so it may be

interrupted.

* Waiting, uninterruptible -- The process is waiting for a lock or

an event. It has disabled signals and therefore, it cannot be

interrupted.

* Stopped -- The process has stopped, typically due to a SIGSTOP

signal. Such a process may resume execution later (i.e., its

state may change to Running) if, for example, it's being executed

under the supervision of a debugger.

* Zombie -- The process is dying (due to a malfunction or power

fault) or has completed its execution. However, its entry hasn't

been removed yet from the system's process table.

Insider: How the basic tech behind the Internet works
Join the discussion
Be the first to comment on this article. Our Commenting Policies