Managing I/O and CPU Scheduling with the RT Kernel

Grants highest priority for disk access. Requests in this class are served before any other class. Within the real-time class, priority is fine-tuned with nice levels from 0 (highest priority) to 7 (lowest priority).

Warning: Risk of disk bandwidth starvation

Assigning real-time I/O priorities incorrectly can deprive other system processes of disk bandwidth.

Assign real-time I/O class only to thoroughly tested critical tasks.

The default scheduling class for standard system processes. Priority is derived from the process CPU nice value (ranging from 0 to 7).

Processes receive disk access only when no other process requests disk I/O. Ideal for background workloads such as logging or maintenance.

The none scheduler is a simple scheduler that performs no reordering of I/O requests. This scheduler is mainly used for specialized environments that run their own schedulers optimized for the used hardware, such as fast NVMe storage, storage systems or hardware RAID controllers.

The main point of deadline scheduling is to try hard to answer a request before a given deadline. This results in good I/O for a random single I/O in real-time environments.

In principle, the mq-deadline scheduler uses two lists with all requests. One is sorted by block sequences to reduce seeking latencies, the other is sorted by expire times for each request. Normally, requests are served according to the block sequence, but if a request reaches its deadline, the scheduler starts to work on this request.

The Budget Fair Queueing (BFQ) scheduler uses a separate I/O queue for each process and tries to divide the bandwidth fairly between all requesting processes.

The main focus of this scheduler is to limit the start latency for a request to a given time. Therefore, for each request, a deadline is calculated from the current time plus the value of read_expire in milliseconds.

Similar to read_expire for write requests.

If a request hits its deadline, it is necessary to move the request from the sorted I/O scheduler list to the dispatch queue. The variable fifo_batch controls how many requests are moved, depending on the cost of each request.

The scheduler normally tries to find contiguous I/O requests and merges them. There are two kinds of merges: The new I/O request may be in front of the existing I/O request (front merge), or it may follow behind the existing request (back merge). Most merges are back merges. Therefore, you can disable the front merge functionality by setting front_merges to 0.

If certain read or write requests hit their deadline, the scheduler prefers the read requests by default. To prevent write requests from being postponed forever, the variable writes_starved controls how often read requests are preferred until write requests are preferred over read requests.

The scheduler normally dispatches requests in a strict ascending order. When needed, it also allows small backward seeks, but it applies a penalty on them. The maximum backward sector seek is defined with back_seek_max, and the multiplier for the penalty is set by back_seek_penalty.

The fifo_expire_* variables define the timeout in milliseconds for asynchronous and synchronous I/O requests. Set fifo_expire_sync lower than fifo_expire_async to prioritize synchronous requests over asynchronous operations.

Defines how long the I/O scheduler idles before servicing the next thread to maintain sequential I/O locality. slice_idle specifies this time in milliseconds, while slice_idle_us specifies it in microseconds.