MPI (Message Passing Interface)

MPI (Message Passing Interface)

MPI (Message Passing Interface) 란 무엇인가?

MPI 자체는 병렬 라이브러리들에 대한 표준규약이다. (125개의 서브 프로그램들로 구성되어 있다.) MPI로 만들어진 병렬 라이브러리를 사용한다면 작성된 응용프로그램이 source level의 호환성을 보장받을 수 있다. MPI는 약 40개 기관이 참여하는 MPI forum에서 관리되고 있으며, 1992년 MPI 1.0 을 시작으로 현재 MPI 2.0까지 버전 업된 상태이며 이들 MPI를 따르는 병렬 라이브러리로는 Ohio supercomputer center 에서 개발한 Lam-MPI 와 Argonne National Laboratory 에서 개발한 MPICH가 널리 사용되고 있다. MPI 2.0에서는 동원되는 프로세스의 수를 시간에 따라서 바꿀 수도 있다. 또한, 병렬 I/O를 지원한다. 메시지 = 데이터+송신지와 수신지 주소

병렬 프로그래밍의 모델들로는 아래와 같은 것들이 있다.

PVM

MPI

OpenMP : 공유메모리 병렬 컴퓨팅의 사실상의 표준이다.

UPC

HPF

왜 MPI인가?

전산물리학을 하는 입장에서 간단하게 말하면, 뭐, 업계의 standard라고 하니 따르겠습니다. 컴퓨터의 기종에 관계없이 일반적인 병렬처리를 위해서는 MPI를 사용하는 것이 일반적으로 유리하다. 물론, OpenMP와 같이 거의 자동적으로 소스 코드를 병렬처리에 맞도록 재설계해 주는 경우 (kapf90 -conc -psyntax=openmp prog.f)도 있지만 SMP (여러 개의 프로세서가 버스를 통하여 하나의 거대한 메모리에 연결된 것. 공유메모리. 이와 같은 장비는 상대적으로 고가일 수밖에 없다. 프로세서 숫자의 확장에 상대적으로 심각한 제한이 있다. Compaq ES40, Sun E10000, HP N-class)와 같은 환경에서만 작동하며 일반적인 적용이 불가능하다. 위에서 언급한 방식으로는 유저가 원하는대로 자동으로 병렬화가 안된다. SMP기종과 달리 일반적인 클러스터 장비들에서는 모든 메모리가 모든 프로세서들에게 연결되어 있지 않다. C, (C++)언어나 포트란언어에서 같은 방식으로 사용되는 MPI를 이용하는 것이 병렬계산의 기본이다. 유저에 따라서는 PVM과 MPI를 동시에 사용하는 아주 전문적인 유저들 (병렬 계산 스페셜 리스트라고 할 만하다.)도 있다. 지역적으로 분산된 장비들을 사용하는 분산컴퓨팅 (distributed computing, cluster computing 과는 구별되는 것이다.) 방식에서도 MPI를 이용할 수 있다. http://www.myri.com : MPICH-GM, http://www.niu.edu/mpi : MPICH-G2

Top 10 Reasons to Prefer MPI Over PVM

1. MPI has more than one freely available, quality implementation. (LAM,MPICH,CHIMP)

2. MPI defines a 3rd party profiling mechanism.

3. MPI has full asynchronous communication.

4. MPI groups are solid and efficient.

5. MPI efficiently manages message buffers.

6. MPI synchronization protects 3rd party software.

7. MPI can efficiently program MPP and clusters.

8. MPI is totally portable. 컴퓨터의 기종에 상관없이 사용될 수 있어야 한다.

9. MPI is formally specified.

10. MPI is a standard.

물리학에서 왜 필요한가?

많은 전산 물리학 문제들이 병렬 알고리즘을 이용한 병렬처리를 하면 상대적으로 쉽게 풀리어진다. 그렇지 못한 경우도 물론 있다. 컴퓨터의 기원은 순차 알고리즘을 근간으로 한다. 이점을 생각하면, 격세지감을 느낀다. 바야흐로, 순차 알고리즘뿐만 아니라 병렬 알고리즘을 동시에 생각할 때가 된 것이다. 물론, 상당한 대가를 치르지만, 그 비용보다 얻는 것이 더 많다면 우리는 병렬계산을 한다. 잘 아시다시피 물리문제가 일반적으로 병렬처리가 용이하도록 정해져있지는 않다. 원천적으로 불가능한 것들도 많다.

많은 경우 전체 계산의 일부분은 병렬처리가 가능하다. 예를 들어 x %가 병렬 처리 가능하다면 병렬 컴퓨터 P대를 사용하면 한 대를 사용할 때보다도 100/{x/P+(100-x)} 배 정도 전체 계산이 빨라진다. 실제 계산에서는 병렬계산을 위하여 정보의 교환이 이루어진다. 이러한 절차 때문에 위의 식에서 표현되는 것보다는 효율이 나오지 못한다. 즉, 프로세서 간 정보의 교환이 병렬화의 효율을 떨어뜨린다. 실제의 계산에서는 하나의 프로그램에 여러 가지 데이터를 각각의 CPU가 자기에게 할당된 자료들을 구별하여 독자적으로 처리하는 형태로 프로그램이 완성된다. 이를 SPMD (single program multiple data)라고 한다. 모든 프로세스가 동일한 하나의 프로그램을 실행한다. 데이터를 분해하여 수행할 수도 있고, 서로 다른 함수들을 나누어서 실행할 수도 있다. 결국 실제 응용 프로그래밍하기가 훨씬 더 어려워 져 버리고 말았다. 결국, 가장 시간이 많이 소모되는 hot spot을 병렬화 할 수 있는가가 관건이다. 병렬 계산의 기본 조건: 같은 인풋에 같은 아웃풋, 사용하는 노드의 수에 관계없이.

병렬 컴퓨터의 발달: 1990년대 후반부터는 단일 프로세서를 이용한 컴퓨터는 www.top500.org (컴퓨터 성능 세계랭킹 500)에서 발견하기가 힘들어짐. 이들은 모두가 500위 이하로 밀려남. 초고성능의 단일 CPU 제작은 상당히 비경제적이다. 다시 말해서, 지금 수준의 단일 CPU들을 동시에 사용하는 것이 좋은 아이디어로 보임.

병렬컴퓨터 (베어울프, Beowulf 1994 년 여름) {Thomas Sterling and Donald Becker, CESDIS, NASA}

*16개의 486 DX4, 100MHz 프로세서 사용

*16 MB of RAM each, 256 MB (total)

* channel bonded ethernet (2x10Mbps)

Beowulf형으로 최초로 슈퍼 컴퓨터 성능 랭킹 www.top500.org에 등재된 컴퓨터 = Avalon: 140 alpha 21164A, 256MB/node, fast ethernet, 12 port Gigabit ethernet, 1998년 Bell Price/Performance prize (저비용 고효율)

