제 3 장 병렬처리를 위한 소프트웨어 기술

제 3 장 병렬처리를 위한 소프트웨어 기술

3.1

프로세서 동기화와 상호배타 방식

3.2 프로세서 스케줄링

3.3 문제 분할

3.4 병렬 알고리즘

Parallel Computer Architecture 1-2

3.1 프로세서 동기화와 상호배타 방식

MIMD 형 병렬컴퓨터들이 가져야 할 새로운 기능들 프로세서들 간의 데이터 교환 : 데이터 의존성 (data dependency) 에

따른 공유 변수들 (shared variables) 의 상호 교환 시스템 공유 자원의 상호 배타적 사용 : 공유 자원 (shared resources)

에 대한 중복 사용 방지 프로그램 실행 시작시간의 동기화 : 계산 과정에서 각 계산 주기마다

프로세서들 간에 처리 시작시간 일치 ( 동기식 병렬 알고리즘 )

병렬처리를 위한 오버헤드 (overhead) 발생 : 추가되는 기능들을

위한 H/W, 프로그램 코드 및 처리 시간


상호배타 메커니즘 (mutual exclusion mechanism)

임계 영역 (critical section)

S/W 를 이용한 상호배타 방식의 구현 방법에서 공유 자원을 이용하기 위하여 수행해야 하는 프로그램 영역

프로세서가 어떤 공유자원을 이용하는 것은 이 영역의 프로그램 코드를 실행함으로써 가능

상호배타 방식 (mutual exclusion mechanism) : 한 번에 한 프로세서만 임계영역을 수행하도록 허용함으로써 구현

임계 영역의 수 : 공유자원 당 한 개 , 혹은 같은 종류의 여러 공유 자원들에 대하여 한 개 존재


프로세서 동기화 (processor synchronization)

목적 시스템의 상태 또는 공유 데이터의 전송 시간에 따라 프로세서들 간의

동작 시간을 일치시키는 것

방법 H/W 기술 + S/W 기술

S/W 기술

o 시스템 혹은 데이터의 상태를 나타내는 공유 변수가 상호 배타적으로 액세스가 가능해야 함 동기화 방식 = 상호배타 방식


프로세서 동기화 및 상호배타 방식의 구현

Bus-locking 방식

Spin-lock 방식

세마포아 (semaphore) 방식

Full/empty 플래그를 이용한 방식

Fetch-and-Add 명령어를 이용한 방식


설명을 위한 시스템 환경

단일 - 버스 공유 - 기억장치 다중프로세서 시스템 ( 프로세서 수 = n)

공유 기억장치에 임계영역 ( 프로그램 코드들 ) 과 공유 변수 (S) 가 저장되어 있는 상태


3.1.1 Bus-locking 방식 프로세서가 버스에 접속된 공유 자원을 액세스하는 동안에는 버스를

독점함으로써 다른 프로세서들이 버스를 사용하지 못하게 하는 방식 구현 방법 : bus locking( 버스 잠금 ) 을 위한 특수 명령어 및 H/W 사용

[ 예 ] 80x86 계열 프로세서의 LOCK 명령어 동작 순서

1. 버스 요구 (bus request) 의 발생

2. 버스 중재에 의한 버스 사용허가 (bus grant) 획득

3. 버스 잠금 (bus locking)

4. 임계영역 (critical section) 의 실행 : 공유 자원의 사용

5. 버스 잠금의 해제 (bus release)


Bus-locking 방식 ( 계속 )

상호배타 프로그램

LOCK(bus);

임계 영역 (C.S.) 의 실행 UNLOCK(bus);

Bus locking 방식을 이용한 경우의 시스템 동작 :


Bus-locking 방식 ( 계속 )

장점

구조가 간단

버스 경합이 없기 때문에 임계영역 실행 시간이 짧다

단점

한 프로세서가 임계 영역을 실행하는 동안에는 버스상의 다른 공유 자원을 사용하려는 모든 프로세서들이 기다려야 하므로 시스템 성능이 저하된다


