mpy - Online in de cloud

PROGRAMMA:

NAAM

mpy - Bericht passeert Yorick

KORTE INHOUD

mpirun -np mp_grootte mpy [ -J pbestand1.i [ -J pbestand2.i [ ... ]]] [ -i bestand1.i [ -i bestand2.i [
...]]]
mpirun -np mp_grootte mpy -partij bestand.i

PRODUCTBESCHRIJVING

yorick is een geïnterpreteerde taal zoals Basic of Lisp, maar veel sneller. Zien Jorick (1) voor
leer er meer over.
Mpy is een parallelle versie van yorick gebaseerd op de Message Passing Interface (MPI). De
De exacte syntaxis voor het starten van een parallelle taak is afhankelijk van uw MPI-omgeving. Het kan zijn
nodig om een ​​speciale daemon te starten voordat u belt mirun of een gelijkwaardig commando.

Verklaringen
Het mpy-pakket vormt een interface met de parallelle programmeerbibliotheek van MPI. MPI staat voor
Interface voor het doorgeven van berichten; het idee is om meerdere exemplaren van yorick that te verbinden
onderling communiceren via berichten. Mpy kan eenvoudig en zeer parallel presteren
taken als puur geïnterpreteerde programma's, of het kan willekeurig complex gecompileerd starten en sturen
pakketten die gratis de gecompileerde MPI API kunnen gebruiken. De geïnterpreteerde API is niet bedoeld
een MPI-verpakking zijn; in plaats daarvan wordt het tot het absolute minimum gestript.

Dit is versie 2 van mpy (uitgebracht in 2010); het is incompatibel met versie 1 van mpy
(uitgebracht halverwege de jaren negentig), omdat versie 1990 talloze ontwerpfouten vertoonde, waardoor het een zeer goede versie was
moeilijk om programma’s te schrijven die vrij zijn van rassenomstandigheden, en onmogelijk op te schalen naar miljoenen
van verwerkers. U kunt de meeste mpy-programma's van versie 1 echter onder versie 2 uitvoeren door dit te doen
mp_include,"mpy1.i" voordat u mp_include een bestand definieert dat een mpy1 parallelle taak definieert (dat wil zeggen
vóór elk bestand dat een aanroep naar mp_task bevat.)

Gebruik aantekeningen
De MPI-omgeving wordt niet echt gespecificeerd door de standaard; bestaande omgevingen zijn dat wel
erg grof en geven sterk de voorkeur aan niet-interactieve batchtaken. Het aantal processen is
opgelost voordat MPI begint; elk proces heeft een rang, een getal van 0 tot één lager dan de
aantal processen. U gebruikt de rang als adres om berichten te verzenden, en het proces
het ontvangen van het bericht kan onderzoeken welke rangen er berichten naar hebben gestuurd, en natuurlijk
ontvang die berichten.

Een groot probleem bij het schrijven van een programma voor het doorgeven van berichten is het verwerken van gebeurtenissen of berichten
aankomen in een ongeplande volgorde. MPI garandeert alleen dat er een reeks berichten wordt verzonden
rang A naar rang B arriveert in de verzonden volgorde. Er is geen garantie over de bestelling van
aankomst van die berichten ten opzichte van berichten verzonden naar B vanaf een derde rang C. In
Stel dat A een bericht naar B stuurt, dan stuurt A een bericht naar C (of zelfs uitwisselingen).
meerdere berichten met C) waardoor C een bericht naar B verstuurt. Het bericht van C
kan vóór het bericht van A bij B aankomen. Een MPI-programma dat dit niet toestaat
mogelijkheid heeft een bug die een "race condition" wordt genoemd. Raceomstandigheden kunnen uiterst subtiel zijn,
vooral als het aantal processen groot is.

De standaard mpy-geïnterpreteerde interface bestaat uit twee variabelen:
mp_size = aantal processen
mp_rank = rang van dit proces en vier functies:
mp_send, naar, bericht; // stuur een bericht om "naar" te rangschikken
msg = mp_recv(van); // ontvang bericht van rang "van"
rangen = mp_probe(blok); // vraag afzenders van openstaande berichten
mp_exec, tekenreeks; // parseer en voer een string uit op elke rang

Je roept mp_exec op rang 0 aan om een ​​parallelle taak te starten. Toen het hoofdprogramma aldus werd aangemaakt
eindigt, keren alle rangen behalve rang 0 terug naar een inactieve lus, wachtend op de volgende
mp_exec. Rang 0 pikt de volgende invoerregel op van stdin (dat wil zeggen, wacht op invoer op zijn
prompt in een interactieve sessie), of beëindigt alle processen als er geen invoer meer is
beschikbaar in een batchsessie.

