макрос WIFSTOPPED(*status) возвращает ненулевое значение, если процесс был приостановлен системой управления заданиями, при этом макрос WSTOPSIG(*status) возвращает номер сигнала, c помощью которого он был приостановлен.

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

После того, как информация о статусе завершения процесса-зомби будет доставлена его предку посредством вызова wait(), все оставшиеся структуры, связанные с данным процессом-зомби, освобождаются, и запись о нем удаляется из таблицы процессов. Таким образом, переход в состояние зомби необходим именно для того, чтобы процесс-предок мог получить информацию о судьбе своего завершившегося потомка, независимо от того, вызвал он wait() до или после фактического его завершения.

Что происходит с процессом-потомком, если его предок вообще не обращался к wait() и/или завершился раньше потомка? Как уже говорилось, при завершении процесса отцом для всех его потомков становится процесс с идентификатором 1. Он и осуществляет системный вызов wait(), тем самым освобождая все структуры, связанные с потомками-зомби.

Часто используется сочетание функций fork()-wait(), если процесс-сын предназначен для выполнения некоторой программы, вызываемой посредством функции exec(). Фактически этим предоставляется процессу-родителю возможность контролировать окончание выполнения процессов-потомков.

1. Использование системного вызова wait()

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

#include <sys/types.h>

#include <unistd.h>

#include <sys/wait.h>

#include <stdio.h>

int main(int argc, char **argv)

{

int i;

for (i=1; i<argc; i++)

{

int status;

if(fork()>0)

{

/*процесс-предок ожидает сообщения от процесса-потомка о завершении */

wait(&status);

printf(“process-father\n”);

continue;

}

execlp(argv[i], argv[i], 0);

return -1;

/*попадем сюда при неуспехе exec()*/

}

return 0;

}

Пусть существуют три исполняемых файла print1, print2, print3, каждый из которых только печатает текст first, second, third соответственно, а код вышеприведенного примера находится в исполняемом файле с именем file. Тогда результатом работы команды file print1 print2 print3 будет

first

process-father

second

process-father

third

process-father

1. Использование системного вызова wait()

В данном примере процесс-предок порождает два процесса, каждый из которых запускает команду echo. Далее процесс-предок ждет завершения своих потомков, после чего продолжает выполнение.

#include <sys/types.h>

#include <unistd.h>

#include <sys/wait.h>

#include <stdio.h>

int main(int argc, char **argv)

{

if ((fork()) == 0) /*первый процесс-потомок*/

{

execl(“/bin/echo”, ”echo”, ”this is”, ”string 1”, 0);

return -1;

}

if ((fork()) == 0) /*второй процесс-потомок*/

{

execl(“/bin/echo”, ”echo”, ”this is”, ”string 2”, 0);

return -1;

}

/*процесс-предок*/

printf(“process-father is waiting for children\n”);

while(wait(NULL) != -1);

printf(“all children terminated\n”);

return 0;

}

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

4.6Жизненный цикл процесса в ОС UNIX.

Подведем короткие итоги. Итак, процесс в UNIX представляет собой исполняемую программу вместе с необходимым ей окружением. Окружение состоит из информации о процессе, которая содержится в различных системных структурах данных, информации о содержимом регистров, программ операционной системы, стеке процесса, информации об открытых файлах, обработке сигналов и так далее. Процесс представляет собой изменяющийся во времени динамический объект. Программа представляет собой часть процесса. Процесс может создавать процессы-потомки посредством системного вызова fork(), может изменять свою программу через системный вызов exec(). Процесс может приостановить свое исполнение, используя вызов wait(), а также завершить свое исполнение посредством функции exit().

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

1. Процесс только что создан посредством вызова fork().

2. Процесс находится в очереди готовых на выполнение процессов.

3. Процесс выполняется в режиме задачи, т.е. реализуется алгоритм, заложенный в программу. Выход из этого состояния может произойти через системный вызов, прерывание или завершение процесса.

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

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

6. Процесс осуществил вызов _exit() или получил сигнал на завершение. Ядро освобождает ресурсы, связанные с процессом, кроме кода возврата и статистики выполнения. Далее процесс переходит в состоянии зомби, а затем уничтожается.

Рис. 12 Жизненный цикл процесса в ОС UNIX.

4.7Начальная загрузка. Формирование О и 1 процессов.

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

1.Аппаратный загрузчик читает нулевой блок системного устройства.

2.После чтения этой программы она выполняется, т.е. ищется и считывается в память файл /unix, расположенный в корневом каталоге и который содержит код ядра системы.

3.Запускается на исполнение этот файл.

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

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

• Он является чисто системным процессом, т.е. существует в течении всего времени работы системы и считается, что он активен, когда работает ядро ОС.