3.1.2 Spin-lock 방식

Lock 변수의 상태를 검사하여 , 허가된 경우에만 임계 영역을 실행하도록 하는 방식 한 번에 한 프로세서만 공유자원 사용

구현 방법 공유 변수 S 를 lock 변수로 사용

공유자원을 사용하려는 프로세서는 Lock 변수 S 를 검사하여 ,

o 공유변수 S = 0 이면 , 임계영역 실행을 시작

o 공유변수 S ≠ 0 이면 , S 에 대한 반복 검사 (spin-lock) 수행


Spin-lock 방식 ( 계속 )

Spin-lock 에 의한 시스템 동작



상호배타 프로그램 ( 공유변수 s 의 초기값 = 0)

do { Test&Set(S) } while (S != 0) ;

임계영역 실행

S = 0 ;

S 검사 및 locking 동작 (do while 문 ) 에 대한 어셈블리 프로그램 :

LOCK(S)

LOCK: LOAD AC, S ; S 를 레지스터에 적재

CMP AC, #0 ; zero(0) 검사

JNZ LOCK ; 만약 0 이 아니라면 , 검사 반복

STO S, #1 ; S 에 1 을 저장

RET



Locking release 를 위한 루틴 : UNLOCK(S)

UNLOCK : STO S, #0 ; S 에 0 을 저장

RET

문제점 : 두 개 이상의 프로세서들이 동시에 S 에 대한 검사를 수행하는 경우에 , 먼저 S 를 읽은 프로세서가 S 를 1 로 세트하기 전에 다른 프로세서가 S 를 읽어간다면 , 두 프로세서들이 모두 임계영역에 들어가게 됨 ( 상호배타가 지켜지지 못함 )

[ 원인 ] S 에 대한 검사와 세트가 원자적으로 (atomically) 수행되지 않기 때문에 발생 .



해결 방법 : S 에 대한 읽기 - 수정 - 쓰기 (read-modify-write)

를 원자 연산 (atomic operation; primitive operation, 혹은 in

divisible operation 이라고 부름 ) 으로 수행

[ 예 ] M68030 의 TAS reg, mem 명령어 :

- 기억장치 mem 번지의 데이터를 읽어서 레지스터에

저장하고 ,

- 그 값에 따라 플래그를 세트한 후에 ,

- mem 번지에 1 을 저장

( 위의 모든 동작이 수행되는 동안 기억장치는 locking 됨 )



‘TAS 명령어’를 이용한 LOCK(S) 프로그램 LOCK : TAS AC, S ; AC S, 플래그 세트 , &

; s 1

JNZ LOCK ; 만약 S ≠ 0, TAS 반복 수행 RET

상호배타 프로그램 :

LOCK(S)

임계영역 실행 UNLOCK(S)



장점 어떤 프로세서가 공유자원을 사용하는 동안에도 다른 프로세서들이

버스를 통한 시스템 동작을 계속할 수 있다

단점 반복 검사를 수행하는 프로세서들에 의해 버스 통신량 (traffic) 이

높아져 시스템 성능이 저하된다

Test&Set 함수 혹은 TAS 명령어의 반복 실행에 따른 S/W

오버헤드 때문에 전체 프로그램 실행 시간이 길어진다



변형들 (variants)

(1) Test&Set with Backoff : 프로세서가 S 검사를 위해

다시 액세스하기 전에 약간의 지연 (delay) 을 가지도록

하는 방식 .

[ 예 ] 지연 시간 : 처음에는 k, 그 이후는 k x ci ( 단 , c 는

시스템에 따른 상수 )



(2) Test-and-Test&Set : S 애 대한 반복 검사 과정 동안에 버스 통신이 발생되지 않도록 하는 방법< 순서 >

① Test&Set(S) 수행 S 가 캐쉬에도 적재

