Уменьшить приоритет процесса linux
Обновлено: 05.07.2024
Когда на компьютере достаточно процессорного времени на исполнение всех процессов, нет необходимости в выставлении приоритетов. Но когда необходимо параллельно запустить несколько процессов, каждый из которых использует всё доступное процессорное время, может очень пригодиться утилита nice.
Команда nice запускает программу с изменённым приоритетом для планироващика задач. Слово «nice» в английском языке обозначает, в частности, «вежливый». По этимологии этой команды процесс с большим значением nice — более вежлив к другим процессам, позволяя им использовать больше процессорного времени, поскольку он сам имеет меньший приоритет (и, следовательно, большее «значение вежливости» — niceness value).
Наибольший приоритет (и наименьшее значение nice) — −20. 19, либо 20 — наименьший приоритет, но это, с другой стороны, самые вежливые процессы.
Чтобы посмотреть идентификатор и значение nice нужного процесса в системе, можно воспользоваться командой ps axl.
Пример использования команды nice — запуск ресурсоёмкой задачи в фоновом режиме, так, чтобы она выполнялась, но освобождала часть процессорного времени для других процессов, как только оно становятся им нужно. Таким образом можно, скажем, запустить кодирование OGG/MP3 с большим значением nice, чтобы оно происходило в фоновом режиме, используя не всё процессорное время, а то, что не используется другими процессами (с меньшим значением nice — то есть с большим приоритетом).
Чтобы запустить команду с определённым приоритетом, слева нужно добавить «nice -n значение_nice», либо «nice --adjustment значение_nice» (adjustment — настройка, регулировка).
То есть: nice -n значение_nice команда.
Если нужно изменить приоритет уже запущенного процесса, можно воспользоваться командой renice.
renice -n значение_nice id_процесса
Команда renice выводит старый и новый приоритет процесса.
Теперь, зная эти команды, можно управлять процессами так, чтобы определённые задачи выполнялись быстрее в случае, когда сразу много процессов используют всё доступное процессорное время.
В некоторых ситуациях может возникнуть необходимость запускать скрипт/программу не со стандартным приоритетом, а с более высоким или низким, либо повысить или понизить приоритет у запущенного ранее процесса. В данной статье мы рассмотрим несколько способов, как можно это с делать.
Что такое приоритет процесса?
Приоритет процесса определяет, как часто именно этот процесс, по сравнению с другими запущенными процессами, стоящими в очереди на выполнение, будет исполняться процессором. В ОС Linux значение приоритета процесса варьируется в диапазоне значений от -20 до 19 (т.е. получается 40 возможных значений: -20, -19, -18 . 0, 1, 2 . 19) и называется niceness (сокращенно NI).
Чем меньше это значение, тем выше приоритет будет у такого процесса. Например, если у нас есть один процесс, работающий с приоритетом 10, а другой процесс работающий с приоритетом 15, то в первую очередь будет выполняться процесс приоритетом 10, а уже после него, тот, где приоритет 15. А в ситуации, когда есть 2 процесса и у одного из них приоритет будет равен -20, а у другого равен 10, то в первую очередь процессор будет обрабатывать тот процесс, у которого приоритет равен -20, а уже после тот, у которого приоритет равен 10.
Как узнать приоритет процесса?
С помощью команды top (все запущенные процессы)
Посмотреть приоритет процесса можно с помощью команды top
С помощью команды ps (конкретный процесс(ы) по его имени)
С помощью команды ps (конкретный процесс по его PID)
Задание приоритета при запуске процесса
Для того, чтобы задать приоритет при старте нового процесса, необходимо воспользоваться командой nice
nice -n [значение приоритета] [команда]
Запустить утилиту top с приоритетом 15:
Изменение приоритета у существующего процесса
Для того, чтобы изменить приоритет у существующего процесса (т.е. такого процесса, который ранее был уже запущен), необходимо воспользоваться командой renice
renice [значение приоритета] -p [id процесса]
В противном случае, вы будете получать ошибку примерно такого содержания:
renice: failed to set priority for 91197 (process ID): Permission denied
Мы изменили приоритет у существующего процесса (команда top из предыдущего примера) с 15 на 0.
Была ли эта статья Вам полезна?
Что в статье не так? Пожалуйста, помогите нам её улучшить!Комментарии к статье (5)
Вы работаете под суперпользователем root? Если нет, то используйте команду sudo или su.
Добавил информацию в статью:
При понижении приоритета у процесса, который является вашим (т.е. запущен под той же учетной записью, под которой вы работаете в системе) - права суперпользователя не требуются, НО при повышении приоритета у процесса, требуется запускать команду renice с правами суперпользователя, т.е. с помощью sudo renice.
было бы еще неплохо добавить шпаргалку, как повесить приоритет по умолчанию для какой-нибудь программы, например на тот же mysql
Возможность для пользователя задавать значение приоритета его собственных процессов определяет ваше отношение к другим пользователям системы. Даете ли вы им возможность использовать поцессор или просто злоупотребляете системными ресурсами без достаточных оснований? В этой статье вы узнаете, как управлять процессами в плане потребления ими ресурсов процессора и изменения приоритета ваших процессов, используя команды nice и renice. Мы начнем с азов теории, поговорим о том, что такое процесс, планирование, как создать дочерний процесс. Затем мы перейдем к команде nice и узнаем, как изменить значение приоритета процесса.
2. Что такое процесс
Простыми словами процесс - это соглашение об именовании, используемое в Linux для обозначения роли запущенной программы. Процесс - это набор правил, которым руководствуется данная программа при использовании выделенного процессорного времени, памяти и ресурсов ввода/вывода. Каждый процесс, запущенный в системе Linux, имеет свой ID (PID), по которому его можно отслеживать.
Ядро Linux позволяет собирать различную информацию о каждом процессе, которая включает, но не ограничивается:
- статус процесса ( работает, спит, зомби или остановлен)
- приоритет выполнения процесса
- информация об используемых ресурсах
- владелец процесса
- сетевые порты и файлы, открытые процессом
- и так далее.
Итак, теперь мы кое-что знаем процессах и можем продвинуться дальше и создать какой-нибудь процесс. Чтобы сделать это, просто откройте терминал и выполните команду yes в фоне, перенаправив ее вывод в /dev/null:
После это воспользуемся командой ps -l, чтобы извлечь информацию о нашем процессе:
Из этой таблицы мы можем узнать немало интересного:
F - FLAG: процесс запущен без привилегий суперпользователя. В противном случае мы могли бы увидеть число 4 или сумму 1 и 4. Подробности можно узнать, посмотрев man-страницу ps.
S - STATE: процесс в настоящее время работает.
UID - ID пользователя, инициализировавшего процесс. UID на самом деле является алиасом EUID (Effective User ID)
PID - ID процесса нашей команды yes 5997.
PPID - Parent Process ID. Это ID родительского для нашей команды yes процесса. В нашем случае это bash с PID 5830.
C - загрузка процессора, целое число, выражается в %.
PRI - Приоритет процесса. Большее значение означает меньший приоритет.
NI - Значение Nice, которое находится в диапазоне от -20 до 19. Большее значение означает меньший приоритет.
2.1. Планирование процессов
Если вы не хотите слишком глубоко вникать в детали планирования и приоритета процессов, то можете пропустить этот раздел. Здесь мы сосредоточимся на описании процессов в Linux и попытаемся обобщить некоторые моменты, так как подробное описание их может занять множество страниц.
С нашей точки зрения необходимо понимать, что принцип работы планировщика Linux (для ядра версии >= 2.6) вытесняющий. Под этим понимается способность ядра выбирать среди всех заданий то, которое имеет наивысший приоритет. Далее, ядро делит списки приоритета на задачи реального времени и пользовательские задания, ранжирующиеся от 1 - 100 и 101 - 140 соответственно.
Далее, ядро Linux выделяет задачам с более высоким приоритетом больший квант времени, а задачам с меньшим приоритетам - меньший квант времени, который в среднем составляет 200 и 10 мс соответственно. Другими словами, каждое задание допускается к выполнению только, если у него остается какая-либо часть времени. Поэтому меньший отрезок времени для выполнения означает, что процесс получает меньше времени в очереди выполнения и, соответственно, получает меньше ресурсов. Когда отрезок времени процесса заканчивается, он помещается в очередь выполнения с истекшим временем, затем его приоритет пересчитывается, и он снова помещается в активную очередь выполнения. Эта зависимость иллюстрируется приведенной здесь диаграммой. Важно помнить, что обе очереди выполнения содержат списки задач, отсортированных по их приоритету.
2.2. Жизненный цикл процесса
Основной принцип управления процессами в Linux включает две важные операции, создающие новый процесс. Операция, при которой процесс копирует себя, и тем самым создает новый процесс с уникальным ID, осуществляется при помощи вызова fork(). За ней часто следует операция exec(), запускающая новую программу. Первый процесс, создающийся при загрузке системы, называется init, он всегда получает PID 1. Все остальные процессы считаются дочерними по отношению к процессу init. В нормальных условиях перед завершением дочернего процесса требуется, чтобы родительский процесс послал ему значение exit. При успешном завершении процесса он отправляет родительскому процессу значение 0. Если по каким-либо причинам дочерний процесс пережил родительский, init отмечает его как не имеющий родителей.
3. Использование команды nice
Так как мощь процессоров на протяжении многих лет возрастает в геометрической прогрессии, соответственно уменьшается важность команды nice. В результате сегодня редко приходится вручную изменять приоритет процессов. Тем не менее, такая возможность имеется и она может быть полезной в некоторых ситуациях. По умолчанию nice устанавливает значение приоритета 10.
Чтобы запустить процесс со значением nice, отличным от 10, можно использовать ключ -n.
Чтобы установить значение nice ниже нуля, требуются права суперпользователя. В противном случае будет установлено значение 0. Ниже мы пробуем задать значение nice -1 без прав root:
Поэтому, чтобы задать значение nice меньше 0, необходимо запускать программу как root, или использовать sudo.
4. Использование команды renice
В предыдущем разделе мы узнали, как запускать программу с заданным значением nice. Теперь мы попробуем изменить значение nice у запущенной программы с помощью команды renice. Итак, у нас есть работающая программа yes со значением nice 10:
Чтобы изменить его значение, мы можем использовать команду renice со значением nice и PID процесса. Давайте изменим значение nice на 15:
Также, команда renice позволяет суперпользователю изменять значение nice процессов любого пользователя. Это делается с помощью ключа -u. Следующая команда изменяет значение приоритета всех процессов пользователя на -19:
5. Заключение
Команда nice может быть удобным инструментом и она очень проста в использовании. Пожалуйста, отметьте, что для изменения значения приоритета также может использоваться команда top.
Сначала используйте команду top, чтобы увидеть информацию о текущем процессе:
Получить:
Вы можете видеть, что есть два свойства PR и NI, эти два являются приоритетными и хорошими значениями
Давайте поговорим о том, что означают эти два значения
1.1 хорошее значение
- Значение, которое отражает статус «приоритет» процесса
- Диапазон значений -20
1.2 Приоритетное значение
- Приоритетное значение
- В Linux реализовано 140 диапазонов приоритетов со значениями от 0 до 139
- От 0 до 99 для процессов в реальном времени, от 100 до 139 для процессов не в реальном времени
1.3 Контакт
Сначала мы используем команду nice для указания и запуска нового процесса. Приоритетная команда для установки команды выглядит следующим образом:
Используйте nice, чтобы открыть bash с хорошим значением 10:
Используйте команду ps для просмотра:
Видно, что когда значение nice равно 10, значение Priority изменяется соответственно:
Nice можно рассматривать как статический приоритет, а Priority можно рассматривать как динамический приоритет:
Хорошее значение от -20 до 19 может быть сопоставлено значению приоритета процесса не в реальном времени от 100 до 139 или значению приоритета от 0 до 99 процессов реального времени
2.1 Операционная система реального времени
Сначала посмотрите на операционную систему реального времени:
- Операционная система реального времени (ОСРВ) означает, что когда генерируются внешние события или данные, они могут быть приняты и обработаны с достаточно быстрой скоростью, а результат обработки может быть в течение указанного времени. Чтобы контролировать производственный процесс или быстро реагировать на систему обработки, запланируйте все доступные ресурсы для выполнения задач в реальном времени и управляйте всеми операционными системами, в которых все задачи реального времени работают в гармонии. Обеспечение своевременного реагирования и высокая надежность являются его основными характеристиками
Операционная система реального времени делится на жесткие в реальном времени и мягкие в реальном времени
-Жесткое в реальном времени - это задача, которая должна быть выполнена в указанное время
- мягкое в реальном времени то, что небольшое превышение указанного времени мало влияет на результат
Linux - строго операционная система не в реальном времени, но приоритет от 0 до 99 - это описание процесса в реальном времени, а процесс в реальном времени сопоставляется с 100 приоритетами отдельно во время проектирования ядра, и это более просто Алгоритм планирования для уменьшения затрат на планирование.
Поэтому Linux следует считать мягкой операционной системой реального времени.
Итак, Linux делит процессы на
- прогресс в реальном времени: приоритет 0
99
- процесс не в реальном времени: приоритет 100
3.1 Для планирования процессов в реальном времени
- Тот, кто имеет наивысший приоритет, исполняется первым
- Одинаковый приоритет с SCHED_FIFO и SCHED_RR
- SCHED_FIFO: планирование «первым пришел - первым вышел»
- SCHED_RR: режим вращения временного среза для планирования, длина временного среза составляет 100 мс
Вы можете просматривать и устанавливать статус приоритета процесса в реальном времени с помощью команды chrt.
3.2 Для планирования процессов не в реальном времени
3.2.1 Планирование O1
Согласно буквальному значению, временная сложность алгоритма планирования O1 равна O (1)
Планировщик O1 разработан в соответствии с классической идеей распределения времени, то есть время выполнения ЦП делится на период, процесс с более высоким приоритетом использует больший временной интервал, а процесс с более низким приоритетом использует меньший временной интервал.
Поток обработки планировщика O1:
-
Когда процесс разветвляется, процессу назначается длина временного интервала, а родительский и дочерний процессы поровну делятся на исходный временной интервал процесса (чтобы процесс не использовал метод fork, чтобы у обрабатываемой им задачи всегда был временной интервал); в первом раунде временных интервалов После этого система перераспределяет длину временного интервала (чтобы процесс «потомства» не был слишком коротким и приводил к несправедливости)
Для всех процессов, которые выполняются или находятся в исполняемой очереди, алгоритм O1 поддерживает два процесса организации очереди;
Проверьте процессы, выполняемые на ЦПУ при каждом системном прерывании (Systick, 1000Hz):
Если возникает какая-либо ситуация, состояние выполнения текущего процесса прекращается и помещается в очередь ожидания, а процесс с наивысшим приоритетом выполняется в очереди ожидания.
Процессы, потребляющие процессор и ввод-вывод
Алгоритм O1 делит процессы с одинаковым приятным значением на два типа в зависимости от их загрузки процессора:
1. Потребление ЦП: всегда используйте ЦП для вычислений. Выделенный ему временной интервал всегда будет исчерпан до того, как программа может быть запланирована (различные арифметические операции, Обработка данных)
2. Тип потребления ввода-вывода: часто освобождают ЦП (vim, shell, интерактивный процесс) до того, как интервал времени исчерпан.
Повысить приоритет процессов ввода-вывода
Поскольку процесс, потребляющий ЦП, занимает много времени, процесс, потребляющий ввод-вывод, очень быстро освобождает ЦП.Если используется одно и то же приятное значение, процесс, потребляющий ЦП, будет планироваться каждый раз, когда он потребляет
Таким образом, ядро будет наблюдать за состоянием использования процессора процессом и динамически регулировать значение приоритета. Диапазон регулировки составляет + -5, чтобы увеличить приоритет потребления ввода-вывода и уменьшить приоритет потребления процессора. Чувство заикания
Вот почему Приоритет называется динамическим приоритетом
3.2.2 Планирование CFS
Из-за O1 производительность многоядерных и многопроцессорных систем не очень хорошая. После Linux 2.6.23 CFS был включен как метод планирования для процессов с общим приоритетом (SCHED_OTHER).
Основная идея: n процессов, выполнение n процессов за относительно короткое время
Меньшее время = максимальное время задержки для процессов, которые должны быть запланированы в состоянии R (очередь выполнения или исполняемая очередь)
Чем больше процессов, тем меньше времени процесс выполняется в цикле.
Планировщик поддерживает общее количество процессорных времен для всех процессов: vruntime
Все ожидающие процессы помещаются в очередь, состоящую из красного и черного деревьев с ключом vruntime. Каждый процесс, запланированный для выполнения, представляет собой процесс в самом левом поддереве красного и черного дерева (то есть процесс с наименьшим временем vruntime).
Планировщик CFS выполняет проверки планирования в прерывании тактового сигнала. Время планирования может быть суммировано как:
- Переход состояния текущего процесса в основном относится к тому, когда текущий процесс завершается и завершается или процесс переходит в спящий режим.
- Когда текущий процесс активно отказывается от процессора
- Когда время текущего процесса превышает идеальное время заполнения каждого фонда
- Диспетчерская проверка происходит, когда процесс возвращается из прерывания, исключения или системного вызова.
Приоритет CFS
- Для CFS приоритет определяется скоростью потребления времени (рост vruntime)
- Скорость увеличения времени различна для разных процессов более низкого уровня: процесс с высоким приоритетом замедляется, а время с низким приоритетом увеличивается.
- Например, процесс с приоритетом 19 потребляет 1 с ЦП, а записи vruntime 1 с, но процесс с приоритетом -20 может занимать 10 с ЦП, а записи vruntime 1 с.
- Разница во времени использования ЦП для каждого уровня составляет 10%. Расчетный результат помещается в массив. При использовании он напрямую берется из массива для сокращения времени использования ЦП.
Минимальное время использования процессора
CFS разработал параметр sched_min_granularity_ns, который используется для установки минимального времени использования ЦП после того, как запланировано выполнение процесса. После того, как запланировано выполнение процесса, он должен выполняться как минимум в течение этого времени, прежде чем произойдет переключение планирования.
Ожидаемое время задержки
Независимо от того, сколько процессов должно быть выполнено, все они имеют ожидаемое время задержки, то есть sched_latency_ns, то есть каждый n процессов выполняется в течение этого времени.
Если число процессов велико, среднее время ЦП, потребляемое каждым процессом, равно sched_latency_ns / n, а sched_min_granularity_ns используется для ограничения минимального времени выполнения.
Vruntime значение нового процесса
CFS поддерживает значение min_vruntime для каждой очереди выполнения ЦП, которое записывает минимальное значение vruntime в очереди выполнения ЦП.
Когда новый процесс появляется в очереди, его vruntime инициализации не будет установлен в 0, но будет установлен на основе значения min_vruntrme
CFS-обработка процессов ввода-вывода
Поскольку процесс ввода-вывода занимает короткое время ЦП, время выполнения процесса остается тем же во время режима гибернации. После пробуждения режима гибернации время выполнения процесса будет намного меньше, чем у других процессов.
Поэтому CFS выполняет компенсацию времени для процессов, требующих ввода-вывода:
Если процесс был разбужен из спящего режима и значение атрибута GENTLE_FAIR_SLEEPERS равно true, тогда для vruntime установлено значение MAX (sched_latency_ns / 2, vruntime)
Другие стратегии планирования для CFS
- SCHED_BATCH: рассматривать процессы только как процессорные
- SCHED_IDLE: Планировщик считает этот приоритет низким, более низким, чем приоритет с хорошим значением 19.
Преимущества CFS перед O1:
При многоядерности каждое ядро поддерживает очередь планирования, и каждый ЦП может планировать свой собственный процесс очереди.
Одна очередь на процессор может избежать использования больших блокировок ядра в глобальной очереди, что повышает эффективность параллельной работы.
Читайте также: