Linux CPU scheduling is a core concept in modern embedded systems running Linux. Unlike bare-metal firmware or simple RTOS environments, embedded Linux platforms must manage multiple concurrent workloads, such as sensor processing, motor control, networking, and user interfaces. The Linux CPU scheduler determines which task runs, when it runs, and for how long, directly affecting system latency, responsiveness, and determinism. This scheduling model is widely used in production embedded Linux systems running kernel 5.x and newer on ARM Cortex-A platforms for industrial control, robotics, and IoT gateways.
Not all embedded tasks have equal importance.
For example:
A motor control loop must execute within strict timing deadlines.
A logging or display task can tolerate delays.
Linux scheduling policies ensure that time-critical tasks preempt less critical ones,
making Linux suitable for both real-time and non-real-time embedded workloads.
First Come First Serve (FCFS) is one of the simplest scheduling concepts.
The first process that enters the ready queue is the first one to execute.
Each process runs until it finishes or blocks.
In embedded Linux, FCFS behavior is implemented using the SCHED_FIFO real-time scheduling policy.
Tasks execute in priority order and continue running until they voluntarily yield the CPU
or block for I/O.
This approach is ideal for deterministic real-time applications where interruptions
must be avoided.
#include
#include
#include
int main() {
struct sched_param param;
param.sched_priority = 80;
sched_setscheduler(0, SCHED_FIFO, ¶m);
while (1) {
printf("SCHED_FIFO task running\n");
sleep(1);
}
}
Shortest Job First (SJF) selects the task with the smallest execution time to minimize
average waiting time. While efficient in theory, it is impractical in real systems
because execution time is not known in advance.
Linux instead uses the Completely Fair Scheduler (CFS), which approximates this idea
by tracking how much CPU time each task has received and favoring tasks that have
used less CPU recently.
In embedded systems, this improves responsiveness for short tasks such as user input
handlers or lightweight sensor reads.
#include
#include
int main() {
while (1) {
printf("Running under CFS scheduler\n");
usleep(100000);
}
}
Priority scheduling assigns each task a priority, and the scheduler always selects
the highest-priority runnable task.
Linux real-time policies support priorities from 1 to 99, where higher numbers
indicate higher priority.
When a high-priority task becomes runnable, it immediately preempts lower-priority tasks.
This behavior is essential for time-critical embedded workloads.
#include
#include
int main() {
struct sched_param param;
sched_getparam(0, ¶m);
printf("Current Priority: %d\n", param.sched_priority);
}
Round Robin scheduling improves fairness by giving each task a fixed time slice (quantum).
When the time slice expires, the task is moved to the end of the queue.
In Linux, this is implemented using SCHED_RR. Tasks with the same priority are scheduled
in a round-robin manner, preventing starvation while maintaining real-time behavior.
#include
#include
#include
int main() {
struct sched_param param;
param.sched_priority = 60;
sched_setscheduler(0, SCHED_RR, ¶m);
while (1) {
printf("SCHED_RR task running\n");
sleep(1);
}
}
| Feature | SCHED_FIFO | SCHED_RR |
|---|---|---|
| Time slicing | No | Yes |
| Fairness | Low | Medium |
| Starvation risk | High | Lower |
| Determinism | Very High | High |
| Best use case | Hard real-time | Equal-priority RT |
A common and effective embedded Linux design uses multiple scheduling policies simultaneously:
This hybrid approach provides real-time determinism without sacrificing system flexibility.
Priority inversion occurs when a low-priority task holds a resource needed by a
high-priority task.
Mitigation strategies include:
Ignoring priority inversion can break real-time behavior—even with correct scheduler selection.
It is the mechanism the Linux kernel uses to decide which process runs on the CPU.
CFS is Linux’s default scheduler, designed to fairly distribute CPU time.
FIFO runs until blocking; Round Robin adds time slicing among equal priorities.
It ensures time-critical tasks meet deadlines without unpredictable delays.
Author
Embedded Systems Trainer – IIES
Updated On: 16-01-26