② 임계영역에 들어가지 못한 프로세서들은 이후의 S 에 대한 검사 동작을 내부적으로 수행 : 자신의 캐쉬 반복 액세스 (local

access)

③ 공유자원 release (S=0) 캐쉬의 S 무효화 캐쉬 미스 기억장치로부터 S 액세스

④ 만약 S=0, Test&Set(S) 를 수행하고 , 임계영역 실행만약 S≠0, ② 번부터 다시 수행



Test-and-Test&Set 을 위한 상호배타 프로그램

Test&Set(S) ;

repeat: do { Load(S) } while (S != 0) ;

Test&Set(S) ;

if (S != 0) goto repeat ;

임계영역 실행

S = 0 ;


3.1.3 세마포아 방식

procedure P(S) --> 최초 S 값은 1 임

while S=0 do wait --> S 가 0 면 1 이 될때까지 기다려야 함

S := S-1 --> S 를 0 로 만들어 다른 프로세스가 들어 오지 못함

end P

procedure V(S) --> 현재상태는 S 가 0 임

S := S+1 --> S 를 1 로 원위치시켜 해제하는 과정 . 이제는 다른

프로세스가 들어 올수 있음

end V

P 와 V 는 쪼갤수 없는 단일 연산이다 . | | 즉 한 프로세스가 P 나 V

를 수행하고 있는 동안에는 프로세스가 인터럽트를 당하지 않는다


세마포아 방식 ( 계속 )

P & V 연산을 이용한 상호배타 메커니즘 P(S)

임계영역 실행 V(S)

최초에 S 의 값은 1 이다 . 위와 같은 CS 를 포함하는 두개의 프로세스 A 와 B 가 있다고 하자 . A 와 B 는 서로 독립적으로 수행되지만 , 두 프로세스가 동시에 CS 로 들어가서는 안된다 . 위와 같이 세마포어를 사용하면 P(S) 를 먼저 수행하는 프로세스가 S를 0 으로 해놓고 CS 에 들어가므로 나중에 도착하는 프로세스는 P에서 더이상 진행되지 못하고 기다리게 된다 . 먼저 들어갔던 프로세스가 V(S) 를 해주어야 비로서 P(S) 에서 기다리던 프로세스가 위험지역에 들어갈 수 있고 따라서 상호배제가 실현된다 .



P & V 연산의 구현 방법 struct semaphore {

int count ;

queueType queue ;

}

void P (semaphore S)

{ S.count-- ;

if (S.count < 0)

{ 프로세서는 ID 를 S.queue 에 저장하고 , 대기 (wait) }

}



void V (semaphore S)

{ S.count++ ;

if (S.count <= 0)

{

S.queue 로부터 프로세서 ID 를 꺼내어 , 그 프로세서로

wakeup 신호 전송

}

}



장점

반복검사가 없으므로 버스 교통량 감소

버스 잠금이 없으므로 다른 공유자원 사용 가능

단점

Wakeup 신호 발생을 위한 H/W 필요

S/W 오버헤드가 크다

임계영역 실행 시간이 긴 경우에 적합 ( 짧은 경우에는 spin-lock

방식이 더 적합 )


3.1.4 배리어 동기화 방식

배리어 (Barrier; 장벽 ) : 동기식 병렬 알고리즘을

처리하는 과정에서 , 계산에 참여한 모든 프로세서들이

다음 동작의 시작 시간을 일치시키기 위하여 기다려야

하는 사건 ( 예 : 모든 프로세서들의 한 주기 계산 종료 )

배리어 동기화 (Barrier Synchronization) : 배리어를 이용하여

프로세서들의 시간을 일치시키는 동작


배리어 동기화 방식 ( 계속 )

배리어 동기화 방식을 이용한 반복 계산 프로그램단 , bar1 : 동기화 변수 , p : 계산에 참여한 프로세서들의 수

계산 수행BARRIER(bar1, p);

계산 수행BARRIER(bar1, p);

계산 수행 :


