mpy.mpich2 - Online sa Cloud

PROGRAMA:

NAME

mpy - Pagpasa ng Mensahe Yorick

SINOPSIS

mpirun -np mp_size mpy [ -j pfile1.i [ -j pfile2.i [ ... ]]] [ -i file1.i [ -i file2.i [
... ]]]
mpirun -np mp_size mpy -batch file.i

DESCRIPTION

Yorick ay isang binibigyang kahulugan na wika tulad ng Basic o Lisp, ngunit mas mabilis. Tingnan mo Yorick (1) to
matuto pa tungkol dito.
Mpy ay isang parallel na bersyon ng Yorick batay sa Message Passing Interface (MPI). Ang
Ang eksaktong syntax para sa paglulunsad ng isang parallel na trabaho ay depende sa iyong kapaligiran ng MPI. Maaaring ito ay
kinakailangan upang maglunsad ng isang espesyal na daemon bago tumawag mirun o katumbas na utos.

Mga Paliwanag
Ang mpy package ay nag-interface kay yorick sa MPI parallel programming library. Ang ibig sabihin ng MPI
Interface ng Pagpasa ng Mensahe; ang ideya ay upang ikonekta ang maramihang mga pagkakataon ng yorick na
makipag-usap sa kanilang sarili sa pamamagitan ng mga mensahe. Ang Mpy ay maaaring gumanap ng simple, lubos na kahanay
mga gawain bilang purong interpreted na mga programa, o maaari itong magsimula at magmaneho ng arbitraryong kumplikadong pinagsama-sama
mga pakete na malayang gamitin ang pinagsama-samang MPI API. Ang interpreted API ay hindi nilayon
upang maging isang MPI wrapper; sa halip ito ay hinubaran hanggang sa pinakamababa.

Ito ang bersyon 2 ng mpy (inilabas noong 2010); hindi ito tugma sa bersyon 1 ng mpy
(inilabas noong kalagitnaan ng 1990s), dahil ang bersyon 1 ay nagkaroon ng maraming depekto sa disenyo na ginagawa itong napakahusay
mahirap magsulat ng mga programang walang kundisyon ng lahi, at imposibleng sukatin sa milyon-milyon
ng mga processor. Gayunpaman, maaari mong patakbuhin ang karamihan sa bersyon 1 mpy program sa ilalim ng bersyon 2 sa pamamagitan ng paggawa
mp_include,"mpy1.i" bago ka mag-mp_include ng anumang file na tumutukoy sa isang mpy1 parallel na gawain (iyon ay
bago ang anumang file na naglalaman ng isang tawag sa mp_task.)

Paggamit mga tala
Ang kapaligiran ng MPI ay hindi talaga tinukoy ng pamantayan; ang mga umiiral na kapaligiran ay
napaka krudo, at lubos na pinapaboran ang mga hindi interactive na batch na trabaho. Ang bilang ng mga proseso ay
naayos bago magsimula ang MPI; bawat proseso ay may ranggo, isang numero mula 0 hanggang isang mas mababa kaysa sa
bilang ng mga proseso. Ginagamit mo ang ranggo bilang isang address upang magpadala ng mga mensahe, at ang proseso
ang pagtanggap ng mensahe ay maaaring suriin upang makita kung aling mga ranggo ang nagpadala ng mga mensahe dito, at siyempre
tumanggap ng mga mensaheng iyon.

Ang isang malaking problema sa pagsulat ng isang programa sa pagpasa ng mensahe ay ang paghawak ng mga kaganapan o mensahe
pagdating sa hindi planadong ayos. Ginagarantiya lamang ng MPI na ang isang pagkakasunud-sunod ng mga mensahe ay ipinapadala ni
rank A hanggang rank B ay darating sa order na ipinadala. Walang garantiya tungkol sa pagkakasunud-sunod ng
pagdating ng mga mensaheng iyon kaugnay ng mga mensaheng ipinadala sa B mula sa ikatlong ranggo C. Sa
partikular, ipagpalagay na nagpapadala si A ng mensahe kay B, pagkatapos ay nagpadala si A ng mensahe sa C (o kahit na nagpapalitan
ilang mga mensahe na may C) na nagreresulta sa pagpapadala ng C ng mensahe sa B. Ang mensahe mula kay C
maaaring dumating sa B bago ang mensahe mula kay A. Isang programa ng MPI na hindi nagpapahintulot para dito
ang posibilidad ay may isang bug na tinatawag na "kondisyon ng lahi". Ang mga kondisyon ng lahi ay maaaring napaka banayad,
lalo na kapag ang bilang ng mga proseso ay malaki.

