Продолжаем тему многопоточности в ядре Linux. В прошлый раз я рассказывала про прерывания, их обработку и tasklet’ы, и так как изначально предполагалось, что это будет одна статья, в своем рассказе о workqueue я буду ссылаться на tasklet’ы, считая, что читатель уже с ними знаком.
Как и в прошлый раз, я постараюсь сделать мой рассказ максимально подробным и детальным.
Статьи цикла:
- Многозадачность в ядре Linux: прерывания и tasklet’ы
- Многозадачность в ядре Linux: workqueue
- Protothread и кооперативная многозадачность
Workqueue
Workqueue — это более сложные и тяжеловесные сущности, чем tasklet’ы. Я даже не буду пытаться описать здесь все тонкости реализации, но самое важное, надеюсь, я разберу более или менее подробно.
Workqueue, как и tasklet’ы, служат для отложенной обработки прерываний (хотя их можно использовать и для других целей), но, в отличие от tasklet’ов, выполняются в контексте kernel-процесса, соответственно, они не обязаны быть атомарными и могут использовать функцию sleep(), различные средства синхронизации и т.п.
Давайте сначала разберемся, как в целом организован процесс обработки workqueue. На картинке он показан очень приближенно и упрощенно, как все происходит на самом деле, подробно описано ниже.
В этом темном деле замешаны несколько сущностей.
Во-первых, work item (для краткости просто work) — это структура, описывающая функцию (например, обработчик прерывания), которую мы хотим запланировать Его можно воспринимать как аналог структуры tasklet. Tasklet’ы при планировании добавлялись в очереди, скрытые от пользователя, теперь же нам нужно использовать специальную очередь — workqueue.
Tasklet’ы разгребаются функцией-планировщиком, а workqueue обрабатывается специальными потоками, которые зовутся worker’ами.
Worker’ы обеспечивают асинхронное исполнение work’ов из workqueue. Хотя они вызывают work’и в порядке очереди, в общем случае о строгом, последовательном выполнении речи не идет: все-таки здесь имеют место вытеснение, сон, ожидание и т.д.
Вообще, worker’ы — это kernel-потоки, то есть ими управляет основной планировщик ядра Linux. Но worker’ы частично вмешиваются в планирование для дополнительной организации параллельного исполнения work’ов. Про это подробнее пойдет ниже.
Чтобы очертить основные возможности механизма workqueue, я предлагаю изучить API.
Про очередь и ее создание
alloc_workqueue(fmt, flags, max_active, args...)
Параметры fmt и args — это printf-формат для имени и аргументы к нему. Параметр max_activate отвечает за максимальное число work’ов, которые из этой очереди могут исполняться параллельно на одном CPU.
Очередь можно создать со следующими флагами:
- WQ_HIGHPRI
- WQ_UNBOUND
- WQ_CPU_INTENSIVE
- WQ_FREEZABLE
- WQ_MEM_RECLAIM
Особое внимание следует уделить флагу WQ_UNBOUND. По наличию этого флага очереди делятся на привязанные и непривязанные.
В привязанных очередях work’и при добавлении привязываются к текущему CPU, то есть в таких очередях work’и исполняются на том ядре, которое его планирует. В этом плане привязанные очереди напоминают tasklet’ы.
В непривязанных очередях work’и могут исполняться на любом ядре.
Важным свойством реализации workqueue в ядре Linux является дополнительная организация параллельного исполнения, которая присутствует у привязанных очередей. Про нее подробнее написано ниже, сейчас скажу, что осуществляется таким образом, чтобы использовалось как можно меньше памяти, и чтобы при этом процессор не простаивал. Реализовано это все с предположением, что один work не использует слишком много тактов процессора.
Для непривязанных очередей такого нет. По сути, такие очереди просто предоставляют work’ам контекст и запускают их как можно раньше.
Таким образом, непривязанные очереди следует использовать, если ожидается интенсивная нагрузка на процессор, так как в таком случае планировщик позаботится о параллельном исполнении на нескольких ядрах.
По аналогии с tasklet’ами, work’ам можно присваивать приоритет исполнения, нормальный или высокий. Приоритет общий на всю очередь. По умолчанию очередь имеет нормальный приоритетом, а если задать флаг WQ_HIGHPRI, то, соответственно, высокий.
Флаг WQ_CPU_INTENSIVE имеет смысл только для привязанных очередей. Этот флаг — отказ от участия в дополнительной организации параллельного исполнения. Этот флаг следует использовать, когда ожидается, что work’и будут расходовать много процессорного времени, в этом случае лучше переложить ответственность на планировщик. Про это подробнее написано ниже.
Флаги WQ_FREEZABLE и WQ_MEM_RECLAIM специфичны и выходят за рамки темы, поэтому подробно на них останавливаться не будем.
Иногда есть смысл не создавать свои собственные очереди, а использовать общие. Основные из них:
- system_wq — привязанная очередь для быстрых work’ов
- system_long_wq — привязанная очередь для work’ов, которые предположительно будут исполняться долго
- system_unbound_wq — непривязанная очередь
Про work’и и их планирование
Теперь разберемся с work’ами. Сначала взглянем на макросы инициализации, декларации и подготовки:
DECLARE(_DELAYED)_WORK(name, void (*function)(struct work_struct *work)); /* на этапе компиляции */
INIT(_DELAYED)_WORK(_work, _func); /* во время исполнения */
PREPARE(_DELAYED)_WORK(_work, _func); /* для изменения исполняемой функции */
В очереди work’и добавляются с помощью функций:
bool queue_work(struct workqueue_struct *wq, struct work_struct *work);
bool queue_delayed_work(struct workqueue_struct *wq, struct delayed_work *dwork, unsigned long delay); /* work будет добавлен в очередь только по истечению delay */
Вот на этом стоит остановиться поподробнее. Хотя мы в качестве параметра указываем очередь, на самом деле, work’и кладутся не в сами workqueue, как это может показаться, а в совершенно другую сущность — в список-очередь структуры worker_pool. Структура worker_pool, по сути, самая главная сущность в организации механизма workqueue, хотя для пользователя она остается за кулисами. Именно с ними работают worker’ы, и именно в них содержится вся основная информация.
Теперь посмотрим, какие пулы есть в системе.
Для начала пулы для привязанных очередей (на картинке). Для каждого CPU статически выделяются два worker pool: один для высокоприоритетных work’ов, другой — для work’ов с нормальным приоритетом. То есть, если ядра у нас четыре, то привязанных пулов будет всего восемь, не смотря на то, что workqueue может быть сколько угодно.
Когда мы создаем workqueue, у него для каждого CPU выделяется служебный pool_workqueue (pwq). Каждый такой pool_workqueue ассоциирован с worker pool, который выделен на том же CPU и соответствует по приоритету типу очереди. Через них workqueue взаимодействует с worker pool.
Worker’ы исполняют work’и из worker pool без разбора, не различая, к какому workqueue они принадлежали изначально.
Для непривязанных очередей worker pool’ы выделяются динамически. Все очереди можно разбить на классы эквивалентности по их параметрам, и для каждого такого класса создается свой worker pool. Доступ к ним осуществляется с помощью специальной хэш-таблицы, где ключом служит набор параметров, а значением, соответственно, worker pool.
На самом деле у непривязанных очередей все немножко сложнее: если у привязанных очередей создавались pwq и очереди для каждого CPU, то здесь они создаются для каждого узла NUMA, но это уже дополнительная оптимизация, которую в деталях рассматривать не будем.
Всякие мелочи
Еще приведу несколько функций из API для полноты картины, но подробно о них говорить не буду:
/* Принудительное завершение */
bool flush_work(struct work_struct *work);
bool flush_delayed_work(struct delayed_work *dwork);
/* Отменить выполнение work */
bool cancel_work_sync(struct work_struct *work);
bool cancel_delayed_work(struct delayed_work *dwork);
bool cancel_delayed_work_sync(struct delayed_work *dwork);
/* Удалить очередь */
void destroy_workqueue(struct workqueue_struct *wq);
Как worker’ы справляются со своей работой
Теперь, как мы познакомились с API, давайте попробуем подробнее разобраться, как это все работает и управляется.
У каждого пула есть набор worker’ов, которые разгребают задачи. Причем, количество worker’ов меняется динамически, подстраиваясь под текущую ситуацию.
Как мы уже выяснили, worker’ы — это потоки, которые в контексте ядра выполняют work’и. Worker достает их по порядку один за другим из ассоциированного с ним worker pool, причем work’и, как мы уже знаем, могут принадлежать к разным исходным очередям.
Worker’ы условно могут находиться в трех логических состояниях: они могут быть простаивающими, запущенными или управляющими.
Worker может простаивать и ничего не делать. Это, например, когда все work’и уже исполняются. Когда worker переходит в это состояние, он засыпает и, соответственно, не будет исполняться до тех пор, пока его не разбудят;
Если не требуется управление пулом и список запланированных work’ов не пуст, то worker начинает исполнять их. Такие worker’ы условно будем называть запущенными.
Если же необходимо, worker берет на себя роль управляющего пулом. У пула может быть либо только один управляющий worker, либо не быть его вообще. Его задача — поддерживать оптимальное число worker’ов на пул. Как он это делает? Во-первых, удаляются worker’ы, которые достаточно долго простаивают. Во-вторых, создаются новые worker’ы, если выполняются сразу три условия:
- еще есть задачи на выполнение (work’и в пуле)
- нет простаивающих worker’ов
- нет работающих worker’ов (то есть активных и при этом не спящих)
Однако, в последнем условии есть свои нюансы. Если очереди пула непривязанные, то учет запущенных worker’ов не осуществляется, для них это условие всегда истинно. То же самое справедливо и в случае выполнения worker’ом задачи из привязанной, но с флагом WQ_CPU_INTENSIVE, очереди. При этом, в случае привязанных очередей, так как worker’ы работают с work’ами из общего пула (который один из двух на каждое ядро на картинке выше), то получается, что некоторые из них учитываются как работающие, а некоторые — нет. Из этого же следует, что выполнение work’ов из WQ_CPU_INTENSIVE очереди может начаться не сразу, зато сами они не мешают исполняться другим work’ам. Теперь должно быть понятно, почему это флаг так называется, и почему он используется, когда мы ожидаем, что work’и будут выполняться долго.
Учет работающих worker’ов осуществляется прямо из основного планировщика ядра Linux. Такой механизм управления обеспечивает оптимальный уровень параллельности (concurrency level), не давая workqueue создавать слишком много worker’ов, но и не заставляя work’и без нужды ждать слишком долго.
Те, кому интересно, могут посмотреть функцию worker’а в ядре, называется она worker_thread().
Со всеми описанными функциями и структурами можно подробнее ознакомиться в файлах include/linux/workqueue.h, kernel/workqueue.c и kernel/workqueue_internal.h. Также по workqueue есть документация в Documentation/workqueue.txt.
Еще стоит отметить, что механизм workqueue используется в ядре не только для отложенной обработки прерываний (хотя это довольно частый сценарий).
Таким образом, мы рассмотрели механизмы отложенной обработки прерываний в ядре Linux — tasklet и workqueue, которые представляют собой особую форму многозадачности. Про прерывания, tasklet’ы и workqueue можно почитать в книге "Linux Device Drivers" авторов Jonathan Corbet, Greg Kroah-Hartman, Alessandro Rubini, правда, информация там временами устаревшая.
В комментарии Zyoma к статье про tasklet’ы также советуется «Ядро Linux. Описание процесса разработки» Р. Лава.
Продолжение следует
В следующей части я расскажу про protothread и кооперативную многозадачность, попробую сравнить все рассмотренные, на первый взгляд, разные сущности и извлечь какие-нибудь полезные идеи.
Автор: LifeV
