mpy - Online în cloud

PROGRAM:

NUME

mpy - Mesaj care trece Yorick

REZUMAT

mpirun -np mp_size mpy [ -j pfile1.i [ -j pfile2.i [ ... ]]] [ -i fisier1.i [ -i fisier2.i [
... ]]]
mpirun -np mp_size mpy -lot dosar.i

DESCRIERE

Yorick este un limbaj interpretat precum Basic sau Lisp, dar mult mai rapid. Vedea Yorick (1) la
afla mai multe despre el.
Mpy este o versiune paralelă a Yorick pe baza interfeței de transmitere a mesajelor (MPI). The
Sintaxa exactă pentru lansarea unui job paralel depinde de mediul dvs. MPI. S-ar putea
este necesar să lansați un daemon special înainte de a apela mirun sau o comandă echivalentă.

explicaţii
Pachetul mpy interfață yorick cu biblioteca de programare paralelă MPI. MPI înseamnă
Interfață de transmitere a mesajelor; ideea este de a conecta mai multe instanțe de yorick care
comunică între ei prin mesaje. Mpy poate fi simplu, extrem de paralel
sarcini ca programe pur interpretate, sau poate porni și conduce compilate arbitrar complexe
pachete care pot folosi gratuit API-ul MPI compilat. API-ul interpretat nu este destinat
a fi un ambalaj MPI; în schimb este dezbrăcat la minimum.

Aceasta este versiunea 2 a mpy (lansată în 2010); este incompatibil cu versiunea 1 a mpy
(lansat la mijlocul anilor 1990), deoarece versiunea 1 avea numeroase defecte de design făcând-o foarte
dificil de scris programe fără condiții de cursă și imposibil de scalat la milioane
a procesoarelor. Cu toate acestea, puteți rula majoritatea programelor mpy versiunea 1 sub versiunea 2 făcând
mp_include,"mpy1.i" înainte de a mp_include orice fișier care definește o sarcină paralelă mpy1 (adică
înainte de orice fișier care conține un apel către mp_task.)

Folosire notiţe
Mediul MPI nu este chiar specificat de standard; mediile existente sunt
foarte brut și favorizează puternic joburile neinteractive în loturi. Numărul de procese este
fixat înainte de începerea MPI; fiecare proces are un rang, un număr de la 0 la unu mai mic decât
numărul de procese. Utilizați rangul ca adresă pentru a trimite mesaje și procesul
primirea mesajului poate sonda pentru a vedea ce ranguri i-au trimis mesaje și, desigur
primi acele mesaje.

O problemă majoră în scrierea unui program de transmitere a mesajelor este gestionarea evenimentelor sau a mesajelor
sosind într-o ordine neplanificată. MPI garantează doar că o secvență de mesaje trimise de
rangul A la rangul B va ajunge în ordinea trimisă. Nu există nicio garanție cu privire la ordinea
sosirea acelor mesaje relativ la mesajele trimise către B de la un rang al treilea C. În
în special, să presupunem că A trimite un mesaj către B, apoi A trimite un mesaj către C (sau chiar schimbă
mai multe mesaje cu C) care are ca rezultat C trimiterea unui mesaj către B. Mesajul de la C
poate ajunge la B înaintea mesajului de la A. Un program MPI care nu permite acest lucru
posibilitatea are o eroare numită „condiție de cursă”. Condițiile de cursă pot fi extrem de subtile,
mai ales când numărul de procese este mare.

Interfața de bază interpretată mpy constă din două variabile:
mp_size = numărul de procese
mp_rank = rangul acestui proces și patru funcții:
mp_send, către, msg; // trimite mesaj la clasarea "la"
msg = mp_recv(de la); // primim mesaj de la rangul "de la"
ranguri = mp_probe(block); // interogați expeditorii mesajelor în așteptare
mp_exec, șir; // analizează și execută șir pe fiecare rang

Apelați mp_exec pe rangul 0 pentru a începe o sarcină paralelă. Când programul principal astfel creat
se termină, toate rangurile, altele decât rangul 0, revin la o buclă inactivă, așteptând următoarea
mp_exec. Rangul 0 preia următoarea linie de intrare de la stdin (adică așteaptă intrarea la sa
prompt într-o sesiune interactivă) sau încheie toate procesele dacă nu mai există nicio intrare
disponibil într-o sesiune lot.

