Семафоры Posix, размещаемые в памяти Мы измеряем скорость работы семафоров Posix (именованных и размещаемых в памяти). В листинге А.24 приведен текст функции main, а в листинге А.23 - текст функции incr.Листинг А.23. Увеличение счетчика с использованием семафоров Posix в

Именованные семафоры Posix В листинге А.26 приведен текст функции main, измеряющей быстродействие именованных семафоров Posix, а в листинге А.25 - соответствующая функция incr.Листинг А.25. Увеличение общего счетчика с использованием именованного семафора Posix//bench/incr_pxsem2.c40 void

Семафоры System V Функция main программы, измеряющей быстродействие семафоров System V, приведена в листинге А.27, а функция incr показана в листинге А.28.Листинг А.27. Функция main для измерения быстродействия семафоров System V//bench/incr_svsem1.c1 #include "unpipc.h"2 #define MAXNTHREADS 1003 int nloop;4 struct {5 int

26.6. Семафоры Семафор - это объект IPC, управляющий доступом к общим ресурсам (устройствам). Семафоры не позволяют одному процессу захватить устройство до тех пор, пока с этим устройством работает другой процесс. Семафор может находиться в двух положениях: 0 (устройство

Семафоры Давайте переместимся из ванной комнаты на кухню, так как это социально адаптированное помещение для одновременного обитания более чем одного человека. На кухне вы можете не пожелать, чтобы все и каждый находились бы там одновременно. В действительности вы бы,

4.4.2. Исключающие семафоры Решение проблемы гонки заключается в том, чтобы позволить только одному потоку обращаться к очереди в конкретный момент времени. Когда поток начинает просматривать очередь, все остальные потоки вынуждены дожидаться, пока он удалит очередное

4.4.5. Обычные потоковые семафоры В предыдущем примере, в котором группа потоков обрабатывает задания из очереди, потоковая функция запрашивает задания до тех пор, пока очередь не опустеет, после чего поток завершается. Эта схема работает в том случае, когда все задания

5.2. Семафоры для процессов Как говорилось в предыдущем разделе, процессы должны координировать свои усилия при совместном доступе к памяти. Вспомните: в разделе 4.4.5, "Обычные потоковые семафоры", рассказывалось о семафорах, которые являются счетчиками, позволяющими

Семафоры Для синхронизации процессов, а точнее, для синхронизации доступа нескольких процессов к разделяемым ресурсам, используются семафоры. Являясь одной из форм IPC, семафоры не предназначены для обмена большими объемами данных, как в случае FIFO или очередей сообщений.

Семафоры В операционной системе Linux семафоры (semaphore) - это блокировки, которые переводят процессы в состояние ожидания. Когда задание пытается захватить семафор, который уже удерживается, семафор помещает это задание в очередь ожидания (wait queue) и переводит это задание в

Семафоры чтения-записи Семафоры, так же как и спин-блокировки, могут быть типа чтения-записи. Ситуации, в которых предпочтительнее использовать семафоры чтения-записи такие же как и в случае использования спин-блокировок чтения-записи.Семафоры чтения-записи

Реализация семафоров в Linux

Теперь, когда вы увидели, что такое семафоры и как они действуют в теории, можно рассмотреть, как их свойства реализованы в ОС Linux. Интерфейс тщательно проработан и предлагает гораздо больше возможностей, чем обычно требуется. Все функции семафоров в Linux оперируют массивами семафоров общего вида, а не одним двоичным семафором. На первый взгляд кажется, что такой подход все усложняет, но если процесс нуждается в блокировке нескольких ресурсов, способность оперировать массивом семафоров - большое подспорье. В этой главе мы сосредоточимся на применении одиночных семафоров, поскольку в большинстве случаев это все, что вам нужно.

#include

int semctl(int sem_id, int sem_num, int command, ...);

Примечание

Обычно заголовочный файл sys/sem.h опирается на два других заголовочных файла: sys/types.h и sys/ipc.h. Как правило, они автоматически включаются в программу файлом sys/sem.h и вам не нужно задавать их явно в директивах # include .

Прорабатывая каждую функцию отдельно, помните о том, что все они спроектированы для использования массивов значений семафоров, что делает их работу существенно более сложной, чем та, что необходима для обработки одного семафора.

Обратите внимание на то, что параметр key действует во многом как имя файла, т.к. он тоже представляет ресурс, который программы могут использовать и кооперироваться при этом, если соблюдают соглашение об общем имени для него. Аналогичным образом идентификатор, возвращаемый функцией semget и применяемый другими функциями, совместно использующими память, очень похож на файловый поток FILE* , возвращаемый функцией fopen и представляющий собой значение, применяемое процессом для доступа к совместно используемому файлу. Как и в случае файлов, у разных процессов будут разные идентификаторы семафоров, несмотря на то, что они ссылаются на один и тот же семафор. Такое применение ключа и идентификаторов - общее для всех средств IPC, обсуждаемых здесь, несмотря на то, что каждое средство применяет независимые ключи и идентификаторы.

Функция semget создает новый семафор или получает ключ существующего семафора.

int semget(key_t key, int num_sems, int sem_flags);

Первый параметр key - целочисленное значение, позволяющее несвязанным процессам обращаться к одному и тому же семафору. Ко всем семафорам осуществляется непрямой доступ с помощью программы, предоставляющей ключ, для которого система затем генерирует идентификатор семафора. Ключ семафора применяется только в функции semget . Все остальные функции семафора используют идентификатор семафора, возвращаемый функцией semget .

Существует особое значение ключа семафора IPC_PRIVATE , которое предназначено для создания семафора, доступ к которому получает только процесс-создатель, но такой семафор редко бывает полезен. Для создания нового семафора следует задавать уникальное ненулевое целое число.

Параметр num_sems определяет количество требуемых семафоров. Почти всегда он равен 1.

Параметр sem_flags - набор флагов, очень похожих на флаги функции open. Младшие девять байтов - права доступа к семафору, ведущие себя, как права доступа к файлу. Кроме того, для создания нового семафора с помощью поразрядной операции OR их можно объединить со значением IPC_CREAT . Не считается ошибкой наличие флага IPC_CREAT и задание ключа существующего семафора. Флаг IPC_CREAT безмолвно игнорируется, если в нем нет нужды. Можно применять флаги IPC_CREAT и IPC_EXCL для гарантированного получения нового уникального семафора. Если семафор уже существует, функция вернет ошибку.

Функция semget вернет в случае успеха положительное (ненулевое) значение, представляющее собой идентификатор, применяемый остальными функциями семафора. В случае ошибки возвращается -1.

Функция semop применяется для изменения значения семафора.

int semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops);