배리어의 구현 방법 struct bar_type {

int counter; struct lock_type lock; int flag = 0; } bar_name;

BARRIER (bar_name, p) { LOCK(bar_name.lock); if (bar_name.counter == 0) bar_name.flag = 0; /* 만약 첫 번째 프로세서라면 , 플래그를 리셋 */ mycount = bar_name.counter++; /* 카운터를 증가시키고 , 지역 변수에 복사 */ UNLOCK(bar_name.lock); if (mycount == p) { /* 만약 마지막 프로세서라면 , */ bar_name.counter = 0; /* 카운터 값을 0 으로 리셋 */ bar_name.flag = 1; /* 대기 중인 프로세서들에게 종료를 통보 */ } else while (bar_name.flag == 0) { }; /* 플래그가 세트될 때까지 대기 */ }


3.1.5 Full/empty flag 를 이용한 방식

공급자 - 소비자 관계 (producer-consumer relationship) :

데이터 의존성이 존재하는 경우에 , 데이터를 교환하는 두 프로세서들 간의 관계

공급자 : 공유변수를 보내주는 프로세서

소비자 : 공유변수를 받아서 사용하는 프로세서


Full/empty flag 를 이용한 방식 ( 계속 )

공유변수의 도착시간과 사용시간의 차이에 따른 상황

프로세서 2 가 공유변수를 사용할 시점보다 먼저 그 변수가 도착하는 경우 즉시 공유변수 사용

프로세서 2 가 공유변수를 원하는 시점까지 그 변수가 전송되지 않은 경우 대기 (wait)

공유변수의 도착 ( 혹은 새로운 값으로 갱신 ) 을 확인하는 방법

Full/empty flag 이용

o Flag = 0 : 데이터가 도착 ( 혹은 갱신 ) 되지 않음

o Flag = 1 : 데이터가 도착 ( 혹은 갱신 ) 되었음


사례

Full/empty flag 를 이용한 동기화 방식

P1 P2

---------- --------------------------------

a = f(x) ; while (flag == 0) do nothing ;

flag = 1 ; b = g(a) ;


Full/empty flag 가 H/W 로 구현된 기억장치 구조

H/W 로 구현된 full/empty flag 를 이용하는 경우

P1 P2

---------- --------------------------------

a = f(x) ; b = g(a) ;


3.1.6 Fetch-and-Add 명령어를 이용한 방식 다단계 상호연결망 (MIN) 인 공유 - 기억장치시스템에서 Fetch_and_add(V,e)

명령어를 이용한 상호 배타 및 프로세서 동기화 방식

New York Univ. 전산학과에서 연구용으로 개발한 NYU Ultracomputer 에서

구현 (Omega Network 이용 : 238쪽 , 그림 6-25 참조 )

F&A(V,e) 명령어 ( 단 , V : 공유변수 , e : 임의의 정수 )

Pi : F&A(V,ei) Pi V

Pj : F&A(V,ej) Pj V + ei

V V + ei + ej

기억장치 모듈과 직접 연결된 스위치에 두 개 ( 이상 ) 의 F&A 명령어를 통합

처리하기 위한 H/W 포함 기억장치 액세스 수 = 1

동일한 기억장소에 대한 동시 액세스들을 직렬화 (serialization)


F&A 명령어가 실행되는 과정


F&A 명령어의 사용 예

[ 예제 3-2] 세 개의 프로세서들이 각각 F&A(V,2) 명령어를 동시에

실행하였고 , 그에 따른 기억장치 요구들이 스위칭 소자에

도착한 순서가 P2, P3, P1 이었다고 가정하자 . 명령어 실행들이

종료된 후에 각 프로세서들에게 보내지는 값들과 공유 변수 V

의 최종값은 무엇이 되는가 ? 단 , V 의 초기값은 0 이다 .

[풀이 ] P2 로 보내지는 값 = 0 (V 의 초기값 )