Pachetul mpy modifică modul în care yorick gestionează directiva de analiză #include și include
și necesită funcții. Și anume, dacă rulează o sarcină paralelă (adică a început o funcție
de mp_exec), toate acestea devin operațiuni colective. Adică, rangul 0 citește întregul
conținutul fișierului și trimite conținutul celorlalte procese ca mesaj MPI (cum ar fi
mp_exec al conținutului fișierului). Fiecare proces, altul decât rangul 0, rulează numai în timpul
sarcini paralele; în afara unei sarcini paralele când rulează numai rangul 0 (și toate celelalte ranguri
așteaptă următorul mp_exec), directiva #include și include și require
funcțiile revin la funcționarea în serie obișnuită, afectând doar rangul 0.

Când mpy pornește, este în modul paralel, astfel încât toate fișierele pe care le include yorick atunci când acesta
start-urile (fișierele din Y_SITE/i0) sunt incluse ca operațiuni colective. Fără asta
caracteristică, fiecare proces Yorick ar încerca să deschidă și să citească fișierele de pornire incluse,
supraîncărcarea sistemului de fișiere înainte ca mpy să pornească vreodată. Trecând conținutul acestora
fișierele ca mesaje MPI este singura modalitate de a vă asigura că există suficientă lățime de bandă pentru fiecare
proces pentru a citi conținutul unui singur fișier.

Ultimul fișier inclus la pornire este fie fișierul specificat în opțiunea -batch, fie
fișierul custom.i. Pentru a evita problemele cu codul din custom.i care ar putea să nu fie sigur pentru
execuție paralelă, mpy nu caută custom.i, ci în schimb custommp.i. The
instrucțiunile din fișierul -batch sau din custommp.i sunt executate în modul serial pe rangul 0
numai. În mod similar, mpy suprascrie funcția obișnuită process_argv, astfel încât -i și altele
Opțiunile liniei de comandă sunt procesate numai pe rangul 0 în modul serial. Intenția în toate acestea
cazuri este de a face ca fișierele -batch sau custommp.i sau -i să includă să se execute numai pe rangul 0, ca
dacă le-ai fi tastat acolo interactiv. Sunteți liber să apelați mp_exec de la oricare dintre acestea
fișiere pentru a începe sarcini paralele, dar fișierul în sine este serial.

O opțiune suplimentară de linie de comandă este adăugată la setul obișnuit:
mpy -j somefile.i
include somefile.i în modul paralel pe toate rangurile (din nou, -i other.i include doar other.i
pe rangul 0 în modul serial). Dacă există mai multe opțiuni -j, se întâmplă includerile paralele
în ordinea liniei de comandă. Dacă opțiunile -j și -i sunt amestecate, totuși, toate includerile -j au loc
înainte de orice -i include.

Ca efect secundar al complexității funcțiilor include în mpy, funcția de încărcare automată este
dezactivat; dacă codul dvs. declanșează de fapt o includere prin apelarea unei funcții încărcate automat, mpy
se va opri cu o eroare. Trebuie să încărcați în mod explicit toate funcțiile necesare pentru o paralelă
sarcinile care utilizează necesită apeluri de funcție în interiorul unei sarcini paralele.

Funcția mp_send poate trimite orice matrice numerică Yorick (tipurile char, short, int, long,
float, double sau complex) sau o valoare de șir scalară. Procesul de trimitere a mesajului
prin MPI păstrează doar numărul de elemente, deci mp_recv produce doar o valoare scalară sau
o matrice 1D de valori, indiferent de ce dimensionalitate a fost transmisă la mp_send.

Funcția mp_recv vă cere să specificați expeditorul mesajului la care doriți
a primi. Se blochează până când sosește un mesaj de la acel expeditor, punând în coadă oricare
mesaje de la alți expeditori care pot ajunge în prealabil. Mesajele din coadă vor fi
a preluat comanda primită atunci când apelați mp_recv pentru expeditorul potrivit. The
Caracteristica de coadă face mult mai ușoară evitarea celor mai simple tipuri de condiții de cursă
când scrieți programe paralele interpretate.

Funcția mp_probe returnează lista tuturor expeditorilor de mesaje aflate în coadă (sau nil dacă
coada este goală). Apel mp_probe(0) pentru a reveni imediat, chiar dacă coada este goală.
Apel mp_probe(1) pentru a bloca dacă coada este goală, revenind numai atunci când cel puțin un mesaj
este disponibil pentru mp_recv. Apel mp_probe(2) să blocheze până la sosirea unui nou mesaj, chiar dacă
unele mesaje sunt disponibile momentan.

