mpy - Online in der Cloud

PROGRAMM:

NAME/FUNKTION

mpy - Nachricht an Yorick

ZUSAMMENFASSUNG

mpirun -np mp_size mpy [ -J pfile1.i [ -J pfile2.i [ ... ]]] [ -ich Datei1.i [ -ich Datei2.i [
... ]]]
mpirun -np mp_size mpy -Charge Datei.i

BESCHREIBUNG

Yorick ist eine interpretierte Sprache wie Basic oder Lisp, aber viel schneller. Sehen Yorick (1) zu
erfahren Sie mehr darüber.
Mpy ist eine parallele Version von Yorick basierend auf dem Message Passing Interface (MPI). Die
Die genaue Syntax zum Starten eines parallelen Jobs hängt von Ihrer MPI-Umgebung ab. Es kann sein
notwendig, um vor dem Aufruf einen speziellen Daemon zu starten mirun oder ein gleichwertiger Befehl.

Erläuterungen
Das mpy-Paket verbindet yorick mit der MPI-Parallelprogrammierungsbibliothek. MPI steht für
Message-Passing-Schnittstelle; die idee ist, mehrere Instanzen von yorick zu verbinden, die
untereinander über Nachrichten kommunizieren. Mpy kann entweder einfache, hochgradig parallele
Aufgaben als reine interpretierte Programme, oder es kann beliebig komplex kompilierte . starten und steuern
Pakete, die die kompilierte MPI-API kostenlos verwenden können. Die interpretierte API ist nicht vorgesehen
ein MPI-Wrapper sein; stattdessen wird es auf das Nötigste reduziert.

Dies ist Version 2 von mpy (veröffentlicht im Jahr 2010); es ist nicht kompatibel mit Version 1 von mpy
(veröffentlicht Mitte der 1990er Jahre), da Version 1 zahlreiche Designfehler aufwies, die es sehr machten
schwierig, Programme ohne Rennbedingungen zu schreiben und unmöglich auf Millionen zu skalieren
von Prozessoren. Sie können jedoch die meisten mpy-Programme der Version 1 unter Version 2 ausführen, indem Sie Folgendes tun:
mp_include,"mpy1.i", bevor Sie eine Datei mp_include, die eine parallele mpy1-Aufgabe definiert (d. h
vor jeder Datei, die einen Aufruf von mp_task enthält.)

Anwendungsbereich merkt an
Die MPI-Umgebung ist vom Standard nicht wirklich spezifiziert; vorhandene Umgebungen sind
sehr grob und bevorzugen stark nicht interaktive Batch-Jobs. Die Anzahl der Prozesse ist
behoben, bevor MPI beginnt; jeder Prozess hat einen Rang, eine Zahl von 0 bis eins weniger als die
Anzahl von Prozessen. Sie verwenden den Rang als Adresse, um Nachrichten zu senden, und der Prozess
Der Empfang der Nachricht kann sondiert werden, um zu sehen, welche Ränge Nachrichten an ihn gesendet haben, und natürlich
diese Nachrichten erhalten.

Ein Hauptproblem beim Schreiben eines Nachrichtenweiterleitungsprogramms ist die Behandlung von Ereignissen oder Nachrichten
in ungeplanter Reihenfolge ankommen. MPI garantiert nur, dass eine Folge von Nachrichten gesendet von
Rang A bis Rang B werden in der gesendeten Reihenfolge ankommen. Es gibt keine Garantie für die Reihenfolge von
Ankunft dieser Nachrichten relativ zu Nachrichten, die von einem dritten Rang C an B gesendet wurden. In
Nehmen wir insbesondere an, A sendet eine Nachricht an B, dann sendet A eine Nachricht an C (oder tauscht sogar aus
mehrere Nachrichten mit C), was dazu führt, dass C eine Nachricht an B sendet. Die Nachricht von C
kann bei B vor der Nachricht von A eintreffen. Ein MPI-Programm, das dies nicht zulässt
Möglichkeit hat einen Fehler namens "Race Condition". Rennbedingungen können extrem subtil sein,
vor allem, wenn die Anzahl der Prozesse groß ist.