P3 로 보내지는 값 = 2 (V+2)

P1 으로 보내지는 값 = 4 {(V+2)+2}

V 의 최종값 = 6 [{(V+2)+2}+2]


F&A 명령어의 사용 예

[ 예제 3-3] 다섯 개의 프로세서들이 다음과 같은 벡터 계산 프로그램을 분담하여 처리하는 경우에 , 각 프로세서는 자신이 담당할 벡터 요소 (vector element) 의 인덱스 i 를 할당받기 위하여 F&A(i,1) 을 실행한다 . 첫 번째 계산을 완료하면 , 프로세서는 다시 F&A(i,1) 명령어를 실행하여 다음 인덱스를

할당받는다 . 명령어가 실행된 순서가 P1, P2, P3, P4, P5인 경우

에 , 각 프로세서들이 할당받게 되는 i 값들을 구하라 . 단 , i

의 초기값은 1 이다 .

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

a[i] = b[i] + c[i];


[ 예제 3-3] ( 계속 )

[ 풀이 ] 모든 프로세서들은 아래와 같이 할당되는 인덱스들을 이용하여 두 번씩의 계산을 수행한다 .

첫 번째 계산 두 번째 계산

P1 에게 할당되는 i = 1 6






3.2 프로세서 스케줄링

병렬컴퓨터에서 Sp < N 이 되는 주요 원인들

병렬처리 오버헤드

낮은 시스템 효율 : 불균등한 작업 할당 , 데이터

의존성

[ 개선 방안 ]

o 프로세서들에게 균등한 작업량 할당

o 프로세서간 통신량이 최소화되도록 문제 분할

o 데이터 의존성이 존재하는 부분은 어느 한 프로세서

혹은 근접한 위치의 프로세서에 할당


프로세서 스케줄링 (processor scheduling)

분할된 작업 ( 태스크 ) 들을 프로세서들에게 적절히 할당하는 과정

프로세서 이용률 향상을 위하여 가능한 한 균등하게 할당

데이터 의존성에 따른 데이터 전송량이 최소화되도록 할당

스케줄링의 분류 결정적 스케줄링 (deterministic scheduling) : 스케줄링 단계에서

태스크의 특성 ( 처리 시간 , 처리 순서 및 데이터 의존성 ) 에 대한 정보를 미리 알고 있는 상태에서 스케줄링 하는 방식

비결정적 스케줄링 (non-deterministic scheduling) : 태스크 처리시간을 임의 변수 (random variable) 인 것으로 가정하고 스케줄링 하는 방식


3.2.1 처리 시간 및 선행 관계에 따른 스케줄링

스케줄링의 목표

한정된 수의 프로세서들을 이용하여 최단 시간 내에 처리를 완료하는 것

프로세서 수가 무한대일 때 최단 시간 내에 처리

선행 그래프 (precedence graph)

태스크들 간의 처리 순서 관계를 보여주는 그래프

그래프의 폭 (width) : 동시에 처리될 수 있는 태스크의 최대 수

흐름 시간 (flow time) : 각 태스크 처리에 걸리는 시간


선행그래프의 예

모든 테스크들의 처리 시간이

동일하다고 가정

T1 < T2 < T4 ...

그래프 폭 = 3

그래프 깊이 = 5


간트 도표

간트 도표 (Gantt chart) : 시간 흐름도 (timing diagram)

시스템 효율 :

(a) : 10/12x100 = 83.3%

(b) : 10/15x100 = 66.7%

[%]100슬롯 시간 전체슬롯 시간 사용된 실제

Ep


사용 가능한 최대 프로세서 수 = 선행 그래프의 폭(width)

처리에 걸리는 최단 시간 = 선행 그래프의 깊이 (depth)


스케줄링의 예 (I) : 태스크의 흐름 시간이 다른 경우


스케줄링의 예 (II) : 중단 (preemption) 이 적용된 경우


스케줄링 예 (II) 의 간트 챠트