Funcția mp_exec folosește un fanout logaritmic - rangul 0 trimite proceselor F, fiecare dintre
care trimite la F mai mult și așa mai departe, până când toate procesele au mesajul. Odată un proces
își finalizează toate operațiunile de trimitere, analizează și execută conținutul mesajului.
Algoritmul de distribuție ajunge la N procese în log la baza F de N pași. Procesele F
rangul 0 trimite la sunt rangurile 1, 2, 3, ..., F. În general, procesul cu rangul r trimite la
clasează r*F+1, r*F+2, ..., r*F+F (când acestea sunt mai mici decât N-1 pentru N procese). Acest set
se numește „personalul” de gradul r. Rangurile cu r>0 primesc mesajul de la rangul (r-1)/F,
care se numeşte „şeful” lui r. Apelul mp_exec interoperează cu coada mp_recv;
cu alte cuvinte, mesajele de la un alt rang decât șeful în timpul unui fanout mp_exec vor fi
pus în coadă pentru extragere ulterioară de către mp_recv. (Fără această caracteristică, orice sarcină paralelă care
folosit un model de mesaj, altul decât fanout logaritmic, ar fi susceptibil la rasă
condiții.)

Fanout-ul logaritmic și echivalentul său interior sunt atât de utile încât mpy oferă un cuplu
de funcții de nivel superior care folosesc același model de fanout ca mp_exec:
mp_handout, msg;
total = mp_handin(valoare);
Pentru a utiliza mp_handout, rangul 0 calculează un mesaj, apoi toate rangurile apelează mp_handout, care trimite mesaj
(o ieșire pe toate rangurile, altele decât 0) peste tot prin același fanout ca mp_exec. A folosi
mp_handin, fiecare proces calculează valoarea, apoi apelează mp_handin, care returnează suma
propria lor valoare și întreg personalul lor, astfel încât pe rangul 0 mp_handin returnează suma celor
valorile din fiecare proces.

Puteți apela mp_handin ca o funcție fără argumente care să acționeze ca o sincronizare; cand
rangul 0 continuă după un astfel de apel, știți că fiecare alt rang a atins acel punct.
Toate sarcinile paralele (orice a început cu mp_exec) trebuie să se termine cu un apel la mp_handin,
sau o garanție echivalentă că toate procesele au revenit la o stare inactivă atunci când sarcina
termină pe locul 0.

Puteți prelua sau modifica parametrul fanout F folosind funcția mp_nfan. Implicit
valoarea este 16, ceea ce ar trebui să fie rezonabil chiar și pentru un număr foarte mare de procese.

O sarcină paralelă specială se numește mp_connect, pe care o puteți folosi pentru a alimenta interpretat
linii de comandă la orice rang non-0, în timp ce toate celelalte ranguri stau inactiv. Locul 0 se află într-un
buclă citind tastatura și trimiterea liniilor la rangul „conectat”, care se execută
și trimite o confirmare înapoi la rangul 0. Rulați funcția mp_disconnect la
finalizați sarcina paralelă și reveniți la rangul 0.

În cele din urmă, o notă despre recuperarea erorilor. În cazul unei erori în timpul unei sarcini paralele,
mpy încearcă să iasă cu grație din mp_exec, astfel încât, atunci când rangul 0 revine, toate celelalte ranguri
se știe că sunt inactivi, gata pentru următorul mp_exec. Această procedură se va bloca pentru totdeauna, dacă există
unul dintre procese este într-o buclă infinită sau, altfel, într-o stare în care nu va fi niciodată
apelați mp_send, mp_recv sau mp_probe, deoarece MPI nu oferă niciun mijloc de a trimite un semnal care
întrerupe toate procesele. (Acesta este unul dintre modurile în care este mediul MPI
„brut”.) Procesul de rang 0 este lăsat cu rangul primului proces care a raportat a
eroare, plus un număr al numărului de procese care au greșit dintr-un alt motiv decât a fi
a trimis un mesaj că un alt rang a greșit. Primul proces de eroare poate intra în dbug
modul prin mp_connect; utilizați mp_disconnect sau dbexit pentru a reveni la modul serial pe rangul 0.

Opţiuni
-j dosar.i include fișierul sursă Yorick dosar.i deoarece mpy pornește în modul paralel
pe toate gradele. Aceasta este echivalentă cu funcția mp_include după mpy
a început.

-i dosar.i include fișierul sursă Yorick dosar.i pe măsură ce pornește mpy, în modul serial.
Aceasta este echivalentă cu directiva #include după ce mpy a pornit.

-lot dosar.i include fișierul sursă Yorick dosar.i pe măsură ce pornește mpy, în modul serial.
Fișierul dvs. de personalizare custommp.i, dacă există, este nu citește, și mpy este
plasat în modul lot. Utilizați comanda de ajutor pentru funcția batch
(ajutor, lot) pentru a afla mai multe despre modul batch. În modul lot, toate
erorile sunt fatale; în mod normal, mpy va opri execuția și va aștepta mai mult
introducerea după o eroare.

Utilizați mpy online folosind serviciile onworks.net