Ang pangunahing mpy interpreted interface ay binubuo ng dalawang variable:
mp_size = bilang ng mga proseso
mp_rank = ranggo ng prosesong ito at apat na function:
mp_send, sa, msg; // magpadala ng mensahe sa ranggo "sa"
msg = mp_recv(mula sa); // tumanggap ng mensahe mula sa ranggo "mula sa"
ranggo = mp_probe(block); // magtanong sa mga nagpadala ng mga nakabinbing mensahe
mp_exec, string; // i-parse at i-execute ang string sa bawat ranggo

Tumawag ka sa mp_exec sa ranggo 0 upang magsimula ng isang parallel na gawain. Kapag ginawa ang pangunahing programa
matapos, lahat ng mga ranggo maliban sa ranggo 0 ay bumalik sa isang idle loop, naghihintay para sa susunod
mp_exec. Kinukuha ng Ranggo 0 ang susunod na linya ng pag-input mula sa stdin (iyon ay, naghihintay ng input sa nito
prompt sa isang interactive na session), o wawakasan ang lahat ng mga proseso kung wala nang input
magagamit sa isang batch session.

Binabago ng mpy package kung paano pinangangasiwaan ni yorick ang #include parser directive, at ang include
at nangangailangan ng mga function. Lalo na, kung ang isang parallel na gawain ay tumatakbo (iyon ay, nagsimula ang isang function
sa pamamagitan ng mp_exec), lahat ito ay naging mga kolektibong operasyon. Ibig sabihin, binabasa ng rank 0 ang kabuuan
mga nilalaman ng file, at ipinapadala ang mga nilalaman sa iba pang mga proseso bilang isang mensahe ng MPI (tulad ng
mp_exec ng mga nilalaman ng file). Ang bawat proseso maliban sa ranggo 0 ay tumatakbo lamang habang
magkatulad na mga gawain; sa labas ng isang parallel na gawain kapag rank 0 lang ang tumatakbo (at lahat ng iba pang rank
ay naghihintay para sa susunod na mp_exec), ang #include na direktiba at ang isama at kailangan
ang mga function ay bumalik sa kanilang karaniwang serial operation, na nakakaapekto lamang sa ranggo 0.

Kapag nagsimula ang mpy, ito ay nasa parallel mode, upang ang lahat ng mga file ni yorick ay kasama kapag ito
nagsisimula (ang mga file sa Y_SITE/i0) ay kasama bilang mga kolektibong operasyon. Kung wala ito
feature, bawat proseso ng yorick ay susubukan na buksan at basahin ang startup kasama ang mga file,
overloading ang file system bago magsimula ang mpy. Pagpasa sa mga nilalaman ng mga ito
file bilang mga mensahe ng MPI ay ang tanging paraan upang matiyak na mayroong sapat na bandwidth para sa bawat isa
proseso upang basahin ang mga nilalaman ng isang file.

Ang huling file na kasama sa startup ay alinman sa file na tinukoy sa -batch na opsyon, o
ang custom.i file. Upang maiwasan ang mga problema sa code sa custom.i na maaaring hindi ligtas para sa
parallel execution, hindi hinahanap ng mpy ang custom.i, ngunit sa halip ay custommp.i. Ang
Ang mga tagubilin sa -batch file o sa custommp.i ay isinasagawa sa serial mode sa ranggo 0
lamang. Katulad nito, in-override ng mpy ang karaniwang function na process_argv, upang ang -i at iba pa
Ang mga opsyon sa command line ay pinoproseso lamang sa ranggo 0 sa serial mode. Ang layunin sa lahat ng ito
Ang mga kaso ay ang gawin ang -batch o custommp.i o -i na isama ang mga file na isasagawa lamang sa ranggo 0, bilang
kung nai-type mo sila doon nang interactive. Malaya kang tumawag sa mp_exec mula sa alinman sa mga ito
mga file upang simulan ang mga parallel na gawain, ngunit ang file mismo ay serial.

Ang isang karagdagang opsyon sa command line ay idinagdag sa karaniwang hanay:
mpy -j somefile.i
kasama ang somefile.i sa parallel mode sa lahat ng rank (muli, -i other.i kasama ang other.i lang
sa ranggo 0 sa serial mode). Kung mayroong maramihang -j na opsyon, ang parallel ay kasama ang mangyayari
sa command line order. Kung pinaghalo ang -j at -i na mga opsyon, gayunpaman, lahat ng -j kasama ang mangyayari
bago ang anumang -i kasama.