Het mpy-pakket wijzigt de manier waarop yorick omgaat met de parserrichtlijn #include en de include
en functies vereisen. Namelijk als er een parallelle taak wordt uitgevoerd (dat wil zeggen dat er een functie is gestart
door mp_exec), worden dit allemaal collectieve operaties. Dat wil zeggen, rang 0 leest het geheel
bestandsinhoud en verzendt de inhoud naar de andere processen als een MPI-bericht (zoals
mp_exec van de bestandsinhoud). Elk proces anders dan rang 0 wordt alleen uitgevoerd tijdens
parallelle taken; buiten een parallelle taak wanneer alleen rang 0 actief is (en alle andere rangen
wachten op de volgende mp_exec), de #include richtlijn en de include en require
functies keren terug naar hun gebruikelijke seriële werking en beïnvloeden alleen rang 0.

Wanneer mpy start, bevindt het zich in de parallelle modus, zodat alle bestanden die Yorick bevat wanneer het wordt gestart
starts (de bestanden in Y_SITE/i0) worden opgenomen als collectieve bewerkingen. Zonder dit
functie zou elk Yorick-proces proberen de opstartbestanden te openen en te lezen,
het bestandssysteem overbelasten voordat mpy ooit wordt gestart. Het doorgeven van de inhoud hiervan
bestanden als MPI-berichten is de enige manier om ervoor te zorgen dat er voldoende bandbreedte is voor iedereen
proces om de inhoud van een enkel bestand te lezen.

Het laatste bestand dat bij het opstarten wordt opgenomen, is het bestand dat is opgegeven in de optie -batch, of
het custom.i-bestand. Om problemen met code in custom.i te voorkomen waarvoor mogelijk niet veilig is
parallelle uitvoering zoekt mpy niet naar custom.i, maar naar custommp.i. De
instructies in het -batch-bestand of in custommp.i worden uitgevoerd in seriële modus op rang 0
alleen. Op dezelfde manier overschrijft mpy de gebruikelijke process_argv-functie, zodat -i en other
opdrachtregelopties worden alleen verwerkt op rang 0 in seriële modus. De bedoeling van dit alles
cases is om de bestanden -batch of custommp.i of -i include alleen op rang 0 te laten uitvoeren, as
als je ze daar interactief had getypt. U bent vrij om mp_exec vanuit elk van deze te bellen
bestanden om parallelle taken te starten, maar het bestand zelf is serieel.

Er is een extra opdrachtregeloptie toegevoegd aan de gebruikelijke set:
mpy -j een bestand.i
bevat somefile.i in parallelle modus op alle rangen (nogmaals, -i other.i omvat alleen other.i
op rang 0 in seriële modus). Als er meerdere -j opties zijn, gebeurt de parallelle include
in opdrachtregelvolgorde. Als de opties -j en -i echter gemengd zijn, gebeuren alle -j-includes
voordat een -i wordt opgenomen.

Als neveneffect van de complexiteit van include-functies in mpy is er de autoload-functie
gehandicapt; als uw code daadwerkelijk een include activeert door een automatisch geladen functie aan te roepen, mpy
stopt met een fout. U moet expliciet alle functies laden die nodig zijn voor een parallel
taken die gebruikmaken van functieaanroepen vereisen zichzelf binnen een parallelle taak.

De mp_send-functie kan elke numerieke yorick-array verzenden (types char, short, int, long,
float, double of complex), of een scalaire tekenreekswaarde. Het proces van het verzenden van het bericht
via MPI behoudt alleen het aantal elementen, dus mp_recv produceert alleen een scalaire waarde of
een 1D-array met waarden, ongeacht de dimensionaliteit die aan mp_send is doorgegeven.

Voor de functie mp_recv moet u de afzender opgeven van het bericht dat u bedoelt
ontvangen. Het blokkeert totdat er daadwerkelijk een bericht van die afzender arriveert, waardoor eventuele berichten in de wachtrij worden geplaatst
berichten van andere afzenders die mogelijk eerder aankomen. De berichten in de wachtrij zullen dat zijn
heeft de bestelling opgehaald die is ontvangen wanneer u mp_recv belt voor de overeenkomende afzender. De
De wachtrijfunctie maakt het aanzienlijk eenvoudiger om de eenvoudigste soorten racecondities te vermijden
wanneer u geïnterpreteerde parallelle programma's schrijft.

De functie mp_probe retourneert de lijst met alle afzenders van berichten in de wachtrij (of nul als
de wachtrij is leeg). Telefoongesprek mp_probe(0) om onmiddellijk terug te keren, zelfs als de wachtrij leeg is.
Bel mp_probe(1) om te blokkeren als de wachtrij leeg is en alleen terugkeert als er minstens één bericht is
is beschikbaar voor mp_recv. Telefoongesprek mp_probe(2) blokkeren totdat er een nieuw bericht binnenkomt, zelfs als
sommige berichten zijn momenteel beschikbaar.