블루진 (Bleu Gene) 컴퓨터는 100만개의 CPU를 이용하려고 한다. 이러한 목표의 시험용 버전인 Blue Gene/L은 32,768(=215)개의 CPU를 이용한다. 2004년 현존하는 최고의 컴퓨터이다. 와, 215개 이쯤되면 거의 막가자는 것이죠!

2004년 6월 Intel Itanium2, Tiger4 1.4GHz, Quadrics 4096 로 만든 클러스터 Thunder (LLNL)가 www.top500.org에서 2위에 랭크되었다. 뿐만 아니라 클러스터 형태의 컴퓨터가 슈퍼 컴퓨터 성능 상위 500위 내에서의 계속해서 점유도를 확장해가고 있다. 일단 병렬컴퓨터의 디자인과 실질적인 사용이 널리 보급된 지금 사실상 대부분의 컴퓨터 센터들을 병렬 컴퓨터를 구비하고 있다. 많은 유저들이 순차프로그램을 사용할 경우 그들에게 적당한 CPU를 할당해주면 되기 때문에 센터입장에서는 효율적으로 유저들을 지원하는 것이다. 유저들 입장에서도 변화가 일어나고 있다. 많은 슈퍼 컴퓨터 사용자들은 계속해서 제공되는 거대한 컴퓨터의 사용을 통해서 자신의 고유한 문제를 해결할 것으로 믿어 왔으나, 최근 동향은 그렇게 전개되고 있지 않다. 한 때 사장되었던 병렬 알고리즘이 리바이블되고 각 그룹마다 새로운 형식의 병렬 컴퓨터 계산이 득세하고 있다. 일반 PC사용자 수준에서는 변화가 없었다고 하더라도 컴퓨터를 이용한 연구 개발 프로젝트에서는 중대한 변화가 일고 있다. http://www.nersc.gov/

분산컴퓨팅 (distributed computing, cluster computing 과는 구별되는 것이다.) 방식으로 유명한 프로젝트는 seti@home, folding@home을 들 수 있다. 이러한 계산 방식은 미리 셋업을 해둔 컴퓨터들(클러스터)을 사용하는 것이 아니라 연구 그룹 이외의 자원하여 컴퓨터를 제공한 (물론, 인터넷을 통한 연결) 사용자의 컴퓨터를 이용하는 것이다. 위에서 언급한 프로젝트들에서는 윈도우, 맥, 리눅스, 유닉스를 가리지 않고 자원하여 제공한 일반 컴퓨터들을 사용하여 과학적 계산 결과들을 얻어낸다. 컴퓨터의 수가 엄청나게 많기 때문에 (1000 대 이상 사용) 많은 CPU시간을 확보할 수 있다.

free cluster (management) softwares:

http://oscar.openclustergroup.org/tiki-index.php

http://rocks.npaci.edu/Rocks/

http://www.mosix.org/

http://www.openpbs.org/

http://www.fysik.dtu.dk/CAMP/pbs.html

http://nfs.sourceforge.net/

http://www-unix.mcs.anl.gov/petsc/petsc-2/

병렬화 항상 필요한가?/병렬화 언제 필요한가?/병렬화의 이득과 비용은?

실제 병렬계산은 특정한 시스템에서 최적화되도록 만들 수밖에 없다. 보통의 이더넷을 통신장비로 사용할 경우 그 통신에 들어가는 시간이 과도하게 많은 경우가 많다. 즉, 계산을 해 버리는 경우가 더 낫을 수 있다. 왜냐하면, 최근에 사용되고 있는 CPU들의 성능이 컴퓨터 간 통신속도에 비해서 충분히 좋기 때문이다. 따라서 통신을 빨리할 수 있는 값싼 장비가 나와야 병렬 계산은 더욱 활성화될 것이다. processor들 사이의 통신 기술이 병렬 컴퓨팅 기법의 핵심 기술 사항이라는 것이다.

통신 장비는 데이터를 주고 받기 전 단계에 소모되는 latency (microsecond)시간 (당연히 짧을수록 좋다.)과 정보가 전해질 때 한꺼번에 얼마나 많이/빨리 전해질 수 있는가 (bandwidth; communication capacity; bits/sec) 라는 두 가지 특성이 있다. (전화를 건다고 생각할 때, 전화를 걸면 상대가 전화를 걸자마자 받지 않는다. 약간은 기다려야 한다:latency. 상대가 전화를 받아도 주어진 시간에 얼마나 많은 정보를 전달할 수 있는 가는 상황에 따라 다르다:bandwidth.) 데이터의 분할, 기능적 분할등을 따져 볼 수 있다.

적은 크기의 데이터를 여러 번 주고 받는 것 보다는 한번에 모아서 주고 받는 것이 유리하다. 이는 데이터 통신시 필요한 latency시간을 줄인다는 의미이다. 최악의 경우 (자주 일어나는 경우이다.) 두 개의 CPU를 사용하여 한 대의 CPU를 사용하는 경우보다 더 느린 계산을 할 수 있다. 고속 통신 장비는 고가이며 CPU 장비와 거의 동일한 가격을 요구한다. 즉, {CPU 16 대 +이더넷(저속 통신 장비) }이 {CPU 8대 + 미리넷(고속통신 장비 이름)}과 얼추 비슷한 견적을 낸다. 보통 유선 인터넷의 bandwidth가 100 Mbps이다. 기가비트 이더넷이 bandwidth에서 패스트 이더넷보다 우의를 보여서 병렬계산에 유리할 것이라고 생각되지만, 많은 경우 latency 때문에 별 효과를 못보는 경우가 많다. 대량의 정보교환이 자주 일어나지 않는 경우에는 오케이다. 일반적인 컴퓨터 코드에서 확실한 병렬 효율성을 확보하려면 결국 고가 장비 (Myrinet)를 사용해야 한다.

Fast Ethernet

Gigabit Ethernet

Myrinet

Quadrics 2

latency

120 microsecond

120 microsecond

7 microsecond

0.5 microsecond

bandwidth

100 Mbps

1 Gbps

1.98 Gbps

1 Gbyte/second

정말로 병렬화해야 되는가? 그렇다면, 다음의 두 가지 항목으로 견적을 내보자! 로드밸런싱과 스피드업

