mpy - Online nel cloud

PROGRAMMA:

NOME

mpy - Messaggio che passa Yorick

SINOSSI

mpirun -np dimensione_mp mpy [ -J pfile1.i [ -J pfile2.i [ ... ]]] [ -io file1.i [ -io file2.i [
...]]]
mpirun -np dimensione_mp mpy -lotto file.i

DESCRIZIONE

Yorick è un linguaggio interpretato come Basic o Lisp, ma molto più veloce. Vedere Yorick (1) a
saperne di più su di esso.
Mpy è una versione parallela di Yorick basato sulla Message Passing Interface (MPI). Il
la sintassi esatta per l'avvio di un lavoro parallelo dipende dall'ambiente MPI. Può essere
necessario lanciare un demone speciale prima di chiamare mirun o un comando equivalente.

Spiegazioni
Il pacchetto MPy interfaccia Yorick alla libreria di programmazione parallela MPI. MPI sta per
Interfaccia di passaggio dei messaggi; l'idea è di collegare più istanze di yorick che
comunicano tra loro tramite messaggi. Mpy può eseguire operazioni semplici, altamente parallele
compiti come puri programmi interpretati, oppure può avviare e guidare compilati arbitrariamente complessi
pacchetti che sono liberi di utilizzare l'API MPI compilata. L'API interpretata non è intesa
essere un wrapper MPI; invece è ridotto al minimo indispensabile.

Questa è la versione 2 di mpy (rilasciata nel 2010); non è compatibile con la versione 1 di mpy
(pubblicato a metà degli anni '1990), perché la versione 1 aveva numerosi difetti di progettazione che la rendevano molto
programmi difficili da scrivere privi di race condition e impossibili da scalare a milioni
di processori. Tuttavia, puoi eseguire la maggior parte dei programmi di versione 1 mpy con la versione 2 facendo
mp_include,"mpy1.i" prima di mp_include qualsiasi file che definisce un'attività parallela mpy1 (cioè
prima di qualsiasi file contenente una chiamata a mp_task.)

Impiego note
L'ambiente MPI non è realmente specificato dallo standard; gli ambienti esistenti sono
molto rozzo e favoriscono fortemente i lavori batch non interattivi. Il numero di processi è
risolto prima dell'inizio di MPI; ogni processo ha un rango, un numero da 0 a uno in meno del
numero di processi. Usi il grado come indirizzo per inviare messaggi e il processo
ricevendo il messaggio può sondare per vedere quali ranghi gli hanno inviato messaggi e, naturalmente,
ricevere quei messaggi.

Un grosso problema nella scrittura di un programma di scambio di messaggi è la gestione di eventi o messaggi
arrivare in un ordine non pianificato. MPI garantisce solo che una sequenza di messaggi inviati da
dal rango A al rango B arriverà nell'ordine inviato. Non vi è alcuna garanzia sull'ordine di
arrivo di quei messaggi relativi a messaggi inviati a B da un terzo grado C. In
particolare, supponiamo che A invii un messaggio a B, quindi A invii un messaggio a C (o anche scambi
diversi messaggi con C) che si traduce in C che invia un messaggio a B. Il messaggio da C
potrebbe arrivare a B prima del messaggio di A. Un programma MPI che non lo consente
possibilità ha un bug chiamato "condizione di gara". Le condizioni di gara possono essere estremamente sottili,
soprattutto quando il numero di processi è grande.

L'interfaccia mpy interpretata di base è costituita da due variabili:
mp_size = numero di processi
mp_rank = rango di questo processo e quattro funzioni:
mp_send, a, msg; // invia un messaggio per classificare "a"
msg = mp_recv(from); // riceve il messaggio dal rango "da"
ranghi = mp_probe(blocco); // interroga i mittenti dei messaggi in sospeso
mp_exec, stringa; // analizza ed esegue la stringa su ogni rango

Chiami mp_exec al livello 0 per avviare un'attività parallela. Quando il programma principale così creato
termina, tutti i ranghi diversi dal rango 0 tornano a un ciclo inattivo, in attesa del successivo
mp_exec. Il rango 0 preleva la riga di input successiva da stdin (ovvero, attende l'input al suo
prompt in una sessione interattiva), o termina tutti i processi se non ci sono più input
disponibile in una sessione batch.