스케줄링의 예 (III) : 프로세서 수의 영향 분석

같은 시간 내에 처리가 완료될 수 있다면 시스템 효율을 향상시키기 위하여 가능한 적은 수의 프로세서들을 사용하도록 스케줄링

스케줄링의 예 [III] : 프로세서 수와 처리 시간


3.2.2 프로세서간 통신시간을 고려한 스케줄링

통신시간과 스케줄링의 상관관계[ 예 ]


프로세서간 통신시간을 고려한 스케줄링 ( 계속 )

효과적인 병렬처리를 위해서는 프로세서간 통신시간에 따라 ,

스케줄링뿐 아니라 그레인의 크기도 달라져야 한다

[ 사례 ] 아래 17개의 태스크들에 대한 스케줄링 ( 단 , T1~T6 = 1, T7~T17 = 4, 통신 = 8 단위시간 소요 )

T1: a = 1; T10: j = e×f T2: b = 2; T11: k = d×f T3: c = 3; T12: l = j×k T4: d = 4; T13: m = 4×l T5: e = 5; T14: n = 3×m T6: f = 6; T15: o = n×i T7: g = a×b; T16: p = o×h T8: h = c×d T17: q = p×g T9: i = d×e


작은 그레인을 이용한 스케줄링의 결과

9

7


그레인 패킹 (grain packing) 을 이용한 스케줄링의 결과

프로세서간 통신시간이 태스크 수행 과정에서 지연을 발생하지 않도록 스케줄링 전체 처리 시간이 패킹을 하지 않은 경우보다 길어짐


3.3 문제 분할 (problem partition)

하나의 (응용 ) 문제를 병렬처리가 가능한 여러 개의 작은 부분들로 나누는 과정

균등 분할 : 모든 프로세서들에 할당되는 작업량 ( 계산량 ,

계산시간 ) 이 같은 경우 완전한 균등 분할은 거의 불가능

프로세서간 데이터 교환 : 프로세서들간의 통신량 ( 데이터 교환량 ) 이 최소화되도록 문제 분할


3.3.1 선형방정식 계산에서의 문제분할

Ax = b

역 매트리스 (inverse matrix) 변환 후에 매트리스 -벡터 곱셈을 이용하여 x 값들을 구하는 경우 (8x8)

A-1b = x


선형방정식 계산에서의 문제분할 ( 계속 )

계산을 위한 C 프로그램 for (i = 1; i <= 8; i++) {

x[i] = 0

for (j = 1; j <= 8; j++) {

x[i] = x[i] + A[i][j] x b(j)

}

}

문제분할 프로세서 수 = 2, 4, 혹은 8 개일 경우 : 균등 분할 가능

프로세서 수 = 3 인 경우 : 불균등 분할 ( 프로세서간 통신 필요 )



균등 분할의 예 ( 프로세서 수 = 2)









불균등 분할의 예 ( 프로세서 수 = 3)



필요한 데이터 교환

P1: (A31*b1 + A32*b2 + A33*b3 + A34*b4 + A35*b5) 의 계산

결과를 P2 로 전송

P2: (A61*b1 + A62*b2 + A63*b3) 의 계산 결과를 P3 로 전송

다른 데이터 교환 방법

P1: (A36*b6 + A37*b7 + A38*b8) 의 계산 결과를 P1 으로 전송 .

P2: (A64*b4 + A65*b5 + A66*b6 + A67*b7 + A68*b8) 의 계산

결과를 P2 로 전송 .


3.3.2 편미분방정식 계산에서의 문제 분할

편미분방정식 (Partial Differential Equation : PDE)

평면상에서 경계 조건 (boundary condition) 이 0 으로 주어졌을

때 평면상의 각 점 (spot: grid 라고도 함 ) 의 값들이 시간에

따라 변하는 과정과 steady state 값을 찾아내는 식 Laplac

e 방정식으로 표현0

2

2

2

2

y

u

x

u