원하는 시기, 정확한 시기(각 CPU마다 원하는 시기)에 원하는 데이터의 송수신 이것이 MPI구현의 핵심이다. 한 가지 더 추가하면 알고리즘을 바꿀 필요가 있을 수도 있다는 것이다. 결과적으로 같은 일을 하여도 병렬화가 가능한 알고리즘과 그렇지 못한 알고리즘이 상존할 수 있다. 또 상황에 따라서는 알고리즘의 효율성이 다소 나쁘더라도 확실한 병렬화의 장점 때문에 병렬계산에서 대우받고 사용되는 알고리즘들도 많이 있다. 이러한 상황의 경우 그렇게 해야 한다면 반드시 따져봐야 할 항목이 있다. 결국, 가능한 한 CPU간 통신들을 줄이고 CPU중심의 계산들이 주축이 되도록 알고리즘을 만들 수 있는 가이다.

마지막으로, 다중처리장비와 소프트웨어 (MPI를 이용한 프로그램)를 통해서 소위 speedup을 원하는 수준까지 향상시킬 수 있는 가이다. 여기서 speedup은, x축을 사용한 CPU 수, y축을 하나의 계산을 수행할 때 CPU시간이 아닌 wall clock시간으로 소요된 전체계산 시간의 역수로 그래프를 그렸을 때, 많은 CPU를 사용하여 실질적인 전체 계산소요 시간의 단축된 정도를 의미한다. 예를 들어, 8대의 CPU를 사용하여 단일 CPU로 계산할 때 보다 7배의 정도 빨리 계산했다면 87.5 %의 speedup을 확보한 경우이다. 이 정도면 일주일에 걸쳐서 할 일을 하루 안(기본 가정: 하나의 CPU를 사용하여 24시간 계산해야 할 경우, 적당히 큰 계산, 큰 작업량 (? 여전히 좋은 표현은 아닌데)으로 봐 줄 수 있겠다.)에 할 수 있다는 것이다. (많은 사람들은 이정도면 만족하는데, 그렇지 못한 상황도 있을 수 있다. 즉, 일의 크기, 한 번 일을 할 때의 소요되는 계산 시간이 결국은 문제이다. 또 다른 형태의 문제로는 한 프로그램 수행에 있어서 메모리가 많이 잡히는 상황이다. 한 CPU에서 처리가 아예 불가능한 경우도 있을 수 있겠다.) 이 정도면 아주 성공적인 병렬계산을 수행한 경우라고 말 할 수 있겠다. 물론, 사용하는 알고리즘이 허용하는 경우에 한해서이다.

또한 기술적으로 (하드웨어 적으로) 고속 통신망을 사용하느냐 안하느냐에 따라서 결정적으로 위의 퍼포먼스는 달라 질 수 있다. 황당한 경우이지만 2개의 CPU를 사용했는데 전체 계산 시간이 1개의 CPU를 사용하는 경우보다 느려지는 경우가 있다. 과도한 CPU간 통신들이 고성능 CPU의 발목을 잡고 있는 경우이다. 이 보다 더 나쁠 순 없다. 병렬계산 최악의 상황이라고 할 수 있다. 고속통신 장비가 필수불가결한 경우이다. 물론, 이 때 다시한번 따져봐야 할 것이 load balancing (CPU 들에게 얼마나 골고루 일들이 균일하게 분배되었는가? 거의 동시에 CPU중심의 계산이 마무리되는가?)일 것이다.

통신에 연관된 각 프로세서들은 어떠한 시기에, 어떠한 데이터 형태를, 얼마만한 사이즈로 받아야 혹은 주어야 하는지를 완전히 알고 있다. 그리고 각각의 CPU는 묵묵히 계산들을 수행한다, 그야말로 독립적으로…….; 그런데, 어떤 CPU는 할당된 일이 많지 않아서 일을 다 끝내고 놀고 있고 어떤 CPU는 아직도 일을 다 못끝내고 아직도 계산을 수행하는 경우가 있을 수 있는데…..엄청난 CPU계산 속도를 고려할 때 상당한 자원의 낭비가 있다. 왜냐하면 결국 계산은 가장 느린(혹은 능력에 비해서 가장 일을 많이 하는 단 하나의 CPU에 의해서 결정되기 때문이다.) 다시 말해서 load balancing이 잘 될수록 병렬계산은 효율적으로 진행될 수 있다.

가장 확실한 방법 중 하나는 각 계산노드에 들어가서 현재 계산을 실행하고 있는 노드들의 계산시간을 분석해 보는 것이다. 각 노드로 ssh를 통해서 들어간다. 그 다음 top명령어를 이용하여 현재 사용한 CPU시간을 노드별로 분석해 본다. 실제 흘러가는 시간 (wall clock)과 더불어서 노드들의 CPU시간 증가를 확인해야 한다. load balancing (모든 노드들에서 CPU시간을 골고루 잘 증가함 )이 잘 되어 보인다고 하더라도 실제 시간의 흐름과 마찬가지로 계산에 사용된 CPU시간의 증가도 확인해야 한다. 주의해야 할 것은 특정노드로부터의 계산결과를 기다리는 시간이 있으면 좋지 않다는 것이다. 그 시간에 그 노드에서도 계산을 할 수 있다면 해야 한다. 어떠한 이유에서든지 각 노드에서 계산이 쉬는 것은 좋지 않다. 물론 고려해야 할 것이 있다. 계산보다 통신에 시간이 더 걸리는 것은 그 자리에서 해결하는 것이 좋다.

top명령어에서 관찰할 때 CPU의 사용 현황이 % 단위로 표시된다. 계산하지 않고 있으면 0.0 %가 된다. 계산을 집중적으로 할 때 당연히 99.0 % 처럼 나온다. 그 중간의 통신 상황에서는 다양한 퍼쎈트 대의 값이 표시된다. 한 번 0.에서 99.0 까지 올라간 다음 높은 CPU 점유율이 유지되는 시간이 길수록 CPU중심의 계산이 잘 되고 있다는 것을 의미한다. 가능한 한 이렇게 만들어야 좋은 병렬 효율성을 얻을 수 있다. 한 노드에 두 개의 CPU를 사용하여 병렬 계산을 할 때의 예. (물론, 다른 노드에서도 유사한 자료를 확인할 수 있다.) 일을 여러 노드에 나누는 것이 목적이 아니다, wall clock시간 기준으로 일을 빨리 처리하기 위해서 병렬계산을 할 뿐이다. 물론 빠른 처리를 위해서는 일을 여러 개의 노드들에 잘 분담해서 처리해야 한다. 나누는 것이 중요하다. 하지만, 더 중요한 것은 빨리 계산하는 것이다.

PID USER PRI NI SIZE RSS SHARE STAT %CPU %MEM TIME COMMAND

14683 ihlee 15 0 11376 11M 1380 S 63.2 1.1 2:27 action_lbfgs.x

14671 ihlee 13 0 11372 11M 1380 S 62.8 1.1 2:27 action_lbfgs.x

14715 ihlee 9 0 1052 1052 852 R 0.2 0.1 0:00 top

당연히 하나의 CPU를 하나의 실행화일이 CPU 중심의 계산을 수행할 때 CPU 점유율이 99.0 %이상 나온다.

