ref (664672), страница 36

Просмтор этого файла доступен только зарегистрированным пользователям. Но у нас супер быстрая регистрация: достаточно только электронной почты!

Текст из файла (страница 36)

Действительно, P₀ истинен, когда t = N -1 и q = 0, и если t = 0 тогда из P следует, что

(i > 0 : state_Pi = passive)  (mc_P0+ q = B),

так что p₀ может определить завершение если state _P0 = passive и mc_P0 + q = 0.

Утверждение P₀ устанавливается, когда p₀ начинает волну, посылая маркер в p_{N -1} с q = 0. Отправление маркера сохраняет P₀, только если отправляют маркер пассивные процессы и добавляют значение их счетчека сообщений; поэтому мы принимаем следующее правило.

Правило 1. Процесс обрабатывает маркер только когда он пассивен, и когда процесс посылает маркер он прибавляет значение своего счетчика сообщений к q.

При этом, P сохраняется при отправлении маркера и также при внутренних действиях; к сожалению, P не сохраняется при получении сообщения процессом p, с i > t. При получении сообщения P₀ принимает значение ложь, то есть, это применимо только когда B> 0. Т.к. Почтовый сохраняется перед тем как принимает значение ложь,сохраняется P₁, где

P₁  (_{i  t} mc_Pi + q )>0.

Утверждение P₁ остается истинным при получении сообщения процессом p_i с i > t ; следовательно, более слабое утверждение P, определенное как P_m  (P₀  P₁) сохраняется при получениисообщения процессом p_i с i > t.

var state_p : {active, passive) ;

color_p : (white, black) ;

mc_p : integer init 0 ;

S_p: { state_p = active }

begin send ( mes ) ;

mc_p := mc_p + 1 (* Правило M *)

end

R_p: { Сообщение (mes) прибывает в p }

begin receive (mes) ; state_p := active ;

mc_p := mc_p - 1; (*Правило M *)

color_p := black (*Правило 2 *)

end

I_p: { state_p = active }

begin state_p := passive end

Начало определения, выполняется один раз процессом p₀:

begin send (tok, white, 0) to p_{N - 1} end

T_p: (* Процесс p обрабатывает маркер (tok,c,q ) *)

{ state_p = passive } (*Правило I *)

begin if p = p₀

then if (c = white)  (color_p = white) (mc_p + q = 0)

then Announce

else send (tok, white,0) to p_{N -1} (*Правило 4 *)

else if (color_p = white) (*Правила I and 3 *)

then send ( tok, c, q + mc_p ) to Next_p

else send ( tok, black, q + mc_p ) to Next_p ;

color_p := white (*Правило 5 *)

end

Алгоритм алгоритма 8.7 safra's.

Это измененное утверждение все еще позволяет обнаружить завершение процессу p₀ при тех же самых условиях, потому что, если t = 0, P₁ читает mc_P0 + q > 0, таким образом если mc_P0 + q = 0 (это уже требовалось для обнаружения), P₁ сохраняется. Отправление маркера сохраняет P₁, и тоже самое происходит при посылке основного сообщения. К сожалению, P₁ может принималь значение ложь при получении сообщения процессом p_i с i  t. Как и в Подразделе 8.3.1, эта ситуация исправляется назначение цвета каждому процессу по следующему правилу:

Правило 2. Процесс получающий сообщение становится черным и P заменяется на P_m  (P₀  P₁  P₂ ), где

P₂   j (t  j  0) : color_p = black.

При каждом получении соощения, при котором P₁ принимает значение ложь, P₂ принимает значение истинна, так что P не принимает значение ложь при любом основном действии. Так как (P  color_P0 = white  t = 0) P₂ , все еще возможно обнаружить завершение с новым утверждением, а именно, проверяя является ли p₀ белым (и пассивным) когда он обрабатывает маркер.

Ослабление P было успешно предотвращает изменение значения Р после основных событий; но более слабое утверждение может принять значение ложь при отправлении маркера, а именно, если процесс t - единственный черный процесс и он посылает маркер. Ситуация исправляется дальнейшим ослаблением P. Маркеру также назначается цвет (белый или черный) , и P ослабляется до P_m  (P₀  P₁  P₂ P₃), где

P₃  маркер черный.

Отправление маркера сохраняет P₃, если черные процессы отправляют черный маркер.

Правило 3. Когда черный процесс посылает маркер, маркер становится черным.

Т.к. (маркер белый)  P₃ завершение может все еще обнаруживаться процессом p₀, а именно, проверкой получает ли он белый маркер (и белый ли он сам и пассивный).

Действительно, теперь можно быть уверенным, что внутренние действия, основные коммуникации и отправление маркеров сохраняют P. Волна заканчивается неудачно, когда маркер возвращается в p₀, если он черный, p₀ черный, или mc_P0 + q  0. Если волна заканчивается неудачно, должна быть начата новая волна.

Правило 4. Когда волна заканчивается неудачно, p₀ начинает новую волну.

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