Первый параметр sem_id - идентификатор семафора, возвращенный функцией semget . Второй параметр sem_ops - указатель на массив структур, у каждой из которых есть, по крайней мере, следующие элементы:

struct sembuf {

short sem_num;

short sem_op;

short sem_flg;

Первый параметр sem_num - номер семафора, обычно 0, если вы не работаете с массивом семафоров. Элемент sem_op - значение, на которое должен изменяться семафор. (Вы можете увеличивать и уменьшать семафор на значения, не равные 1.) Как правило, применяются только два значения: -1 для операции P , заставляющей ждать, пока семафор не станет доступен, и +1 для операции V , оповещающей о том, что в данный момент семафор доступен.

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

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

Функция semctl позволяет напрямую управлять данными семафора.

int semctl (int sem_id, int sem_num, int command, ...);

Первый параметр sem_id - идентификатор семафора, полученный от функции semget . Параметр sem_num - номер семафора. Он применяется при работе с массивом семафоров. Обычно этот параметр равен 0, первый и единственный семафор. Параметр command - предпринимаемое действие, и четвертый параметр, если присутствует, - union (объединение) типа semun , которое в соответствии со стандартом X/Open должно содержать как минимум следующие элементы:

union semun {

int val;

struct semid_ds *buf;

unsigned short *array;

В большинстве версий ОС Linux определение объединения semun включено в заголовочный файл (обычно sem.h), несмотря на то, что стандарт X/Open настаивает на том, что вы должны привести собственное объявление. Если вы поймете, что должны объявить его самостоятельно, проверьте, нет ли объявления этого объединения на страницах интерактивного справочного руководства, относящихся к функции semctl . Если вы найдете его, мы полагаем, что вы примените определение из вашего справочного руководства, даже если оно отличается от приведенного на страницах этой книги.

Существует множество разных значений параметра command, допустимых в функции semctl . Обычно применяются два из них, которые описаны далее. Более подробную информацию о функции semctl см. в интерактивном справочном руководстве.

Два часто используемых значения command таковы:

SETVAL - применяется для инициализации семафора с заданным значением. Это значение передается как элемент val объединения semun . Такое действие необходимо для того, чтобы увеличить значение семафора перед первым его применением;

IPC_RMID - применяется для удаления идентификатора семафора, когда он больше не нужен.

Функция semctl возвращает разные значения, зависящие от параметра command . Если значение команды - IPC_RMID , функция в случае успешного завершения вернет 0 и -1 в противном случае.

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

В этой статье мы начнём обсуждение различных типов блокировок, доступных при программировании модулей ядра.

Типы блокировок

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

Принципиально другой вид блокировок —активные блокировки — появился вместе с SMP системами, когда процессор, ожидая освобождения недоступного ресурса, не переводится в блокированное состояние, а выполняет пустые циклы. В этом случае, процессор не освобождается для выполнения другого ожидающего процесса в системе, а продолжает активное выполнение ("пустых" циклов) в контексте текущей ветви исполнения.

Эти два типа блокировок (каждый из которых включает несколько подвидов) принципиально отличаются по ключевым параметрам:

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

Семафоры (мьютексы)

Семафоры ядра определены в файле . Так как задачи, конфликтующие при захвате блокировки, переводятся в состояние ожидания и в этом состоянии ожидают освобождения блокировки, то семафоры хорошо подходят для блокировок, которые могут удерживаться в течение длительного времени. С другой стороны, семафоры не очень пригодны для блокировок, которые удерживаются в течение короткого интервала, так как накладные затраты на перевод процессов в состояние ожидания могут превысить время, в течение которого удерживается блокировка. Кроме того, существует и явное ограничение на использование семафоров в ядре, так как их невозможно использовать в коде, который не должен переходить в блокированное состояние, например, при обработке верхней половины прерываний.

Спин-блокировки позволяют удерживать блокировку только одной задачи в любой момент времени, но для семафора количество задач (count), которые разрешено одновременно удерживать с его помощью (владеть семафором), может быть задано при декларации переменной семафора в соответствующем поле структуры:

Если значение count больше 1, то семафор называется счетным семафором и допускает количество потоков, которые одновременно удерживают блокировку, не больше, чем значение счетчика использования (count). Встречается ситуация, когда разрешенное количество потоков, которые одновременно могут удерживать семафор, равно 1 (как и для спин-блокировок), и такие семафоры называются бинарными или взаимоисключающими блокировками (mutex, мютекс, потому что он гарантирует взаимоисключающий доступ — mutual exclusion). Бинарные семафоры (мьютексы) чаще всего используются для обеспечения взаимоисключающего доступа к фрагментам кода, называемым критической секцией.

Независимо от того, определено ли поле владельца, захватившего мютекс (так как это делается по разному в различных POSIX-совместимых ОС), принципиальными особенностями мютекса, в отличии от счётного семафора будет то, что:

1. у захваченного мютекса всегда будет единственный владелец, захвативший его;
2. освободить блокированные на мютексе потоки (освободить мютекс) может только один владеющий мютексом поток.

В случае счётного семафора освободить потоки, блокированные на семафоре, может любой из потоков, владеющий семафором.

Статическое определение и инициализация семафоров выполняется макросом:

Для создания взаимоисключающей блокировки (mutex) есть более короткий синтаксис:

— где в обоих случаях name — это имя переменной типа семафор.

Но чаще всего семафоры создаются динамически, как составная часть более крупных структур данных. В таком случае для инициализации счётного семафора используется функция:

А для инициализации бинарных семафоров (мютексов) используются макросы:

В ОС Linux для захвата семафора (мютекса) используется операция down() , уменьшающая его счетчик на единицу. Если значение счетчика больше или равно нулю, то блокировка захвачена успешно и задача может входить в критический участок. Если значение счетчика (после декремента) меньше нуля, то задание помещается в очередь ожидания и процессор переходит к выполнению других задач. Метод up() используется для того, чтобы освободить семафор (после завершения выполнения критического участка), его выполнение увеличивает счётчик семафора на единицу, при этом один из имеющихся заблокированных потоков может захватить блокировку (принципиальным является то, что невозможно повлиять на то, какой конкретно поток из числа заблокированных будет выбран). Ниже перечислены другие операции над семафорами.

• void down(struct semaphore *sem) — переводит задачу в блокированное состояние ожидания с флагом TASK_UNINTERRUPTIBLE . В большинстве случаев это нежелательно, так как процесс, который ожидает освобождения семафора, не будет отвечать на сигналы.
• int down_interruptible(struct semaphore *sem) — выполняет попытку захватить семафор. Если эта попытка неудачна, то задача переводится в блокированное состояние с флагом TASK_INTERRUPTIBLE (в структуре задачи). Такое состояние процесса означает, что задание может быть возвращено к выполнению с помощью сигнала, а такая возможность обычно очень ценна. Если сигнал приходит в то время, когда задача блокирована на семафоре, то задача возвращается к выполнению, а функция down_interruptible() возвращает значение — EINTR .
• int down_trylock(struct semaphore *sem) — используется для неблокирующего захвата семафора. Если семафор уже захвачен, то функция немедленно возвращает ненулевое значение. В случае успешного захвата семафора возвращается нулевое значение и захватывается блокировка.
• int down_timeout(struct semaphore *sem, long jiffies) — используется для попытки захвата семафора на протяжении интервала времени jiffies системных тиков.

Спин-блокировки

Блокирующая попытка входа в критическую секцию при использовании семафоров означает потенциальный перевод задачи в блокированное состояние и переключение контекста, что является дорогостоящей операцией. Спин-блокировки (spinlock_t) используются для синхронизации в случаях, когда:

• контекст выполнения не позволяет переходить в блокированное состояние (контекст прерывания);
• или требуется кратковременная блокировка без переключение контекста.

Они представляют собой активное ожидание освобождения в пустом цикле. Если необходимость синхронизации связана только с наличием в системе нескольких процессоров, то для небольших критических секций следует использовать спин-блокировку, основанную на простом ожидании в цикле. Спин-блокировка может быть только бинарной. Определения, относящиеся к spinlock_t , распределены по нескольким заголовочным файлам:

Для инициализации spinlock_t и родственного типа rwlock_t , о котором будет подробно рассказано ниже, раньше (и в литературе) использовались макросы:

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

Эти макросы представляют собой статические определения отдельных (автономных) переменных типа spinlock_t . И так же, как и для других примитивов, возможна динамическая инициализация ранее объявленной переменной (чаще всего эта переменная является полем в составе более сложной структуры):

Основной интерфейс spinlock_t содержит пару вызовов для захвата и освобождения блокировки:

Если при компиляции ядра не было активировано SMP (использование многопроцессорности) и не сконфигурировано вытеснение кода в ядре (обязательно выполнение обоих условий), то spinlock_t вообще не компилируются (и на их месте останутся пустые места) за счёт препроцессорных директив условной трансляции.

Примечание : В отличие от реализаций в некоторых других операционных системах, спин-блокировки в операционной системе Linux не рекурсивны. Это означает, что показанный ниже код автоматически приведёт к ситуации deadlock (процессор будет бесконечно выполнять этот фрагмент и произойдёт деградация системы, так как число процессоров, доступных в системе, уменьшится):

Рекурсивный захват спин-блокировки может неявно произойти в обработчике прерываний, поэтому перед захватом такой блокировки нужно запретить прерывания на локальном процессоре. Это общий случай, поэтому для него предоставляется специальный интерфейс:

Для спин-блокировки определены ещё такие вызовы, как:

• int spin_try_lock(spinlock_t *sl) — попытка захвата без блокирования, если блокировка уже захвачена, функция возвратит ненулевое значение;
• int spin_is_locked(spinlock_t *sl) — возвращает ненулевое значение, если блокировка в данный момент захвачена.

Блокировки чтения-записи

Особым, но часто встречающимся, случаем синхронизации являются сценарий "чтения-записи". "Читатели" только считывают состояние некоторого ресурса, и поэтому могу иметь к нему совместный параллельный доступ. "Писатели" изменяют состояние ресурса, и поэтому писатель должен иметь к ресурсу монопольный доступ, причем чтение ресурса для всех читателей в этот момент времени так же должно быть заблокировано. Для реализации блокировок чтения-записи в ядре Linux существуют отдельные версии семафоров и спин-блокировок. Мьютексы реального времени не имеют реализации, подходящей для использования в данном сценарии.

Примечание : Обратим внимание на то, что в точности той же функциональности можно достичь, используя классические примитивы синхронизации (мьютекс или спин-блокировку), просто захватывая критический участок независимо от типа предстоящей операции. Блокировки чтения-записи введены из соображений эффективности реализации для массового сценария такого использования.

Для семафоров вместо структуры struct semaphore вводится структура struct rw_semaphore , а набор интерфейсных функций для захвата/освобождения (простые down() / up()) расширяется до:

• down_read(&rwsem) — попытка захватить семафор для чтения;
• up_read(&rwsem — освобождение семафора для чтения;
• down_write(&rwsem) — попытка захватить семафор для записи;
• up_write(&rwsem) — освобождение семафора для записи;

Семантика этих операций следующая:

• если семафор ещё не захвачен, то любой захват (down_read() или down_write()) будет успешным (без блокирования);
• чтения , то последующие попытки захвата семафора для чтения (down_read()) будут завершаться успешно (без блокирования), но запрос на захват такого семафора для записи (down_write()) закончится блокированием;
• если семафор захвачен уже для записи , то любая последующая попытка захвата семафора (down_read() или down_write()) закончится блокированием;

Статически определенный семафор чтения-записи создаётся макросом:

Семафоры чтения-записи, которые создаются динамически, должны быть инициализированы с помощью функции:

Примечание : Из описания инициализации видно, что семафоры чтения-записи являются исключительно бинарными (не счётными), то есть (в терминологии Linux) фактически не семафорами, а мютексами.

Ниже представлен пример того, как семафоры чтения-записи могут быть использованы при работе (обновлении и считывании) циклических списков Linux (о которых мы говорили ранее):

Точно так же, как это сделано для семафоров, вводится и блокировка чтения-записи для спин-блокировки:

С набором операций:

Примечание : Если при компиляции ядра не было установлено SMP и не сконфигурировано вытеснение кода в ядре, то spinlock_t вообще не скомпилируются (на их месте останутся пустые места), а, значит, и соответствующие им rwlock_t .

Также, блокировку, захваченную для чтения, уже нельзя далее повысить до блокировки, захваченной для записи.:

Такая последовательностью операторов гарантирует возникновение deadlock, так как при захвате блокировки на запись будет выполняться периодическая проверка, пока все потоки, которые захватили блокировку для чтения, ее не освободят, это касается и текущего потока, который не сможет сделать этого никогда...

Но несколько потоков чтения могут безопасно захватывать одну и ту же блокировку чтения-записи, поэтому один поток также может безопасно рекурсивно захватывать одну и ту же блокировку для чтения несколько раз, например в обработчике прерываний без запрета прерываний.

Заключение

На момент создания механизма блокировок чтения-записи с их внедрением связывали значительное повышение производительности, и они вызывали заметный энтузиазм разработчиков. Но последующая практика показала, что этому механизму присуща скрытая опасность того, что при высокой и равномерной плотности запросов чтения, запрос на модификацию (запись) структуры записи может отсрочиваться на неограниченно большие интервалы времени. Об этой особенности нужно помнить, оценивая возможность применения этого механизма в своём коде. Частично смягчить это ограничение пытается следующий подвид блокировок - сериальные блокировки, которые мы рассмотрим в следующей статье.

В теории операционных систем семафор представляет собой неотрицательную целую переменную, над которой возможны два вида операций: P и V .

• P -операция над семафором представляет собой попытку уменьшения значения семафора на 1. Если перед выполнением P -операции значение семафора было больше 0, P -операция выполняется без задержек. Если перед выполнением P -операции значение семафора было 0, процесс, выполняющий P -операцию, переводится в состояние ожидания до тех пор, пока значение семафора не станет большим 0.
• V -операция над семафором представляет собой увеличение значения семафора на 1. Если при этом имеются процессы, задержанные на выполнении P -операции на данном семафоре, один из этих процессов выходит из состояния ожидания и может выполнить свою P -операцию.

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

Взаимное исключение на семафоре

Для реализации взаимного исключения, например, предотвращения возможности одновременного изменения двумя или более процессами общих данных, создается двоичный (с возможными значениями 0 и 1) семафор S . Начальное значение этого семафора - 1. Критические секции кода (секции, которые могут одновременно выполняться только одним процессом) обрамляются "скобками" P(S) (в начале секции) и V(S) (в конце секции). Процесс, входящий в критическую секцию, выполняет операцию P(S) и переводит семафор в 0. Если в критической секции уже находится другой процесс, то значение семафора уже 0, тогда второй процесс, желающий войти в критическую секцию, блокируется в своей P -операции до тех пор, пока процесс, находящийся в критической секции сейчас, не выйдет из нее, выполнив на выходе операцию V(S) .

Синхронизация на семафоре

Для обеспечения синхронизации создается двоичный семафор S с начальным значением 0. Значение 0 означает, что событие, еще не наступило. Процесс, сигнализирующий о наступлении события, выполняет операцию V(S) , устанавливающую семафор в 1. Процесс, ожидающий наступления события, выполняет операцию P(S) . Если к этому моменту событие уже произошло, ожидающий процесс продолжает выполняться, если же событие еще не произошло, процесс переводится в состояние ожидания до тех пор, пока сигнализирующий процесс не выполнит V(S) .

В случае, если одного и того же события ожидают несколько процессов, процесс, успешно выполнивший операцию P(S) , должен вслед за ней выполнить V(S) , чтобы продублировать сигнал о событии для следующего ожидающего процесса.

Семафор - счетчик ресурсов

Если у нас имеется N единиц некоторого ресурса, то для контроля его распределения создается общий семафор S с начальным значением N . Выделение ресурса сопровождается операцией P(S) , освобождение - операцией V(S) . Значение семафора, таким образом, отражает число свободных единиц ресурса. Если значение семафора 0, то есть, свободных единиц болше не остается, то очередной процесс, запрашивающий единицу ресурса будет переседен в ожидание в операции P(S) до тех пор, пока какой-либо из использующих ресурс процессов не освободит единицу ресурса, выполнив при этом V(S) .

Системные вызовы Unix/Linux

В ОС Unix/Linux механизм семафоров обслуживается тремя системными вызовами:

Реализация семафоров в Linux

Теперь, когда вы увидели, что такое семафоры и как они действуют в теории, можно рассмотреть, как их свойства реализованы в ОС Linux. Интерфейс тщательно проработан и предлагает гораздо больше возможностей, чем обычно требуется. Все функции семафоров в Linux оперируют массивами семафоров общего вида, а не одним двоичным семафором. На первый взгляд кажется, что такой подход все усложняет, но если процесс нуждается в блокировке нескольких ресурсов, способность оперировать массивом семафоров - большое подспорье. В этой главе мы сосредоточимся на применении одиночных семафоров, поскольку в большинстве случаев это все, что вам нужно.

#include
int semctl(int sem_id, int sem_num, int command, ...);

Обычно заголовочный файл sys/sem.h опирается на два других заголовочных файла: sys/types.h и sys/ipc.h. Как правило, они автоматически включаются в программу файлом sys/sem.h и вам не нужно задавать их явно в директивах # include .

Прорабатывая каждую функцию отдельно, помните о том, что все они спроектированы для использования массивов значений семафоров, что делает их работу существенно более сложной, чем та, что необходима для обработки одного семафора.

Обратите внимание на то, что параметр key действует во многом как имя файла, т.к. он тоже представляет ресурс, который программы могут использовать и кооперироваться при этом, если соблюдают соглашение об общем имени для него. Аналогичным образом идентификатор, возвращаемый функцией semget и применяемый другими функциями, совместно использующими память, очень похож на файловый поток FILE* , возвращаемый функцией fopen и представляющий собой значение, применяемое процессом для доступа к совместно используемому файлу. Как и в случае файлов, у разных процессов будут разные идентификаторы семафоров, несмотря на то, что они ссылаются на один и тот же семафор. Такое применение ключа и идентификаторов - общее для всех средств IPC, обсуждаемых здесь, несмотря на то, что каждое средство применяет независимые ключи и идентификаторы.

semget

Функция semget создает новый семафор или получает ключ существующего семафора.

int semget(key_t key, int num_sems, int sem_flags);

Первый параметр key - целочисленное значение, позволяющее несвязанным процессам обращаться к одному и тому же семафору. Ко всем семафорам осуществляется непрямой доступ с помощью программы, предоставляющей ключ, для которого система затем генерирует идентификатор семафора. Ключ семафора применяется только в функции semget . Все остальные функции семафора используют идентификатор семафора, возвращаемый функцией semget .

Существует особое значение ключа семафора IPC_PRIVATE , которое предназначено для создания семафора, доступ к которому получает только процесс-создатель, но такой семафор редко бывает полезен. Для создания нового семафора следует задавать уникальное ненулевое целое число.

Параметр num_sems определяет количество требуемых семафоров. Почти всегда он равен 1.

Параметр sem_flags - набор флагов, очень похожих на флаги функции open. Младшие девять байтов - права доступа к семафору, ведущие себя, как права доступа к файлу. Кроме того, для создания нового семафора с помощью поразрядной операции OR их можно объединить со значением IPC_CREAT . Не считается ошибкой наличие флага IPC_CREAT и задание ключа существующего семафора. Флаг IPC_CREAT безмолвно игнорируется, если в нем нет нужды. Можно применять флаги IPC_CREAT и IPC_EXCL для гарантированного получения нового уникального семафора. Если семафор уже существует, функция вернет ошибку.

Функция semget вернет в случае успеха положительное (ненулевое) значение, представляющее собой идентификатор, применяемый остальными функциями семафора. В случае ошибки возвращается -1.

Функция semop применяется для изменения значения семафора.

int semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops);

Первый параметр sem_id - идентификатор семафора, возвращенный функцией semget . Второй параметр sem_ops - указатель на массив структур, у каждой из которых есть, по крайней мере, следующие элементы:

struct sembuf {
short sem_num;
short sem_op;
short sem_flg;
}

Первый параметр sem_num - номер семафора, обычно 0, если вы не работаете с массивом семафоров. Элемент sem_op - значение, на которое должен изменяться семафор. (Вы можете увеличивать и уменьшать семафор на значения, не равные 1.) Как правило, применяются только два значения: -1 для операции P, заставляющей ждать, пока семафор не станет доступен, и +1 для операции V , оповещающей о том, что в данный момент семафор доступен.

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

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

Функция semctl позволяет напрямую управлять данными семафора.

int semctl (int sem_id, int sem_num, int command, ...);

Первый параметр sem_id - идентификатор семафора, полученный от функции semget . Параметр sem_num - номер семафора. Он применяется при работе с массивом семафоров. Обычно этот параметр равен 0, первый и единственный семафор. Параметр command - предпринимаемое действие, и четвертый параметр, если присутствует, - union (объединение) типа semun , которое в соответствии со стандартом X/Open должно содержать как минимум следующие элементы:

union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
}

В большинстве версий ОС Linux определение объединения semun включено в заголовочный файл (обычно sem.h), несмотря на то, что стандарт X/Open настаивает на том, что вы должны привести собственное объявление. Если вы поймете, что должны объявить его самостоятельно, проверьте, нет ли объявления этого объединения на страницах интерактивного справочного руководства, относящихся к функции semctl . Если вы найдете его, мы полагаем, что вы примените определение из вашего справочного руководства, даже если оно отличается от приведенного на страницах этой книги.