#!/bin/csh -f

set nodes = (hpc1 hpc2 hpc3 hpc4 hpc5 hpc6 hpc7 hpc8 \\

hpc9 hpc10 hpc11 hpc12 hpc13 hpc14 hpc15 hpc16 \\

hpc17 hpc18 hpc19 hpc20 hpc21 hpc22 hpc23 hpc24 \\

hpc25 hpc26 hpc27 hpc28 hpc29 hpc30 hpc31 hpc32 \\

hpc33 hpc34 hpc35 hpc36 hpc37 hpc38 hpc39 hpc40 \\

hpc41 hpc42 hpc43 hpc44 hpc45 hpc46 hpc47 hpc48 \\

hpc49 hpc50 hpc51 hpc52 hpc53 hpc54 hpc55 hpc56 \\

hpc57 hpc58 hpc59 hpc60 hpc61 hpc62 hpc63 hpc64 \\

hpc65 hpc66 hpc67 hpc68 hpc69 hpc70 hpc71 hpc72 \\

hpc73 hpc74 hpc75 hpc76 hpc77 hpc78 hpc79 hpc80 \\

hpc81 hpc82 hpc83 hpc84 hpc85 hpc86 hpc87 hpc88 \\

hpc89 hpc90 hpc91 hpc92 hpc93 hpc94 hpc95 hpc96 \\

hpc97 hpc98 hpc99 hpc100 hpc101 hpc102 hpc103 hpc104 \\

hpc105 hpc106 hpc107 hpc108 hpc109 hpc110 hpc111 hpc112 \\

hpc113 hpc114 hpc115 hpc116 hpc117 hpc118 hpc119 hpc120 \\

hpc121 hpc122 hpc123 hpc124 hpc125 hpc126 hpc127 hpc128 )

foreach n ($nodes)

echo ‘———-‘ $n ‘———–‘

rsh $n $*

end

만약 61개의 노드에 계산이 분포된 경우 앞에서 이야기한 확인이 결코 쉽지 않다. 이럴 경우 위에서 제시한 스크립트 (이름을 pexec라고 하면. 또한 노드들의 이름을 위에서와 같이 hpc*처럼 정의한 경우.)를 이용하여 아래와 같은 명령을 주면된다. 병렬 계산 중에 아래의 명령어를 실행한다. 실제 각 노드들에서 소모된 CPU 시간들을 체크할 수 있다. 아래와 같이 그 결과가 나왔다면, 로드 밸런싱이 잘 되어 있다고 말할수 있다. rsh를 통하여 노드에 들어가고 프린트하는 시간이 포함되기 때문에 이와 관련된 시간에 의한 오차는 무시한 경우 이다. 완전히 동일한 시간을 소모한다면 오름차순으로 나올 것 이다. 프로그램 개발 단계와 응용 단계에서 로드 밸런싱 결함의 심각한 문제를 빨리 체크해 낼 수 있다.

$ pexec ps |grep admd>summary_file

10487 ? 00:08:04 admd.x

5696 ? 00:08:04 admd.x

5174 ? 00:08:05 admd.x

5166 ? 00:08:05 admd.x

5159 ? 00:08:05 admd.x

5150 ? 00:08:05 admd.x

5150 ? 00:08:05 admd.x

5150 ? 00:08:05 admd.x

5150 ? 00:08:05 admd.x

5223 ? 00:08:06 admd.x

9241 ? 00:08:06 admd.x

5502 ? 00:08:06 admd.x

5339 ? 00:08:06 admd.x

5392 ? 00:08:06 admd.x

5355 ? 00:08:06 admd.x

5639 ? 00:08:07 admd.x

5336 ? 00:08:07 admd.x

12646 ? 00:08:07 admd.x

5296 ? 00:08:07 admd.x

5543 ? 00:08:08 admd.x

8310 ? 00:08:08 admd.x

5790 ? 00:08:08 admd.x

5360 ? 00:08:08 admd.x

5360 ? 00:08:08 admd.x

5360 ? 00:08:08 admd.x

3118 ? 00:08:08 admd.x

5336 ? 00:08:09 admd.x

5334 ? 00:08:09 admd.x

5334 ? 00:08:09 admd.x

5334 ? 00:08:09 admd.x

9306 ? 00:08:09 admd.x

5736 ? 00:08:09 admd.x

위의 경우와 같이 각 노드들에서 8분씩만 계산을 하였다고 해도, 8분/노드 *61노드 => 총 CPU 사용시간 488 분이 되는 것이다. 즉, 8분만에 488 분 (=8.1333 시간)의 CPU시간을 소모한 계산이다. 다시 말해서, 병렬효율이 높은 경우, 8분만에 8시간 짜리 작업을 완성할 수 있다는 것이다. 이 정도되면 가히 고효율이라고 할 수 있겠다. 컴퓨터 사용료는 통상 사용한 총 CPU시간 기준이다. 단위 시간당 많은 CPU 시간을 사용했기 때문에 돈도 많이 내어야 하는 것은 당연하다.

