Демьянович Ю.К., Иванцова О.Н. Технология программирования для распределенных параллельных систем

Подождите немного. Документ загружается.

BYTE c1, c2, dummy:

SEQ

West?c1

WHILE TRUE

ALT

West?c2

SEQ

East!c1

c1:=c2

Ask?dummy # процессу East нужен байт

SEQ

East!c1

West?c1

§ 2. О языке CSP

Современные версии языка CS P позволяют его использовать в

различных аспектах моделирования приложений:

– протоколов взаимодействия;

– протоколов безопасности;

– протоколов отказоустойчивых систем.

Все взаимодействия происходят в результате событий. Основ-

ными являются операторы:

– присоединения (префиксации — последовательного выполне-

ния);

– рекурсии (повторения);

– защищенного выбора (недетерминированного выбора).

Оператор присоединения используется для задания последова-

тельного порядка событий.

Пример 1. Если red и green — события, то светофор, который

один раз включает green, а потом red, задается так

green --> red --> STOP

Здесь STOP — простейший процесс в CSP, который не нуждается

во взаимодействии.

Пример 2. Для описания повторения используется рекурсия; в

частности, циклическое включение green и red имеет вид

LIGHT=green --> red --> LIGHT

Для описания взаимодействия пр оцес сов друг с другом исполь-

зуются каналы.

Пример 3.

COPY1=West?c:char --> East!c --> COPY1

# копирование по символу

Пример 4. Программа вычисления НОД:

GCD=Input?id, x, y --> GCD(id, x, y)

GCD(id, x, y)= if (x=y) then

Output!id, x --> GCD

else if (x>y) then

GCD(id, x-y, y)

else

GCD(id, x, y-x)

Здесь используются два взаимно-рек урсивн ых процесса. Пер-

вый GCD ждет события ввода и вызывает второй процесс GCD().

Второй процесс повторяется до выполнения условия x=y, затем вы-

водит результат и запускает первый процесс для ожидания еще од-

ного события ввода.

Пример 5. Следующая программа определяет поведение систе-

мы, буферизующей один или два символа.

COPY=West?c1:char --> COPY2(c1)

COPY2(c1)=West?c2:char --> East!c1 --> COPY2(c2)

[ ]

East!c1 --> West?c1:char --> COPY2(c2)

Второй процесс ис польз ует оператор защищенного выбора [ ]:

– защита в первой части ждет ввода из канала West;

– защита во второй части ждет вывода из канала East.

Выбор недетерминирован: возможны оба взаимодействия.

§ 3. О языке Linda

В языке Linda обобщается идея разделяемых переменных и

асинхронной передачи сообщений. Любой последовательный язык

можно дополнить примитивами из Linda и получить параллельный

вариант.

Имеются кортежи процессов — процедуры которые выполня-

ются асинхронно, и кортежи данных — помеченные записи. Здесь

имеется шесть примитивов для доступа к пространству корте-

жей (разделяемой ассоциативной памяти); кортежем называется

отмеченная запись дан ных.

Пространство кортежей (ПК) похоже на единый разделяемый

канал связи, но кортежи не упорядочены.

OUT — операция помещения кортежа

(запись — аналог send — в канал кортеж помещается);

IN — операция извлечения кортежа

(чтение — аналог receive — из канала кор теж извлекается);

EVAL — операция создания процесса;

INP — операция ввода (неблокирующая);

RDP — операция чтения (неблокирующая);

RD — операция просмотра (блокирующая).

Пространство кортежей состоит:

– из множества пассивных кортежей;

– из множества активных кортежей.

Каждый кортеж имеет вид

("tag", value_1, . . ., value_n)

где метка "tag" является строкой (для различения кортежей).

Значения (value_1, . . ., value_n) — это нуль или несколь-

ко значений данных (целых чисел , действительных чисел или мас-

сивов).

Для обработки кортежей служат три базовых неделимых при-

митива: OUT, IN, RD.

OUT("tag", expr_1, . . ., expr_n);

— помещение кортежа в ПК (аналогично оператору send, но

вместо канала рассматривается пространство кортежей).

IN("tag", field_1, . . ., field_n);

— извлечение кортежа из ПК (аналогично оператору receive).

Каждое поле field_i может быть выражением или формаль-

ным параметром вида ?var, где var — имя переменной выполняе-

мого процесса.

Аргументы примитива IN называются шаблоном. Процесс IN

ждет, пока в ПК появится хотя бы один кортеж, соответству-

ющий шаблону, и удаляет его из ПК.

Кортеж d соответствует шаблону t, если

1) их метки идентичны;

2) число полей d и t одинаково;

