Я читал, что ядро Linux является превентивным, что отличается от большинства ядер Unix. Итак, что это значит для того, чтобы ядро было упреждающим?
Некоторые аналоги или примеры были бы лучше, чем чисто теоретическое объяснение.
Приоритет - это всего лишь одна парадигма многозадачности. Есть и такие, как Cooperative Multi-tasking. Сравнивая их, можно добиться лучшего понимания.
Представьте себе простой взгляд на упреждающую многозадачность. У нас есть две пользовательские задачи, обе из которых работают все время без использования ввода-вывода или выполнения вызовов ядра. Эти две задачи не должны делать ничего особенного, чтобы работать в многозадачной операционной системе. Ядро, как правило, основано на прерывании таймера, просто решает, что время для одной задачи приостанавливается, чтобы запустить другую. Задача, о которой идет речь, совершенно не осознает, что что-то произошло.
Однако большинство задач делают случайные запросы ядра через системные вызовы. Когда это происходит, существует один и тот же контекст пользователя, но CPU выполняет код ядра от имени этой задачи.
Старые ядра Linux никогда не позволяли бы превзойти задачу, пока она была занята запуском кода ядра. (Обратите внимание, что операции ввода-вывода всегда добровольно перепланируются. Я говорю о случае, когда код ядра имеет некоторую интенсивную работу с процессором, например сортировку списка.)
Если система позволяет выполнить эту задачу при запуске кода ядра, то у нас есть так называемое "упреждающее ядро". Такая система невосприимчива к непредсказуемым задержкам, которые могут возникать во время системных вызовов, поэтому она может быть лучше подходит для встроенных или задач реального времени.
Например, если на конкретном процессоре есть две задачи, и один берет системный вызов, который занимает 5 мс, а другой - приложение для MP3-плеера, которое должно подавать звуковой канал каждые 2 мс, вы можете услышать заикание аудио.
Аргумент против предпосылки заключается в том, что весь код ядра, который может быть вызван в контексте задачи, должен иметь возможность выжить при преодолении - существует, например, много плохого кода драйвера устройства, который может быть лучше, если он всегда может завершить перед тем как разрешить выполнение другой задачи на этом процессоре. (В многопроцессорных системах правило, а не исключение в наши дни, весь код ядра должен быть повторно включен, поэтому этот аргумент сегодня не так важен.) Кроме того, если та же цель может быть решена путем улучшения системных вызовов с плохими латентность, возможно, предпосылка не нужна.
Компромисс - это CONFIG_PREEMPT_VOLUNTARY, что позволяет переключать задачу в определенных точках внутри ядра, но не везде. Если есть небольшое количество мест, где код ядра может увязнуть, это дешевый способ уменьшить латентность, сохраняя при этом сложность управления.
До ядра Linux версии 2.5.4 ядро Linux не было превентивным, что означает, что процесс, работающий в режиме ядра, не может быть удален из процессора, пока он сам не покинет процессор, или он не начнет ждать завершения какой-либо операции ввода вывода.
Как правило, процесс в пользовательском режиме может войти в режим ядра с помощью системных вызовов. Раньше, когда ядро не было превентивным, процесс с более низким приоритетом мог перенести процесс более высокого приоритета, отказав ему в доступе к процессору, многократно вызывая системные вызовы и оставаясь в режиме ядра. Даже если срок действия более низкого приоритета истек, он будет продолжать работать до тех пор, пока он не завершит свою работу в ядре или не будет отменен принудительно. Если процесс с более высоким приоритетом, ожидающий запуска, представляет собой текстовый редактор, в котором пользователь печатает или MP3-плеер готов пополнить свой звуковой буфер, результатом является низкая интерактивность. Таким образом, недопустимое ядро в то время было основным недостатком.
В традиционных ядрах unix была единственная блокировка, которая поддерживалась потоком во время работы кода ядра. Поэтому никакой другой код ядра не может прервать этот поток.
Это упростило проектирование ядра, поскольку вы знали, что, хотя один поток использует ресурсы ядра, ни один другой поток не был. Поэтому разные потоки не могут испортить друг друга.
В однопроцессорных системах это не вызывает слишком много проблем.
Однако в многопроцессорных системах у вас может быть ситуация, когда несколько потоков на разных процессорах или ядрах все равно хотят запускать код ядра одновременно. Это означает, что в зависимости от типа рабочей нагрузки у вас может быть много процессоров, но все они проводят большую часть времени, ожидая друг друга.
В Linux 2.6 ресурсы ядра были разделены на гораздо меньшие единицы, защищенные отдельными блокировками, и код ядра был проверен, чтобы убедиться, что блокировки были сохранены только в то время, когда соответствующие ресурсы использовались. Поэтому теперь разные процессоры должны ждать друг друга только в том случае, если они хотят получить доступ к одному и тому же ресурсу (например, к аппаратным ресурсам).
Предотвращение позволяет ядру дать IMPRESSION параллелизма: у вас есть только один процессор (скажем, десять лет назад), но вы чувствуете, что все ваши процессы работают одновременно. Это потому, что ядро выгружает (т.е. Выносит выполнение из) выполнение из одного процесса, чтобы передать его следующему (возможно, в соответствии с их приоритетом).
РЕДАКТИРОВАТЬ Не превентивные ядра ожидают, что процессы вернут руку (т.е. Во время системных вызовов), поэтому, если ваш процесс вычисляет множество данных и не вызывает функцию yield, другие процессы не смогут выполнить выполнять свои звонки. Говорят, что такие системы являются кооперативными, поскольку они требуют сотрудничества процессов для обеспечения справедливости времени выполнения
EDIT 2 Основная цель preemption - улучшить реактивность системы между несколькими задачами, так что это хорошо для конечных пользователей, тогда как, с другой стороны, серверы хотят достичь максимальной пропускной способности, поэтому они не нужны: (из конфигурации ядра Linux)
Это означает, что планировщик операционной системы может приостанавливать выполнение запущенных процессов, чтобы процессор мог обрабатывать другой процесс, когда захочет; обычный способ сделать это - дать каждому процессу, ожидающему, что процессор будет "квантом" времени процессора для запуска. После того, как он истек, планировщик возвращает элемент управления (и текущий процесс не может этого избежать), чтобы дать другому кванту другому процессу.
Этот метод часто сравнивается с совместной многозадачностью, в которой процессы поддерживают процессор в течение всего времени, в котором они нуждаются, без прерывания и для запуска других приложений они должны явно вызывать функцию "выхода"; естественно, чтобы избежать ощущения застревания системы, хорошо управляемые приложения часто будут давать процессор. Тем не менее, если в приложении есть ошибка (например, бесконечный цикл без вызовов на выходе), вся система будет зависать, так как процессор полностью сохраняется неисправной программой.
Практически все последние настольные ОС используют упреждающую многозадачность, что, даже если оно более дорогое с точки зрения ресурсов, в целом более стабильно (сложнее, когда приложение с ошибкой sigle повесило всю систему, поскольку ОС всегда находится в контроль). С другой стороны, когда ресурсы жесткие и ожидается, что приложение будет хорошо себя вести, используется совместная многозадачность. Windows 3 была совместной многозадачной ОС; более недавним примером может быть RockBox, замена прошивки PMP с открытым исходным кодом.
Ядро linux является монолитным и дает небольшое время вычислений для всего выполняющегося процесса последовательно. Это означает, что процессы (например, программы) не запускаются одновременно, но им предоставляется регулярный отклик для выполнения их логики. Основная проблема заключается в том, что некоторая логика может занять больше времени, чтобы завершить работу и не дать ядру дать время для следующего процесса. Это приводит к "отставанию" системы.
Ядро preemtive имеет возможность контекст переключения. Это означает, что он может остановить "зависающий" процесс, даже если он еще не закончен, и дать вычислительное время следующему процессу, как ожидалось. "Висячий" процесс будет продолжать выполняться, когда его время пришло без проблем.
Практически это означает, что ядро имеет возможность выполнять задачи в реальном времени, что особенно интересно для записи и редактирования звука.
ubuntu studio districution включает в себя упреждающее ядро, а также бесплатное программное обеспечение, предназначенное для аудио и видео.
Я думаю, что он стал превентивным с 2.6. превентивные средства, когда новый процесс готов к запуску, процессор будет назначен новому процессу, ему не нужно, чтобы работающий процесс был кооперативным и отказался от процессора.
Ядро Linux является превентивным, означает, что ядро поддерживает preemption.
Например, существуют два процесса: P1 (более высокий приоритет) и P2 (более низкий приоритет), которые выполняют системные вызовы чтения, и они работают в режиме ядра. Предположим, что P2 запущен и находится в режиме ядра, и планируется запустить P2.
Если доступно предварительное использование ядра, то на уровне ядра может произойти преемственность. я P2 может быть выгружен, но спать и P1 может продолжать работать.
Если приоритет ядра недоступен, поскольку P2 находится в режиме ядра, система просто ждет завершения P2, а затем