Значение конкретного семафора из набора хранится во внутренней структуре sem:
ushort semval Значение семафора pid_t sempid Идентификатор процесса, выполнившего последнюю операцию над семафором ushort semncnt Число процессов, ожидающих увеличения значения семафора ushort semzcnt Число процессов, ожидающих обнуления семафора
Помимо собственно значения семафора, в структуре sem хранится идентификатор процесса, вызвавшего последнюю операцию над семафором, число процессов, ожидающих увеличения значения семафора, и число процессов, ожидающих, когда значение семафора станет равным нулю. Эта информация позволяет ядру производить операции над семафорами, которые мы обсудим несколько позже.
Для получения доступа к семафору (и для его создания, если он не существует) используется системный вызов semop(2):
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflag);
В случае успешного завершения операции функция возвращает дескриптор объекта, в случае неудачи - -1. Аргумент nsems задает число семафоров в группе. В случае, когда мы не создаем, а лишь получаем доступ к существующему семафору, этот аргумент игнорируется. Аргумент semflag определяет права доступа к семафору и флажки для его создания (IPC_CREAT, IPC_EXCL).
После получения дескриптора объекта процесс может производить операции над семафором, подобно тому, как после получения файлового дескриптора процесс может читать и записывать данные в файл. Для этого используется системный вызов semop(2):
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semop(int semid, struct sembuf *semop, size_t nops);
В качестве второго аргумента функции передается указатель на структуру данных, определяющую операции, которые требуется произвести над семафором с дескриптором semid. Операций может быть несколько, и их число указывается в последнем аргументе nops. Важно, что ядро обеспечивает атомарность выполнения критических участков операций (например, проверка значения — изменение значения) по отношению к другим процессам.
Каждый элемент набора операций semop имеет вид:
struct sembuf {
short sem_num; /* номер семафора в группе */
short sem_op; /* операция */
short sem_flg; /* флаги операции */
}
UNIX допускает три возможные операции над семафором, определяемые полем semop:
1. Если величина semop положительна, то текущее значение семафора увеличивается на эту величину.
2. Если значение semop равно нулю, процесс ожидает, пока семафор не обнулится.
3. Если величина semop отрицательна, процесс ожидает, пока значение семафора не станет большим или равным абсолютной величине semop. Затем абсолютная величина semop вычитается из значения семафора.
Можно заметить, что первая операция изменяет значение семафора (безусловное выполнение), вторая операция только проверяет его значение (условное выполнение), а третья — проверяет, а затем изменяет значение семафора (условное выполнение).
При работе с семафорами взаимодействующие процессы должны договориться об их использовании и кооперативно проводить операции над семафорами. Операционная система не накладывает ограничений на использование семафоров. В частности, процессы вольны решать, какое значение семафора является разрешающим, на какую величину изменяется значение семафора и т.п.
Таким образом, при работе с семафорами процессы используют различные комбинации из трех операций, определенных системой, по-своему трактуя значения семафоров.
В качестве примера рассмотрим два случая использования бинарного семафора (т.е. значения которого могут принимать только 0 и 1). В первом примере значение 0 является разрешающим, а 1 запирает некоторый разделяемый ресурс (файл, разделяемая память и т.п.), ассоциированный с семафором. Определим операции, запирающие ресурс и освобождающие его:
static struct sembuf sop_lock[2] = {
0, 0, 0, /* ожидать обнуления семафора */
0, 1, 0 /* затем увеличить значение семафора на 1 */
};
static struct sembuf sop_unlock[1] = {
0,-1, 0 /* обнулить значение семафора */
};
Итак, для запирания ресурса процесс производит вызов:
semop(semid, &sop_lock[0], 2);
обеспечивающий атомарное выполнение двух операций:[43]
1. Ожидание доступности ресурса. В случае, если ресурс уже занят (значение семафора равно 1), выполнение процесса будет приостановлено до освобождения ресурса (значение семафора равно 0).
2. Запирание ресурса. Значение семафора устанавливается равным 1. Для освобождения ресурса процесс должен произвести вызов:
semop(semid, &sop_unlock[0], 1);
который уменьшит текущее значение семафора (равное 1) на 1, и оно станет равным 0, что соответствует освобождению ресурса. Если какой-либо из процессов ожидает ресурса (т. е. произвел вызов операции sop_lock), он будет "разбужен" системой, и сможет в свою очередь запереть ресурс и работать с ним.
Во втором примере изменим трактовку значений семафора: значению 1 семафора соответствует доступность некоторого ассоциированного с семафором ресурса, а нулевому значению — его недоступность. В этом случае содержание операций несколько изменится.
static struct sembuf sop_lock[2] = {
0, -1, 0, /* ожидать разрешающего сигнала (1),
затем обнулить семафор */
};
static struct sembuf sop_unlock[1] = {
0, 1, 0 /* увеличить значение семафора на 1 */
};
Процесс запирает ресурс вызовом:
semop(semid, &sop_lock[0], 1);
а освобождает:
semop(semid, &sop_unlock[0], 1);
Во втором случае операции получились проще (по крайней мере их код стал компактнее), однако этот подход имеет потенциальную опасность: при создании семафора, его значения устанавливаются равными 0, и во втором случае он сразу же запирает ресурс. Для преодоления данной ситуации процесс, первым создавший семафор, должен вызвать операцию sop_unlock, однако в этом случае процесс инициализации семафора перестанет быть атомарным и может быть прерван другим процессом, который, в свою очередь, изменит значение семафора. В итоге, значение семафора станет равным 2, что повредит нормальной работе с разделяемым ресурсом.
Можно предложить следующее решение данной проблемы:
/* Создаем семафор, если он уже существует semget
возвращает ошибку, поскольку указан флаг IPC_EXCL */
if ((semid = semget(key, nsems, perms | IPC_CREAT | IPC_EXCL)) < 0) {
if (errno = EEXIST) {
/* Действительно, ошибка вызвана существованием объекта */
if ((semid = semget(key, nsems, perms)) < 0)
return(-1); /* Возможно, не хватает системных ресурсов */
} else
return(-1); /* Возможно, не хватает системных ресурсов * /
}
/* Если семафор создан нами, проинициализируем его */
else
semop(semid, &sop_unlock[0], 1);
Разделяемая память
Интенсивный обмен данными между процессами с использованием рассмотренных механизмов межпроцессного взаимодействия (каналы, FIFO, очереди сообщений) может вызвать падение производительности системы. Это, в первую очередь, связано с тем, что данные, передаваемые с помощью этих объектов, копируются из буфера передающего процесса в буфер ядра и затем в буфер принимающего процесса. Механизм разделяемой памяти позволяет избавиться от накладных расходов передачи данных через ядро, предоставляя двум или более процессам возможность непосредственного получения доступа к одной области памяти для обмена данными.
Безусловно, процессы должны предварительно "договориться" о правилах использования разделяемой памяти. Например, пока один из процессов производит запись данных в разделяемую память, другие процессы должны воздержаться от работы с ней. К счастью, задача кооперативного использования разделяемой памяти, заключающаяся в синхронизации выполнения процессов, легко решается с помощью семафоров.
Примерный сценарий работы с разделяемой памятью выглядит следующим образом:
1. Сервер получает доступ к разделяемой памяти, используя семафор.
2. Сервер производит запись данных в разделяемую память.
3. После завершения записи сервер освобождает разделяемую память с помощью семафора.
