Priority Inversion in Operating Systems

Let us first put 'priority inversion' in the context of the Big Picture i.e. where does this come from.

In Operating System, one of the important concepts is Task Scheduling. There are several Scheduling methods such as First Come First Serve, Round Robin, Priority-based scheduling, etc. Each scheduling method has its pros and cons. As you might have guessed, Priority Inversion comes under Priority-based Scheduling. Basically, it's a problem which arises sometimes when Priority-based scheduling is used by OS. In Priority-based scheduling, different tasks are given different priorities so that higher priority tasks can intervene in lower priority tasks if possible. 

So, in priority-based scheduling, if a lower priority task (L) is running and if a higher priority task (H) also needs to run, the lower priority task (L) would be preempted by a higher priority task (H). Now, suppose both lower and higher priority tasks need to share a common resource (say access to the same file or device) to achieve their respective work. In this case, since there are resource sharing and task synchronization is needed, several methods/techniques can be used for handling such scenarios. For sake of our topic on Priority Inversion, let us mention a synchronization method say mutex. Just to recap on the mutex, a task acquires mutex before entering the critical section (CS) and releases mutex after exiting the critical section (CS).

Now, say both L and H share a common Critical Section (CS) i.e. the same mutex is needed for this CS.

Priority Inversion Problem

Coming to our discussion of priority inversion, let us examine some scenarios:

1) L is running but not in CS; H needs to run; H preempts L; H starts running; H relinquishes or releases control; L resumes and starts running 
2) L is running in CS; H needs to run but not in CS; H preempts L; H starts running; H relinquishes control; L resumes and starts running. 
3) L is running in CS; H also needs to run in CS; H waits for L to come out of CS; L comes out of CS; H enters CS and starts running

Please note that the above scenarios don't show the problem of any Priority Inversion (not even scenario 3). Basically, so long as lower priority task isn't running in shared CS, higher priority task can preempt it. But if L is running in shared CS and H also needs to run in CS, H waits until L comes out of CS. The idea is that CS should be small enough so that it doesn't result in H waiting for a long time while L was in CS. That's why writing a CS code requires careful consideration. In any of the above scenarios, priority inversion (i.e. reversal of priority) didn't occur because the tasks are running as per the design.

Now let us add another task of middle priority say M. Now the task priorities are in the order of L < M < H. In our example, M doesn't share the same Critical Section (CS). In this case, the following sequence of task running would result in a 'Priority Inversion' problem.

4) L is running in CS; H also needs to run in CS; H waits for L to come out of CS; M interrupts L and starts running; M runs till completion and relinquishes control; L resumes and starts running till the end of CS; H enters CS and starts running.

Note that neither L nor H share CS with M.

Here, we can see that running of M has delayed the running of both L and H. Precisely speaking, H is of higher priority and doesn't share CS with M; but H had to wait for M. This is where Priority-based scheduling didn't work as expected because priorities of M and H got inverted in spite of not sharing any CS. This problem is called Priority Inversion. This is what the heck was Priority Inversion! In a system with priority-based scheduling, higher priority tasks can face this problem and it can result in unexpected behavior/result. In general purpose OS, it can result in slower performance. In RTOS, it can result in more severe outcomes. The most famous 'Priority Inversion' problem was what happened at Mars Pathfinder.

Solutions to Priority Inversion

Priority inversion can lead to significant delays and system inefficiencies. To resolve or prevent this issue, the following solutions are commonly used:

• Priority Inheritance: Priority Inheritance is the technique that is intended to solve the issues related to the Priority Inversion. In Priority Inheritance, the priority of task L is raised in order to match that of higher priority task H once L has acquired a critical section and H is waiting for it; this is to prevent other mid priority tasks to preempt task L, which could delay execution of task H once it releases the critical section. The task L comes out the critical section with the return of the priority to its original level. This approach assist in the conservation of the efficiency level of task scheduling from the impact of Priority Inversion.

• Priority Ceiling Protocol: In Priority ceiling Protocol every resource is assigned a priority ceiling, which is the highest priority of all processes that may access the resource. A process can only access a resource if its priority is higher than the ceiling of all currently held resources. This prevents medium-priority processes from preempting lower-priority processes that are using shared resources.

• Avoid Shared Resources: Keep critical sections of code (where resources are locked) short and efficient so resources are released quickly.

• Avoid Long Critical Sections: Assign processes a preemption threshold, ensuring a process cannot be preempted by others unless they exceed the threshold.

• Use Real-Time Operating Systems (RTOS): Many RTOS systems implement mechanisms like priority inheritance or priority ceiling protocols automatically to handle priority inversion effectively.

Difference Between Priority Inversion and Priority Inheritance

Priority Inversion happens when a high-priority process is blocked because a low-priority process is holding a resource, and a medium-priority process interrupts the low-priority process, causing delays. Priority Inheritance, on the other hand, is a solution to this problem. It temporarily increases the priority of the low-priority process holding the resource to match the high-priority process, allowing it to finish and release the resource quickly.

read more about - Difference Between Priority Inversion and Priority Inheritance

Priority Inversion in Operating System

Visit Course