Почему вытеснение не решает инверсию приоритета?

Хорошо, допустим, у нас есть два процесса. Предположим также, что процесс с более низким приоритетом получает блокировку. Когда процесс с более высоким приоритетом становится готовым, он вытесняет другой процесс. Если процесс с более высоким приоритетом нуждается в этой блокировке, он не может ее получить из-за другого процесса с более низким приоритетом. Это означает, что процесс с более низким приоритетом блокирует процесс с более высоким приоритетом. Это предотвращает запуск процесса с более высоким приоритетом. Это называется "инверсия приоритета".

Очевидно, что вытеснение не является решением проблемы инверсии приоритетов. Решение - "Приоритетное наследование". Это означает, что мы должны временно увеличивать приоритет процесса всякий раз, когда он получает блокировку, которая также необходима процессу с более высоким приоритетом. Это должен быть процесс с наивысшим приоритетом среди других процессов, которым может потребоваться такая же блокировка.

Пусть 3 потока A, B, C с соответствующими приоритетами Высокий, Средний, Низкий.

C получает процессор и блокирует L. Затем B пробуждается некоторыми событиями и вытесняет C. Теперь A пробуждается и получает процессор, вытесняя B. A запрашивает блокировку L, но терпит неудачу, поскольку L уже принадлежит C. A вытесняется из-за недоступности блокировки и возвращает процессор B. Нам нужно дождаться завершения B, что в конечном итоге приведет к передаче процессора C. C завершит работу и снимет блокировку, которая окончательно разбудит A.

Это инверсия приоритета, потому что B выполняется, тогда как у нас есть поток A в системе с более высоким приоритетом, ожидающий завершения потока с более низким приоритетом. (в данном случае C).

Кстати, решением является приоритетное наследование.

Вытеснение означает отключение процессора, чтобы задача больше не выполнялась.

Этого недостаточно, потому что задача с низким приоритетом содержит ресурс, который нужен задаче с высоким приоритетом.

Теперь, если бы ресурс можно было просто забрать (другой вид «вытеснения»), то это действительно решило бы инверсию приоритета. Но это обычно невозможно, потому что незавершенное действие низкоприоритетной задачи привело бы к несоответствиям.

Предположим, у вас есть 3 процесса:

• A — высокий приоритет
• B – обычный приоритет
• C — низкий приоритет

а также то, что A и C используют, скажем, один и тот же файл (это может быть любой общий ресурс), использование которого должно быть синхронизировано.

Теперь предположим, что ни A, ни B не готовы к запуску, а C запускается и получает блокировку для использования файла. Пока C удерживает блокировку файла, A готовится к запуску, и операционная система вытесняет C и запускает A . A выполняется до такой степени, что ему также нужен файл, и когда он пытается получить блокировку, он блокируется, поскольку C удерживает блокировку. Если в это время B был готов к запуску, он будет выполнен вместо A, потому что A не готов к запуску. Чтобы A был готов, блокировка файла должна быть снята с помощью C, а C не запустится и не снимет блокировку, поскольку выше приоритетный процесс B запущен. Таким образом, A ожидает C, который, в свою очередь, ожидает B. Простое вытеснение B в этой ситуации не принесет пользы, потому что A не готов и не будет готов, пока не запустится C и >C не может быть запущен, так как только что вытесненный более высокий приоритет B готов к запуску.

Из Вики

Рассмотреть возможность,

L --> Задача с низким приоритетом
H --> Задача с высоким приоритетом
M --> Задача со средним приоритетом
R --> Ресурс

Шаг 1: L получает R
Шаг 2: H запрашивает R (в настоящее время используется с L, поэтому H будет ждать, пока L откажется от R.)
Шаг 3: M прибывает (M является незаблокированным Задача, т. е. не требует R)
Шаг 4: L вытесняется M. (поэтому L не может отказаться от R. Из-за этого H не может работать.)

После того, как M закончит свое выполнение, L откажется от R. После этого только H может продолжить. В приведенном выше сценарии задача со средним приоритетом (M) выполнялась перед задачей с высоким приоритетом (H).

Это реальный сценарий инверсии приоритетов в вытесняющем ядре.

инверсия приоритета — проблематичный сценарий при планировании, когда задача с более высоким приоритетом косвенно вытесняется задачей с более низким приоритетом, эффективно «инвертируя» относительные приоритеты двух задач.

Допустим, есть задача L с низким приоритетом. Для этой задачи требуется ресурс R. Предположим, что L выполняется и получает ресурс R. Теперь есть другая задача H с высоким приоритетом. Эта задача также требует ресурса R. Предположим, что H начинается после того, как L получила ресурс R. Теперь H должна ждать, пока L освободит ресурс R. До этого момента все работает, как ожидалось, но возникают проблемы, когда новая задача M (которая не использует R) в это время запускается со средним приоритетом. Поскольку R все еще используется (L), H не может работать. Поскольку M является незаблокированной задачей с наивысшим приоритетом, она будет запланирована раньше L. Поскольку L была вытеснена M, L не может отказаться от R. Таким образом, M будет выполняться до тех пор, пока не будет завершена, затем L будет выполняться - по крайней мере, до момента, когда он может отказаться от R, и тогда будет работать H. Таким образом, в приведенном выше сценарии задача со средним приоритетом выполнялась перед задачей с высоким приоритетом, что фактически давало нам инверсию приоритета.