Далее ядро копирует "0" процесс и создает "1" процесс. Алгоритм создания этого процесса напоминает стандартную процедуру, хотя и носит упрощенный характер. Сначала процесс "1" представляет собой полную копию процесса "0" , т.е. у него нет области кода. Далее происходит увеличение его размера и во вновь созданную кодовую область копируется программа, реализующая системный вызов exec(), необходимый для выполнения программы /etc/init. На этом завершается подготовка первых двух процессов. Первый из них представляет собой структуру данных, при помощи которой ядро организует мультипрограммный режим и управление процессами. Второй – это уже подобие реального процесса. Далее ОС переходит к выполнению программ диспетчера. Диспетчер наделен обычными функциями и на первом этапе у него нет выбора – он запускает exec(), который заменит команды процесса "1" кодом, содержащимся в файле /etc/init. Получившийся процесс, называемый init, призван настраивать структуры процессов системы. Далее он подключает интерпретатор команд к системной консоли. Так возникает однопользовательский режим, так как консоль регистрируется с корневыми привилегиями и доступ по каким-либо другим линиям связи невозможен. При выходе из однопользовательского режима init создает многопользовательскую среду. С этой целью для каждого активного канала связи, т.е. каждого терминала, init создает отдельный процесс, выполняющий команду getty. Эта программа ожидает входа в систему кого-либо по каналу связи. Далее, используя системный вызов exec(), getty передает управление программе login, проверяющей пароль. Во время работы ОС процесс init ожидает завершения одного из порожденных им процессов (т.е. окончания сессии работы с системой), после чего он активизируется и создает для соответствующего терминала новый процесс getty взамен завершившегося . Таким образом, процесс init поддерживает многопользовательскую структуру во время функционирования системы. Схема описанного “круговорота” представлена на Рис. 13

Рис. 13 Поддержка многопользовательской работы в ОС UNIX.

4.8Планирование процессов в ОС UNIX.

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

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

В общем случае, значение приоритета есть некоторая функция

 P_PRI = F(P_NICE, P_CPU)

Т.е. в вычислении приоритета P_PRI используются две изменяемые составляющие - P_NICE и P_CPU (в простейшем случае эти составляющие просто суммируются). P_NICE - это пользовательская составляющая приоритета. Его начальное значение полагается равным системной константе NZERO, в процессе выполнения процесса P_NICE может модифицироваться системным вызовом nice(). Аргументом этого системного вызова является добавка к текущему значению (для обычного – непривилегированного - процесса эти добавки представляют собой неотрицательные числа). Значение P_NICE наследуется при порождении процессов, и таким образом, значение приоритета не может быть понижено при наследовании. Заметим, что изменяться P_NICE может только в сторону увеличения значения (до некоторого предельного значения), таким образом пользователь может снижать приоритет своих процессов.

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

Упрощенная формула вычисления приоритета такова

P_PRI = P_USER + P_NICE + P_CPU

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

P_PRI = P_USER + P_NICE – NZERO + P_CPU/a

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

1. Планирование процессов.

Рассмотрим два активных процесса, разделяющих процессор, причем таких, что ни их процессы-предки, ни они сами не меняли составляющую P_NICE системным вызовом nice(). Тогда P_NICE=NZERO и оба процесса имеют начальное значение приоритета P_PRI=P_USER, так как для них обоих в начальный момент P_CPU=0. Пусть прерывание по таймеру происходит через N единиц времени, и каждый раз значение P_CPU увеличивается на единицу, а в вычисление приоритета составляющая P_CPU входит с коэффициентом 1/A. Таким образом, дополнительная единица в приоритете процесса, занимающего процессор, «набежит» через А таймерных интервалов. Значение P_CPU второго процесса остается неизменным, и его приоритет остается постоянным. Через NA единиц времени разница приоритетов составит единицу в пользу второго процесса и произойдет смена процессов на процессоре.

4.9Принципы организация свопинга.

В системе определенным образом выделяется пространство для области свопинга. Есть пространство оперативной памяти, в котором находятся процессы, обрабатываемые системой в режиме мультипрограммирования. Есть область на ВЗУ, предназначенная для откачки этих процессов по мере необходимости. Упрощенная схема планирования подкачки основывается на использовании некоторого приоритета, который называется P_TIME и также находится в контексте процесса. В этом параметре аккумулируется время пребывания процесса в состоянии мультипрограммной обработки, или в области свопинга. В поле P_TIME существует счётчик выгрузки (outage) и счётчик загрузки (inage).

При перемещении процесса из оперативной памяти в область свопинга или обратно система обнуляет значение параметра P_TIME. Для загрузки процесса в память из области свопинга выбирается процесс с максимальным значением P_TIME. Если для загрузки этого процесса нет свободного пространства оперативной памяти, то система ищет среди процессов в оперативной памяти процесс, ожидающий ввода/вывода (сравнительно медленных операций, процессы у которых приоритет выше значения P_ZERO) и имеющий максимальное значение P_TIME (т.е. тот, который находился в оперативной памяти дольше всех). Если такого процесса нет, то выбирается просто процесс с максимальным значением P_TIME.

Часть III. реализация взаимодействия процессов.

В этой части будет рассмотрен весь спектр средств межпроцессного взаимодействия, которые предоставляет программисту ОС UNIX. Отметим, что многие из этих средств (такие как сигналы, средства IPC, сокеты, MPI) или их аналоги имеются и в других операционных системах. Таким образом, данное рассмотрение будет полезно в целом для формирования представления о многообразии механизмов взаимодействия процессов, теоретические основы которых были рассмотрены ранее.