Die grundlegende von mpy interpretierte Schnittstelle besteht aus zwei Variablen:
mp_size = Anzahl der Prozesse
mp_rank = Rang dieses Prozesses und vier Funktionen:
mp_senden, an, Nachricht; // Nachricht an Rang "an" senden
msg = mp_recv(von); // Nachricht vom Rang "von" empfangen
Ränge = mp_probe(block); // Absender von ausstehenden Nachrichten abfragen
mp_exec, Zeichenfolge; // String auf jedem Rang analysieren und ausführen

Sie rufen mp_exec auf Rang 0 auf, um eine parallele Task zu starten. Wenn das so erstellte Hauptprogramm
beendet, alle Ränge außer Rang 0 kehren in eine Leerlaufschleife zurück und warten auf die nächste
mp_exec. Rang 0 nimmt die nächste Eingabezeile von stdin auf (d. h. wartet auf Eingabe an seinem
Eingabeaufforderung in einer interaktiven Sitzung) oder beendet alle Prozesse, wenn keine Eingabe mehr erfolgt
in einer Batch-Sitzung verfügbar.

Das mpy-Paket ändert, wie yorick die #include-Parser-Direktive und die include-Anweisung behandelt
und Funktionen benötigen. Nämlich wenn eine parallele Task läuft (d.h. eine Funktion gestartet
von mp_exec), werden diese alle zu kollektiven Operationen. Das heißt, Rang 0 liest das gesamte
Dateiinhalt und sendet den Inhalt als MPI-Nachricht an die anderen Prozesse (wie
mp_exec des Dateiinhalts). Jeder Prozess außer Rang 0 läuft nur während
parallele Aufgaben; außerhalb einer parallelen Aufgabe, wenn nur Rang 0 läuft (und alle anderen Ränge
warten auf die nächste mp_exec), die #include-Direktive und das include und require
Funktionen kehren zu ihrem üblichen seriellen Betrieb zurück und betreffen nur Rang 0.

Wenn mpy startet, befindet es sich im Parallelmodus, sodass alle Dateien, die yorick enthält, wenn es
Starts (die Dateien in Y_SITE/i0) sind als Sammeloperationen enthalten. Ohne das
Funktion würde jeder yorick-Prozess versuchen, die Startup-Include-Dateien zu öffnen und zu lesen,
Überladen des Dateisystems, bevor mpy überhaupt gestartet wird. Weitergabe des Inhalts dieser
Dateien als MPI-Nachrichten ist der einzige Weg, um sicherzustellen, dass genügend Bandbreite für alle vorhanden ist
Prozess zum Lesen des Inhalts einer einzelnen Datei.

Die letzte beim Start eingeschlossene Datei ist entweder die in der Option -batch angegebene Datei oder
die Datei custom.i. Um Probleme mit Code in custom.i zu vermeiden, die möglicherweise nicht sicher sind für
parallele Ausführung sucht mpy nicht nach custom.i, sondern nach custommp.i. Die
Anweisungen in der -batch-Datei oder in custommp.i werden im seriellen Modus auf Rang 0 ausgeführt
nur. In ähnlicher Weise überschreibt mpy die übliche Funktion process_argv, sodass -i und andere
Befehlszeilenoptionen werden im seriellen Modus nur auf Rang 0 verarbeitet. Die Absicht in all diesen
Fällen besteht darin, die Dateien -batch oder custommp.i oder -i include nur auf Rang 0 auszuführen, da
wenn Sie sie dort interaktiv eingegeben hätten. Es steht Ihnen frei, mp_exec von diesen aus aufzurufen
Dateien, um parallele Aufgaben zu starten, aber die Datei selbst ist seriell.

Dem üblichen Set wird eine zusätzliche Kommandozeilenoption hinzugefügt:
mpy -j irgendeine Datei.i
enthält somefile.i im parallelen Modus auf allen Rängen (wieder, -i other.i enthält nur other.i
auf Rang 0 im seriellen Modus). Wenn es mehrere -j-Optionen gibt, passieren die parallelen Einschlüsse
in Befehlszeilenreihenfolge. Wenn die Optionen -j und -i jedoch gemischt werden, passieren alle -j-Includes
vor jedem -i enthält.