De mp_exec-functie gebruikt een logaritmische fanout - rang 0 verzendt naar F-processen, elk van
die meer naar F stuurt, enzovoort, totdat alle processen de boodschap hebben. Eenmaal een proces
voltooit al zijn verzendbewerkingen, parseert en voert de inhoud van het bericht uit.
Het fanout-algoritme bereikt N processen logaritmisch tot de basis F van N stappen. De F-processen
rang 0 verzendt naar rang 1, 2, 3, ..., F. Over het algemeen verzendt het proces met rang r naar
rangschikt r*F+1, r*F+2, ..., r*F+F (wanneer deze kleiner zijn dan N-1 voor N processen). Deze set
wordt de "staf" van rang r genoemd. Rangen met r>0 ontvangen het bericht van rang (r-1)/F,
die de "baas" van r wordt genoemd. De mp_exec-aanroep werkt samen met de mp_recv-wachtrij;
met andere woorden, berichten van een andere rang dan de baas tijdens een mp_exec fanout zullen dat wel zijn
in de wachtrij geplaatst voor later ophalen door mp_recv. (Zonder deze functie kan elke parallelle taak die
een ander berichtpatroon gebruikte dan logaritmische fanout zou vatbaar zijn voor racen
voorwaarden.)

De logaritmische fanout en zijn innerlijke equivalent zijn zo nuttig dat mpy er een paar biedt
van functies op een hoger niveau die hetzelfde fanout-patroon gebruiken als mp_exec:
mp_handout, bericht;
totaal = mp_handin(waarde);
Om mp_handout te gebruiken, berekent rang 0 een bericht, waarna alle rangen mp_handout aanroepen, waardoor het bericht wordt verzonden
(een uitvoer op alle rangen behalve 0) overal door dezelfde fanout als mp_exec. Gebruiken
mp_handin, elk proces berekent de waarde en roept vervolgens mp_handin aan, wat de som retourneert van
hun eigen waarde en al hun personeel, zodat op rang 0 mp_handin de som retourneert van de
waarden uit elk proces.

Je kunt mp_handin aanroepen als een functie zonder argumenten om als synchronisatie te fungeren; wanneer
rang 0 gaat door na zo'n oproep, je weet dat elke andere rang dat punt heeft bereikt.
Alle parallelle taken (alles wat begint met mp_exec) moet eindigen met een aanroep naar mp_handin,
of een gelijkwaardige garantie dat alle processen zijn teruggekeerd naar een inactieve status wanneer de taak wordt uitgevoerd
eindigt op rang 0.

U kunt de fanout-parameter F ophalen of wijzigen met behulp van de mp_nfan-functie. De standaard
waarde is 16, wat zelfs voor zeer grote aantallen processen redelijk zou moeten zijn.

Een speciale parallelle taak heet mp_connect, die u kunt gebruiken om geïnterpreteerde feeds in te voeren
opdrachtregels naar een enkele niet-0-rang, terwijl alle andere rangen inactief zijn. Rang 0 bevindt zich in a
lus leest het toetsenbord en verzendt de regels naar de "verbonden" rang, die wordt uitgevoerd
ze, en stuurt een bevestiging terug naar rang 0. U voert de functie mp_disconnect uit naar
voltooi de parallelle taak en ga terug naar rang 0.

Tenslotte nog een opmerking over foutherstel. In het geval van een fout tijdens een parallelle taak,
mpy probeert de mp_exec netjes af te sluiten, zodat wanneer rang 0 terugkeert, alle andere rangen
Het is bekend dat ze inactief zijn, klaar voor de volgende mp_exec. Deze procedure zal voor altijd blijven hangen als die er is
een van de processen bevindt zich in een oneindige lus, of anderszins in een toestand waarin dit nooit zal gebeuren
bel mp_send, mp_recv of mp_probe, omdat MPI geen middelen biedt om een ​​signaal te verzenden dat
onderbreekt alle processen. (Dit is een van de manieren waarop de MPI-omgeving werkt
"ruw".) Het proces met rang 0 behoudt de rang van het eerste proces dat a rapporteerde
fout, plus een telling van het aantal processen dat om een ​​andere reden dan de fout is opgetreden
stuurde een bericht dat een andere rang een fout had gemaakt. Het eerste foutieve proces kan dbug binnendringen
modus via mp_connect; gebruik mp_disconnect of dbexit om terug te keren naar de seriële modus op rang 0.

Opties
-j bestand.i bevat het Yorick-bronbestand bestand.i terwijl mpy in parallelle modus start
op alle rangen. Dit is gelijk aan de functie mp_include na mpy
is begonnen.

-i bestand.i bevat het Yorick-bronbestand bestand.i terwijl mpy start, in seriële modus.
Dit is gelijk aan de #include-richtlijn nadat mpy is gestart.

-partij bestand.i bevat het Yorick-bronbestand bestand.i terwijl mpy start, in seriële modus.
Uw aanpassingsbestand custommp.i, indien aanwezig, is niet lezen, en mpy is
in batchmodus geplaatst. Gebruik de help-opdracht voor de batchfunctie
(help, batch) voor meer informatie over de batchmodus. In batchmodus, allemaal
fouten zijn fataal; Normaal gesproken stopt mpy de uitvoering en wacht op meer
invoer na een fout.

Gebruik mpy online met behulp van onworks.net-services