3) значение каждого выражения в t (если оно указано) р авно

соответствующему значению в кортеже данных d.

После того, как кортеж будет удален из ПК формальным пара-

метрам шаблона при сваивается соответствующие значения.

Пример 1. Реализация семафора.

Пусть sem — символьное имя семафора. Тогда операция V над

семафором (увеличение семафора на единицу) будет иметь вид

OUT("sem"), а операция P над семафором (ожидание увел иче ния се-

мафора на единицу, если он был нуль) будет иметь вид IN("sem").

Замечание. Операции P и V состоят из следующих неделимых

операций: P(s): <await(s>0); s=s-1;>, V(s): <s=s+1;>.

Значение семафора — число кортежей sem в пространстве кор-

тежей.

Для моделирования массива семафоров используется дополни-

тельное поле, пред ставляющее индекс массива, например

IN("sems", i); # P[sems[I]]

OUT("sems", i); # V[sems[I]]

Базовый примитив RD (блокирующий) используется д ля про-

смотра кортежей в пространстве кортежей (без их изъятия из этого

пространства — в отличие от примитива IN). Если t — шаблон, то

RD(t) приостанавливает процесс до тех пор, пока в пространстве

кортежей не появится кортеж, соответствующий шаблону t.

Примитивы INP и RDP выполняют те же действия, что IN и RD, но

не являются блокирующими; они кроме того возвращают TRUE или

FALSE в зависимости от того, есть или нет кортежа в пространстве

кортежей с данным шаблоном.

INP — извлекает кортеж из ПК (если он есть);

RDP — читает кортеж (но оставляет его в ПК).

Пример 2. Реализация барьера-счетчика.

OUT("barier", 0);

# создание элемента barier в ПК с нулевым

# значением счетчика

Достигнув барьера тот или иной процес с извлекает счетчик из

ПК:

IN("barier", ?counter);

# получение кортежа "barier"

OUT("barier", counter=counter+1);

# увеличение счетчика на единицу

Далее процесс ждет, пока к барьеру придут все n процессов с

помощью блокирующего чтен ия

RD("barier", n);

При появлении указанного кортежа в ПК процесс продол жает

работу.

Шестой (и последний) примитив в языке Linda — примитив,

создающий новые кортежи

EVAL("tag", expr_1, . . ., expr_n);

Среди expr_i могут быть процедуры или функции. При созда-

нии кортежа они вычисляются, причем все поля кортежа вычис-

ляются параллельно. Меткой кортежа становится метка "tag", а

полями — значения после вычисления функций и процедур.

Пример 3. Рассмотрим параллельный оператор

co[i=1 to n]

a[i]=f(i);

Ему соответствует C-программа, обогащенная примитивами

Linda

for(i=1; i<=n; i++) EVAL("a", i, f(i));

В пространстве кортежей оказывается соответствующие n кор-

тежей.

Пример 4. Обмен сообщениями “с помощью каналов”

OUT("ch", expressions);

— посылка в “канал”.

IN("ch", expressions);

— получение из “канала”.

§ 4. Портфель задач

Реализация параллельных вычислений возможна с использова-

нием так называемого портфеля задач.

Задача здесь представляет независимую единицу работы. За-

дачи помещаются в “портфель”, разделяемый всеми процессами,

работающими по программе

while(true) {

[получить задачу из "портфеля"];

if([задач больше нет])

break; # выход из цикла

}

Парадигма портфеля задач имеет следующие положительные

черты:

1) она весьма проста:

– нужно дать представление задач;

– определить портфель (набор задач, их расположение);

– дать программу выполнения задачи;

– определить кри тери й ее окончания;

2) программы с использ ованием портфеля задач легко масшта-

бируются: нужно просто изменить число процессов (но производи-

тельность может не измениться, если число процессов больше числа

задач);

3) упрощается балансировка нагрузки: освободившиеся процес-

сы берут на себя решение новых задач из портфеля (пока задач в

два или три раза больше, чем процессов, загрузка процессов ока-

жется более или менее одинаковой).

Рассмотрим решение задачи о генерации простых чисел (решето

Эратосфена) с помощью портфеля задач, используя C-Linda (эта

задача уже рассматривалась ранее на языке CSP).

Числа-кандидаты на простое число хранятся в пространстве

кортежей. Управляющий проц есс собирает результаты и помещает

числа-кандидаты в портфел ь.

Каждый процесс удаляет число-кандидат из портфеля и прове-

ряет, является ли оно простым, деля его на м´еньшие простые чис-

ла. Для реализации этой схемы (т. е. для того, чтобы все м´еньшие

простые числа уже име лис ь) проверять кандидатов нужно в воз-