Als Nebeneffekt der Komplexität der Include-Funktionen in mpy ist die Autoload-Funktion
Behinderte; Wenn Ihr Code tatsächlich ein Include durch Aufrufen einer automatisch geladenen Funktion auslöst, mpy
wird mit einem Fehler angehalten. Sie müssen alle Funktionen, die für eine Parallele erforderlich sind, explizit laden
Aufgaben, die erfordern, rufen sich selbst innerhalb einer parallelen Aufgabe auf.

Die Funktion mp_send kann ein beliebiges numerisches Yorick-Array senden (Typen char, short, int, long,
float, double oder complex) oder ein skalarer Zeichenfolgenwert. Der Vorgang des Sendens der Nachricht
via MPI behält nur die Anzahl der Elemente bei, daher erzeugt mp_recv nur einen Skalarwert oder
ein 1D-Array von Werten, egal welche Dimensionalität an mp_send übergeben wurde.

Für die Funktion mp_recv müssen Sie den Absender der Nachricht angeben, die Sie senden möchten
erhalten. Es blockiert, bis tatsächlich eine Nachricht von diesem Absender eintrifft, und stellt jede in die Warteschlange
Nachrichten von anderen Absendern, die möglicherweise zuvor eintreffen. Die Nachrichten in der Warteschlange werden
Es wird die Bestellung abgerufen, die beim Aufrufen von mp_recv für den übereinstimmenden Absender erhalten wurde. Die
Warteschlangenfunktion macht es deutlich einfacher, die einfachsten Arten von Race-Conditions zu vermeiden
wenn Sie interpretierte parallele Programme schreiben.

Die Funktion mp_probe gibt die Liste aller Absender von Nachrichten in der Warteschlange zurück (oder nil, wenn
die Warteschlange ist leer). Anruf mp_probe(0), um sofort zurückzukehren, auch wenn die Warteschlange leer ist.
Telefon mp_probe(1) zu blockieren, wenn die Warteschlange leer ist, nur zurückkehren, wenn mindestens eine Nachricht
ist für mp_recv verfügbar. Anruf mp_probe(2) zu blockieren, bis eine neue Nachricht eintrifft, auch wenn
Einige Nachrichten sind derzeit verfügbar.

Die Funktion mp_exec verwendet einen logarithmischen Fanout - Rang 0 sendet an F Prozesse, jeder von
die an F mehr sendet, und so weiter, bis alle Prozesse die Nachricht haben. Einmal ein Prozess
schließt alle seine Sendeoperationen ab, analysiert und führt den Inhalt der Nachricht aus.
Der Fanout-Algorithmus erreicht N Prozesse in log zur Basis F von N Schritten. Die F-Prozesse
Rang 0 sendet an die Ränge 1, 2, 3, ..., F. Im Allgemeinen sendet der Prozess mit Rang r an
Ränge r*F+1, r*F+2, ..., r*F+F (wenn diese kleiner als N-1 für N Prozesse sind). Dieses Set
wird der "Stab" des Ranges r genannt. Ränge mit r>0 erhalten die Nachricht von Rang (r-1)/F,
die der "Chef" von r genannt wird. Der Aufruf mp_exec interagiert mit der Warteschlange mp_recv;
mit anderen Worten, Nachrichten von einem anderen Rang als dem Boss während eines mp_exec-Fanouts werden
zum späteren Abruf durch mp_recv in die Warteschlange gestellt. (Ohne diese Funktion kann jede parallele Aufgabe, die
ein anderes Nachrichtenmuster als logarithmisches Fanout verwendet würde, wäre anfällig für Rassen
Bedingungen.)