Il pacchetto mpy modifica il modo in cui yorick gestisce la direttiva #include parser e include
e richiedono funzioni. Vale a dire, se è in esecuzione un'attività parallela (ovvero, una funzione avviata)
da mp_exec), queste diventano tutte operazioni collettive. Cioè, il rango 0 legge l'intero
contenuto del file e invia il contenuto agli altri processi come messaggio MPI (come
mp_exec del contenuto del file). Ogni processo diverso dal rango 0 è in esecuzione solo durante
compiti paralleli; al di fuori di un'attività parallela quando è in esecuzione solo il rango 0 (e tutti gli altri ranghi
sono in attesa del prossimo mp_exec), la direttiva #include e include e require
le funzioni tornano alla loro normale operazione seriale, interessando solo il rango 0.

All'avvio di mpy, è in modalità parallela, in modo che tutti i file yorick includa quando lo fa
avvia (i file in Y_SITE/i0) sono inclusi come operazioni collettive. Senza questo
caratteristica, ogni processo di Yorick tenterà di aprire e leggere i file di inclusione di avvio,
sovraccaricare il file system prima che mpy venga avviato. Passando il contenuto di questi
file come messaggi MPI è l'unico modo per garantire che ci sia abbastanza larghezza di banda per ogni
processo per leggere il contenuto di un singolo file.

L'ultimo file incluso all'avvio è il file specificato nell'opzione -batch, oppure
il file custom.i. Per evitare problemi con il codice in custom.i che potrebbe non essere sicuro per
esecuzione parallela, mpy non cerca custom.i, ma invece custommp.i. Il
le istruzioni nel file -batch o in custommp.i vengono eseguite in modalità seriale al rango 0
soltanto. Allo stesso modo, mpy sovrascrive la consueta funzione process_argv, in modo che -i e other
le opzioni della riga di comando vengono elaborate solo al rango 0 in modalità seriale. L'intento in tutti questi
casi è fare in modo che i file -batch o custommp.i o -i include vengano eseguiti solo al rango 0, come
se li avessi digitati lì in modo interattivo. Sei libero di chiamare mp_exec da uno di questi
file per avviare attività parallele, ma il file stesso è seriale.

Un'ulteriore opzione della riga di comando viene aggiunta al solito set:
mpy -j qualchefile.i
include somefile.i in modalità parallela su tutti i ranghi (di nuovo, -i other.i include solo other.i
al rango 0 in modalità seriale). Se ci sono più opzioni -j, il parallelo include succede
nell'ordine della riga di comando. Se le opzioni -j e -i sono miste, tuttavia, tutte le opzioni -j incluse si verificano
prima di qualsiasi -i include.

Come effetto collaterale della complessità delle funzioni di inclusione in mpy, la funzione di caricamento automatico è
Disabilitato; se il tuo codice attiva effettivamente un'inclusione chiamando una funzione caricata automaticamente, mpy
si fermerà con un errore. Devi caricare esplicitamente tutte le funzioni necessarie per un parallelo
le attività che utilizzano la funzione require si richiamano all'interno di un'attività parallela.

La funzione mp_send può inviare qualsiasi array numerico yorick (tipi char, short, int, long,
float, double o complex) o un valore di stringa scalare. Il processo di invio del messaggio
via MPI conserva solo il numero di elementi, quindi mp_recv produce solo un valore scalare o
un array 1D di valori, indipendentemente dalla dimensionalità passata a mp_send.

La funzione mp_recv richiede di specificare il mittente del messaggio che intendi
ricevere. Si blocca fino a quando un messaggio non arriva effettivamente da quel mittente, mettendo in coda qualsiasi
messaggi di altri mittenti che potrebbero arrivare in anticipo. I messaggi in coda saranno
recuperato l'ordine ricevuto quando chiami mp_recv per il mittente corrispondente. Il
la funzione di accodamento rende notevolmente più facile evitare i tipi più semplici di race condition
quando si scrivono programmi paralleli interpretati.

La funzione mp_probe restituisce l'elenco di tutti i mittenti dei messaggi in coda (o nullo se
la coda è vuota). Chiamata mp_sonda(0) per tornare immediatamente, anche se la coda è vuota.
Call mp_sonda(1) per bloccare se la coda è vuota, ritornando solo quando almeno un messaggio
è disponibile per mp_recv. Chiamata mp_sonda(2) bloccare fino all'arrivo di un nuovo messaggio, anche se
alcuni messaggi sono attualmente disponibili.

