Домой  |  Карта  |  Индекс  |  Поиск

автор Leonardo Giordani <leo.giordani(at)libero.it> Об авторе: Студент факультета телекоммуникаций Миланского политехнического института, работает сетевым администратором, интересуется программированием (в основном на ассемблере и C/C++). C 1999 года работает исключительно с Linux/Unix. Перевод на Русский: Kolobynin Alexey <alexey_ak0(at)mail.ru> Содержание: Введение Понятие процесса Процессы в Linux и Unix Многозадачность в libc Рекомендуется к прочтению Страница отзывов

Параллельное программирование - принципы и введение в процессы

Резюме:

Цель данного цикла статей — познакомить читателя с понятием многозадачности и с ее реализацией в операционной системе Linux. Начиная с теоретических идей основ многозадачности, мы закончим написанием приложения, которое продемонстрирует взаимодействие между процессами по простому, но эффективному протоколу. Для понимания статьи вам нужны:

• минимальные знания оболочки;
• знания основ языка C (синтаксис, циклы, библиотеки).

Введение

Понятие процесса

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

Перед тем как разбираться, что происходит внутри нашего Linux, определимся с технической терминологией: пусть дана выполняющаяся ПРОГРАММА, в данный момент времени КОД — это набор инструкций, из которых она состоит, ОБЛАСТЬ ПАМЯТИ — это часть машинной памяти, занятой ее данными, СОСТОЯНИЕ ПРОЦЕССОРА — значения параметров микропроцессора, такие как флаги или Счетчик Команд (адрес следующей инструкции для выполнения).

Определим понятие ВЫПОЛНЯЮЩАЯСЯ ПРОГРАММА как совокупность КОДА, ОБЛАСТИ ПАМЯТИ и СОСТОЯНИЯ ПРОЦЕССОРА. Если в какое-то время работы машины сохранить эту информацию и заменить ее на тот же набор другой выполняющейся программы, то выполнение последней будет продолжено с точки, где она была остановлена ранее: проделывая эту процедуру поочередно для первой и второй программы, мы получим ранее описанное чередование выполнения программ. Термин ПРОЦЕСС (или ЗАДАЧА) используется для обозначения выполняющейся программы.

Рассмотрим, что происходит с машиной, о которой мы говорили во введении: в каждый момент времени выполняется только одна задача (есть только один микропроцессор, и он не может делать два дела одновременно), и машина исполняет часть ее кода; после определенного промежутка времени, называемого КВАНТОМ, выполняющийся процесс останавливается, его информация сохраняется и заменяется на ту же информацию другого процесса, чей код будет выполняться в следующий квант времени и т.д. Это то, что мы называем многозадачностью.

Как было отмечено во введении, многозадачность порождает набор проблем, решение многих из них нетривиально, например управление очередью остановленных процессов (ПЛАНИРОВКА). Тем не менее, они должны быть решены в архитектуре каждой операционной системы. Возможно, этим проблемам будет посвящена одна из последующих статей, может быть с представлением некоторых частей кода ядра Linux.  

Процессы в Linux и Unix

Давайте узнаем кое-что о процессах, выполняющихся на нашей машине. Команда, которая даст нам нужную информацию, называется ps(1) - это сокращение от "process status" (англ. — состояние процесса). Открыв обычную командную строку и введя команду ps, мы получим что-то вроде

  PID TTY          TIME CMD
 2241 ttyp4    00:00:00 bash
 2346 ttyp4    00:00:00 ps

Я говорил, что данный список не полный, однако давайте на минуту здесь остановимся: ps выдал нам список процессов, выполняющихся на текущем терминале. Мы видим в последнем столбце имя, при помощи которого был запущен процесс (например "mozilla" для браузера Mozilla или "gcc" для GNU Compiler Collection). "ps" появляется в этом списке, так как эта команда выполнялась, когда выводился список выполняющихся процессов. Другой выведенный процесс — это Bourne Again Shell — оболочка, работающая на моих терминалах.