Der logarithmische Fanout und sein nach innen gerichtetes Äquivalent sind so nützlich, dass mpy ein Paar liefert
von Funktionen auf höherer Ebene, die das gleiche Fanout-Muster wie mp_exec verwenden:
mp_handout, msg;
gesamt = mp_handin (Wert);
Um mp_handout zu verwenden, berechnet Rang 0 eine Nachricht, dann rufen alle Ränge mp_handout auf, das eine Nachricht sendet
(eine Ausgabe auf allen Rängen außer 0) überall durch den gleichen Fanout wie mp_exec. Benutzen
mp_handin, jeder Prozess berechnet den Wert und ruft dann mp_handin auf, was die Summe von zurückgibt
ihren eigenen Wert und alle ihre Mitarbeiter, so dass mp_handin auf Rang 0 die Summe der
Werte aus jedem Prozess.

Sie können mp_handin als Funktion ohne Argumente aufrufen, um als Synchronisation zu fungieren; Wenn
Rang 0 wird nach einem solchen Aufruf fortgesetzt, Sie wissen, dass jeder andere Rang diesen Punkt erreicht hat.
Alle parallelen Tasks (alles, was mit mp_exec begonnen wurde) müssen mit einem Aufruf von mp_handin enden.
oder eine gleichwertige Garantie, dass alle Prozesse in einen Ruhezustand zurückgekehrt sind, wenn die Aufgabe
endet auf Rang 0.

Sie können den Fanout-Parameter F mit der Funktion mp_nfan abrufen oder ändern. Der Standard
Wert ist 16, was auch bei sehr vielen Prozessen sinnvoll sein sollte.

Eine spezielle parallele Task heißt mp_connect, mit der Sie interpretierte
Befehlszeilen zu einem einzelnen Nicht-0-Rang, während alle anderen Ränge untätig bleiben. Rang 0 sitzt in a
Schleife, die die Tastatur liest und die Zeilen an den "verbundenen" Rang sendet, der ausgeführt wird
sie und sendet eine Bestätigung zurück an Rang 0. Sie führen die Funktion mp_disconnect an
Erledige die parallele Aufgabe und falle auf Rang 0 zurück.

Abschließend noch ein Hinweis zur Fehlerbehebung. Bei einem Fehler während einer parallelen Task,
mpy versucht, mp_exec ordnungsgemäß zu beenden, so dass, wenn Rang 0 zurückkehrt, alle anderen Ränge
bekanntermaßen im Leerlauf sind, bereit für die nächste mp_exec. Dieses Verfahren wird für immer hängen, wenn überhaupt
einer der Prozesse befindet sich in einer Endlosschleife oder sonst in einem Zustand, in dem er es nie tun wird
rufen Sie mp_send, mp_recv oder mp_probe auf, da MPI keine Möglichkeit bietet, ein Signal zu senden, das
unterbricht alle Prozesse. (Dies ist eine der Möglichkeiten, wie die MPI-Umgebung
"roh".) Der Rang 0 Prozess bleibt mit dem Rang des ersten Prozesses, der a gemeldet hat
Fehler, plus eine Zählung der Anzahl der Prozesse, die aus einem anderen Grund als
schickte eine Nachricht, dass ein anderer Rang einen Fehler gemacht hatte. Der erste fehlerhafte Prozess kann in dbug . eintreten
Modus über mp_connect; Verwenden Sie mp_disconnect oder dbexit, um auf Rang 0 in den seriellen Modus zurückzukehren.

Optionen
-j Datei.i enthält die Yorick-Quelldatei Datei.i wenn mpy im Parallelmodus startet
auf allen Rängen. Dies entspricht der Funktion mp_include nach mpy
hat begonnen.

-i Datei.i enthält die Yorick-Quelldatei Datei.i wie mpy startet, im seriellen Modus.
Dies entspricht der #include-Direktive, nachdem mpy gestartet wurde.

-Charge Datei.i enthält die Yorick-Quelldatei Datei.i wie mpy startet, im seriellen Modus.
Ihre Anpassungsdatei custommp.i, falls vorhanden, ist nicht lesen, und mpy ist
in den Batch-Modus versetzt. Verwenden Sie den Hilfebefehl für die Batch-Funktion
(Hilfe, Batch), um mehr über den Batch-Modus zu erfahren. Im Batch-Modus alle
Fehler sind fatal; Normalerweise wird mpy die Ausführung anhalten und auf weitere warten
Eingabe nach einem Fehler.

Verwenden Sie mpy online mit den onworks.net-Diensten