| ИНФОРМАЦИЯ | |
© Крюков В.А.
Курс лекций
"Распределенные
ОС"
Традиционно распределенные вычисления базируются на модели передачи сообщений, в которой данные передаются от процессора к процессору в виде сообщений. Удаленный вызов процедур фактически является той же самой моделью (или очень близкой).
DSM - виртуальное адресное пространство, разделяемое всеми узлами (процессорами) распределенной системы. Программы получают доступ к данным в DSM примерно так же, как они работают с данными в виртуальной памяти традиционных ЭВМ. В системах с DSM данные перемещаются между локальными памятями разных компьютеров аналогично тому, как они перемещаются между оперативной и внешней памятью одного компьютера.
Миграционный алгоритм позволяет интегрировать DSM с виртуальной памятью, обеспечивающейся операционной системой в отдельных узлах. Если размер страницы DSM совпадает с размером страницы виртуальной памяти (или кратен ей), то можно обращаться к разделяемой памяти обычными машинными командами, воспользовавшись аппаратными средствами проверки наличия в оперативной памяти требуемой страницы и замены виртуального адреса на физический. Конечно, для этого виртуальное адресное пространство процессоров должно быть достаточно, чтобы адресовать всю разделяемую память. При этом, несколько процессов в одном узле могут разделять одну и ту же страницу.
Для определения места расположения блоков данных миграционный алгоритм может
использовать сервер, отслеживающий перемещения блоков, либо воспользоваться
механизмом подсказок в каждом узле. Возможна и широковещательная рассылка
запросов.
При использовании такого алгоритма требуется отслеживать расположение всех
блоков данных и их копий. Например, каждый собственник блока может отслеживать
расположение его копий.
Данный алгоритм может снизить среднюю стоимость
доступа по чтению тогда, когда количество чтений значительно превышает
количество записей.
Одним из способов обеспечения консистентности данных является использование специального процесса для упорядочивания модификаций памяти. Все узлы, желающие модифицировать разделяемые данные должны посылать свои модификации этому процессу. Он будет присваивать каждой модификации очередной номер и рассылать его широковещательно вместе с модификацией всем узлам, имеющим копию модифицируемого блока данных. Каждый узел будет осуществлять модификации в порядке возрастания их номеров. Разрыв в номерах полученных модификаций будет означать потерю одной или нескольких модификаций. В этом случае узел может запросить недостающие модификации.
Все перечисленные алгоритмы являются неэффективными. Добиться эффективности
можно только изменив семантику обращений к памяти.
Все однопроцессорные системы обеспечивают строгую консистентность, но в
распределенных многопроцессорных системах ситуация намного сложнее. Предположим,
что переменная X расположена в памяти машины B, и процесс, который выполняется
на машине A, пытается прочитать значение этой переменной в момент времени T1.
Для этого машине B посылается запрос переменной X. Немного позже, в момент
времени T2, процесс, выполняющийся на машине B, производит операцию записи
нового значения в переменную X. Для обеспечения строгой консистентности операция
чтения должна возвратить в машину А старое значение переменной вне зависимости
от того, где расположена машина A и насколько близки между собой два момента
времени T1 и T2. Однако, если T1-T2 равно 1 нсек, и машины расположены друг от
друга на расстоянии 3-х метров, то сигнал о запросе значения переменной должен
быть передан на машину B со скоростью в 10 раз превышающей скорость света, что
невозможно.
| P1: W(x)1 | P1: W(x)1 |
| --------------------------------> t | -----------------------------------> t |
| P2: R(x)1 | P2: R(x)0 R(x)1 |
| а) | б) |
а) Строго консистентная память
б) Память без строгой консистентности
Последовательная консистентность не гарантирует, что операция чтения возвратит значение, записанное другим процессом наносекундой или даже минутой раньше, в этой модели только точно гарантируется, что все процессы знают последовательность всех записей в память. Результат повторного выполнения параллельной программы в системе с последовательной консистентностью (как, впрочем, и при строгой консистентности) может не совпадать с результатом предыдущего выполнения этой же программы, если в программе нет регулирования операций доступа к памяти с помощью механизмов синхронизации.
Два примера правильного выполнения одной программы. В примерах используются следующие обозначения:
| P1: | W(x)1 | W(y)1 | |||
| P2: | W(z)1 | ||||
| P3: | R(x)0 | R(y)0 | R(z)1 | R(y)0 | |
| P4: | R(x)0 | R(y)1 | R(z)1 | R(x)1 |
| P1: | W(x)1 | W(y)1 | |||
| P2: | W(z)1 | ||||
| P3: | R(x)0 | R(y)1 | R(z)0 | R(y)1 | |
| P4: | R(x)1 | R(y)1 | R(z)0 | R(x)1 |
| P1: | W(x)1 | W(y)1 | |||
| P2: | W(z)1 | ||||
| P3: | R(x)0 | R(y)0 | R(z)1 | R(y)0 | |
| P4: | R(x)0 | R(y)1 | R(z)0 | R(x)1 |
| P1: | W(x)1 | W(y)1 | |||
| P2: | W(z)1 | ||||
| P3: | R(x)1 | R(y)0 | R(z)1 | R(y)1 | |
| P4: | R(x)0 | R(y)1 | R(z)1 | R(x)0 |
Рассмотрим пример. Предположим, что процесс P1 модифицировал переменную x, затем процесс P2 прочитал x и модифицировал y. В этом случае модификация x и модификация y потенциально причинно зависимы, так как новое значение y могло зависеть от прочитанного значения переменной x. С другой стороны, если два процесса одновременно изменяют значения различных переменных, то между этими событиями нет причинной связи. Операции, которые причинно не зависят друг от друга называются параллельными.
Причинная модель консистентности памяти определяется следующим условием: Последовательность операций записи, которые потенциально причинно зависимы, должна наблюдаться всеми процессами системы одинаково, параллельные операции записи могут наблюдаться разными узлами в разном порядке.
Пример.
(а) Нарушение модели причинной
консистентности
| P1: | W(x)1 | ||||
| P2: | R(x)1 | W(x)2 | |||
| P3: | R(x)2 | R(x)1 | |||
| P4: | R(x)1 | R(x)2 |
(б) корректная последовательность для модели причинной консистентности.
| P1: | W(x)1 | W(x)3 | ||||
| P2: | R(x)1 | W(x)2 | ||||
| P3: | R(x)1 | R(x)3 | R(x)2 | |||
| P4: | R(x)1 | R(x)2 | R(X)3 |
При реализации причинной консистентности для случая размножения страниц выполнение операций с общей памятью требует ожидания выполнения только тех предыдущих операций записи, которые являются потенциально причинно зависимыми. Параллельные операции записи не задерживают выполнение операций с общей памятью, а также не требуют неделимости широковещательных рассылок.
Определение потенциальной причинной зависимости может осуществляться компилятором посредством анализа зависимости операторов программы по данным.
Система DSM может это осуществить
посредством нумерации всех записей на каждом процессоре, распространения этих
номеров по всем процессорам вместе с модифицируемыми данными, и задержке любой
модификации на любом процессоре до тех пор, пока он не получит все те
модификации, о которых известно процессору - автору задерживаемой
модификации.
Пример допустимой последовательности
событий в системе с PRAM консистентностью.
| P1: | W(x)1 | ||||
| P2: | R(x)1 | W(x)2 | |||
| P3: | R(x)1 | R(x)2 | |||
| P4: | R(x)2 | R(x)1 |
Преимущество модели PRAM консистентности заключается в простоте ее
реализации, поскольку операции записи на одном процессоре могут быть
конвейеризованы: выполнение операций с общей памятью можно начинать не дожидаясь
завершения предыдущих операций записи (модификации всех копий страниц,
например), необходимо только быть уверенным, что все процессоры увидят эти
записи в одном и том же порядке.
PRAM консистентность может приводить к
результатам, противоречащим интуитивному представлению. Пример:
| Процесс P1 | Процесс P2 |
| .......... | .......... |
| a = 1; | b = 1; |
| if (b==0) kill (P2); | if (a==0) kill (P1); |
| .......... | .......... |
Оба процесса могут быть убиты, что невозможно при последовательной
консистентности.
Модель процессорной консистентности отличается от модели
PRAM консистентности тем, что в ней дополнительно требуется когерентность
памяти: Для каждой переменной x есть общее согласие относительно порядка, в
котором процессоры модифицируют эту переменную, операции записи в разные
переменные - параллельны. Таким образом, к упорядочиванию записей каждого
процессора добавляется упорядочивание записей в переменные или группы
Рассмотрим, для примера, процесс, который в критической секции циклически читает и записывает значение некоторых переменных. Даже, если остальные процессоры и не пытаются обращаться к этим переменным до выхода первого процесса из критической секции, для удовлетворения требований описанных выше моделей консистентности они должны видеть все записи первого процессора в порядке их выполнения, что, естественно, совершенно не нужно. Наилучшее решение в такой ситуации - это позволить первому процессу завершить выполнение критической секции и, только после этого, переслать остальным процессам значения модифицированных переменных, не заботясь о пересылке промежуточных результатов, и порядка их вычисления внутри критической секции.
Предложенная в 1986 г. (Dubois et al.) модель слабой консистентности, основана на выделении среди переменных специальных синхронизационных переменных и описывается следующими правилами:
Второе правило гарантирует, что выполнение процессором операции обращения к синхронизационной переменной возможно только после выталкивания конвейера (полного завершения выполнения на всех процессорах всех предыдущих операций записи переменных, выданных данным процессором). Третье правило определяет, что при обращении к обычным (не синхронизационным) переменным на чтение или запись, все предыдущие обращения к синхронизационным переменным должны быть выполнены полностью. Выполнив синхронизацию перед обращением к общей переменной, процесс может быть уверен, что получит правильное значение этой переменной.
a) Пример допустимой последовательности событий.
| P1: | W(x)1 | W(x)2 | S | |||
| P2: | R(x)1 | R(x)2 | S | |||
| P3: | R(x)2 | R(x)1 | S |
б) Пример недопустимой последовательности событий.
| P1: | W(x)1 | W(x)2 | S | ||
| P2: | S | R(x)1 |
В отличие от предыдущих моделей консистентности, модель слабой
консистентности ориентирована на консистентность групповых операций
чтения/записи. Эта модель наиболее эффективна для приложений, в которых
отдельные (изолированные) обращения к общим переменным встречаются довольно
редко.
В модели консистентности по выходу введены специальные функции обращения к синхронизационным переменным:
(1) ACQUIRE - захват синхронизационной переменной, информирует систему о входе в критическую секцию;
(2) RELEASE - освобождение синхронизационной переменной, определяет завершение критической секции.
Захват и освобождение используется для организации доступа не ко всем общим переменным, а только к тем, которые защищаются данной синхронизационной переменной. Такие общие переменные называют защищенными переменными.
Пример допустимой последовательности событий для модели с консистентностью по
выходу. (Acq(L) - захват синхронизационной переменной L; Rel(L) - освобождение
синхронизационной переменной).
| P1: | Acq(L) | W(x)1 | W(x)2 | Rel(L) | ||||
| P2: | Acq(L) | R(x)2 | Rel(L) | |||||
| P3: | R(x)1 |
Следующие правила определяют требования к модели консистентности по выходу:
При выполнении всех этих требований и использовании методов захвата и освобождения, результат выполнения программы будет таким же, как при выполнении этой программы в системе с последовательной моделью консистентности.
- До выполнения обращения к общей переменной, должны быть полностью выполнены все предыдущие захваты синхронизационных переменных данным процессором.
- Перед освобождением синхронизационной переменной должны быть закончены все операции чтения/записи, выполнявшиеся процессором прежде.
- Реализация операций захвата и освобождения синхронизационной переменной должны удовлетворять требованиям процессорной консистентности (последовательная консистентность не требуется).
Существует модификация консистентности по выходу - ленивая. В отличие от
описанной (энергичной) консистентности по выходу, она не требует выталкивания
всех модифицированных данных при выходе из критической секции. Вместо этого, при
запросе входа в критическую секцию процессу передаются текущие значения
защищенных разделяемых данных (например, от процесса, который последним
находился в критической секции, охраняемой этой синхронизационной переменной).
При повторных входах в критическую секцию того же самого процесса не требуется
никаких обменов сообщениями.
Кроме того, критические секции, охраняемые одной синхронизационной переменной могут быть двух типов:
(а) Модели консистентности, не использующие операции синхронизации.
| Консистентность | Описание |
| Строгая | Упорядочение всех доступов к разделяемым данным по абсолютному времени |
| Последовательная | Все процессы видят все записи разделяемых данных в одном и том же порядке |
| Причинная | Все процессы видят все причинно-связанные записи данных в одном и том же порядке |
| Процессорная | PRAM-консистентность + когерентность памяти |
| PRAM | Все процессоры видят записи любого процессора в одном и том же порядке |
(б) Модели консистентности с операциями синхронизации.
| Консистентность | Описание |
| Слабая | Разделяемые данные можно считать консистентными только после выполнения синхронизации |
| По выходу | Разделяемые данные становятся консистентными после выхода из критической секции |
| По входу | Связанные с критической секцией разделяемые данные становятся консистентными при входе в нее |
WRITE-UPDATE - организуется обновление копий у всех владельцов.
К этому же типу DSM (не знающих заранее ничего о содержимом памяти) можно
отнести и аппаратные реализации на базе кэшей (Convex SPP).
Знание информации о режиме использования разделяемых переменных позволяет воспользоваться более эффективными протоколами когерентности.
Рассмотрим следующую программу, которая автоматически распараллеливается посредством размножения всех переменных на все процессоры и распределения между ними витков цикла.
s = 0;
izer = 0;
for (i = 1; i < L2-1; i++)
{
r = A[i-1]*A[i+1];
C[i] = r;
s = s + r*r;
if (A[i]==0) { izer = i};
}
A[izer] = 1;
r - приватно (фактически не является разделяемой);
C - раздельно используется (любой элемент массива изменяется не более, чем одним процессом, и никакой процесс не читает элемент, изменяемый другими);
s - редукционная переменная, используемая для суммирования;
izer - переменная, хранящая индекс последнего нулевого элемента массива А;
Приведения в консистентное состояние переменных A и r - не требуется.
Для приведения в консистентное состояние массива С необходимо при завершении цикла каждому процессу послать остальным все свои изменения в массиве С.
Для переменной s в конце цикла надо довыполнить операцию редукции - сложить все частичные суммы, полученные разными процессорами в своих копиях переменной s и разослать результат всем процессорам (если бы начальное значение переменной s было отлично от нуля, то это надо было бы учесть).
Переменной izer на всех процессорах при выходе из цикла должно быть присвоено то значение, которое было получено на витке цикла с максимальным номером (требуется фиксировать на каждом процессоре максимальный номер витка, на котором переменной присваивается значение. При распределении витков последовательными блоками между процессорами достаточно фиксировать сам факт изменения переменной каждым процессором).
Вне цикла приведение в консистентное состояние переменной A[izer] не
требуется, поскольку на каждом процессоре выполняется один и тот же оператор,
который присваивает одно и то же значение всем копиям переменной.
В таких случаях потери эффективности из-за доступа к данным через функции могут быть вполне приемлемыми, поскольку они могут сполна компенсироваться тем выигрышем, который достигается балансировкой загрузки.
 Содержание
курса
| Далее: Лекция
7. |
© Лаборатория Параллельных Информационных
Технологий, НИВЦ МГУ