La funzione mp_exec utilizza un fanout logaritmico: il rango 0 invia ai processi F, ciascuno di
che invia a F altro, e così via, finché tutti i processi non hanno il messaggio. Una volta che un processo
completa tutte le sue operazioni di invio, analizza ed esegue il contenuto del messaggio.
L'algoritmo di fanout raggiunge N processi in log alla base F di N passi. I processi F
rango 0 invia a sono ranghi 1, 2, 3, ..., F. In generale, il processo con rango r invia a
ranghi r*F+1, r*F+2, ..., r*F+F (quando questi sono minori di N-1 per N processi). questo set
è chiamato il "personale" di rango r. I ranghi con r>0 ricevono il messaggio dal rango (r-1)/F,
che è chiamato il "capo" di r. La chiamata mp_exec interagisce con la coda mp_recv;
in altre parole, i messaggi di un grado diverso dal boss durante un fanout di mp_exec saranno
in coda per un successivo recupero da mp_recv. (Senza questa funzione, qualsiasi attività parallela che
utilizzato un modello di messaggio diverso dal fanout logaritmico sarebbe suscettibile alla razza
condizioni.)

Il fanout logaritmico e il suo equivalente interno sono così utili che mpy fornisce una coppia
di funzioni di livello superiore che utilizzano lo stesso pattern di fanout di mp_exec:
mp_dispensa, msg;
totale = mp_handin(valore);
Per usare mp_handout, rank 0 calcola un msg, quindi tutti i rank chiamano mp_handout, che invia msg
(un output su tutti i ranghi diversi da 0) ovunque dallo stesso fanout di mp_exec. Usare
mp_handin, ogni processo calcola il valore, quindi chiama mp_handin, che restituisce la somma di
il proprio valore e tutto il proprio pentagramma, in modo che al rango 0 mp_handin restituisca la somma di
valori di ogni processo.

Puoi chiamare mp_handin come una funzione senza argomenti per agire come una sincronizzazione; quando
il grado 0 continua dopo tale chiamata, sai che ogni altro grado ha raggiunto quel punto.
Tutte le attività parallele (tutto ciò che è iniziato con mp_exec) devono terminare con una chiamata a mp_handin,
o una garanzia equivalente che tutti i processi siano tornati a uno stato inattivo quando l'attività
finisce al rango 0.

È possibile recuperare o modificare il parametro di fanout F utilizzando la funzione mp_nfan. Il predefinito
il valore è 16, che dovrebbe essere ragionevole anche per un numero molto elevato di processi.

Un'attività parallela speciale si chiama mp_connect, che puoi usare per alimentare l'interpretato
righe di comando a qualsiasi singolo rango diverso da 0, mentre tutti gli altri ranghi rimangono inattivi. Il rango 0 si trova in a
loop leggendo la tastiera e inviando le righe al rango "connesso", che esegue
loro e invia un riconoscimento al rango 0. Esegui la funzione mp_disconnect per
completare l'attività parallela e tornare al rango 0.

Infine, una nota sul ripristino degli errori. In caso di errore durante un'attività parallela,
mpy tenta di uscire con grazia da mp_exec, in modo che quando ritorna il rango 0, tutti gli altri ranghi
sono noti per essere inattivi, pronti per il prossimo mp_exec. Questa procedura si bloccherà per sempre, se presente
uno dei processi è in un ciclo infinito, o altrimenti in uno stato in cui non sarà mai
chiamare mp_send, mp_recv o mp_probe, perché MPI non fornisce alcun mezzo per inviare un segnale che
interrompe tutti i processi. (Questo è uno dei modi in cui l'ambiente MPI è
"grezzo".) Il processo di rango 0 viene lasciato con il rango del primo processo che ha riportato a
guasto, più un conteggio del numero di processi che si sono guasti per un motivo diverso dall'essere
ha inviato un messaggio che un altro rango aveva sbagliato. Il primo processo di errore può entrare in dbug
modalità tramite mp_connect; usa mp_disconnect o dbexit per tornare alla modalità seriale al livello 0.

Opzioni
-j file.i include il file sorgente Yorick file.i come mpy si avvia in modalità parallela
su tutti i ranghi. Questo è equivalente alla funzione mp_include dopo mpy
è iniziato.

-i file.i include il file sorgente Yorick file.i all'avvio di mpy, in modalità seriale.
Questo è equivalente alla direttiva #include dopo l'avvio di mpy.

-lotto file.i include il file sorgente Yorick file.i all'avvio di mpy, in modalità seriale.
Il tuo file di personalizzazione custommp.i, se presente, è non è un leggi, e mpy è
posto in modalità batch. Usa il comando di aiuto sulla funzione batch
(aiuto, batch) per saperne di più sulla modalità batch. In modalità batch, tutto
gli errori sono fatali; normalmente, mpy interromperà l'esecuzione e attenderà di più
input dopo un errore.

Usa mpy online utilizzando i servizi onworks.net