편미분방정식 계산에서의 문제 분할 ( 계속 )

유한차이법 (finite difference method) 을 이용한 계산

)},(),(),(),({4

1),( 1111 iiiiiiiiii yxGyxGyxGyxGyxG



9 개의 점들에 대한 문제 분할의 결과 ( 프로세서의 수 = 4)



48 개의 점들에 대한 문제 분할의 결과 ( 프로세서의 수 = 9)


3.4 병렬 알고리즘

3.4.1 동기식 병렬 알고리즘 (synchronous parallel algorithm)

프로세서들의 계산 시작 시간을 일치시켜 처리하는 알고리즘

PDE 를 Jacobi’s iterative method 로 계산하는 과정

① 각 프로세서는 자신에 할당된 점 (grid) 의 값을 계산

② 이전 주기 (previous iteration) 의 값과 현재 값의 차이를 허용오차 (ε) 와 비교

③ 수렴 조건 (|G(i-1) – G(i)| < ε) 을 만족하면 통보

④ 모든 프로세서들이 현재 주기를 종료할 때까지 대기 : 계산 주기 < 동기화 >

⑤ 데이터 전송 : 계산된 값들을 다른 프로세서들에 전송

⑥ 모든 프로세서들의 데이터 전송 완료 시까지 대기 : 데이터 전송 주기 <

동기화 >

⑦ 모든 프로세서들이 수렴 종료를 통보한 경우에는 전체 계산 종료 .

그렇지않으면 , ①번부터 반복


동기식 병렬 알고리즘 ( 계속 )

① ~ ④ : 계산 주기

⑤ ~ ⑦ : 데이터 교환 주기

④, ⑥ : 프로세서 동기 ( 배리어 동기화 방식을 이용 )

계산 주기 수행

BARRIER(pde_synch, p);

데이터 교환 주기 수행

BARRIER(pde_synch, p);


배리어 동기화 루틴

BARRIER (pde_synch, p)

{

LOCK(pde_synch.lock);

if (pde_synch.counter == 0)

pde_synch.flag = 0; /* 만약 첫 번째 프로세서라면 , 플래그를 리셋 */

mycount = pde_synch.counter++; /* 카운터를 증가시키고 , 지역 변수에 복사 */

UNLOCK(pde_synch.lock);

if (mycount == p) { /* 만약 마지막으로 종료한 프로세서라면 , */

pde_synch.counter = 0; /* 카운터를 0 으로 리셋 */

pde_synch.flag = 1; /* 주기의 종료를 알림 */

}

else

while (pde_synch.flag == 0) { }; /* 플래그가 세트될 때까지 대기 */

}


3.4.2 비동기식 병렬 알고리즘

asynchronous parallel algorithm

매 주기 종료 시에 , 프로세서들 간에 다음 주기의 시작을

일치시키지 않고 즉시 다음 주기를 시작하는 방식

계산 주기와 데이터 교환 주기도 별도 구분되지 않는다

PDE 의 계산 순서

1. 프로세서는 할당된 점의 값을 계산하고 , 즉시 전송

2. 이전 주기 값과 비교하여 수렴 여부 검사

3. (2) 가 만족 시 수렴 통보

4. 모든 점들이 수렴된 경우에는 계산 종료 , 그렇지않은 경우에는

(1) 부터 반복


비동기식 병렬 알고리즘 ( 계속 )

장점 동기화 과정이 필요하지 않으므로 S/W 오버헤드가 없다

프로세서 대기 시간이 없다 프로세서 이용률 증가

다른 프로세서가 계산한 새로운 값들을 즉시 사용할 수 있으므로 수렴 속도가 빨라져 , 반복횟수가 줄어든다 전체 계산에 걸리는 시간 단축

단점 계산 결과가 수렴하지 못하고 발산 (diverge) 할 수 있으므로

알고리즘의 검토 및 수정이 필요

Documents

제 3 장 병렬처리를 위한 소프트웨어 기술