Пропустим (пока) информацию в столбцах TIME и TTY и рассмотрим PID — Process IDentifier (англ. — идентификатор процесса). pid — уникальное положительное число, которое присваивается каждому выполняющемуся процессу. Если выполнение процесса завершилось, его pid может быть использован заново, однако гарантируется, что во время выполнения процесса, его pid остается неизменным. Из всего этого следует, что вывод, который каждый из вас будет получать при выполнении ps, может отличаться от приведенного выше. Чтобы удостоверится, что я говорю правду, откроем еще одну оболочку, не закрывая первую, и запустим ps: теперь команда выдаст нам тот же список процессов, однако с другими номерами pid, что свидетельствует о том, что это разные процессы, хотя программы одни и те же.

Мы можем также получить список всех процессов, запущенных на нашей машине: страница man говорит, что ключ -e обозначает "выбрать все процессы". Введем "ps -e" в терминале, и ps выведет нам длинный список, отформатированный как выше. Чтобы нам было удобнее анализировать этот список, можем перенаправить вывод в файл ps.log:

ps -e > ps.log

Теперь мы можем посмотреть этот файл, открыв его в любимом редакторе (или просто командой less). Как говорилось в начале статьи, число выполняющихся процессов больше чем мы могли ожидать. Теперь мы видим, что список содержит не только процессы, запущенные нами (через командную строку или графическую оболочку), но и множество других, некоторые из которых имеют странные имена. Количество и состав процессов в списке зависит от конфигурации вашей системы, однако есть несколько процессов, присутствующих на всех машинах. Во-первых, вне зависимости от конфигурации процесс с pid равным 1 — это всегда "init", прародитель всех процессов. Он имеет первый pid, так как это первый процесс, запускаемый операционной системой. Также мы можем легко заметить наличие множества процессов с именами, заканчивающимися на "d" — это так называемые "демоны" — одни из самых важных процессов в системе. Мы в подробностях изучим init и демонов в одной из следующих статей.  

Многозадачность в libc

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

Стандартная библиотека C (libc, реализованная в Linux в glibc), использует возможности многозадачности Unix System V. Unix System V (далее SysV) — коммерческая реализация Unix, породившая одно из двух самых важных семейтв Unix, второе — BSD Unix.

В libc тип pid_t определен как целое, способное вместить в себе pid. Впредь мы будем использовать этот тип для работы с pid, однако это нужно только для ясности: использование целого типа дало бы тот же результат.

Рассмотрим функцию, которая сообщает нам pid процесса, содержащего нашу программу

pid_t getpid (void)

(она определена вместе с pid_t в unistd.h и sys/types.h) и напишем программу, которая выведет в стандартный вывод свой pid. При помощи любого редактора напишите следующий код

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>

int main()
{
  pid_t pid;

  pid = getpid();
  printf("pid присвоенный процессу - %d\n", pid);

  return 0;
}

gcc -Wall -o print_pid print_pid.c

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

pid_t fork(void)

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

- РАЗВЕТВИТЬ
- ЕСЛИ ТЫ ДОЧЕРНИЙ ПРОЦЕСС ВЫПОЛНИТЬ (...)
- ЕСЛИ ТЫ РОДИТЕЛЬСКИЙ ПРОЦЕСС ВЫПОЛНИТЬ (...)

int main()
{
  pid_t pid;

  pid = fork();
  if (pid == 0)
  {
    КОД ДОЧЕРНЕГО ПРОЦЕССА
  }
  КОД РОДИТЕЛЬСКОГО ПРОЦЕССА
}

(01) #include <unistd.h>
(02) #include <sys/types.h>
(03) #include <stdio.h>

(04) int main()
(05) {
(05)   pid_t pid;
(06)   int i;

(07)   pid = fork();

(08)   if (pid == 0){
(09)     for (i = 0; i  < 8; i++){
(10)       printf("-ДОЧЕРНИЙ-\n");
(11)     }
(12)     return(0);
(13)   }

(14)   for (i = 0; i < 8; i++){
(15)     printf("+РОДИТЕЛЬСКИЙ+\n");
(16)   }

(17)   return(0);
(18) }