Заметим, что процесс p окрашивающий в белый цвет не изменяет заначение P на ложь если i > t, и что P всегда становится истинным когда p₀ начинает волну, посылая маркер в p_{N -1}.Из этого следует, что окрашивание в белый цвет может благополучно иметь место при отправлении маркера.

Правило 5. Каждые процесс становится белым сразу после посылки маркера. При этом гарантируется конечный успех волны после завершения основного вычисления. Алгоритм дается как Алгоритм 8.7.

Теорема 8.9 Алгоритм Сафра (Алгоритм 8.7) - правильный алгоритм обнаружения завершения для вычислений с асинхронным прохождением сообщений.

Доказательство. Алгоритм был разработан так, что предикат P, определенный как P_m  (P₀  P₁  P₂ P₃) - инвариант алгоритма.

Чтобы показать безопасность, заметим, что завершение обнаружевается при t = 0, state_P0 = passive, color_P0 = white, и mc_P0 + q = 0.Из этих условий  P₃,  P₂, и  P₁, следовательно P_m  P₀, из чего вместе с state_P0 = passive и mc_P0 + q = 0 следует term.

Чтобы показать живость, заметим, что после завершения основного вычисления счетчики сообщений не изменяют свои значения и их сумма, равняется 0. Волна, начатая в такой конфигурациизаканчивается с mc_P0 +q = 0 и все процессы окрашены в белый цвет, что гарантирует, что следующая волна будет успешной. 

В отличие от алгоритма Dijkstra-Feijen-Van Gasteren, алгоритм Сафра не имеет ограниченной сложности для худшего случая; маркер может быть пропущен неограниченное число раз, в то время как все процессы - пассивные, но некоторые основные сообщения находятся в процессе передачи в течение длительный периода времени. Что касается алгоритма Dijkstra-Feijen-Van Gasteren, для основного вычисления со сложностью времени T можно ожидать выполнения (T + N) сообщений.

Векторно-расчетный алгоритм. Mattern [Mat87] предложил алгоритм, сопоставимый с алгоритмом Сафра, но который поддерживает отдельный счетчик сообщений для каждого адресата. Для процесса p счетчик сообщений - массив mc_p[P]. Когда p посылает сообщение q, p изменяет счетчик mc_p [q] := mc_p [q]+l и когда p получает сообщение, он изменяет счетчик mc_p [p] := mc_p [p] - 1. Маркер также содержит массив счетчиков, и когда p обрабатывает маркер, к mc_p добавляется в маркер и обнуляется (массив в начале содержит нули). Завершение обнаружено, когда маркер равняется 0.

Алгоритм векторного-подсчета имеет некоторые преимущества по сравнению с алгоритмом Сафра, но также и страдает от некоторых серьезных неудобств. Одно из преимуществ алгоритма состоит в том, что завершение обнаруживается быстрее, а именно за один обход маркера после возникновения завершения. Второе преимущество состоит в том, что пока вычисление не закончилось, маркер приостанавливается чаще, что может уменьшить число управляющих сообщений, используемых алгоритмом. В алгоритме Сафра, каждый пассивный процесс передает маркер; в алгоритме векторного подсчета такой процесс p не будет отправлять маркер если из информации, содержащейся в маркере следует, что сообщение находиться на пути к p.

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

8.3.3 Использование Подтверждений

Алгоритм Сафра подсчитывает основные сообщения, которые посланы и получены, чтобы знать есть ли основные сообщения, находящиесы в процессе передачи. Также возможно гарантировать это используя подтверждения; несколько авторов предложили такое усовершенствование алгоритма Dijkstra-Feijen-Van Gasteren, см., например, Naimi [Nai88]. Это разновидность принципа обсуждается лишь кратко, потому что результирующий алгоритм не во всех смыслах является усовершенствованием алгоритма Shavit-Francez, и поэтому устарел.

Сначала, заметим, что никакое сообщение не находится в процессе передачи эквивалентено для всех p никакое сообщение, посланное p не находится в процессе передачи. Каждый процесс ответственен за сообщения, которые он послало, то есть, он должен позабититься о том, чтобы алгоритм объявления не был вызван, пока не будет уверенности в том, что все основные сообщения, посланные им получены. Метод обнаружения определяет для каждого процесса p локальное условие quiet(p) таким образом, что

quiet(p)  (state_p = passive  никакие основный сообщения, посланные процессом р не находятся в процессе передачи)

удовлетворен. Тогда (p : quiet(p))  term.

Чтобы устанавить, что никакое сообщение, посланное p не находится в процессе передачи, каждое сообщение подтверждается, и каждый процесс поддерживает счетчик числа подтверждений, которые он должен еще получить. Формально, утверждение P_ определяется как

P_ = p : (unack_p = # (передается сообщение,посланное p) + # (передается подтверждение для p))

и поддерживается инвариант в соответствии с следующим правилом.

var state_p : (active, passive) ;

color_p : (white, black) ;

unack_p : integer init 0 ;

S_p: { state_p = active }

begin send (mes) ; unack_p:= unack_p + 1 : (* Правило A *)

color_p := black (*Правило B *)

end

Характеристики

Список файлов реферата