растающем порядке. Возможна приостановка рабочего процесса в

ожидании, что другой процесс сгенерирует м´еньшее простое число,

но взаимная блокировка исключается.

Гене раци я простых чисел на языке C-Linda

РАБОЧИЙ ПРОЦЕСС

# include "linda.h"

# define LIMIT 1000

/* верхняя граница числа простых чисел */

void worker() { /* функция без параметров */

int primes[LIMIT]={2,3} /* таблица простых чисел */

int numPrimes=1, i, candidate, isprime;

/* numPrimes - номер очередного простого числа */

/* циклическое получение кандидатов и их проверка */

while(true) {

if(RDP("stop"))

/* проверка завершения: появился ли

в пространстве кортежей "stop" */

return; /* выход из функции */

IN("candidate", ?candidate); /* получить кандидата */

OUT("candidate", candidate+2);

/* вывод следующего нечетного в качестве

кандидата погружаем в ПК */

i=0; isprime=1;

while(primes[i]*primes[i]<=candidate) {

/* далее нет необходимости проверять

ибо на остальные числа делится не может */

if(candidate%primes[i]==0){

isprime=0; break;

}

i++;

if(i>numPrimes) { /* требуется следующее простое */

numPrimes++;

RD("prime", numPrimes, ?primes[numPrimes]);

}

/* сообщаем результат управляющему процессу */

OUT("result", candidate, isprime);

/* погружаем в ПК результат */

}

УПРАВЛЯЮЩИЙ ПРОЦЕСС

real_main(int argc, char*argv[ ]) {

/* argc - число аргументов командной строки

(больше или равно единицы)

char*argv[ ] - массив символьных указателей,

в котором каждый элемент

указывает на аргумент командной строки */

int primes[LIMIT]={2,3}

/* локальная таблица простых чисел */

int limit, numWorkers, i, isprime;

int numPrimes=2, value=5;

limit=atoi(argv[1];) /* считать командную строку */

numWorkers=atoi(argv[2]);

/* создать рабочие процессы и поместить их в портфель

число пять (первый кандидат): */

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

EVAL("worker", worker());

/* создание рабочих процессов в ПК */

OUT("candidate", value); /* - создание кандидата в ПК;

получить результаты рабочих процессов

в порядке возрастания: */

while(numPrimes<limit) {

IN("result", value, ?isprime); /* извлечь кандидата */

if(isprime){ /* поместить результат в таблицу и в ПК */

primes[numPrimes]=value; /* расширить таблицу */

OUT("prime", numPrimes, value);

/* -- погрузить простое в ПК */

numPrimes++;

}

value=value+2;

}

/* завершить рабочие процессы, вывести простые числа */

OUT("stop"); /* погрузить "stop" в ПК */

for (i=0; i<=limit; i++)

printf("%d\n", primes[i]);

/* распечатать массив primes */

}

Замечание. Генерацией новых кандидатов в ПК заним аются ра-

бочие процессы.

Головная программа сначала выполняет один процесс:

1) она начинает с чтения аргументов командной строки для

определения, сколько нужно простых чисел и сколько процессов

можно использовать;

2) затем используется примитив EVAL для создания рабочих про-

цессов;

3) далее используется примитив OUT для помещения в простран-

ство кортежей числа-кандидата пять;

4) для получения результатов от рабочих процессов использует-

ся примитив IN (извлекает простые числа из ПК), причем резуль-

таты получаются в порядке возрастания простых чисел;

5) получив простое число программа помещ ает его и его номер в

пространство кортежей, а также дополняет таблицу простых чисел;

6) работа завершается, когда real_main получает limit про-

стых чисел: управляющий процесс сообщает об остановке, помещая

в ПК кортеж "stop";

7) real_main распечатывает таблицу простых чисел primes.

Что делают рабочие процессы?

1) каждый рабочий процесс многократно получает число-

кандидат из ПК;

2) проверяет, простое ли оно;

3) отправляет его управляющему проц есс у, помещая в ПК;

4) помещает следующее нечетное число в ПК (таким образом, в

ПК находится не более одного числа-кандидата);

5) каждый рабочий процесс поддерживает локальную табли-

цу простых чисел и дополняет ее, из влекая простые числа из ПК,

причем в строго возрастающем порядке;

6) на каждой итерации рабочий процесс проверяет, не нужно

ли ему остановиться с помощью RDP (неблокирующий), который

вырабатывает “истина”, если есть кортеж "stop".

Замечание. Пока будет получено limit простых чисел , будет

проверено больше чисел-кандидатов, чем необходимо; для исклю-

чения этого эффекта нужно существенно увеличить число перед а-

ваемых сообщений.