Bilang isang side effect ng pagiging kumplikado ng isama ang mga function sa mpy, ang tampok na autoload ay
may kapansanan; kung ang iyong code ay aktwal na nag-trigger ng isang isama sa pamamagitan ng pagtawag sa isang autoloaded function, mpy
ay titigil sa isang error. Dapat mong tahasang i-load ang anumang mga function na kinakailangan para sa isang parallel
Ang mga gawain gamit ang nangangailangan ng function ay tinatawag ang kanilang mga sarili sa loob ng isang parallel na gawain.

Ang function na mp_send ay maaaring magpadala ng anumang numerong yorick array (mga uri ng char, maikli, int, mahaba,
float, double, o complex), o isang scalar string value. Ang proseso ng pagpapadala ng mensahe
sa pamamagitan ng MPI ay pinapanatili lamang ang bilang ng mga elemento, kaya ang mp_recv ay gumagawa lamang ng isang scalar value o
isang 1D na hanay ng mga halaga, kahit na anong dimensyon ang ipinasa sa mp_send.

Ang mp_recv function ay nangangailangan sa iyo na tukuyin ang nagpadala ng mensahe na iyong sinadya
tumanggap. Ito ay humaharang hanggang sa may dumating na mensahe mula sa nagpadalang iyon, na pumipila
mga mensahe mula sa iba pang mga nagpadala na maaaring dumating nang maaga. Ang mga nakapila na mensahe ay magiging
kinuha ito sa order na natanggap noong tumawag ka sa mp_recv para sa katugmang nagpadala. Ang
Ang tampok na queuing ay ginagawang mas madali upang maiwasan ang mga pinakasimpleng uri ng kondisyon ng lahi
kapag ikaw ay sumulat ng interpreted parallel programs.

Ibinabalik ng mp_probe function ang listahan ng lahat ng mga nagpadala ng mga naka-queue na mensahe (o wala kung
walang laman ang pila). Tumawag mp_probe(0) upang bumalik kaagad, kahit na ang pila ay walang laman.
tawag mp_probe(1) upang harangan kung ang pila ay walang laman, bumabalik lamang kapag hindi bababa sa isang mensahe
ay magagamit para sa mp_recv. Tumawag mp_probe(2) upang harangan hanggang sa dumating ang isang bagong mensahe, kahit na
ang ilang mga mensahe ay kasalukuyang magagamit.

Ang mp_exec function ay gumagamit ng logarithmic fanout - ang ranggo 0 ay ipinapadala sa F na mga proseso, bawat isa
na nagpapadala sa F nang higit pa, at iba pa, hanggang sa lahat ng mga proseso ay may mensahe. Sa sandaling isang proseso
kinukumpleto ang lahat ng pagpapatakbo nito sa pagpapadala, pinag-parse nito at isinasagawa ang mga nilalaman ng mensahe.
Ang algorithm ng fanout ay umabot sa N proseso sa log sa base F ng N hakbang. Ang mga proseso ng F
Ang ranggo 0 ay ipinapadala sa mga ranggo 1, 2, 3, ..., F. Sa pangkalahatan, ang prosesong may ranggo r ay nagpapadala sa
niranggo ang r*F+1, r*F+2, ..., r*F+F (kapag mas mababa ang mga ito sa N-1 para sa N proseso). Itong set
ay tinatawag na "staff" ng ranggo r. Ang mga ranggo na may r>0 ay tumatanggap ng mensahe mula sa ranggo (r-1)/F,
na tinatawag na "boss" ng r. Ang mp_exec na tawag ay interoperate sa mp_recv queue;
sa madaling salita, magiging mga mensahe mula sa isang ranggo maliban sa boss sa panahon ng mp_execut fanout
nakapila para sa pagbawi sa ibang pagkakataon ng mp_recv. (Kung wala ang tampok na ito, anumang parallel na gawain na
gumamit ng pattern ng mensahe maliban sa logarithmic fanout ay magiging madaling kapitan sa lahi
kundisyon.)