스피드업 계산 예를 표시했다. wall clock 시간 기준으로 얼마나 빨리 계산을 할 수 있는가를 표시한다. 단일 노드를 활용할 경우 약 30분 정도 소요 (wall clock기준되는 계산의 예를 표시했다. 상당히 병렬화가 잘 된 경우의 예로 받아 들일 수 있는 경우이다. Embarrassingly parallel 알고리즘의 경우 이상적인 스피드업 값 (대각선으로 표시된 값에 접근하는 경우이다. 소위 observed speedup이란 (wall-clock time of serial execution)와 (wall-clock time of parallel execution)의 비율을 말한다. 즉, CPU시간 기준이 아니라 wall-clock 시간 기준으로 빨라지는 것으로 정의되는 것이다.

통상의 구조는 어떠한가?

MPI 함수 125개 중 아래의 6개만 사용하는 프로그램도 상당히 많다. 아주 행복한 계산들을 수행하는 경우이다. 실제로 이러한 함수만을 이용하는 응용프로그램들이 많이 존재한다.

MPI_INIT: MPI 환경 초기화하기 : 유저 수준에서 바꿀 것이 사실상 없음. 모든 CPU에서 공통으로 불리어진다.

MPI_COMM_SIZE: 사용 중인 processor 숫자 반환 : 유저 수준에서 바꿀 것이 사실상 없음.

MPI_COMM_RANK: 현 CPU의 번호 (rank라도 함. processor 갯수가 nproc일 때, 가능한 rank 값은0,1,2,3….nproc-1이다.) : 유저 수준에서 바꿀 것이 사실상 없음.

두 개의 processor 간 통신: rank값들을 사용하여서 현재 processor 번호를 확인하고 준비된 데이터를 원하는 processor로 전송한다. 마찬가지로 현재의 processor번호를 확인하고 전송되어 올 데이터를 받는다. 물론, 병렬계산은 “짜고 치는 고스톱이기 때문에 우리는 어떤 processor로부터 데이터가 오는지 그리고 어떤 processor가 이 데이터를 받아야 하는지 다 알고 있다. 정보가 특정한 노드로 보내어지는데, 그 노드가 받지 않으면 일이 안됩니다. 반드시 받아야 다음의 일들이 진행됩니다. 즉, 프로그래밍 작업중에, deadlock (교착)에 걸리는지 안 걸리는 지를 점검해야 합니다. 최소 두 대의 CPU들간에 다른 CPU로 부터의 데이터 송신이 지속적으로 발생한 경우.통신, 계산 순서 의존성, 동기화, 그리고 교착 상황의 체크가 병렬 프로그래밍의 주요 항목이라고 할 수 있다. 통상, 순차 프로그램의 완성, 최적화 이후에 병렬 프로그래밍에 착수 한다.

MPI_SEND: 원하는 processor에게 데이터 전송시 사용 : 유저의 구체적인 목적이 적용됨 (원하는 데이터 형, 사이즈,…)

MPI_RECV: 원하는 processor로부터 데이터 전송받을 때 사용 : 유저의 구체적인 목적이 적용됨 (원하는 데이터 형, 사이즈,…)

MPI_FINALIZE: MPI 환경 종료하기: 유저 수준에서 바꿀 것이 사실상 없음. 모든 CPU에서 공통으로 불리어진다.

MPI 함수들은 포트란 버전과 C 버전으로 나누어져 있다. 구체적인 함수 모양은 언어의 특성을 고려하다보니 다르게 생겼지만, 수행하는 일은 사실상 같다. 실제 포트란에서 사용될 때의 모습. 잘 알려진 것처럼 포트란에서는 소문자/대문자 구별이 없다.즉, mpi_init나 MPI_init나 같은 함수를 지칭한다.

program test

USE important_module, ONLY : variables, sub_program_names

implicit none

include “mpif.h”

integer istatus(MPI_STATUS_SIZE) ! MPI_STATUS_SIZE는 위에서 선언한 include문으로 불러들인 내용에서 이미 정의된 것들이다.

………………….

……………………….

integer nproc,myid,ierr,idestination,isource,iroot,kount

INTEGER itemp,itemq,irate

CHARACTER*8 fnnd ; CHARACTER*10 fnnt

………….

………….

…………..

………..

메시지 = 데이터+송신지와 수신지 주소

커뮤티케이터 = 서로 통신할 수 있는 프로세스들의 집합. (MPI 핸들이다.) MPI_COMM_WORLD는 기본 커뮤티케이터이다. 헤더파일에서 정의된다. 사용자가 특별한 프로세스들만으로 구성되는 커뮤티케이터를 만들 수 있다.

………………

call MPI_Init(ierr)

call MPI_Comm_size(MPI_COMM_WORLD,nproc,ierr)

call MPI_Comm_rank(MPI_COMM_WORLD,myid,ierr)

if(myid == 0)then ! —–[ PROCESS ID = 0

CALL DATE_AND_TIME(date=fnnd,time=fnnt)

write(6,'(1x,a10,2x,a8,2x,a10)’) ‘date,time ‘, fnnd,fnnt

CALL SYSTEM_CLOCK(itemp,irate)

endif ! —–] PROCESS ID = 0

if(myid == 0)then ! —–[ PROCESS ID = 0

각종 입력들……

endif ! —–] PROCESS ID = 0

읽어 들인 정보 중에서 모든 노드에게 “방송할 필요가 있는 경우

kount=1 ; iroot=0

call MPI_BCAST(natom,kount,MPI_INTEGER,iroot,MPI_COMM_WORLD,ierr)

myid는 processor번호를 나타낸다. (myid=0,1,2,3,….nproc-1 중의 하나 값을 가진다. 각 노드마다 다른 값을 가진다.)

nproc는 현재 몇 개의 processor가 살아있는지를 나타낸다. (모든 노드에서 같은 값을 가진다.) 즉, SPMD에 따라서, 모든 컴퓨터에서 같은 프로그램을 수행하기 때문에 모든 컴퓨터에서 현재 살아있는 컴퓨터의 숫자 (nproc)는 같다. 각 컴퓨터마다 자신의 번호 (myid 값)는 컴퓨터마다 다르다. 따라서, 병렬 계산은 nproc와 myid값을 가지고 주어진 문제에 대한 분업/병렬 작업들을 설계할 수 있다. 당연히, 메모리 할당도 노드별로 다르게, 또는 동시에 같은 크기로 잡을 수 있다. 미리 선언해 두는 부분은 모든 노드에서 같이 해 두어야 한다. 예를 들면, real*8, allocatable :: abcd(:,:,:)처럼. 당연히 한 노드에서만 메모리 할당이 될 경우도 있을 수 있다. 병렬 프로그래밍은 기본적으로 노드별 작업을 설계해야 하기 때문에 순차 프로그래밍 보다 더 난이도가 높다. 보다 많은 테스트 작업들이 필요하다. 일반으로 순차 프로그램을 끝내고 그 다음 병렬 프로그램을 작성한다.

itag=19

idestination=1

call MPI_Send(real_array_user,n_array_length,MPI_REAL8,idestination,itag,MPI_COMM_WORLD,ierr)

real*8 형태의 데이터가 가야할 곳 지정해주어야 한다. 물론, 이 데이터의 크기도 보내는 곳에서 지정해줘야 한다. 특정 노드에서 정보를 보내기 때문에 위 함수는 특정 노드에서 불려져야 한다.

itag=19

isource=0

call MPI_Recv(real_array_user,n_array_length,MPI_REAL8,isource,itag,MPI_COMM_WORLD,istatus,ierr)

데이터를 받는 쪽에서는 그 형태와 크기를 알고 있어야 하며, 어디에서부터 출발했는지를 알아야 한다.

MPI_REAL (실수, 싱글 프리시전)과 MPI_REAL8 (실수, 더블 프리시전)는 엄연히 다른 값들 임을 유의해야 한다. MPI_REAL8보다는 MPI_DOUBLE_PRECISION을 사용하는 것이 좋다. 왜냐하면, LAM에서도 사용가능하기때문이다. MPI_REAL8는 MPICH에서만 사용가능한 것이다.

!

………………….

………..

……………………..

…………….

master/slave 형식으로 일할 경우, 일들을 나누어서 수행하는 경우: myid=0에서 일들을 분배하고, 취합 한다. myid=0에서도 일부/균등 일들을 수행한다. 해야 할 총 일들의 단위가 (np+1)인 경우이고, 동원된 노드의 수는 nproc (> 1) 이다. myid=1,2,….nproc-2 :이들 노드들은 균등한 일의 양을 수행한다. myid=0 노드는 상황에 따라서 위의 노드들 보다 적은 양을 일들을 수행한다. 물론, 균등한 일의 양을 취급하는 경우도 있다.

nblk=(np+1)/nproc+1 ; if( np+1 == (nblk-1)*nproc) nblk=nblk-1

allocate(wk_input(natom,3,nblk),wk_output(natom,3,nblk),wk_output2(nblk))

wk_input=0.0d0 ; wk_output=0.0d0 ; wk_output2=0.0d0

!

if(myid == 0)then ! —–[ PROCESS ID = 0

! 정보를 나누어서 전달하기

do loop=0,nproc-2

jj=0

do j=(loop)*nblk,(loop+1)*nblk-1

jj=jj+1 ; wk_input(:,:,jj)=qq(:,:,j)

enddo

kount=3*natom*nblk ; idest=loop+1 ; itag=1

call MPI_SEND(wk_input,kount,MPI_DOUBLE_PRECISION,idest,itag,MPI_COMM_WORLD,ierr)

enddo

! 적당히 할당된 일하기, myid=0에서

do j=(nproc-1)*nblk,np

call sma_energy_force(qq(1,1,j),force(1,1,j),vofqj(j))

enddo

! myid /=0에서 보내온 정보를 나누어서 받아들이기

do loop=0,nproc-2

kount=3*natom*nblk ; isour=loop+1 ; itag=3

call MPI_RECV(wk_output,kount,MPI_DOUBLE_PRECISION,isour,itag,MPI_COMM_WORLD,istatus,ierr)

jj=0

do j=(loop)*nblk,(loop+1)*nblk-1

jj=jj+1 ; force(:,:,j)=wk_output(:,:,jj)

enddo

kount=nblk ; isour=loop+1 ; itag=4

call MPI_RECV(wk_output2,kount,MPI_DOUBLE_PRECISION,isour,itag,MPI_COMM_WORLD,istatus,ierr)

jj=0

do j=(loop)*nblk,(loop+1)*nblk-1

jj=jj+1 ; vofqj(j)=wk_output2(jj)

enddo

enddo

!

else ! —–| PROCESS ID = 0

! myid=0에서 보내온 정보 받아들이기

kount=3*natom*nblk ; isour=0 ; itag=1

call MPI_RECV(wk_input,kount,MPI_DOUBLE_PRECISION,isour,itag,MPI_COMM_WORLD,istatus,ierr)

! 할당된 일하기, myid /=0에서

do jj=1,nblk

call sma_energy_force(wk_input(1,1,jj),wk_output(1,1,jj),wk_output2(jj))

enddo

! 정보를 myid=0로 보내기, myid/=0에서 보내기임

kount=3*natom*nblk ; idest=0 ; itag=3

call MPI_SEND(wk_output,kount,MPI_DOUBLE_PRECISION,idest,itag,MPI_COMM_WORLD,ierr)

kount=nblk ; idest=0 ; itag=4

call MPI_SEND(wk_output2,kount,MPI_DOUBLE_PRECISION,idest,itag,MPI_COMM_WORLD,ierr)

!

endif ! —–] PROCESS ID = 0

……………….

……………………………..

………….. elapsed (or wall) clock : DOUBLE PRECISION MPI_WTIME()

t1=mpi_wtime()

…..null input 형식으로 입력이 없다.노드에 따라 달리 시작한다.

————code to be timed ———-

t2=mpi_wtime()

if(myid == 0) write(6,*) t2-t1,’ sec’

if(myid == 0)then ! —–[ PROCESS ID = 0

각종 출력들……

endif ! —–] PROCESS ID = 0

……………

………..

if(myid == 0)then ! —–[ PROCESS ID = 0

CALL SYSTEM_CLOCK(itemq)

write(6,'(2e15.4,2x,a9)’) float(itemq-itemp)/float(irate)/60.,float(itemq-itemp)/float(irate)/3600.,’ min or h’

endif ! —–] PROCESS ID = 0

call MPI_Finalize(ierr)

stop

end program test

MPI_Wtime()함수를 사용할 수 있다. double precision변수이다. wall-clock-time 측정에 사용된다. microsecond 수준의 분해능을 가지고 C/C++/Fortran에서 사용가능하다. 물론, 컴퓨터 기종에 상관없이 사용가능하다.

s1=MPI_WTIME()

….

s2=MPI_WTIME()

s2-s1 sec단위로 출력됨

      program main

      include “mpif.h”

      real*8, parameter :: PI25DT = 3.141592653589793238462643d0

      real*8  xmypi, gpi, hh, xsum, x, f

      integer npoints, myid, nproc, i, ierr

!                                 function to integrate

      f(x) = 4.d0 / (1.d0 + x*x)

      call MPI_INIT(ierr)

      call MPI_COMM_RANK(MPI_COMM_WORLD, myid, ierr)

      call MPI_COMM_SIZE(MPI_COMM_WORLD, nproc, ierr)

10   if ( myid == 0 ) then

         write(6,*), ‘Enter the number of intervals: (0 to quit) ‘

         read(5,*) npoints

      endif

!                                 broadcast npoints

      call MPI_BCAST(npoints,1,MPI_INTEGER,0,MPI_COMM_WORLD,ierr)

!                                 check for quit signal

      if ( npoints <=  0 ) goto 30

!                                 calculate the interval size

      hh = 1.0d0/float(npoints)

      xsum  = 0.0d0

      do i = myid+1, npoints, nproc

         x = hh * (float(i) – 0.5d0)

         xsum = xsum + f(x)

      enddo

      xmypi = hh * xsum

!                                 collect all the partial xsum

      call MPI_REDUCE(xmypi,gpi,1,MPI_DOUBLE_PRECISION,MPI_SUM,0, MPI_COMM_WORLD,ierr)

!                                 node 0 prints the answer.

      if (myid ==   0) then

         write(6,*), ‘gpi is ‘, gpi, ‘ Error is’, abs(gpi – PI25DT)

      endif

      goto 10

30   call MPI_FINALIZE(ierr)

      stop

      end

!234567890

subroutine equal_load(n1,n2,nproc,myid,istart,ifinish)

implicit none

integer nproc,myid,istart,ifinish,n1,n2

integer iw1,iw2

iw1=(n2-n1+1)/nproc ; iw2=mod(n2-n1+1,nproc)

istart=myid*iw1+n1+min(myid,iw2)

ifinish=istart+iw1-1 ; if(iw2 > myid) ifinish=ifinish+1

! print*, n1,n2,myid,nproc,istart,ifinish

return

end

!234567890

program equal_load_sum

implicit none

include ‘mpif.h’

integer nn

real*8, allocatable :: aa(:)

integer nproc,myid,ierr,istart,ifinish

integer i

real*8 xsum,xxsum

nn=10000

call MPI_INIT(ierr)

call MPI_COMM_SIZE(MPI_COMM_WORLD, nproc, ierr)

call MPI_COMM_RANK(MPI_COMM_WORLD, myid, ierr)

call equal_load(1,nn,nproc,myid,istart,ifinish)

allocate(aa(istart:ifinish)) ! 단순한 인덱스의 분할 뿐만아니라 메모리의 분할이 이루어지고 있다. 노드별로

do i=istart,ifinish

aa(i)=float(i)

enddo

xsum=0.0d0

do i=istart,ifinish

xsum=xsum+aa(i)

enddo

call MPI_REDUCE(xsum,xxsum,1,MPI_DOUBLE_PRECISION,MPI_SUM,0,MPI_COMM_WORLD,ierr)

xsum=xxsum

if(myid == 0)then

write(6,*) xsum,’ xsum’

endif

deallocate(aa)

call MPI_FINALIZE(ierr)

end program equal_load_sum

위와 같은 경우: 블록 (block) 분할이라고 한다.

순환 (cyclic) 분할은 위와 대비되는 것이다.

do i=n1,n2

——-

enddo

위의 루프가 아래처럼 바뀐다.

do i=n1+myid,n2,nproc

——-

enddo

block-cyclic 분할: nblk의 사이즈만큼씩 처리한다.

do j=n1+myid*nblk,n2,nproc*nblk

do i=j,min(j+nblk-1,n2)

……….

enddo

enddo

병렬계산의 이면: 실제 컴퓨터계산에서는 유한한 정밀도를 사용한다. 따라서, aa(1)+aa(2)+aa(3)+,,,,aa(100)과 같이 순차 프로그램에의해서, 순차적으로 계산된 양은 병렬 프로그램에의해서, 즉, [aa(1)+aa(2)+aa(3)]+[aa(4)+aa(5)+aa(6)]+[aa(7)+aa(8)+aa(9)]+….처럼,부분적으로 합해진 합들의 합이며, 순서 또한 순차프로램의 것과 차이가 있다. 이 결과들로 인해서 정밀도 근처의 오차가 있을 수 있다. 결국 MPI_REDUCE를 사용할 경우 rounding error가 있다는 것이다. 통상 실전에서 이것이 문제가 되는 경우는 그리 많지 않다.

블록킹과 논-블로킹 통신: MPI_Send, MPI_Recve들은 통신이 완료될 때까지 호출한 프로세스들을 블로킹해둔다. 블로킹 통신의 경우 교착이 발생할 수 있다. 교착은 일종의 프로그래밍 에러이다. 송, 수신 연산의 초기화와 종료를 분리한 형식의 호출을 통한 통신이 논-블로킹 통신이다. 두 호출사이에 프로그램이 다른 일들을 할 수 있다는 장점이 있다. 논-블로킹 통신을 호출해서 초기화하는 것을 포스팅(posting)이라고 한다.

실제 MPI프로그램에서는 각각의 CPU를 이용한 일 처리 전후에 일어나는 데이터의 교환이 핵심이다. 따라서 프로그래머가 원하는 대로 데이터가 적절한 시기에 적절한 CPU로 전파되는지를 프린트를 통해서 확인할 필요가 있다. 원하는 시기에 원하는 노드로의 정확한 데이터 송신 및 수신 이것을 반드시 테스트해야 한다. 이것이야 말로 모든 MPI 구현의 핵심이기 때문이다. 하나의 프로그램에서 각기 다른 CPU상에서 일어나는 일들을 다같이 점검해야 한다. 물론, 허용한다면, 너무 자주 컴퓨터 간 통신을 하지 않을수록 병렬 효율성은 좋다.

많이 쓰는 것 한 가지 더 추가하면 mpi_bcast를 이야기할 수 있겠다. 이것은 broadcast를 의미한다. 특별히, 모든 노드에게 알릴 때 사용한다. 알리고자 하는 정보의 근원지를 지정한다.물론, 정보의 크기와 형태를 지정해줘야 한다.

iroot=0 ; kount=1

call MPI_BCAST(l_pbc,kount,MPI_LOGICAL,iroot,MPI_COMM_WORLD,ierr)

정보가 공유되도록 방송하는 관계로 모든 노드에서 동시에 위의 함수가 불려져야 한다. 특정한 노드에서만 변수값이 새로 읽어지거나 계산되었을 때, 그리고 이것이 모든 노드들에게 알려질 필요가 있을 때 사용한다.

point-to-point 통신이 아닌 집단적인 통신이다. collective communication

master/slave 형식: master 노드에서 중요한 일들을 수행하고 그 이외의 노드들은 master의 지휘하에 계산들을 수행하는 형식. 알고리즘 구현에서 유리한 경우가 있다. 물론, 그렇지 못한 경우도 많다. master노드가 거의 하는 일이 없어지면 병렬 효율성이 떨어지기 마련이다. 물론, master도 일정한 slave노드처럼 일정한 계산들을 수행함으로써 전체 병렬 효율성을 높일 수 있다. master/slave형식의 경우 대개 메모리의 한계는 문제가 되질 않은 경우이다. 하지만, 거대 계산의 경우 메모리 할당 문제 때문에 변수들을 여러 노드들에 걸쳐서 표현할 수밖에 없는 경우도 매우 많이 있다. 이러한 경우는 master/slave노드 개념의 프로그래밍은 좋은 아이디어가 아니다.

Introduction to MPI

http://www.llnl.gov/computing/tutorials/workshops/workshop/mpi/MAIN.html

http://www.netlib.org/utk/papers/intro-mpi/intro-mpi.html

http://www.nas.nasa.gov/Groups/SciCon/Tutorials/MPIintro/toc.html

http://www-unix.mcs.anl.gov/mpi/tutorial/mpiintro/

http://www-unix.mcs.anl.gov/mpi/tutorial/mpibasics/

http://www.ats.ucla.edu/at/hpc/parallel_computing/mpi-intro.htm

http://www.gre.ac.uk/~selhpc/announcements/mpi-24-06-96.html

Introduction to MPI 2

http://acrl.cs.unb.ca/php/training/mpi/cmacphee-intro_to_mpi2/index.html

Cornell theory center의 Code Examples

http://www.tc.cornell.edu/Services/Docs/Examples/

———————————————————————

http://krissol.kriss.re.kr/~ihlee/compphys/mpi_phys.htm

  mpi_for_physicist.pdf

cf.  

koerfgen_parallel_linear_algebra_methods.pdf

mohr_introduction_to_parallel_computing.pdf

mpi2tutorial.tar.tar

MPI

# by 바죠 | 2007/01/21 21:09 | 전산물리학 노트 | 트랙백 | 덧글(4)

2007년 01월 12일

infiniband latency

http://vmi.ncsa.uiuc.edu/performance/pmb_lt.php

Fast Ethernet

Gigabit Ethernet

Myrinet

Quadrics 2

latency

120 microsecond

120 microsecond

7 microsecond

0.5 microsecond

bandwidth

100 Mbps

1 Gbps

1.98 Gbps

1 Gbyte/second

http://pcline.todaykorea.co.kr/bbs/bbs/board.php?bo_table=contents_hw&wr_id=28

http://vmi.ncsa.uiuc.edu/performance/pmb_lt.php

MPI, 슈퍼컴퓨팅

# by 바죠 | 2007/01/12 15:51 | 전산물리학 노트 | 트랙백 | 덧글(4)

2006년 05월 10일

pbsnodes 명령어/클러스터

man pbsnodes

NAME

pbsnodes – pbs node manipulation

SYNOPSIS

pbsnodes [-{c|o|r}] [-s server] [nodename …]

pbsnodes -{a|l} [-s server]

DESCRIPTION

The pbsnodes command is used to mark nodes down, free or off line. It can also be used to list nodes and their state.

Node information is obtained by sending a request to the PBS job server.

If pbsnodes is run without options (other than -s ), the nodes specified as operands are marked DOWN and unavailable to

run jobs. It is importaint that all the nodes known to be down are given as arguments on the command line. This is

because nodes which are not listed are assumed to be UP and will be indicated as such if they were previously marked

DOWN. None of the other options will change the marking for nodes which are not given on the command line.

In order to execute pbsnodes with other than the -a or -l options, the user must have PBS Manager or Operator privilege.

OPTIONS

-a All nodes and their attributes are listed. The attributes include “state” and “properities”.

-c Clear OFFLINE or DOWN from listed nodes. The listed nodes are “free” to be allocated to jobs.

-l List all nodes marked in any way.

-o Mark listed nodes as OFFLINE even if currently in use. This is different from being marked DOWN. An

automated script that checks nodes being up or down and calls pbsnodes with a list of nodes down will not

change the status of nodes marked OFFLINE. This gives the administrator a tool to hold a node out of

service without changing the automatic script.

-r clear OFFLINE from listed nodes.

-r specify the PBS server to which to connect.

==================================================================================================

pbsnodes -a |grep free|wc

35 105 630

지금 free 상태(즉, 사용 가능한) 노드 수가 35임을 알 수 있다.

가능한 상태: down,

job-exclusive

down일 경우, super user 가 이 노드를 offline 상태로 만들어 줄 필요가 있다.

———————————————————————————————————-

1.

배치 파일 안에서

#PBS -l nodes=필요nodes수:그룹+필요nodes수:그룹

예: #PBS -ㅣ nodes=2:beta+2:gamma

beta에서 2대 그리고 gamma 에서 2대 = 총 4대

2.

작업을 새로이 서브미트시킬 때

노드가 다운상태일때는

자동으로 알아서 다운된 머신을 제외시킨 상태에서

작업이 안도는 머신을 선택하여 서브미트합니다.

노드 상태를 알고싶으실 때는

pbsnodes -a

하시면 상태가 나옵니다.

3.

pbsnodes -o 노드이름 –> root 유저로서 offline 상태 만들기

예: pbsnodes -o hpc22

pbsnodes -c 노드이름 –> root 유저로서 offline 해제

예: pbsnodes -c hpc22

——————————————-

[19] Error: Unable to open a GM port !

미리넷카드의 모듈에 문제 발생

——————————————-

#!/bin/sh

##!/bin/csh -f

#set nodes = (hpf1 hpf2 hpf3 hpf4 hpf5 hpf6 hpf7 hpf8 \\

# hpf9 hpf10 hpf11 hpf12 hpf13 hpf14 hpf15 hpf16 \\

# hpf17 hpf18 hpf19 hpf20 hpf21 hpf22 hpf23 hpf24 \\

# hpf25 hpf26 hpf27 hpf28 hpf29 hpf30 hpf31 hpf32 \\

# hpf33 hpf34 hpf35 hpf36 hpf37 hpf38 hpf39 hpf40 \\

# hpf41 hpf42 hpf43 hpf44 hpf45 hpf46 hpf47 hpf48 \\

# hpf49 hpf50 hpf51 hpf52 hpf53 hpf54 hpf55 hpf56 \\

# hpf57 hpf58 hpf59 hpf60 hpf61 hpf62 hpf63 hpf64 \\

# hpf65 hpf66 hpf67 hpf68 hpf69 hpf70 hpf71 hpf72 \\

# hpf73 hpf74 hpf75 hpf76 hpf77 hpf78 hpf79 hpf80 \\

# hpf81 hpf82 hpf83 hpf84 hpf85 hpf86 hpf87 hpf88 \\

# hpf89 hpf90 hpf91 hpf92 hpf93 hpf94 hpf95 hpf96 \\

# hpf97 hpf98 hpf99 hpf100 hpf101 hpf102 hpf103 hpf104 \\

# hpf105 hpf106 hpf107 hpf108 hpf109 hpf110 hpf111 hpf112 \\

# hpf113 hpf114 hpf115 hpf116 hpf117 hpf118 hpf119 hpf120 \\

# hpf121 hpf122 hpf123 hpf124 hpf125 hpf126 hpf127 hpf128 )

#

#foreach n ($nodes)

# echo ‘———-‘ $n ‘———–‘

# rsh $n $*

#end

i=$1

j=$2

k=`expr $j ‘+’ 1`

while [ “$i” -lt “$k” ]

do

echo “–hpc$i ”

rsh hpf$i $3

#rsh hpf$i /usr/local/INSTALL/gm/bin/gm_allsize –quiet

sleep 1

i=$(($i+1))

done

사용예:

pexec 110 127 ps -u ihlee |grep admd

——–offline 상태 확인 명령어———

pbsnodes -l

hpf100               offline

hpf105               offline

hpf107               offline

——–

===============================

—–(새유저 등록방법)————

루트 유저로서

#adduser 새ID

하신후

#cd /var/yp

#make

하시고

#ypcat passwd

라고 치신 후 새ID가 등록되어 있으면 됩니다.

——————————-

qsub  job_script

qstat  -a

qstat  -u userID

qstat  -an

qdel  jobID(number)

qhold jobID(number)

qrls  jobID(number)

————————————————————

부팅순서:

0. 에어콘

1. UPS (있으면)

2. 네트워크 스위치

3. 프론트엔드 서버의 외부 디스크 시스템 (있으면)

4. 프론트엔드 서버

5. 컴퓨팅 노드들의 부팅 서버들

6. 컴퓨팅 노드들