Строки (01)—(03) содержат включения заголовочных файлов необходимых библиотек (стандартный ввод/вывод, многозадачность).
Функция main (как обычно в GNU) возвращает целое, которое равно нулю, если все прошло без ошибок и код ошибки, если что-то случилось не то. Давайте пока будем считать, что все выполняется без ошибок (мы добавим обработку ошибок, когда уясним основные идеи). Далее, мы определяем переменную для pid (05) и целое для счетчика в циклах. Типы этих переменных, как замечалось ранее, одинаковы, однако тут они указаны различными для ясности.
В строке (07) мы вызываем функцию fork, которая возвратит нуль в программу, выполняющуюся в дочернем процессе, и pid дочернего процесса в родительском; проверка производится в строке (08). Теперь код строк (09)—(13) будет исполнен в дочернем процессе, а оставшийся код (14)—(16) в родительском.
Эти части кода просто выводят 8 раз в стандартный вывод слово "-ДОЧЕРНИЙ-" или "+РОДИТЕЛЬСКИЙ+" в зависимости от того, какой процесс выполняется, а затем завершают выполнение, возвращая 0. Последнее по-настоящему важно, так как без этого "return" дочерний процесс после завершения цикла будет выполнять далее код родительского (попробуйте, это не повредит вашей машине, просто произойдет то, чего мы не хотим). Подобные ошибки очень сложно будет обнаружить, так как выполнение многозадачных программ (особенно сложных) дает различные результаты при каждом выполнении, отлаживать их пользуясь результатами просто невозможно.

Возможно, вы будете не удовлетворены выполнением программы: я не могу утверждать, что результатом будет смесь из двух строк, все зависит от скорости выполнения такого короткого цикла. Возможно, на выходе вы получите последовательность строк "+РОДИТЕЛЬСКИЙ+", а затем строк "-ДОЧЕРНИЙ-" или наоборот. Тогда попробуйте еще несколько раз выполнить программу, результат может поменяться.

Вставляя задержку случайной длины перед каждым вызовом prinf, мы сможем нагляднее увидеть эффект многозадачности: мы сделаем это при помощи функций sleep и rand.

sleep(rand()%4)

(09)  for (i = 0; i < 8; i++){
(->)    sleep (rand()%4);
(10)    printf("-ДОЧЕРНИЙ-\n");
(11)  }

[leo@mobile ipc2]$ ./fork_demo2
-ДОЧЕРНИЙ-
+РОДИТЕЛЬСКИЙ+
+РОДИТЕЛЬСКИЙ+
-ДОЧЕРНИЙ-
-ДОЧЕРНИЙ-
+РОДИТЕЛЬСКИЙ+
+РОДИТЕЛЬСКИЙ+
-ДОЧЕРНИЙ-
-ДОЧЕРНИЙ-
+РОДИТЕЛЬСКИЙ+
+РОДИТЕЛЬСКИЙ+
-ДОЧЕРНИЙ-
-ДОЧЕРНИЙ-
-ДОЧЕРНИЙ-
+РОДИТЕЛЬСКИЙ+
+РОДИТЕЛЬСКИЙ+
[leo@mobile ipc2]$

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

pid_t waitpid (pid_t PID, int *STATUS_PTR, int OPTIONS)

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>

int main()
{
  pid_t pid;
  int i;

  pid = fork();

  if (pid == 0){
    for (i = 0; i < 14; i++){
      sleep (rand()%4);
      printf("-ДОЧЕРНИЙ-\n");
    }
    return 0;
  }

  sleep (rand()%4);
  printf("+РОДИТЕЛЬСКИЙ+ Ожидаю завершения выполнения дочернего процесса...\n");
  waitpid (pid, NULL, 0);
  printf("+РОДИТЕЛЬСКИЙ+ ...завершен\n");

  return 0;
}

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

Рекомендуется к прочтению

• Silberschatz, Galvin, Gagne, Operating System Concepts - Sixth Edition, Wiley&Sons, 2001
• Tanenbaum, WoodHull, Operating Systems: Design and Implementation - Second Edition, Prentice Hall, 2000
• Stallings, Operating Systems - Fourth Edition, Prentice Hall, 2002
• Bovet, Cesati, Understanding the Linux Kernel, O'Reilly, 2000

На русском языке

• Операционная система UNIX / А.М. Робачевский. - СПб.: БХВ-Петербург, 2001.
• Сетевые операционные системы / В.Г. Олифер, Н.А. Олифер. - СПб.: Питер, 2001.

Страница отзывов

2002-12-05, generated by lfparser version 2.31