Ang logarithmic fanout at ang panloob na katumbas nito ay lubhang kapaki-pakinabang na ang mpy ay nagbibigay ng isang pares
ng mas mataas na antas ng mga function na gumagamit ng parehong pattern ng fanout bilang mp_exec:
mp_handout, msg;
kabuuan = mp_handin(halaga);
Upang gumamit ng mp_handout, ang ranggo 0 ay nagko-compute ng isang mensahe, pagkatapos ang lahat ng mga ranggo ay tumawag sa mp_handout, na nagpapadala ng mensahe
(isang output sa lahat ng mga ranggo maliban sa 0) saanman sa pamamagitan ng parehong fanout bilang mp_exec. Upang gamitin
mp_handin, ang bawat proseso ay nagko-compute ng halaga, pagkatapos ay tumatawag sa mp_handin, na nagbabalik ng kabuuan ng
kanilang sariling halaga at lahat ng kanilang mga tauhan, upang sa ranggo 0 mp_handin ibinalik ang kabuuan ng
mga halaga mula sa bawat proseso.

Maaari mong tawagan ang mp_handin bilang isang function na walang mga argumento upang kumilos bilang isang synchronization; kailan
Ang ranggo 0 ay nagpapatuloy pagkatapos ng naturang tawag, alam mo na ang bawat iba pang ranggo ay umabot sa puntong iyon.
Ang lahat ng magkakatulad na gawain (anumang nagsimula sa mp_exec) ay dapat tapusin sa isang tawag sa mp_handin,
o isang katumbas na garantiya na ang lahat ng mga proseso ay bumalik sa isang idle na estado kapag ang gawain
matatapos sa rank 0.

Maaari mong kunin o baguhin ang fanout parameter F gamit ang mp_nfan function. Ang default
ang halaga ay 16, na dapat ay makatwiran kahit para sa napakalaking bilang ng mga proseso.

Ang isang espesyal na parallel na gawain ay tinatawag na mp_connect, na maaari mong gamitin sa feed interpreted
command lines sa anumang solong non-0 na ranggo, habang ang lahat ng iba pang mga ranggo ay walang ginagawa. Ang ranggo 0 ay nakaupo sa a
loop sa pagbabasa ng keyboard at pagpapadala ng mga linya sa "konektado" rank, na executes
sa kanila, at nagpapadala ng pagkilala pabalik sa ranggo 0. Patakbuhin mo ang function na mp_disconnect sa
kumpletuhin ang parallel na gawain at bumaba pabalik sa ranggo 0.

Panghuli, isang tala tungkol sa pagbawi ng error. Sa kaganapan ng isang error sa isang parallel na gawain,
Sinusubukan ng mpy na maayos na lumabas sa mp_exec, upang kapag bumalik ang ranggo 0, lahat ng iba pang ranggo
ay kilala na idle, handa na para sa susunod na mp_exec. Ang pamamaraang ito ay mananatili magpakailanman kung mayroon man
ang isa sa mga proseso ay nasa isang walang katapusang loop, o kung hindi man ay nasa isang estado kung saan ito ay hindi kailanman
tumawag sa mp_send, mp_recv, o mp_probe, dahil ang MPI ay hindi nagbibigay ng paraan upang magpadala ng signal na
nakakagambala sa lahat ng mga proseso. (Ito ay isa sa mga paraan kung saan ang kapaligiran ng MPI ay
"crude".) Ang rank 0 na proseso ay naiwan sa ranggo ng unang proseso na nag-ulat ng a
fault, kasama ang bilang ng bilang ng mga prosesong nag-fault para sa isang dahilan maliban sa pagiging
nagpadala ng mensahe na may pagkakamali ang isa pang ranggo. Ang unang proseso ng faulting ay maaaring pumasok sa dbug
mode sa pamamagitan ng mp_connect; gumamit ng mp_disconnect o dbexit para bumalik sa serial mode sa rank 0.

Options
-j file.i kasama ang Yorick source file file.i habang nagsisimula ang mpy sa parallel mode
sa lahat ng ranggo. Ito ay katumbas ng mp_include function pagkatapos ng mpy
nagsimula na.

-i file.i kasama ang Yorick source file file.i habang nagsisimula ang mpy, sa serial mode.
Ito ay katumbas ng #include na direktiba pagkatapos magsimula ang mpy.

-batch file.i kasama ang Yorick source file file.i habang nagsisimula ang mpy, sa serial mode.
Ang iyong customization file na custommp.i, kung mayroon man, ay hindi basahin, at ang mpy ay
inilagay sa batch mode. Gamitin ang help command sa batch function
(help, batch) para malaman ang higit pa tungkol sa batch mode. Sa batch mode, lahat
ang mga pagkakamali ay nakamamatay; karaniwan, ititigil ng mpy ang pagpapatupad at maghihintay ng higit pa
input pagkatapos ng isang error.

Gumamit ng mpy.mpich2 online gamit ang mga serbisyo ng onworks.net