parallel - Online in der Cloud

PROGRAMM:

NAME/FUNKTION

parallel – Shell-Befehlszeilen aus der Standardeingabe parallel erstellen und ausführen

ZUSAMMENFASSUNG

Parallel [Optionen] [Befehl [Argumente]] <list_of_arguments

Parallel [Optionen] [Befehl [Argumente]] ( ::: Argumente | :::: argfile(s) ) ...

Parallel --semaphore [Optionen] Befehl

#!/usr/bin/parallel --shebang [Optionen] [Befehl [Argumente]]

BESCHREIBUNG

GNU Parallel ist ein Shell-Tool zum parallelen Ausführen von Jobs auf einem oder mehreren Computern. A
Job kann ein einzelner Befehl oder ein kleines Skript sein, das für jede der Zeilen in ausgeführt werden muss
die Eingabe. Die typische Eingabe ist eine Liste von Dateien, eine Liste von Hosts, eine Liste von Benutzern, eine Liste
von URLs oder eine Liste von Tabellen. Ein Job kann auch ein Befehl sein, der aus einer Pipe liest. GNU
Parallel kann dann die Eingabe in Blöcke aufteilen und einen Block in jeden Befehl einleiten
parallel.

Wenn Sie heute xargs und tee verwenden, finden Sie GNU Parallel sehr einfach als GNU zu verwenden Parallel
ist so geschrieben, dass es die gleichen Optionen wie xargs hat. Wenn Sie Schleifen in der Shell schreiben, werden Sie fündig
GNU Parallel Möglicherweise können Sie die meisten Schleifen ersetzen und sie durch Ausführen schneller ausführen
mehrere Jobs parallel.

GNU Parallel stellt sicher, dass die Ausgabe der Befehle dieselbe ist, die Sie auch erhalten würden
Sie führen die Befehle nacheinander aus. Dadurch ist es möglich, Ausgaben von GNU zu verwenden Parallel
als Eingabe für andere Programme.

Für jede Eingabezeile GNU Parallel wird ausführen Befehl mit der Zeile als Argumente. Wenn nein
Befehl gegeben ist, wird die Eingabezeile ausgeführt. Mehrere Linien werden parallel gefahren.
GNU Parallel kann oft als Ersatz verwendet werden xargs or Katze | bash.

Leserbriefe Guide
Sehen Sie sich zunächst die Einführungsvideos für eine kurze Einführung an:
http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Schauen Sie sich die BEISPIELs nach der Liste von OPTIONAL. Das gibt Ihnen eine Vorstellung davon, was
GNU Parallel ist fähig zu.

Verbringen Sie dann eine Stunde damit, das Tutorial durchzugehen (Mann parallel_tutorial). Ihre Kommandozeile
werde dich dafür lieben.

Abschließend möchten Sie vielleicht noch einen Blick auf den Rest dieses Handbuchs werfen, wenn Sie keine besonderen Anforderungen haben
bereits abgedeckt.

OPTIONAL

Befehl Befehl zur Ausführung. Wenn Befehl oder die folgenden Argumente enthalten Ersetzung
Zeichenfolgen (wie z {}) jede Instanz wird durch die Eingabe ersetzt.

If Befehl gegeben ist, GNU Parallel Lösen Sie die gleichen Aufgaben wie xargs. Wenn Befehl is
nicht gegeben GNU Parallel wird sich ähnlich verhalten Katze | sh.

Dem Befehl muss eine ausführbare Datei, ein Skript, ein zusammengesetzter Befehl oder eine Funktion sein.

Wenn es sich um eine Bash-Funktion handelt, müssen Sie dies tun exportieren -f zuerst die Funktion. Aliase verwenden
Kopieren Sie die vollständige Umgebung wie unten beschrieben --env Und verwenden env_parallel beantragen müssen
of Parallel.

Wenn es sich um eine ZSH-Funktion handelt, müssen Sie diese Hilfsfunktion verwenden exportf zu
exportieren und $PARALLEL_SHELL auf Bash setzen:

Funktion exportf (){
export $(echo $1)="`whence -f $1 | sed -e "s/$1 //" `"
}

Funktion my_func(){
echo $1;
echo „Hallo“;
}

exportf my_func
PARALLEL_SHELL=/ bin / bash parallel "my_func {}" ::: 1 2

Der Befehl darf das Zeichen \257 (Makron: X) nicht enthalten.

{} Eingabezeile. Diese Ersatzzeichenfolge wird durch eine vollständige ausgelesene Zeile ersetzt
Eingabequelle. Die Eingabequelle ist normalerweise stdin (Standardeingabe), kann aber auch
mit gegeben werden -a, :::, oder auch ::::.

Die Ersatzzeichenfolge {} kann mit geändert werden -I.

Wenn die Befehlszeile keine Ersatzzeichenfolgen enthält, dann {} wird angehängt
die Befehlszeile.

{.} Eingabezeile ohne Erweiterung. Diese Ersatzzeichenfolge wird durch die ersetzt
Eingabe mit entfernter Erweiterung. Wenn die Eingabezeile enthält . nach dem letzten /
das Letzte . bis das Ende der Zeichenfolge entfernt wird und {.} wird ersetzt werden
mit dem Rest. Z.B foo.jpg wird foo, subdir/foo.jpg wird Unterverzeichnis/foo,
sub.dir/foo.jpg wird sub.dir/foo, Unterverzeichnis/Bar bleibt bestehen Unterverzeichnis/Bar. Wenn der
Die Eingabezeile enthält nicht . es bleibt unverändert.

Die Ersatzzeichenfolge {.} kann mit geändert werden --ähm.

Um Ersatzzeichenfolgen zu verstehen, siehe {}.

{/} Basisname der Eingabezeile. Diese Ersatzzeichenfolge wird durch die Eingabe ersetzt
wobei der Verzeichnisteil entfernt wurde.

Die Ersatzzeichenfolge {/} kann mit geändert werden --basenamereplace.

Um Ersatzzeichenfolgen zu verstehen, siehe {}.

{//} Verzeichnisname der Eingabezeile. Diese Ersatzzeichenfolge wird durch das Verzeichnis des ersetzt
Eingabezeile. Sehen dirname(1).

Die Ersatzzeichenfolge {//} kann mit geändert werden --dirnamereplace.

Um Ersatzzeichenfolgen zu verstehen, siehe {}.

{/.} Basisname der Eingabezeile ohne Erweiterung. Diese Ersatzzeichenfolge wird sein
ersetzt durch die Eingabe mit entferntem Verzeichnis- und Erweiterungsteil. es ist ein
Kombination von {/} und {.}.

Die Ersatzzeichenfolge {/.} kann mit geändert werden --basenameextensionreplace.

Um Ersatzzeichenfolgen zu verstehen, siehe {}.

{#} (Alpha-Test)
Sequenznummer des auszuführenden Jobs. Diese Ersatzzeichenfolge wird durch ersetzt
die Sequenznummer des ausgeführten Jobs. Es enthält die gleiche Nummer wie
$PARALLEL_SEQ.

Die Ersatzzeichenfolge {#} kann mit geändert werden --seqreplace.

Um Ersatzzeichenfolgen zu verstehen, siehe {}.

{%} (Alpha-Test)
Job-Slot-Nummer. Diese Ersatzzeichenfolge wird durch den Slot des Jobs ersetzt
Zahl zwischen 1 und der Anzahl der parallel auszuführenden Jobs. Es wird nie 2 geben
Gleichzeitig ausgeführte Jobs mit derselben Job-Slot-Nummer.

Die Ersatzzeichenfolge {%} kann mit geändert werden --slotreplace.

Um Ersatzzeichenfolgen zu verstehen, siehe {}.

{n} Argument aus der Eingabequelle n oder unter der n'tes Argument. Dieser Positionsersatz
Die Zeichenfolge wird durch die Eingabe aus der Eingabequelle ersetzt n (bei Verwendung mit -a or
::::) oder mit dem n'tes Argument (bei Verwendung mit -N). Wenn n negativ ist, bezieht es sich
zu den nDas letzte Argument.

Um Ersatzzeichenfolgen zu verstehen, siehe {}.

{n.} Argument aus der Eingabequelle n oder unter der n'tes Argument ohne Erweiterung. es ist ein
Kombination von {n} und {.}.

Diese Positionsersatzzeichenfolge wird durch die Eingabe von input ersetzt
Quelle n (bei Verwendung mit -a or ::::) oder mit dem n'tes Argument (bei Verwendung mit
-N). Bei der Eingabe wird die Erweiterung entfernt.

Zum Verständnis der Positionsersetzungszeichenfolgen siehe {n}.

{n/} Basisname des Arguments aus der Eingabequelle n oder unter der n'tes Argument. es ist ein
Kombination von {n} und {/}.

Diese Positionsersatzzeichenfolge wird durch die Eingabe von input ersetzt
Quelle n (bei Verwendung mit -a or ::::) oder mit dem n'tes Argument (bei Verwendung mit
-N). Bei der Eingabe wird das Verzeichnis (falls vorhanden) entfernt.

Zum Verständnis der Positionsersetzungszeichenfolgen siehe {n}.

{n//} Verzeichnisname des Arguments aus der Eingabequelle n oder unter der n'tes Argument. es ist ein
Kombination von {n} und {//}.

Diese Positionsersatzzeichenfolge wird durch das Verzeichnis der Eingabe ersetzt
Eingabequelle n (bei Verwendung mit -a or ::::) oder mit dem n'tes Argument (bei Verwendung
mit -N). Sehen dirname(1).

Zum Verständnis der Positionsersetzungszeichenfolgen siehe {n}.

{n/.} Basisname des Arguments aus der Eingabequelle n oder unter der n'tes Argument ohne Erweiterung.
Es ist eine Kombination aus {n}, {/} und {.}.

Diese Positionsersatzzeichenfolge wird durch die Eingabe von input ersetzt
Quelle n (bei Verwendung mit -a or ::::) oder mit dem n'tes Argument (bei Verwendung mit
-N). Bei der Eingabe werden das Verzeichnis (falls vorhanden) und die Erweiterung entfernt.

Zum Verständnis der Positionsersetzungszeichenfolgen siehe {n}.

{=perl Ausdruck=}
Ersetzen Sie durch berechnet perl Ausdruck. $_ wird das Gleiche enthalten wie {}. Nach
Auswerten perl Ausdruck $_ wird als Wert verwendet. Es wird empfohlen
Ändern Sie nur $_, aber Sie haben vollen Zugriff auf das gesamte GNU Parallelist intern
Funktionen und Datenstrukturen.

Dem {=perl Ausdruck=} muss als einzelne Zeichenfolge angegeben werden.

Siehe auch: --rpl --parens

{=n perl Ausdruck=}
Positionsäquivalent zu {= perl Ausdruck =}. Um die Position zu verstehen
Ersatzsaiten siehe {n}.

Siehe auch: {= perl Ausdruck =} {n}.

::: Argumente
Verwenden Sie Argumente aus der Befehlszeile als Eingabequelle anstelle von stdin (Standard).
Eingang). Im Gegensatz zu anderen Optionen für GNU Parallel ::: wird nach dem platziert Befehl und
vor den Argumenten.

Folgendes ist gleichwertig:

(Echo-Datei1; Echo-Datei2) | paralleles gzip
paralleles gzip ::: Datei1 Datei2
parallel gzip {} ::: Datei1 Datei2
parallel --arg-sep ,, gzip {} ,, Datei1 Datei2
parallel --arg-sep ,, gzip ,, Datei1 Datei2
parallel ::: "gzip-Datei1" "gzip-Datei2"

Um eine Behandlung zu vermeiden ::: als Sondernutzung --arg-sep um das Argumenttrennzeichen auf zu setzen
etwas anderes. Siehe auch --arg-sep.

stdin (Standardeingabe) wird an den ersten Prozesslauf übergeben.

Wenn mehrere ::: angegeben werden, wird jede Gruppe als Eingabequelle behandelt, und zwar alle
Es werden Kombinationen von Eingabequellen generiert. Beispiel: ::: 1 2 ::: abc wird
ergeben die Kombinationen (1,a) (1,b) (1,c) (2,a) (2,b) (2,c). Das ist nützlich
zum Ersetzen verschachtelter for-Schleifen.

::: und :::: kann gemischt werden. Diese sind also gleichwertig:

Parallelecho {1} {2} {3} ::: 6 7 ::: 4 5 ::: 1 2 3
paralleles Echo {1} {2} {3} :::: <(seq 6 7) <(seq 4 5) :::: <(seq 1 3)
parallel -a <(seq 6 7) echo {1} {2} {3} :::: <(seq 4 5) :::: <(seq 1 3)
parallel -a <(seq 6 7) -a <(seq 4 5) echo {1} {2} {3} ::: 1 2 3
seq 6 7 | parallel -a - -a <(seq 4 5) echo {1} {2} {3} ::: 1 2 3
seq 4 5 | paralleles Echo {1} {2} {3} :::: <(seq 6 7) - ::: 1 2 3

:::: argfiles
Eine andere Art zu schreiben -a argfile1 -a argfile2 ...

::: und :::: kann gemischt werden.

Weitere Informationen finden Sie auch in den -a, ::: und --xapply.

--Null
-0 Verwenden Sie NUL als Trennzeichen. Normalerweise enden Eingabezeilen mit \n (Newline). Wenn sie enden
in \0 (NUL), dann verwenden Sie diese Option. Es ist nützlich für die Verarbeitung von Argumenten, die möglicherweise auftreten
enthalten \n (Neuzeile).

--arg-Datei Eingabedatei
-a Eingabedatei
Verwenden Sie die Eingabedatei als Eingabequelle. Wenn Sie diese Option verwenden, ist stdin (Standardeingabe).
dem ersten Prozessdurchlauf gegeben. Andernfalls wird stdin (Standardeingabe) umgeleitet
von /dev/null.

Wenn mehrere -a sind jeweils gegeben Eingabedatei wird als Eingabequelle behandelt und
Alle Kombinationen von Eingabequellen werden generiert. ZB die Datei foo enthält 1
2, die Datei Bar enthält a b c. -a foo -a Bar ergeben die Kombinationen
(1,a) (1,b) (1,c) (2,a) (2,b) (2,c). Dies ist nützlich, um verschachtelte For-
Schleifen

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] --xapply und {n}.

--arg-file-sep sep-str
Verwenden Sie die sep-str statt :::: als Trennzeichenfolge zwischen Befehl und Argument
Dateien. Nützlich, wenn :::: wird vom Befehl für etwas anderes verwendet.

Siehe auch: ::::.

--arg-sep sep-str
Verwenden Sie die sep-str statt ::: als Trennzeichenfolge. Nützlich, wenn ::: wird verwendet für
etwas anderes durch den Befehl.

Auch nützlich, wenn Sie Befehle verwenden ::: aber Sie möchten trotzdem Argumente lesen
stdin (Standardeingabe): Einfach ändern --arg-sep zu einer Zeichenfolge, die nicht in der ist
Befehlszeile.

Siehe auch: :::.

--Bar Zeigen Sie den Fortschritt als Fortschrittsbalken an. In der Leiste wird angezeigt: % der abgeschlossenen Aufträge,
geschätzte verbleibende Sekunden und Anzahl der gestarteten Jobs.

Es ist kompatibel mit Zenität:

seq 1000 | parallel -j30 --bar '(echo {};sleep 0.1)' 2> >(zenity --progress
--auto-kill) | Toilette

--basefile Datei
--bf Datei
Datei wird an jedes sshlogin übertragen, bevor ein Job gestartet wird. Es wird sein
entfernt, wenn --Aufräumen ist aktiv. Bei der Datei kann es sich um ein auszuführendes Skript oder um ein allgemeines Skript handeln
Basisdaten, die für die Jobs benötigt werden. Mehrere --bf kann angegeben werden, um mehr zu übertragen
Basisdateien. Der Datei wird auf die gleiche Weise übertragen wie --Transfer.

--basenamereplace ersetzen-str
--bnr ersetzen-str
Verwenden Sie die Ersatzzeichenfolge ersetzen-str statt {/} für den Basisnamen der Eingabezeile.

--basenameextensionreplace ersetzen-str
--bner ersetzen-str
Verwenden Sie die Ersatzzeichenfolge ersetzen-str statt {/.} für den Basisnamen der Eingabezeile
ohne Verlängerung.

--bg Führen Sie den Befehl im Hintergrund aus, also GNU Parallel Ich werde nicht auf den Abschluss warten
Befehl vor dem Beenden. Dies ist die Standardeinstellung, wenn --Semaphor wird gesetzt.

Siehe auch: --fg, Mann SEM.

Impliziert --Semaphor.

--bibtex Drucken Sie den BibTeX-Eintrag für GNU aus Parallel und deaktivieren Sie den Zitierhinweis.

--Block Größe
--Block Größe Größe
Größe des Blocks in Bytes. Die Größe kann mit K, M, G, T, P, k, m, g, t nachgestellt werden.
oder p, was die Größe mit 1024, 1048576, 1073741824, 1099511627776 multiplizieren würde,
1125899906842624, 1000, 1000000, 1000000000, 1000000000000 oder 1000000000000000
beziehungsweise.

GNU Parallel versucht, die Blockgröße einzuhalten, kann aber um die Länge von eins abweichen
aufzeichnen. Aus Leistungsgründen Größe sollte größer als ein einzelner Datensatz sein.

Größe Der Standardwert ist 1M.

Weitere Informationen finden Sie auch in den --Rohr für die Nutzung hiervon.

--Katze Erstellen Sie eine temporäre Datei mit Inhalt. Normalerweise --Rohr wird Daten an die weitergeben
Programm auf stdin (Standardeingabe). Mit --Katze GNU Parallel erstellt eine
temporäre Datei mit dem Namen in {}, so können Sie Folgendes tun: Parallel --Rohr --Katze wc {}.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] --fifo.

--Aufräumen
Übertragene Dateien entfernen. --Aufräumen entfernt die übertragenen Dateien auf dem
Remote-Computer, nachdem die Verarbeitung abgeschlossen ist.

Log-Name '*gz' finden | parallel \
--sshlogin server.example.com --transfer --return {.}.bz2 \
--cleanup "zcat {} | bzip -9 >{.}.bz2"

Mit --Transfer Die auf den Remote-Computer übertragene Datei wird entfernt
dem Remote-Computer. Erstellte Verzeichnisse werden nicht entfernt – auch wenn dies der Fall ist
leer.

Mit --Rückkehr Die vom Remote-Computer übertragene Datei wird entfernt
dem Remote-Computer. Erstellte Verzeichnisse werden nicht entfernt – auch wenn dies der Fall ist
leer.

--Aufräumen wird ignoriert, wenn es nicht mit verwendet wird --Transfer or --Rückkehr.

--colsep regexp
-C regexp
Spaltentrenner. Die Eingabe wird als Tabelle mit behandelt regexp Trennen der
Säulen. Auf die n-te Spalte kann über zugegriffen werden {n} or {n.}. Z.B 3 {} ist der 3.
Spalte.

--colsep impliziert --trimmen rl.

regexp ist ein regulärer Perl-Ausdruck: http://perldoc.perl.org/perlre.html

--Kompresse
Temporäre Dateien komprimieren. Wenn die Ausgabe groß und sehr komprimierbar ist, wird dies der Fall sein
beanspruchen weniger Speicherplatz in $TMPDIR und sind aufgrund weniger Festplatten-E/A möglicherweise schneller.

GNU Parallel werde versuchen lzop, Schweinchen, gzip, pbzip2, plzip, bzip2, lzma, lzip, xz in
Geben Sie diese Reihenfolge ein und verwenden Sie die erste verfügbare.

--compress-programm Prg
--decompress-programm Prg
Verwenden Sie die Prg zum (De-)Komprimieren temporärer Dateien. Es wird angenommen dass Prg -dc werden wir
Dekomprimieren Sie stdin (Standardeingabe) in stdout (Standardausgabe), sofern nicht
--decompress-programm gegeben ist.

--ctrlc Sendet SIGINT an Aufgaben, die auf Remotecomputern ausgeführt werden, und beendet diese dadurch.

--Trennzeichen delim
-d delim Eingabeelemente werden durch das angegebene Zeichen beendet. Anführungszeichen und Backslash sind
nicht speziell; Jedes Zeichen in der Eingabe wird wörtlich genommen. Deaktiviert die End-
of-file-String, der wie jedes andere Argument behandelt wird. Dies kann verwendet werden, wenn
Die Eingabe besteht lediglich aus durch Zeilenumbrüche getrennten Elementen, obwohl dies fast der Fall ist
Es ist immer besser, Ihr Programm so zu gestalten, dass es --null verwendet, wo dies möglich ist. Der
Das angegebene Trennzeichen kann ein einzelnes Zeichen oder ein Escape-Zeichen im C-Stil sein, z
\n oder ein oktaler oder hexadezimaler Escape-Code. Oktale und hexadezimale Escape-Codes
gelten wie für den Befehl printf. Multibyte-Zeichen sind nicht vorhanden
unterstützt.

--dirnamereplace ersetzen-str
--dnr ersetzen-str
Verwenden Sie die Ersatzzeichenfolge ersetzen-str statt {//} für Verzeichnisname der Eingabezeile.

-E eof-str
Setzen Sie die Dateiendezeichenfolge auf eof-str. Wenn das Ende der Dateizeichenfolge als auftritt
Eingabezeile, der Rest der Eingabe wird ignoriert. Wenn weder -E noch -e wird genutzt,
Es wird keine Dateiendezeichenfolge verwendet.

--verzögern Sekunden
Beginn des nächsten Auftrags verzögern Sekunden Sekunden. GNU Parallel wird pausieren Sekunden Sekunden nach
Beginn jedes Jobs. Sekunden kann weniger als 1 Sekunde betragen.

--Probelauf
Drucken Sie den Job aus, um ihn auf stdout (Standardausgabe) auszuführen, aber führen Sie den Job nicht aus. Verwenden -v
-v um den SSH/Rsync-Wrapping einzuschließen, wenn der Job auf einem Remote-Gerät ausgeführt werden würde
Computer. Rechnen Sie jedoch nicht im wahrsten Sinne des Wortes damit, da der Job möglicherweise eingeplant ist
einen anderen Computer oder den lokalen Computer, wenn: in der Liste enthalten ist.

--eof[=eof-str]
-e[eof-str]
Diese Option ist ein Synonym für die -E Möglichkeit. Benutzen -E stattdessen, weil es POSIX ist
konform für xargs während dies bei dieser Option nicht der Fall ist. Wenn eof-str weggelassen wird, gibt es keine
Ende der Dateizeichenfolge. Wenn weder -E noch -e verwendet wird, wird keine End-of-File-Zeichenfolge verwendet.

--env jung (Alpha-Test)
Umgebungsvariable kopieren jung. Dies wird kopiert jung an die Umgebung, die die
Der Befehl wird ausgeführt. Dies ist besonders nützlich für die Remote-Ausführung.

In Basch jung kann auch eine Bash-Funktion sein – denken Sie daran exportieren -f
Funktion, siehe Befehl.

Die Variable '_' ist etwas Besonderes. Es werden alle Umgebungsvariablen außer der kopiert
diejenigen, die in erwähnt werden ~/.parallel/ignored_vars.

Zum Kopieren von Bash-Arrays benötigen Sie eine Importfunktion, da dies bei Bash-Arrays nicht möglich ist
exportiert:

import_array () {
lokale Funktion=$1; Schicht;
exportieren $func='() {
'"$(für arr in $@; do
deklarieren -p $arr|sed '1s/declare -./&g/'
Erledigt)"'
}'
}

deklarieren -A assoc='([one]="1" [two]="2")'
deklarieren -a indexed='([0]="eins" [1]="zwei")'

import_array my_importer assoc indiziert

parallel --env my_importer \
'my_importer; echo "{}" "${indexed[{}]}" "${assoc[${indexed[{}]}]}"' ::: "${!indexed[@]}"

Um die vollständige Umgebung zu kopieren, verwenden Sie diese Funktion (z. B. indem Sie sie in .bashrc einfügen):

env_parallel() {
export parallel_bash_environment='() {
'"$(echo "shopt -s expand_aliases 2>/dev/null"; alias;typeset -p | grep -vFf <(readonly; echo GROUPS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_;typeset -f)"'
}'
# Ausführen als: env_parallel [normale parallele Optionen]
`welche Parallele` „$@“
parallel_bash_environment deaktiviert
}
# Anruf als:
env_parallel [normale parallele Optionen]

Siehe auch: --record-env.

--eta Zeigt die geschätzte Anzahl an Sekunden bis zum Abschluss an. Dies erzwingt GNU Parallel
um alle Jobs zu lesen, bevor Sie mit der Ermittlung der Anzahl der Jobs beginnen. GNU Parallel
Normalerweise wird nur der nächste auszuführende Job gelesen. Impliziert --Fortschritt.

--fg Führen Sie den Befehl im Vordergrund aus, also GNU Parallel Ich werde auf den Abschluss warten
Befehl vor dem Beenden.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] --bg, Mann SEM.

Impliziert --Semaphor.

--fifo Erstellen Sie ein temporäres FIFO mit Inhalt. Normalerweise --Rohr wird Daten an die weitergeben
Programm auf stdin (Standardeingabe). Mit --fifo GNU Parallel erstellt eine
temporäres FIFO mit dem Namen in {}, so können Sie Folgendes tun: Parallel --Rohr --fifo wc {}.

Achtung: Wenn keine Daten aus dem FIFO gelesen werden, wird der Job für immer blockiert.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] --Katze.

--filter-hosts
Entfernen Sie ausgefallene Hosts. Für jeden Remote-Host: Überprüfen Sie, ob die Anmeldung über SSH funktioniert. Wenn
not: diesen Host nicht verwenden.

Derzeit ist das möglich nicht setzen --filter-hosts in einem Profil, $PARALLEL,
/etc/parallel/config oder ähnlich. Das liegt daran, dass GNU Parallel verwendet GNU Parallel
Um dies zu berechnen, erhalten Sie eine Endlosschleife. Dies wird wahrscheinlich in a behoben
spätere Veröffentlichung.

--Gnu Verhalten Sie sich wie GNU Parallel. Diese Option hatte historisch gesehen Vorrang vor --tollef.
Dem --tollef Die Option ist jetzt nicht mehr verfügbar und kann daher nicht verwendet werden. --Gnu wird gehalten
für Kompatibilität.

--Gruppe Gruppenausgabe. Die Ausgabe der einzelnen Aufträge wird gruppiert und nur dann gedruckt, wenn
Der Befehl ist beendet. stderr (Standardfehler) zuerst, gefolgt von stdout
(Standardausgabe). Dies nimmt einige CPU-Zeit in Anspruch. In seltenen Fällen GNU Parallel
nimmt viel CPU-Zeit in Anspruch und es ist akzeptabel, dass die Ausgaben unterschiedlich sind
Befehle werden miteinander gemischt, dann wird die Gruppierung mit deaktiviert -u kann GNU beschleunigen
Parallel um den Faktor 10.

--Gruppe ist die Standardeinstellung. Kann mit umgekehrt werden -u.

Siehe auch: --line-buffer - Gruppierung aufheben

--help
-h Drucken Sie eine Zusammenfassung der Optionen für GNU Parallel und verlassen.

--halt-on-error Welle
--Halt Welle
Wie sollte GNU Parallel beenden, wenn einer oder mehrere Jobs fehlschlagen?

0 Nicht anhalten, wenn ein Job fehlschlägt. Der Exit-Status entspricht der Anzahl der fehlgeschlagenen Jobs.
Dies ist der Standardwert.

1 Starten Sie keine neuen Jobs, wenn ein Job fehlschlägt, sondern schließen Sie die laufenden Jobs ab
inklusive Aufräumen. Der Exit-Status ist der Exit-Status vom letzten
scheiternder Job.

2 Beenden Sie alle Jobs sofort und beenden Sie den Vorgang ohne Bereinigung. Der Exit-Status
ist der Beendigungsstatus des fehlgeschlagenen Jobs.

1-99 % Wenn Welle% der Jobs schlagen fehl und mindestens 3: Starten Sie keine neuen Jobs, aber
Schließen Sie die laufenden Jobs einschließlich der Bereinigung ab. Der Exit-Status ist der
Exit-Status des letzten fehlgeschlagenen Jobs.

--Header regexp
Verwenden Sie Regexp als Header. Für den normalen Gebrauch wird der übereinstimmende Header (normalerweise der erste) verwendet
Zeile: --Header '.*\N') wird mit geteilt --colsep (Standardeinstellung ist „\t“)
und Spaltennamen können als Ersatzvariablen verwendet werden: {Spalte Name}.

Für --Rohr Der übereinstimmende Header wird jeder Ausgabe vorangestellt.

--Header : ist ein Alias ​​für --Header '.*\N'.

If regexp eine Zahl ist, wird sie mit so vielen Zeilen übereinstimmen.

-I ersetzen-str
Verwenden Sie die Ersatzzeichenfolge ersetzen-str anstatt {}.

--ersetzen[=ersetzen-str]
-i[ersetzen-str]
Diese Option ist ein Synonym für -Iersetzen-str if ersetzen-str angegeben ist, und für
-I{} ansonsten. Diese Option ist veraltet; verwenden -I stattdessen.

--joblog Logdatei
Logdatei für ausgeführte Jobs. Speichern Sie eine Liste der ausgeführten Jobs unter Logdatei begann
Folgendes durch Tabulatoren getrenntes Format: Sequenznummer, SSH-Login, Startzeit als Sekunden
seit Epoche, Laufzeit in Sekunden, übertragene Bytes in Dateien, Bytes in Dateien
zurückgegeben, Exit-Status, Signal und Befehlsausführung.

Um die Zeiten in ISO-8601-strikt umzuwandeln, gehen Sie wie folgt vor:

perl -a -F"\t" -ne 'chomp($F[2]=`date -d \@$F[2] +%FT%T`); drucken join("\t",@F)'

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] --Lebenslauf.

--Arbeitsplätze N
-j N
--max-procs N
-P N Anzahl der Stellenangebote. Führen Sie bis zu N Jobs parallel aus. 0 bedeutet so viele wie möglich.
Der Standardwert ist 100 %, wodurch ein Job pro CPU-Kern ausgeführt wird.

If --Semaphor Der Standardwert ist 1, wodurch ein Mutex entsteht.

--Arbeitsplätze +N
-j +N
--max-procs +N
-P +N Addieren Sie N zur Anzahl der CPU-Kerne. Führen Sie so viele Jobs parallel aus. Siehe auch
--use-cpus-instead-of-cores.

--Arbeitsplätze -N
-j -N
--max-procs -N
-P -N Subtrahieren Sie N von der Anzahl der CPU-Kerne. Führen Sie so viele Jobs parallel aus. Wenn die
Ist die ausgewertete Zahl kleiner als 1, wird 1 verwendet. Siehe auch
--use-cpus-instead-of-cores.

--Arbeitsplätze N%
-j N%
--max-procs N%
-P N% Multiplizieren Sie N% mit der Anzahl der CPU-Kerne. Führen Sie so viele Jobs parallel aus. Sehen
ebenfalls --use-cpus-instead-of-cores.

--Arbeitsplätze Profil
-j Profil
--max-procs Profil
-P Profil
Parameter aus Datei lesen. Nutzen Sie den Inhalt von Profil als Parameter für -j. Z.B
Profil könnte die Zeichenfolge 100 % oder +2 oder 10 enthalten. Wenn Profil wird geändert, wenn a
Auftrag abgeschlossen, Profil wird erneut gelesen und die neue Anzahl von Jobs berechnet. Wenn
Die Anzahl ist niedriger als zuvor. Laufende Jobs können zwar beendet werden, sind aber neu
Jobs werden erst gestartet, wenn die gewünschte Anzahl Jobs erreicht ist. Das
ermöglicht es, die Anzahl gleichzeitig laufender Jobs während GNU zu ändern
Parallel läuft.

--Ordnung halten
-k Behalten Sie die Reihenfolge der Ausgabe bei, die der Reihenfolge der Eingabe entspricht. Normalerweise die Ausgabe eines Jobs
wird gedruckt, sobald der Auftrag abgeschlossen ist. Versuchen Sie Folgendes, um den Unterschied zu sehen:

parallel -j4 schlafen {}\; echo {} ::: 2 1 4 3
parallel -j4 -k schlafen {}\; echo {} ::: 2 1 4 3

Bei Verwendung mit --onall or --nonall Die Ausgabe wird nach Sshlogin gruppiert und sortiert
Ordnung.

-L maximale Anzahl an Zeilen
Bei Verwendung mit --Rohr: Aufzeichnungen lesen von maximale Anzahl an Zeilen.

Bei anderweitiger Verwendung: Höchstens verwenden maximale Anzahl an Zeilen nicht leere Eingabezeilen pro Befehlszeile.
Nachgestellte Leerzeichen bewirken, dass eine Eingabezeile bei der nächsten Eingabe logisch fortgeführt wird
Linie.

-L 0 bedeutet, eine Zeile zu lesen, aber 0 Argumente in die Befehlszeile einzufügen.

Impliziert -X es sei denn -m, --xargs, oder auch --Rohr wird gesetzt.

--maximale Anzahl an Zeilen[=maximale Anzahl an Zeilen]
-l[maximale Anzahl an Zeilen]
Bei Verwendung mit --Rohr: Aufzeichnungen lesen von maximale Anzahl an Zeilen.

Bei anderer Verwendung: Synonym für die -L Möglichkeit. nicht wie -L, der maximale Anzahl an Zeilen
Argument ist optional. Wenn maximale Anzahl an Zeilen ist nicht angegeben, der Standardwert ist eins. Der -l
Die Option ist veraltet, da der POSIX-Standard dies vorsieht -L stattdessen.

-l 0 ist ein Alias ​​für -l 1.

Impliziert -X es sei denn -m, --xargs, oder auch --Rohr wird gesetzt.

--line-buffer
Pufferausgabe auf Zeilenbasis. --Gruppe hält die Ausgabe insgesamt zusammen
Job. - Gruppierung aufheben Ermöglicht die Verwechslung der Ausgabe mit einer halben Zeile, die von einem Job stammt und
eine halbe Zeile, die von einem anderen Job stammt. --line-buffer passt dazwischen: GNU
Parallel druckt eine vollständige Zeile, ermöglicht jedoch das Mischen unterschiedlicher Zeilen
Arbeitsplätze.

--line-buffer benötigt mehr CPU-Leistung als beide --Gruppe und - Gruppierung aufheben, aber kann
sei schneller als --Gruppe wenn die CPU nicht der limitierende Faktor ist.

Siehe auch: --Gruppe - Gruppierung aufheben

--Belastung Tragfähigkeit
Starten Sie keine neuen Jobs auf einem bestimmten Computer, es sei denn, die Anzahl der laufenden Prozesse ist erreicht
auf dem Computer ist weniger als Tragfähigkeit. Tragfähigkeit verwendet die gleiche Syntax wie --Arbeitsplätze,
so 100% für eine pro CPU ist eine gültige Einstellung. Der einzige Unterschied ist 0, was ist
interpretiert als 0.01.

--controlmaster
-M Verwenden Sie den ControlMaster von ssh, um SSH-Verbindungen schneller herzustellen. Nützlich, wenn Jobs remote ausgeführt werden
und sind sehr schnell zu laufen. Dies ist für SSH-Logins deaktiviert, die ihre eigenen angeben
ssh-Befehl.

--xargs Mehrere Argumente. Geben Sie so viele Argumente ein, wie die Länge der Befehlszeile zulässt.

If {} Wird diese nicht verwendet, werden die Argumente an die Zeile angehängt. Wenn {} verwendet wird
jeweils mehrmals {} wird durch alle Argumente ersetzt.

Unterstützung für --xargs mit --sshlogin ist begrenzt und kann fehlschlagen.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] -X für Kontext ersetzen. Im Zweifelsfall verwenden -X wie das höchstwahrscheinlich der Fall sein wird
Was wird benötigt.

-m Mehrere Argumente. Geben Sie so viele Argumente ein, wie die Länge der Befehlszeile zulässt.
Wenn mehrere Jobs parallel ausgeführt werden: Verteilen Sie die Argumente gleichmäßig
die Jobs. Verwenden -j1 um es zu umgehen.

If {} Wird diese nicht verwendet, werden die Argumente an die Zeile angehängt. Wenn {} verwendet wird
jeweils mehrmals {} wird durch alle Argumente ersetzt.

Unterstützung für -m mit --sshlogin ist begrenzt und kann fehlschlagen.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] -X für Kontext ersetzen. Im Zweifelsfall verwenden -X wie das höchstwahrscheinlich der Fall sein wird
Was wird benötigt.

--minversion Version
Drucken Sie die Version GNU aus Parallel und verlassen. Wenn die aktuelle Version von GNU Parallel
weniger als Version Der Exit-Code ist 255. Ansonsten ist er 0.

Dies ist nützlich für Skripte, die auf Funktionen basieren, die nur von einem bestimmten Anbieter verfügbar sind
Version von GNU Parallel.

--nonall (Beta-test)
--onall ohne Argumente. Führen Sie den Befehl auf allen mit angegebenen Computern aus --sshlogin
aber nimm keine Argumente. GNU Parallel werde mich anmelden --Arbeitsplätze Anzahl der Computer in
parallel und führen Sie den Job auf dem Computer aus. -j Passt an, wie viele Computer protokolliert werden sollen
in parallel.

Dies ist nützlich, um denselben Befehl (z. B. uptime) auf einer Liste von Servern auszuführen.

--onall (Beta-test)
Führen Sie alle Jobs auf allen mit angegebenen Computern aus --sshlogin. GNU Parallel werde protokollieren
in --Arbeitsplätze Mehrere Computer parallel schalten und jeweils einen Job darauf ausführen
Computer. Die Reihenfolge der Jobs wird nicht geändert, bei einigen Computern jedoch möglicherweise
vor anderen fertig werden. -j Passt an, wie viele Computer gleichzeitig angemeldet werden sollen.

Beim Benutzen --Gruppe Die Ausgabe wird nach jedem Server gruppiert, also die gesamte Ausgabe
von einem Server werden zusammengefasst.

--output-as-files
--outputasfiles
--Dateien Anstatt die Ausgabe auf stdout (Standardausgabe) zu drucken, wird die Ausgabe jedes Auftrags gedruckt
wird in einer Datei gespeichert und der Dateiname wird anschließend ausgedruckt.

--Rohr
--spreadstdin
Verteilen Sie die Eingabe auf Jobs auf stdin (Standardeingabe). Liest einen Datenblock von stdin
(Standardeingabe) und geben Sie einen Datenblock als Eingabe für einen Job.

Die Blockgröße wird bestimmt durch --Block. Die Saiten --recstart und --rezendiert erzählen
GNU Parallel wie eine Aufzeichnung beginnt und/oder endet. Der gelesene Block wird das Finale haben
Teilsatz entfernt, bevor die Sperre an den Job übergeben wird. Der Teil
Der Datensatz wird dem nächsten Block vorangestellt.

If --recstart angegeben wird, wird dies zum Teilen am Beginn der Aufzeichnung verwendet.

If --rezendiert angegeben wird, wird dies zum Teilen am Ende des Datensatzes verwendet.

Wenn beides --recstart und --rezendiert Sind beide gegeben, müssen beide übereinstimmen, um eine Aufteilung zu finden
Position.

Wenn weder --recstart noch --rezendiert sind gegeben --rezendiert Der Standardwert ist „\n“. Haben
Keine Verwendung von Datensatztrennzeichen --rezendiert "".

--Dateien wird oft verwendet mit --Rohr.

Siehe auch: --recstart, --rezendiert, --fifo, --Katze, --pipepart.

--pipepart (Beta-test)
Teile einer physischen Datei weiterleiten. --pipepart funktioniert ähnlich wie --Rohr, aber es ist viel
Schneller. Es gibt einige Einschränkungen:

* Die Datei muss eine physische (durchsuchbare) Datei sein und mit angegeben werden -a or
::::.

* Rekordzählung (-N) und Zeilenzählung (-L/-l) arbeite nicht.

--schlicht Ignorieren Sie alle --Profil, $PARALLEL und ~/.parallel/config um die volle Kontrolle zu erlangen
die Befehlszeile (von GNU verwendet). Parallel intern bei Aufruf mit --sshlogin).

--Plus Zusätzliche Ersetzungszeichenfolgen aktivieren: {+/} {+.} {+..} {+...} {..} {...} {/ ..}
{/...}. Die Idee dahinter ist, dass „{+foo}“ dem Gegenteil von „{foo}“ und {} = entspricht
{+/}/{/} = {.}.{+.} = {+/}/{/.}.{+.} = {..}.{+..} = {+/}/{/ ..}.{+..} =
{...}.{+...} = {+/}/{/...}.{+...}

--Fortschritt
Fortschritt der Berechnungen anzeigen. Listen Sie die an der Aufgabe beteiligten Computer mit auf
Anzahl der erkannten CPU-Kerne und die maximale Anzahl auszuführender Jobs. Nach dieser Show
Fortschritt für jeden Computer: Anzahl laufender Jobs, Anzahl abgeschlossener Jobs und
Prozentsatz aller von diesem Computer ausgeführten Aufgaben. Der Prozentsatz wird nur sein
verfügbar, nachdem alle Jobs als GNU geplant wurden Parallel Lesen Sie erst das nächste
Job, wenn Sie bereit sind, ihn zu planen – so vermeiden Sie Zeit- und Speicherverschwendung
Beim Start alles lesen.

Durch das Senden von GNU Parallel SIGUSR2 können Sie das Ein-/Ausschalten umschalten --Fortschritt auf einem
GNU ausführen Parallel verarbeiten.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] --eta.

--max-args=max-args
-n max-args
Höchstens verwenden max-args Argumente pro Befehlszeile. Weniger als max-args Argumente
wird verwendet, wenn die Größe (siehe -s Option) überschritten wird, es sei denn, die -x Option ist
gegeben, in diesem Fall GNU Parallel wird aussteigen.

-n 0 bedeutet, ein Argument zu lesen, aber 0 Argumente in die Befehlszeile einzufügen.

Impliziert -X es sei denn -m wird gesetzt.

--max-replace-args=max-args
-N max-args
Höchstens verwenden max-args Argumente pro Befehlszeile. Wie -n macht aber auch
Ersatzsaiten 1 {} .. {max-args} das repräsentiert Argument 1 .. max-args. Wenn
zu wenige Argumente {n} wird leer sein.

-N 0 bedeutet, ein Argument zu lesen, aber 0 Argumente in die Befehlszeile einzufügen.

Dadurch wird der Besitzer des Homedir auf den Benutzer festgelegt:

tr ':' '\n' < / etc / passwd | Parallel -N7 chown 1 {} 6 {}

Impliziert -X es sei denn -m or --Rohr wird gesetzt.

Bei Verwendung mit --Rohr -N ist die Anzahl der zu lesenden Datensätze. Das ist etwas
langsamer als --Block.

--max-line-length-allowed
Geben Sie die maximal zulässige Anzahl von Zeichen in der Befehlszeile aus und beenden Sie sie (verwendet).
von GNU Parallel selbst, um die Leitungslänge auf entfernten Computern zu bestimmen).

--Anzahl der CPUs
Geben Sie die Anzahl der physischen CPUs aus und beenden Sie den Vorgang (von GNU verwendet). Parallel sich zu
Bestimmen Sie die Anzahl der physischen CPUs auf Remote-Computern.

--Anzahl der Kerne
Geben Sie die Anzahl der CPU-Kerne aus und beenden Sie den Vorgang (von GNU verwendet). Parallel selbst zu bestimmen
die Anzahl der CPU-Kerne auf Remote-Computern).

--keine Notiz
Zitierungshinweis nicht anzeigen. Ein Zitierhinweis wird auf stderr (Standard) gedruckt
Fehler) nur, wenn stderr (Standardfehler) ein Terminal ist, das der Benutzer nicht angegeben hat
--keine Notiz, und der Benutzer hat nicht ausgeführt --bibtex Einmal.

--nett Nettigkeit
Führen Sie den Befehl so nett aus. Für einfache Befehle können Sie einfach hinzufügen schön in
vor dem Kommando. Wenn der Befehl jedoch aus mehreren Unterbefehlen besteht (z. B.:
ls|wc) dann voranstellen schön wird nicht immer funktionieren. --nett Ich werde dafür sorgen, dass alle Subs
Befehle sind nett.

--interaktiv
-p Fragen Sie den Benutzer, ob er jede Befehlszeile ausführen und eine Zeile daraus lesen soll
Terminal. Führen Sie die Befehlszeile nur aus, wenn die Antwort mit „y“ oder „Y“ beginnt.
Impliziert -t.

--parens Parensstring
Verwenden Sie diese Option, um Start- und Endklammern für zu definieren {= perl Ausdruck =}. Die Linke und
Die rechte Klammer kann aus mehreren Zeichen bestehen und wird als gleich angenommen
Länge. Die Standardeinstellung ist {==} Angabe {= als Startklammer und =} als Ende
Klammer.

Eine weitere nützliche Einstellung ist ,,,, was beide Klammern ergeben würde ,,:

parallel --parens ,,,, echo foo ist ,,s/I/O/g,, ::: FII

Siehe auch: --rpl {= perl Ausdruck =}

--Profil Profilname
-J Profilname
Profil verwenden Profilname für Optionen. Dies ist nützlich, wenn Sie mehrere haben möchten
Profile. Sie könnten ein Profil für die parallele Ausführung von Jobs auf dem lokalen Server haben
Computer und ein anderes Profil zum Ausführen von Jobs auf Remotecomputern. Siehe die
Beispiele finden Sie im Abschnitt PROFILDATEIEN.

Profilname entspricht der Datei ~/.parallel/Profilname.

Durch Wiederholen können Sie mehrere Profile erstellen --Profil. Wenn Teile der Profile
Bei Konflikten werden die späteren verwendet.

Standard: config

--zitieren
-q Preisanfrage Befehl. Dadurch wird die Befehlszeile in Anführungszeichen gesetzt, Sonderzeichen also nicht
von der Shell interpretiert. Siehe den Abschnitt „ZITIEREN“. Die meisten Menschen werden es nie brauchen
Das. Die Zitierung ist standardmäßig deaktiviert.

--no-run-if-empty
-r Wenn die stdin (Standardeingabe) nur Leerzeichen enthält, führen Sie den Befehl nicht aus.

Bei Verwendung mit --Rohr das ist langsam.

--noswap Starten Sie keine neuen Jobs auf einem bestimmten Computer, wenn sowohl ein Swap-In als auch ein Swap-Out erfolgt
Aktivität.

Die Swap-Aktivität wird nur alle 10 Sekunden abgetastet, da die Abtastung 1 Sekunde dauert
zu tun.

Die Swap-Aktivität wird als (Swap-In)*(Swap-Out) berechnet, was in der Praxis ein guter Wert ist
Wert: Auswechseln ist kein Problem, Eintauschen ist kein Problem, aber beides
Das Ein- und Auswechseln weist normalerweise auf ein Problem hin.

--record-env
Notieren Sie aktuelle Umgebungsvariablen in ~/.parallel/ignored_vars. Das ist nützlich
vor der Verwendung --env _.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] --env.

--recstart Startzeichenfolge
--rezendiert Endstring
If --recstart ist gegeben Startzeichenfolge wird zum Teilen beim Aufnahmestart verwendet.

If --rezendiert ist gegeben Endstring wird zum Teilen am Ende der Aufzeichnung verwendet.

Wenn beides --recstart und --rezendiert erhalten die kombinierte Zeichenfolge
endstringstartstring müssen übereinstimmen, um eine geteilte Position zu finden. Das ist nützlich
wenn entweder Startzeichenfolge or Endstring Match mitten in einer Platte.

Wenn weder --recstart noch --rezendiert sind dann gegeben --rezendiert Der Standardwert ist „\n“. Zu
Verwenden Sie kein Datensatztrennzeichen --rezendiert "".

--recstart und --rezendiert werden mit verwendet --Rohr.

Verwenden Sie die --regexp interpretieren --recstart und --rezendiert als reguläre Ausdrücke. Das ist
allerdings langsam.

--regexp Verwenden Sie die --regexp interpretieren --recstart und --rezendiert als reguläre Ausdrücke. Das ist
allerdings langsam.

--remove-rec-sep
--removerecsep
--rrs Entfernen Sie den passenden Text --recstart und --rezendiert bevor Sie es an die weiterleiten
Befehl.

Nur verwendet mit --Rohr.

--Ergebnisse Präfix
--res Präfix
Speichern Sie die Ausgabe in Dateien. Die Dateien werden in einem Verzeichnisbaum mit Stammverzeichnis gespeichert
at Präfix. Innerhalb dieses Verzeichnisbaums führt jeder Befehl zu zwei Dateien:
Präfix/ /stdout und Präfix/ /stderr, wo ist eine Folge von
Verzeichnisse, die den Header der Eingabequelle darstellen (falls verwendet). --Header :oder
die Nummer der Eingabequelle und entsprechende Werte.

Z.B:

parallel --header : --results foo echo {a} {b} ::: a I II ::: b III IIII

generiert die Dateien:

foo/a/I/b/III/stderr
foo/a/I/b/III/stdout
foo/a/I/b/IIII/stderr
foo/a/I/b/IIII/stdout
foo/a/II/b/III/stderr
foo/a/II/b/III/stdout
foo/a/II/b/IIII/stderr
foo/a/II/b/IIII/stdout

und

parallel --results foo echo {1} {2} ::: I II ::: III IIII

generiert die Dateien:

foo/1/I/2/III/stderr
foo/1/I/2/III/stdout
foo/1/I/2/IIII/stderr
foo/1/I/2/IIII/stdout
foo/1/II/2/III/stderr
foo/1/II/2/III/stdout
foo/1/II/2/IIII/stderr
foo/1/II/2/IIII/stdout

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] --Dateien, --Header, --joblog.

--Lebenslauf Wird mit dem letzten unvollendeten Job fortgesetzt. Durch Lesen --joblog oder unter der --Ergebnisse dir
GNU Parallel wird den letzten unvollendeten Job herausfinden und von dort aus fortfahren. Als
GNU Parallel betrachtet nur die Sequenznummern in --joblog dann die Eingabe, die
Befehl, und --joblog alle müssen unverändert bleiben; sonst GNU Parallel Mai
Führen Sie falsche Befehle aus.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] --joblog, --Ergebnisse, --resume-failed.

--resume-failed
Alle fehlgeschlagenen Versuche wiederholen und mit dem letzten nicht abgeschlossenen Auftrag fortfahren. Durch Lesen --joblog GNU
Parallel wird die fehlgeschlagenen Jobs ermitteln und diese erneut ausführen. Danach wird es so sein
Nehmen Sie den letzten unvollendeten Auftrag wieder auf und fahren Sie von dort aus fort. Als GNU Parallel schaut nur an
die Sequenznummern in --joblog dann die Eingabe, der Befehl und --joblog alle
müssen unverändert bleiben; sonst GNU Parallel führt möglicherweise falsche Befehle aus.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] --joblog, --Lebenslauf.

--Wiederholungen n
Wenn ein Job fehlschlägt, wiederholen Sie ihn auf einem anderen Computer, auf dem er nicht fehlgeschlagen ist. Mach das
n mal. Wenn es weniger sind als n Computer in --sshlogin GNU Parallel wird wieder-
Benutze alle Computer. Dies ist nützlich, wenn einige Jobs ohne ersichtlichen Grund fehlschlagen
(z. B. Netzwerkausfall).

--Rückkehr Dateinamen
Übertragen Sie Dateien von Remotecomputern. --Rückkehr wird verwendet mit --sshlogin wenn das
Argumente sind Dateien auf den Remotecomputern. Wenn die Verarbeitung abgeschlossen ist, wird die Datei
Dateinamen wird vom Remote-Computer mit übertragen rsync und wird gestellt
relativ zum Standard-Anmeldeverzeichnis. Z.B

echo foo/bar.txt | parallel \
--sshlogin server.example.com --return {.}.out touch {.}.out

Dadurch wird die Datei übertragen $HOME/foo/bar.out vom Computer
server.beispiel.com in die Datei foo/bar.out nach dem Rennen aufnehmen foo/bar.out on
server.beispiel.com.

echo /tmp/foo/bar.txt | parallel \
--sshlogin server.example.com --return {.}.out touch {.}.out

Dadurch wird die Datei übertragen /tmp/foo/bar.out vom Computer server.beispiel.com
in die Datei /tmp/foo/bar.out nach dem Rennen aufnehmen /tmp/foo/bar.out on
server.beispiel.com.

Durch mehrmaliges Wiederholen der Optionen können mehrere Dateien übertragen werden:

echo /tmp/foo/bar.txt | \
parallel --sshlogin server.example.com \
--return {.}.out --return {.}.out2 touch {.}.out {.}.out2

--Rückkehr wird oft verwendet mit --Transfer und --Aufräumen.

--Rückkehr wird bei Verwendung mit ignoriert --sshlogin : oder wenn es nicht verwendet wird --sshlogin.

--round-robin
--runden Normalerweise --Rohr gibt jeder Instanz des Befehls einen einzelnen Block. Mit
--round-robin Alle Blöcke werden nach dem Zufallsprinzip in bereits laufende Befehle geschrieben.
Dies ist nützlich, wenn die Initialisierung des Befehls lange dauert.

--Ordnung halten wird nicht funktionieren mit --round-robin da es unmöglich ist, nachzuverfolgen, welche
welcher Eingangsblock welchem ​​Ausgang entspricht.

--rpl 'Etikett perl Ausdruck'
Verwenden Sie die Etikett als Ersatzzeichenfolge für perl Ausdruck. Dies macht es möglich
Definieren Sie Ihre eigenen Ersatzzeichenfolgen. GNU ParallelEs sind 7 Ersatzsaiten dabei
implementiert als:

--rpl '{} '
--rpl '{#} 1 $_=$job->seq()'
--rpl '{%} 1 $_=$job->slot()'
--rpl '{/} s:.*/::'
--rpl '{//} $Global::use{"File::Basename"} ||= eval "use File::Basename; 1;"; $_ = dirname($_);'
--rpl '{/.} S:.*/::; s:\.[^/.]+$::;'
--rpl '{.} s:\.[^/.]+$::'

Wenn die benutzerdefinierte Ersatzzeichenfolge mit „{“ beginnt, kann sie auch als verwendet werden
Positionsersatzzeichenfolge (wie {2.}).

Es wird empfohlen, nur $_ zu ändern, Sie haben jedoch vollen Zugriff auf das gesamte GNU
Parallel's interne Funktionen und Datenstrukturen.

Hier sind ein paar Beispiele:

Entfernen Sie 2 Erweiterungen (z. B. .tar.gz)
--rpl '{..} s:\.[^/.]+$::;s:\.[^/.]+$::;'
Behalten Sie nur die Erweiterung
--rpl '{ext} s:.*\.::'
Ist die Auftragsreihenfolge gerade oder ungerade?
--rpl '{odd} $_=$job->seq()%2?"odd":"even"'

Siehe auch: {= perl Ausdruck =} --parens

--max-chars=max-chars
-s max-chars
Höchstens verwenden max-chars Zeichen pro Befehlszeile, einschließlich des Befehls und
Anfangsargumente und die abschließenden Nullen am Ende der Argumentzeichenfolgen.
Der größte zulässige Wert ist systemabhängig und wird als Argument berechnet
Längenbeschränkung für exec, abzüglich der Größe Ihrer Umgebung. Der Standardwert ist
das Maximum.

Impliziert -X es sei denn -m wird gesetzt.

--show-limits
Zeigt die vom Betriebssystem vorgegebenen Beschränkungen der Befehlszeilenlänge an
System und die -s Möglichkeit. Leiten Sie die Eingabe von /dev/null weiter (und geben Sie möglicherweise Folgendes an
--no-run-if-empty), wenn Sie GNU nicht möchten Parallel etwas tun.

--Semaphor
Funktioniert als Zählsemaphor. --Semaphor wird GNU verursachen Parallel zu starten
Befehl im Hintergrund. Wenn die Anzahl gleichzeitiger Jobs erreicht ist, wird GNU
Parallel wartet, bis einer dieser Schritte abgeschlossen ist, bevor ein weiterer Befehl gestartet wird.

--Semaphor impliziert --bg es sei denn --fg angegeben.

--Semaphor impliziert --semaphorename `tty` es sei denn --semaphorename angegeben.

Benutzt mit --fg, --Warten und --semaphorename.

Der Befehl SEM ist ein Alias ​​für Parallel --Semaphor.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] Mann SEM.

--semaphorename Name
--Ich würde Name
Verwenden Sie die Name als Name des Semaphors. Standard ist der Name des steuernden TTY
(Ausgabe von tty).

Die Standardeinstellung funktioniert normalerweise wie erwartet, wenn sie interaktiv verwendet wird, aber wenn sie in verwendet wird
ein Skript Name sollte eingestellt werden. $$ or mein_Aufgabenname sind oft ein guter Wert.

Das Semaphor wird in gespeichert ~/.parallel/semaphores/

Impliziert --Semaphor.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] Mann SEM.

--semaphoretimeout Sekunden
Wenn der Semaphor nicht innerhalb von Sekunden freigegeben wird, nehmen Sie ihn trotzdem.

Impliziert --Semaphor.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] Mann SEM.

--seqreplace ersetzen-str
Verwenden Sie die Ersatzzeichenfolge ersetzen-str statt {#} für Jobsequenznummer.

- Shebang
--hashbang
GNU Parallel kann als Shebang-Befehl (#!) als erste Zeile von a aufgerufen werden
Skript. Der Inhalt der Datei wird als Eingabequelle behandelt.

Liken:

#!/usr/bin/parallel --shebang -r Traceroute

foss.org.my
debian.org
freenetproject.org

- Shebang muss als erste Option eingestellt werden.

Auf FreeBSD env wird gebraucht:

#!/usr/bin/env -S parallel --shebang -r Traceroute

foss.org.my
debian.org
freenetproject.org

--shebang-wrap
GNU Parallel kann Skripte parallelisieren, indem die Shebang-Zeile umbrochen wird. Wenn das Programm
kann so ausgeführt werden:

Katzenargumente | parallel the_program

dann kann das Skript wie folgt geändert werden:

#!/usr/bin/parallel --shebang-wrap /the/original/parser --with-options

zB

#!/usr/bin/parallel --shebang-wrap /usr/bin/python

Wenn das Programm wie folgt ausgeführt werden kann:

Katzendaten | parallel --pipe the_program

dann kann das Skript wie folgt geändert werden:

#!/usr/bin/parallel --shebang-wrap --pipe /the/original/parser --with-options

zB

#!/usr/bin/parallel --shebang-wrap --pipe / Usr / bin / perl -w

--shebang-wrap muss als erste Option eingestellt werden.

--shellquote
Führt den Befehl nicht aus, sondern zitiert ihn. Nützlich zum Verfassen von Zitaten
Befehle für GNU Parallel.

--skip-first-line
Verwenden Sie nicht die erste Eingabezeile (von GNU verwendet). Parallel selbst, wenn mit aufgerufen
- Shebang).

--sshdelay Sekunden
Den nächsten SSH-Start verzögern um Sekunden Sekunden. GNU Parallel wird pausieren Sekunden Sekunden
nach jedem Start von SSH. Sekunden kann weniger als 1 Sekunde betragen.

-S [ncpu/]sshlogin[,[ncpu/]sshlogin[,...]]
--sshlogin [ncpu/]sshlogin[,[ncpu/]sshlogin[,...]]
Verteilen Sie Jobs an Remote-Computer. Die Jobs werden auf einer Liste von Remote ausgeführt
Computers. GNU Parallel bestimmt die Anzahl der CPU-Kerne auf der Fernbedienung
Computern und führen Sie die von angegebene Anzahl von Jobs aus -j. Wenn die Nummer ncpu is
GNU gegeben Parallel verwendet diese Zahl für die Anzahl der CPU-Kerne auf dem Host.
Normalerweise ncpu wird nicht benötigt.

An sshlogin hat die Form:

[sshcommand [Optionen]] [Benutzername@]Hostname

Der sshlogin darf kein Passwort erfordern.

Das sshlogin „:“ ist etwas Besonderes, es bedeutet „kein SSH“ und wird daher auf dem ausgeführt
lokalen Computer.

Das sshlogin '..' ist etwas Besonderes, es liest sshlogins aus ~/.parallel/sshloginfile

Das sshlogin „-“ ist ebenfalls etwas Besonderes, es liest sshlogins von stdin (Standardeingabe).

Um weitere SSH-Logins anzugeben, trennen Sie die SSH-Logins durch Komma oder wiederholen Sie die Optionen
mehrmals.

Beispiele: siehe --sshloginfile.

Der Remote-Host muss über GNU verfügen Parallel installiert.

--sshlogin Es ist bekannt, dass es Probleme mit verursacht -m und -X.

--sshlogin wird oft verwendet mit --Transfer, --Rückkehr, --Aufräumen und --trc.

--sshloginfile Dateinamen (Beta-test)
--slf Dateinamen (Beta-test)
Datei mit sshlogins. Die Datei besteht aus sshlogins in separaten Zeilen. Leer
Zeilen und Zeilen, die mit „#“ beginnen, werden ignoriert. Beispiel:

server.beispiel.com
[E-Mail geschützt]
8/my-8-core-server.example.com
2/[E-Mail geschützt]
# Auf diesem Server läuft SSH auf Port 2222
ssh -p 2222 server.example.net
4/ssh -p 2222 quadserver.example.net
# Verwenden Sie ein anderes SSH-Programm
myssh -p 2222 -l meinBenutzername hexacpu.example.net
# Verwenden Sie ein anderes SSH-Programm mit der Standardanzahl an Kernen
//usr/local/bin/myssh -p 2222 -l meinBenutzername hexacpu.example.net
# Verwenden Sie ein anderes SSH-Programm mit 6 Kernen
6//usr/local/bin/myssh -p 2222 -l meinBenutzername hexacpu.example.net
# Gehen Sie von 16 Kernen auf dem lokalen Computer aus
16/:

Bei Verwendung eines anderen SSH-Programms muss das letzte Argument der Hostname sein.

Mehrere --sshloginfile sind erlaubt.

GNU Parallel sucht zunächst im aktuellen Verzeichnis nach der Datei; Wenn das fehlschlägt, schauen Sie nach
für die Datei in ~/.parallel.

Die sshlogin-Datei '..' ist etwas Besonderes, sie liest sshlogins aus ~/.parallel/sshloginfile

Die sshlogin-Datei '.' ist etwas Besonderes, es liest Sshlogins aus
/etc/parallel/sshloginfile

Die sshloginfile '-' ist ebenfalls etwas Besonderes, sie liest sshlogins von stdin (Standard).
Eingang).

Wenn die sshlogin-Datei geändert wird, wird sie erneut gelesen, wenn ein Job abgeschlossen ist
meistens einmal pro Sekunde. Dadurch ist es möglich, währenddessen Hosts hinzuzufügen und zu entfernen
läuft.

Dies kann verwendet werden, um einen Daemon zu haben, der die sshlogin-Datei so aktualisiert, dass sie nur enthält
Server, die aktiv sind:

cp original.slf tmp2.slf
während [1]; Tun
schöne Parallele --nonall -j0 -k --slf original.slf --tag echo | perl 's/\t$//' > tmp.slf
if diff tmp.slf tmp2.slf; Dann
mv tmp.slf tmp2.slf
fi
Schlaf 10
Erledigt &
parallel --slf tmp2.slf ...

--slotreplace ersetzen-str
Verwenden Sie die Ersatzzeichenfolge ersetzen-str statt {%} für Job-Slot-Nummer.

--Leise Still. Der auszuführende Auftrag wird nicht gedruckt. Dies ist die Standardeinstellung. Kann sein
umgekehrt mit -v.

--tty Öffnen Sie das TTY-Terminal. Wenn GNU Parallel wird zum Starten eines interaktiven Programms verwendet
Dann ist diese Option möglicherweise erforderlich. Es wird jeweils nur ein Job gestartet (d. h -j1),
die Ausgabe nicht puffern (d. h -u), und es wird ein TTY für den Job geöffnet. Wenn der Job
Wenn es fertig ist, wird der nächste Job das tty bekommen.

--Schild Tag-Zeilen mit Argumenten. Jeder Ausgabezeile werden die Argumente vorangestellt
und TAB (\t). In Kombination mit --onall or --nonall Die Zeilen werden vorangestellt
stattdessen mit dem sshlogin.

--Schild wird bei der Verwendung ignoriert -u.

--tagstring str
Markieren Sie Zeilen mit einer Zeichenfolge. Jeder Ausgabezeile wird ein vorangestellt str und TAB
(\T). str kann Ersatzzeichenfolgen wie {} enthalten.

--tagstring wird bei der Verwendung ignoriert -u, --onall und --nonall.

--tmpdir dirname
Verzeichnis für temporäre Dateien. GNU Parallel Normalerweise puffert es die Ausgabe in
temporäre Dateien in /tmp. Indem man es einstellt --tmpdir Sie können dafür ein anderes Verzeichnis verwenden
Dateien. Einstellung --tmpdir entspricht dem Setzen von $TMPDIR.

--tmux Verwenden Sie die tmux zur Ausgabe. Starte ein tmux Sitzung und führen Sie jeden Job in einem Fenster darin aus
Sitzung. Es wird keine weitere Ausgabe erzeugt.

--Auszeit Welle
Auszeit für Befehl. Wenn der Befehl länger ausgeführt wird als Welle Sekunden wird es dauern
getötet mit SIGTERM, gefolgt von SIGTERM 200 ms später, gefolgt von SIGKILL 200 ms
später.

If Welle folgt ein %-Wert, dann wird das Timeout dynamisch als a berechnet
Prozentsatz der mittleren durchschnittlichen Laufzeit. Nur Werte > 100 % sind sinnvoll.

- ausführlich
-t Drucken Sie den Auftrag, der auf stderr ausgeführt werden soll (Standardfehler).

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] -v, -p.

--Transfer
Übertragen Sie Dateien auf Remotecomputer. --Transfer wird verwendet mit --sshlogin wenn das
Argumente sind Dateien und sollten auf die Remote-Computer übertragen werden. Die Dateien
wird mit übertragen rsync und wird relativ zum Standardarbeitsverzeichnis platziert.
Wenn der Pfad enthält /./ Der verbleibende Pfad ist relativ zum Arbeitsverzeichnis.
zB

echo foo/bar.txt | parallel \
--sshlogin server.example.com --transfer wc

Dadurch wird die Datei übertragen foo/bar.txt an den Computer server.beispiel.com zu den
Datei $HOME/foo/bar.txt vor dem Laufen wc foo/bar.txt on server.beispiel.com.

echo /tmp/foo/bar.txt | parallel \
--sshlogin server.example.com --transfer wc

Dadurch wird die Datei übertragen foo/bar.txt an den Computer server.beispiel.com zu den
Datei /tmp/foo/bar.txt vor dem Laufen wc /tmp/foo/bar.txt on server.beispiel.com.

--Transfer wird oft verwendet mit --Rückkehr und --Aufräumen.

--Transfer wird bei Verwendung mit ignoriert --sshlogin : oder wenn es nicht verwendet wird
--sshlogin.

--trc Dateinamen
Übergabe, Rückgabe, Reinigung. Kurzschrift für:

--Transfer --Rückkehr Dateinamen --Aufräumen

--trimmen
Leerraum in der Eingabe entfernen.

n Kein Beschnitt. Die Eingabe wird nicht geändert. Dies ist die Standardeinstellung.

l Linke Trimmung. Entfernen Sie Leerzeichen am Anfang der Eingabe. ZB „a bc“ -> „a bc“.

r Rechte Trimmung. Entfernen Sie Leerzeichen am Ende der Eingabe. ZB „a bc“ -> „a bc“.

lr
rl Beide trimmen. Entfernen Sie Leerzeichen sowohl am Anfang als auch am Ende der Eingabe. ZB „a bc“
-> „a vc“. Dies ist die Standardeinstellung, wenn --colsep wird eingesetzt.

- Gruppierung aufheben
-u Gruppierung der Ausgabe aufheben. Die Ausgabe wird so schnell wie möglich gedruckt und übergeht GNU Parallel
interne Verarbeitung. Dies kann dazu führen, dass die Ausgabe verschiedener Befehle gemischt wird
sollte daher nur verwendet werden, wenn Ihnen die Ausgabe egal ist. Vergleichen Sie diese:

Parallel -j0 'schlafen {};Echo -n start{};schlafen {};Echo {}Ende' ::: 1 2 3 4

Parallel -u -j0 'schlafen {};Echo -n start{};schlafen {};Echo {}Ende' ::: 1 2 3 4

Es deaktiviert auch --Schild. GNU Parallel Gibt schneller aus mit -u. Vergleichen Sie die Geschwindigkeit von
diese:

parallele seq ::: 300000000 >/dev/null
parallel -u seq ::: 300000000 >/dev/null
parallel --line-buffer seq ::: 300000000 >/dev/null

Kann mit umgekehrt werden --Gruppe.

Siehe auch: --line-buffer --Gruppe

--extensionreplace ersetzen-str
--ähm ersetzen-str
Verwenden Sie die Ersatzzeichenfolge ersetzen-str statt {.} für Eingabezeile ohne
Erweiterung.

--use-cpus-instead-of-cores
Zählen Sie die Anzahl der physischen CPUs anstelle der CPU-Kerne. Bei der Berechnung der Anzahl
Jobs, die gleichzeitig im Verhältnis zur Anzahl der CPU-Kerne ausgeführt werden sollen, können Sie GNU erfragen
Parallel stattdessen auf die Anzahl der physischen CPUs zu schauen. Das wird Sinn machen für
Computer mit Hyperthreading als zwei Jobs, die auf einer CPU ausgeführt werden
Hyperthreading wird langsamer ausgeführt als zwei Jobs, die auf zwei physischen CPUs ausgeführt werden. Manche
Multi-Core-CPUs können schneller laufen, wenn nur ein Thread pro physischer CPU ausgeführt wird.
Die meisten Benutzer werden diese Option nicht benötigen.

-v Ausführlich. Drucken Sie den auszuführenden Auftrag auf stdout (Standardausgabe). Kann umgekehrt werden
mit --Leise. Siehe auch -t.

Verwenden Sie die -v -v um den Wrapping-SSH-Befehl bei der Remote-Ausführung auszudrucken.

--Version
-V Drucken Sie die Version GNU aus Parallel und verlassen.

--workdir meindir
--wd meindir
Übertragene Dateien mit --Transfer und --Rückkehr wird relativ zu sein meindir on
Remote-Computern, und der Befehl wird im Verzeichnis ausgeführt meindir.

Das Sonderangebot meindir Wert ... erstellt Arbeitsverzeichnisse darunter ~/.parallel/tmp/ on
die entfernten Computer. Wenn --Aufräumen gegeben ist, werden diese Verzeichnisse entfernt.

Das Sonderangebot meindir Wert . Verwendet das aktuelle Arbeitsverzeichnis. Wenn der Strom funktioniert
dir liegt unter deinem Home-Verzeichnis, dem Wert . wird als relativer Pfad zu Ihrem behandelt
Heimverzeichnis. Das heißt, wenn Ihr Home-Verzeichnis auf Remote-Computern unterschiedlich ist (z. B
(wenn Ihr Login anders ist) ist der relative Pfad immer noch relativ zu Ihrem Zuhause
d.

Um den Unterschied zu sehen, versuchen Sie Folgendes:

Parallel -S Server pwd ::: ""

Parallel --wd . -S Server pwd ::: ""

Parallel --wd ... -S Server pwd ::: ""

--Warten Warten Sie, bis alle Befehle abgeschlossen sind.

Impliziert --Semaphor.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] Mann SEM.

-X Mehrere Argumente mit Kontext ersetzen. Geben Sie so viele Argumente wie der Befehl ein
Leitungslänge zulässt. Wenn mehrere Jobs parallel ausgeführt werden: Verteilen Sie die
Streitigkeiten gleichmäßig unter den Jobs. Verwenden -j1 um es zu umgehen.

If {} Wird diese nicht verwendet, werden die Argumente an die Zeile angehängt. Wenn {} wird verwendet als
Teil eines Wortes (wie pic{}.jpg), dann wird das ganze Wort wiederholt. Wenn {} is
jeweils mehrfach verwendet {} wird durch die Argumente ersetzt.

Normalerweise -X wird das Richtige tun, wohingegen -m kann zu unerwarteten Ergebnissen führen, wenn {}
wird als Teil eines Wortes verwendet.

Unterstützung für -X mit --sshlogin ist begrenzt und kann fehlschlagen.

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] -m.

--Ausfahrt
-x Beenden Sie, wenn die Größe (siehe -s Option) überschritten wird.

--xapply Lesen Sie mehrere Eingabequellen wie xapply. Wenn mehrere Eingabequellen angegeben sind, eine
Das Argument wird aus jeder Eingabequelle gelesen. Die Argumente können sein
Im Befehl as wird darauf zugegriffen 1 {} .. {n}, damit 1 {} wird eine Zeile aus der ersten Eingabe sein
Quelle und 6 {} bezieht sich ab dem 6. auf die Zeile mit derselben Zeilennummer
Eingabequelle.

Vergleichen Sie diese beiden:

paralleles Echo {1} {2} ::: 1 2 3 ::: abc
parallel --xapply echo {1} {2} ::: 1 2 3 ::: abc

Argumente werden recycelt, wenn eine Eingabequelle mehr Argumente hat als die
Andere:

parallel --xapply echo {1} {2} {3} ::: 1 2 ::: I II III ::: abcdefg

[VORLÄUFIGE VOLLAUTOMATISCHE TEXTÜBERSETZUNG - muss noch überarbeitet werden. Wir bitten um Ihr Verständnis.] --Header.

Beispiel: Arbeiten as xargs -n1. Argument anhängen

GNU Parallel kann ähnlich funktionieren xargs -n1.

Zum Komprimieren aller HTML-Dateien mit gzip Lauf:

gefunden . -Name '*.html' | Parallel gzip --Beste

Wenn die Dateinamen möglicherweise einen Zeilenumbruch enthalten, verwenden Sie -0. Ersetzen Sie FOO BAR in allen Dateien durch FUBAR
in diesem Verzeichnis und Unterverzeichnissen:

gefunden . -Art f -print0 | Parallel -q0 perl -i -Sport 's/FOO BAR/FUBAR/g'

Note -q wird wegen des Platzes in „FOO BAR“ benötigt.

Beispiel: Lesebrillen Argumente für Befehl Linie

GNU Parallel kann die Argumente von der Befehlszeile anstelle von stdin (Standardeingabe) übernehmen.
Zum Komprimieren aller HTML-Dateien im aktuellen Verzeichnis mit gzip Lauf:

Parallel gzip --Beste ::: *.html

So konvertieren Sie *.wav in *.mp3 mithilfe von LAME, wobei pro CPU-Kernlauf ein Prozess ausgeführt wird:

Parallel paralytisch {} -o {.}.mp3 ::: * .wav

Beispiel: Einsetzen mehrere Argumente

Beim Verschieben vieler Dateien wie folgt: mv * .log Zielverzeichnis Sie erhalten manchmal die Fehlermeldung:

Bash: /bin/mv: Argument Liste auch lange

weil es zu viele Dateien gibt. Sie können stattdessen Folgendes tun:

ls | grep -E '\.log$' | Parallel mv {} Zielverzeichnis

Das wird laufen mv für jede Datei. Es geht schneller, wenn mv bekommt so viele Argumente, dass
passt auf die Zeile:

ls | grep -E '\.log$' | Parallel -m mv {} Zielverzeichnis

Beispiel: Kontext ersetzen

Um die Dateien zu entfernen pict0000.jpg .. pict9999.jpg du könntest es tun:

ff -w 0 9999 | Parallel rm pict{}.jpg

Sie könnten auch tun:

ff -w 0 9999 | perl -Sport 's/(.*)/pict$1.jpg/' | Parallel -m rm

Der erste wird ausgeführt rm 10000 Mal, während der letzte nur ausgeführt wird rm so oft wie nötig
Halten Sie die Länge der Befehlszeile kurz genug, um dies zu vermeiden Argument Liste auch lange (typischerweise
läuft 1-2 mal).

Sie könnten auch Folgendes ausführen:

ff -w 0 9999 | Parallel -X rm pict{}.jpg

Dies wird auch nur ausgeführt rm so oft wie nötig, um die Länge der Befehlszeile kurz zu halten
genug.

Beispiel: Berechnen Intensiv Jobs & Karriere und Substitution

Wenn ImageMagick installiert ist, wird eine Miniaturansicht einer JPG-Datei generiert:

verkaufen -Geometrie 120 foo.jpg thumb_foo.jpg

Dies wird mit Jobs zur Anzahl der CPU-Kerne parallel für alle JPG-Dateien in einem Verzeichnis ausgeführt:

ls * .jpg | Parallel verkaufen -Geometrie 120 {} Daumen_{}

Um dies rekursiv zu tun, verwenden Sie gefunden:

gefunden . -Name '*.jpg' | Parallel verkaufen -Geometrie 120 {} {}_thumb.jpg

Beachten Sie, wie das Argument beginnen muss {} as {} Enthält den Pfad (z. B. Laufen). verkaufen
-Geometrie 120 ./foo/bar.jpg thumb_./foo/bar.jpg wäre eindeutig falsch). Der Befehl wird
Generieren Sie Dateien wie ./foo/bar.jpg_thumb.jpg.

Verwenden Sie die {.} um das zusätzliche .jpg im Dateinamen zu vermeiden. Dieser Befehl erstellt Dateien wie
./foo/bar_thumb.jpg:

gefunden . -Name '*.jpg' | Parallel verkaufen -Geometrie 120 {} {.}_thumb.jpg

Beispiel: Substitution und Umleitung

Dadurch wird neben der .gz-Datei eine unkomprimierte Version der .gz-Dateien generiert:

Parallel zcat {} ">„{.} ::: *.gz

Das Zitieren von > ist erforderlich, um die Weiterleitung zu verschieben. Eine andere Lösung besteht darin, das zu zitieren
ganzer Befehl:

Parallel „zcat {} >{.}" ::: *.gz

Andere Shell-Sonderzeichen (z. B. * ; $ > < | >> <<) müssen ebenfalls in Anführungszeichen gesetzt werden.
da sie andernfalls von der Shell interpretiert und nicht an GNU übergeben werden könnten Parallel.

Beispiel: Bestehend Befehle

Ein Job kann aus mehreren Befehlen bestehen. Dadurch wird jeweils die Anzahl der Dateien gedruckt
Verzeichnis:

ls | Parallel 'Echo -n {}" "; ls {}|wc -l '

Um die Ausgabe in eine Datei mit dem Namen zu schreiben .dir:

ls | Parallel '(Echo -n {}" "; ls {}|wc -l) > {}.dir'

Selbst kleine Shell-Skripte können von GNU ausgeführt werden Parallel:

gefunden . | Parallel 'a={}; name=${a##*/}; Upper=$(echo "$name" | tr "[:untere:]"
"[:Oberer, höher:]"); Echo „$name - $upper"'

ls | Parallel 'mv {} „$(Echo {} | tr "[:Oberer, höher:]" "[:untere:]")"'

Listen Sie anhand einer URL-Liste alle URLs auf, deren Download fehlschlägt. Drucken Sie die Zeilennummer und die aus
URL.

Katze URL-Datei | Parallel „wget {} 2>/ dev / null || grep -n {} URL-Datei"

Erstellen Sie ein Spiegelverzeichnis mit denselben Dateinamen, außer dass alle Dateien und Symlinks leer sind
Dateien.

cp -rs /die/Quelle/Verzeichnis Mirror_dir; gefunden Spiegelverzeichnis -Art l | Parallel -m rm {} '&&' aufnehmen
{}

Suchen Sie die Dateien in einer Liste, die nicht vorhanden sind

Katze Dateiliste | Parallel 'wenn [ ! -e {} ] ; dann Echo {}; fi'

Beispiel: maximal einfach anrufen Bash Funktionen

Wenn der zusammengesetzte Befehl länger als eine Zeile ist, wird er schwer lesbar. In Bash ist das möglich
Funktionen nutzen. Denken Sie daran exportieren -f die Funktion.

Tu es() {
echo Mach es für 1 $
Schlaf 2
echo Fertig mit $1
}
export -f doit
parallel doit ::: 1 2 3

doubleit() {
echo Mach es für 1 $ 2 $
Schlaf 2
echo Fertig mit $1 $2
}
export -f doubleit
paralleles Doubleit ::: 1 2 3 ::: ab

Um dies auf Remote-Servern zu tun, müssen Sie die Funktion mit übertragen --env:

parallel --env doit -S server doit ::: 1 2 3
parallel --env doubleit -S server doubleit ::: 1 2 3 ::: ab

Wenn Ihre Umgebung (Aliase, Variablen und Funktionen) klein ist, können Sie sie vollständig kopieren
Umgebung, ohne es tun zu müssen exportieren -f irgendetwas. Führen Sie einfach zuerst Folgendes aus:

env_parallel() {
export parallel_bash_environment='() {
'"$(echo "shopt -s expand_aliases 2>/dev/null"; alias;typeset -p | grep -vFf <(readonly; echo GROUPS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_;typeset -f)"'
}'
# Ausführen als: env_parallel parallel_bash_environment "2>/dev/null;" ...
`welche Parallele` „$@“
parallel_bash_environment deaktiviert
}

Und dann anrufen als:

env_parallel doit ::: 1 2 3
env_parallel doubleit ::: 1 2 3 ::: ab
env_parallel -S server doit ::: 1 2 3
env_parallel -S server doubleit ::: 1 2 3 ::: ab

Beispiel: Funktion Tester

So testen Sie ein Programm mit verschiedenen Parametern:

Prüfer() {
if (eval "$@") >&/dev/null; Dann
perl -e 'printf "\033[30;102m[ OK ]\033[0m @ARGV\n"' "$@"
sonst
perl -e 'printf "\033[30;101m[FAIL]\033[0m @ARGV\n"' "$@"
fi
}
export -f tester
Paralleltester my_program ::: arg1 arg2
paralleler Tester-Ausgang ::: 1 0 2 0

If mein_programm schlägt ein Fehler fehl, wird ein rotes FAIL gedruckt, gefolgt vom fehlgeschlagenen Befehl. ansonsten
Es wird ein grünes OK gedruckt, gefolgt vom Befehl.

Beispiel: Entfernen Datei Erweiterung wann Verarbeitung Dateien

Beim Verarbeiten von Dateien wird die Dateierweiterung mit entfernt {.} ist oft nützlich.

Erstellen Sie für jede ZIP-Datei ein Verzeichnis und entpacken Sie sie in dieses Verzeichnis:

Parallel 'mkdir {.}; cd {.}; entpacken ../{}' ::: *.Postleitzahl

Komprimieren Sie alle .gz-Dateien im aktuellen Verzeichnis erneut mit bzip2 1 Job pro CPU-Kern ausführen
parallel:

Parallel „zcat {} | bzip2 >{.}.bz2 && rm {}" ::: *.gz

Konvertieren Sie alle WAV-Dateien mit LAME in MP3:

gefunden Sounddir -Art f -Name '*.wav' | Parallel paralytisch {} -o {.}.mp3

Legen Sie alle konvertierten Dateien im selben Verzeichnis ab:

gefunden Sounddir -Art f -Name '*.wav' | Parallel paralytisch {} -o mydir/{/.}.mp3

Beispiel: Entfernen XNUMX Datei Erweiterungen wann Verarbeitung Dateien

Wenn Sie ein Verzeichnis mit tar.gz-Dateien haben und diese in das entsprechende Verzeichnis extrahieren möchten
(z. B. foo.tar.gz wird in das Verzeichnis foo extrahiert) Sie können Folgendes tun:

Parallel --Plus 'mkdir {..}; Teer -C {..} -xf {}' ::: *.tar.gz

Beispiel: Herunterladen 10 Bildern für jeder of passt 30 Tage

Nehmen wir an, eine Website speichert Bilder wie:

http://www.example.com/path/to/YYYYMMDD_##.jpg

Dabei ist JJJJMMTT das Datum und ## die Zahl 01-10. Dadurch werden Bilder für heruntergeladen
Letzte 30 Tage:

Parallel wget http://www.example.com/path/to/'$(Datum -d "Heute -{1} Tage"
+%Y%m%d)_{2}.jpg' ::: $(seq 30) ::: $(seq -w 10)

$(Datum -d "Heute -{1} Tage" +%Y%m%d) gibt die Daten im Format JJJJMMTT mit {1} Tagen an
subtrahiert.

Beispiel: Kopieren Dateien as letzte geändert Datum (ISO8601) mit hinzugefügt zufällig Ziffern

gefunden . | Parallel 'vgl {} ../destdir/{= $a = int(10000*rand); $_ = `Datum -r „$_“
+%FT%T"$a"`; kauen; =}'

Beispiel: Digital Uhr mit „blinkt“ :

Das : in einer Digitaluhr blinkt. Damit jede zweite Zeile ein „:“ und der Rest ein „ „a“ hat
Der Perl-Ausdruck wird verwendet, um die dritte Eingabequelle anzuzeigen. Wenn der Wert modudo 3 2 ist: Verwenden
: andernfalls verwenden Sie „ „:

Parallel -k Echo {1}'{=3 $_=$_%2?":":" "=}'{2}{3} ::: {0..12} ::: {0..5} ::: {0..9}

Beispiel: Aggregieren Inhalt of Dateien

Dies:

parallel --header : echo x{X}y{Y}z{Z} \> x{X}y{Y}z{Z} \
::: X {1..5} ::: Y {01..10} ::: Z {1..5}

generiert die Dateien x1y01z1 .. x5y10z5. Wenn Sie die Ausgabegruppierung aggregieren möchten
Auf x und z können Sie Folgendes tun:

parallele Auswertung 'cat {=s/y01/y*/=} > {=s/y01//=}' ::: *y01*

Für alle Werte von x und z führt es Befehle aus wie:

Katze x1y*z1 > x1z1

Am Ende erhält man also x1z1 .. x1z5, die jeweils den Inhalt aller Werte von y enthalten.

Beispiel: Breite zuerst Parallel Netz Crawler/Spiegel

Das folgende Skript crawlt und spiegelt parallel eine URL. Es lädt die ersten Seiten herunter
sind 1 Klick nach unten, dann 2 Klicks nach unten, dann 3; statt der normalen Tiefe zuerst, wo die
Der erste Link wird auf jeder Seite zuerst abgerufen.

Führen Sie es so aus:

PARALLEL=-j100 ./parallel-crawl http://gatt.org.yeslab.org/

Entferne das wget Teil, wenn Sie nur einen Webcrawler möchten.

Es funktioniert, indem es eine Seite aus einer Liste von URLs abruft und auf dieser Seite nach Links sucht
sich innerhalb derselben Start-URL befinden und noch nicht gesehen wurden. Diese Links sind
zu einer neuen Warteschlange hinzugefügt. Wenn alle Seiten aus der Liste fertig sind, wird die neue Warteschlange verschoben
Durchsuchen Sie die Liste der URLs und beginnen Sie den Vorgang erneut, bis keine unsichtbaren Links mehr gefunden werden.

#!/ bin / bash

# Z.B http://gatt.org.yeslab.org/
URL=$1
# Bleiben Sie im Startverzeichnis
BASEURL=$(echo $URL | perl -pe 's:#.*::; s:(//.*/)[^/]*:$1:')
URLLIST=$(mktemp urllist.XXXX)
URLLIST2=$(mktemp urllist.XXXX)
SEEN=$(mktemp seen.XXXX)

# Spider, um die URLs abzurufen
echo $URL >$URLLIST
cp $URLLIST $SEEN

while [ -s $URLLIST ] ; Tun
Katze $URLLIST |
parallel lynx -listonly -image_links -dump {} \; wget -qm -l1 -Q1 {} \; echo Spidered: {} \>\&2 |
perl -ne 's/#.*//; s/\s+\d+.\s(\S+)$/$1/ und mache { $seen{$1}++ oder drucke }' |
grep -F $BASEURL |
grep -v -x -F -f $SEEN | tee -a $SEEN > $URLLIST2
mv $URLLIST2 $URLLIST
erledigt

rm -f $URLLIST $URLLIST2 $SEEN

Beispiel: Prozess Dateien für a Teer Datei während Auspacken

Wenn sich die zu verarbeitenden Dateien in einer TAR-Datei befinden, entpacken Sie eine Datei und verarbeiten Sie sie
Das sofortige Entpacken ist möglicherweise schneller als das erste Entpacken aller Dateien.

Teer F foo.tgz | perl -ne 'drucken $l;$l=$_;END{print $l}' | Parallel Echo

Der Perl-Einzeiler wird benötigt, um Race Condition zu vermeiden.

Beispiel: Umschreiben a for-Schleife und a while-read-Schleife

for-Schleifen wie folgt:

(für x in „Katzenliste“; tun
do_something $x
erledigt) | Prozessausgabe

und while-read-Schleifen wie diese:

Katzenliste | (während read x ; do
do_something $x
erledigt) | Prozessausgabe

kann so geschrieben werden:

Katze Liste | Parallel etwas tun | Prozessausgabe

Beispiel: Finden Sie heraus, welcher Hostname in einer Liste die IP-Adresse 1.2.3 4 hat:

Katze hosts.txt | Parallel -P 100 Gastgeber | grep 1.2.3.4

Wenn die Verarbeitung weitere Schritte erfordert, sieht die for-Schleife wie folgt aus:

(für x in „Katzenliste“; tun
no_extension=${x%.*};
do_something $x skalieren $no_extension.jpg
do_step2 <$x $no_extension
erledigt) | Prozessausgabe

und while-Schleifen wie diese:

Katzenliste | (während read x ; do
no_extension=${x%.*};
do_something $x skalieren $no_extension.jpg
do_step2 <$x $no_extension
erledigt) | Prozessausgabe

kann so geschrieben werden:

Katze Liste | Parallel "etwas tun {} Treppe {.}.jpg ; do_step2 <{} {.}" | Prozessausgabe

Beispiel: Umschreiben verschachtelt for-Schleifen

Verschachtelte For-Schleifen wie folgt:

(für x in „cat xlist“ ; tun
für y in „cat ylist“; Tun
tu_etwas $x $y
erledigt
erledigt) | Prozessausgabe

kann so geschrieben werden:

Parallel etwas tun 1 {} 2 {} :::: xlist ylist | Prozessausgabe

Verschachtelte For-Schleifen wie folgt:

(für Geschlecht in MF ; do
für Größe in SML XL XXL ; Tun
echo $gender $size
erledigt
erledigt) | Sortieren

kann so geschrieben werden:

Parallel Echo 1 {} 2 {} ::: M F ::: S M L XL XXL | sortieren

Beispiel: Erkenntnis niedrigste Unterschied zwischen Dateien

diff eignet sich gut zum Auffinden von Unterschieden in Textdateien. diff | wc -l gibt einen Hinweis auf
die Größe des Unterschieds. Um die Unterschiede zwischen allen Dateien im aktuellen Verzeichnis zu finden
machen:

Parallel --Schild 'Unterschied 1 {} 2 {} | wc -l ' ::: * ::: * | sortieren -nk3

Auf diese Weise ist es möglich zu sehen, ob einige Dateien näher an anderen Dateien liegen.

Beispiel: for-Schleifen mit Überblick Namen

Wenn Sie mehrere verschachtelte For-Schleifen ausführen, kann es einfacher sein, den Überblick über die Schleifenvariable zu behalten
wenn es benannt ist, anstatt nur eine Nummer zu haben. Verwenden --Header : das erste Argument lassen
ein benannter Alias ​​für die Positionsersatzzeichenfolge sein:

parallel --header : echo {gender} {size} ::: gender MF ::: size SML XL XXL

Dies funktioniert auch, wenn die Eingabedatei eine Datei mit Spalten ist:

cat adressbuch.tsv | parallel --colsep '\t' --header : echo {Name} {E-Mail-Adresse}

Beispiel: Zu Zählen Unterschiede zwischen alle Dateien in a dir

Die richtigen --Ergebnisse Die Ergebnisse werden in /tmp/diffcount* gespeichert.

parallel --results /tmp/diffcount "diff -U 0 {1} {2} |tail -n +3 |grep -v '^@'|wc -l" ::: * ::: *

Um den Unterschied zwischen Datei A und Datei B zu sehen, schauen Sie sich die Datei „/tmp/diffcount/1/A/2/B“ an.

Beispiel: Beschleunigung up schnell Jobs & Karriere

Das Starten eines Jobs auf dem lokalen Computer dauert etwa 10 ms. Dies kann ein großer Aufwand sein, wenn
Die Ausführung des Jobs dauert nur wenige ms. Oftmals können Sie kleine Aufgaben mit gruppieren -X welches wird
machen den Overhead weniger bedeutsam. Vergleichen Sie die Geschwindigkeit dieser:

seq -w 0 9999 | paralleles Touch-Bild{}.jpg

seq -w 0 9999 | parallel -X touch pict{}.jpg

Wenn Ihr Programm nicht mehrere Argumente akzeptieren kann, können Sie GNU verwenden Parallel erscheinen
mehrere GNU Parallels:

seq -w 0 999999 | parallel -j10 --pipe parallel -j0 touch pict{}.jpg

If -j0 erzeugt normalerweise 252 Jobs, dann versucht das oben Genannte, 2520 Jobs zu erzeugen. Auf einem normalen
Auf einem GNU/Linux-System können Sie mit dieser Technik problemlos 32000 Jobs erzeugen. Erhöhen
Anhebung der 32000-Stellen-Grenze /proc/sys/kernel/pid_max um 4194303.

Beispiel: Die richtigen Schale Variablen

Wenn Sie Shell-Variablen verwenden, müssen Sie diese korrekt in Anführungszeichen setzen, da sie sonst möglicherweise geteilt werden
auf Leerzeichen.

Beachten Sie den Unterschied zwischen:

V=("Die 12 Platten meines Bruders sind <\$\$\$>"'!' Foo Bar wert)
parallel echo ::: ${V[@]} # Das ist wahrscheinlich nicht das, was Sie wollen

und:

V=("Die 12 Platten meines Bruders sind <\$\$\$>"'!' Foo Bar wert)
paralleles Echo ::: "${V[@]}"

Bei Verwendung von Variablen im eigentlichen Befehl, die Sonderzeichen (z. B. Leerzeichen) enthalten
Sie können sie mit zitieren '"$VAR"' oder mit "'s und". -q:

V="Hier sind zwei"
paralleles Echo "'$V'" ::: Leerzeichen
parallel -q echo "$V" ::: Leerzeichen

Beispiel: Gruppe an Möglichkeiten für das Ausgangssignal: Linien

Wenn Sie Jobs ausführen, die Daten ausgeben, möchten Sie häufig nicht, dass die Ausgabe mehrerer Jobs erfolgt
gemeinsam laufen. GNU Parallel Standardmäßig wird die Ausgabe jedes Jobs gruppiert, sodass die Ausgabe erfolgt
wird gedruckt, wenn der Auftrag abgeschlossen ist. Wenn Sie möchten, dass während des Auftrags vollständige Zeilen gedruckt werden
Laufen können Sie verwenden --line-buffer. Wenn Sie möchten, dass die Ausgabe so schnell wie möglich gedruckt wird
du kannst benutzen -u.

Vergleichen Sie die Ausgabe von:

Parallel Traceroute ::: foss.org.my debian.org freenetproject.org

zur Ausgabe von:

Parallel --line-buffer Traceroute ::: foss.org.my debian.org freenetproject.org

und:

Parallel -u Traceroute ::: foss.org.my debian.org freenetproject.org

Beispiel: Etikett Möglichkeiten für das Ausgangssignal: Linien

GNU Parallel gruppiert die Ausgabezeilen, es kann jedoch schwierig sein, die verschiedenen Jobs zu erkennen
Start. --Schild stellt das Argument voran, um es besser sichtbar zu machen:

Parallel --Schild Traceroute ::: foss.org.my debian.org freenetproject.org

--Schild arbeitet mit --line-buffer aber nicht mit -u:

Parallel --Schild --line-buffer Traceroute ::: foss.org.my debian.org freenetproject.org

Überprüfen Sie die Betriebszeit der Server ~/.parallel/sshloginfile:

Parallel --Schild -S .. --nonall Betriebszeit

Beispiel: Behalten Auftrag of Möglichkeiten für das Ausgangssignal: gleich as Auftrag of Varianten des Eingangssignals:

Normalerweise wird die Ausgabe eines Auftrags gedruckt, sobald er abgeschlossen ist. Manchmal will man
Die Reihenfolge der Ausgabe bleibt dieselbe wie die Reihenfolge der Eingabe. Das kommt häufig vor
wichtig, wenn die Ausgabe als Eingabe für ein anderes System verwendet wird. -k Ich werde die Bestellung sicherstellen
Die Ausgabe erfolgt in derselben Reihenfolge wie die Eingabe, auch wenn spätere Jobs vor früheren Jobs enden.

Hängen Sie an jede Zeile einer Textdatei eine Zeichenfolge an:

Katze Textdatei | Parallel -k Echo {} append_string

Wenn Sie entfernen -k Einige Zeilen werden möglicherweise in der falschen Reihenfolge ausgegeben.

Ein weiteres Beispiel ist der Zucker Traceroute:

Parallel Traceroute ::: foss.org.my debian.org freenetproject.org

wird Traceroute von foss.org.my, debian.org und freenetproject.org geben, aber das wird so sein
sortiert danach, welcher Auftrag zuerst erledigt wurde.

Um die Reihenfolge wie bei der Eingabe beizubehalten, führen Sie Folgendes aus:

Parallel -k Traceroute ::: foss.org.my debian.org freenetproject.org

Dadurch wird sichergestellt, dass die Traceroute zu foss.org.my zuerst gedruckt wird.

Ein etwas komplexeres Beispiel ist das parallele Herunterladen einer großen Datei in Blöcken: Etwas Internet
Verbindungen liefern mehr Daten, wenn Sie Dateien parallel herunterladen. Zum Herunterladen
Dateien parallel, siehe: „BEISPIEL: 10 Bilder für jeden der letzten 30 Tage herunterladen“. Aber falls
Wenn Sie eine große Datei herunterladen, können Sie die Datei in Blöcken parallel herunterladen.

Zum Herunterladen können Sie Byte 10000000-19999999 verwenden curl:

curl -r 10000000 19999999 http://example.com/the/big/file > file.part

Um eine 1-GB-Datei herunterzuladen, müssen 100 10-MB-Blöcke heruntergeladen und richtig kombiniert werden
Ordnung.

ff 0 99 | Parallel -k curl -r \
{}0000000-{}9999999 http://example.com/the/big/file > Datei

Beispiel: Parallel grep

grep -r Greps rekursiv durch Verzeichnisse. Auf Multicore-CPUs GNU Parallel kann oft
Beschleunigen Sie das.

gefunden . -Art f | Parallel -k -j150% -n 1000 -m grep -H -n STRING {}

Dadurch werden 1.5 Jobs pro Kern ausgeführt und 1000 Argumente ausgegeben grep.

Beispiel: Grepping n Linien für m regulär Ausdrücke.

Die einfachste Lösung, eine große Datei nach vielen regulären Ausdrücken zu durchsuchen, ist:

grep -f regexps.txt Bigfile

Oder wenn die regulären Ausdrücke feste Zeichenfolgen sind:

grep -F -f regexps.txt Bigfile

Es gibt zwei begrenzende Faktoren: CPU und Festplatten-E/A. Die CPU lässt sich leicht messen: Wenn der grep dauert
>90 % CPU (z. B. bei Top-Lauf), dann ist die CPU ein limitierender Faktor und die Parallelisierung
wird das beschleunigen. Wenn nicht, ist die Festplatten-E/A der begrenzende Faktor und hängt davon ab
Bei einem Festplattensystem kann die Parallelisierung schneller oder langsamer sein. Der einzige Weg, es sicher zu wissen, ist
messen.

Wenn die CPU der begrenzende Faktor ist, sollte eine Parallelisierung der regulären Ausdrücke erfolgen:

cat regexp.txt | parallel --pipe -L1000 --round-robin grep -f - bigfile

Wenn eine Zeile mit mehreren regulären Ausdrücken übereinstimmt, wird die Zeile möglicherweise dupliziert. Der Befehl startet einen
grep pro CPU und Bigfile einmal pro CPU lesen, aber da dies parallel erfolgt, werden alle Lesevorgänge durchgeführt
außer dass der erste im RAM zwischengespeichert wird. Abhängig von der Größe von regexp.txt kann dies der Fall sein
schneller, wenn --block 10m anstelle von -L1000 verwendet wird. Wenn regexp.txt zu groß ist, um in den RAM zu passen,
Entfernen Sie --round-robin und passen Sie -L1000 an. Dies führt dazu, dass Bigfile häufiger gelesen wird.

Einige Speichersysteme schneiden beim parallelen Lesen mehrerer Chunks besser ab. Das ist wahr
für einige RAID-Systeme und für einige Netzwerkdateisysteme. Um das Lesen von zu parallelisieren
Bigfile:

parallel --pipepart --block 100M -a bigfile -k grep -f regexp.txt

Dadurch wird Bigfile in 100-MB-Blöcke aufgeteilt und grep für jeden dieser Blöcke ausgeführt. Zu
Parallelisieren Sie sowohl das Lesen von Bigfile als auch von Regexp.txt und kombinieren Sie die beiden mit --fifo:

parallel --pipepart --block 100M -a bigfile --fifo cat regexp.txt \
\| parallel --pipe -L1000 --round-robin grep -f - {}

Wenn eine Zeile mit mehreren regulären Ausdrücken übereinstimmt, wird die Zeile möglicherweise dupliziert.

Beispiel: Die richtigen entfernt Computer

Um Befehle auf einem Remote-Computer auszuführen, muss SSH eingerichtet sein und Sie müssen sich anmelden können
ohne Eingabe eines Passwortes (Die Befehle ssh-Kopie-ID und SSH-Agent kann Ihnen dabei helfen).

Wenn Sie sich bei einem ganzen Cluster anmelden müssen, möchten Sie den Hostschlüssel normalerweise nicht akzeptieren
für jeden Gastgeber. Sie möchten sie beim ersten Mal akzeptieren und gewarnt werden, falls dies jemals der Fall sein sollte
geändert. Das zu tun:

# Fügen Sie die Server zur sshlogin-Datei hinzu
(echo servera; echo serverb) > .parallel/my_cluster
# Stellen Sie sicher, dass .ssh/config vorhanden ist
Berühren Sie .ssh/config
cp .ssh/config .ssh/config.backup
# StrictHostKeyChecking vorübergehend deaktivieren
(echo 'Host *'; echo StrictHostKeyChecking nein) >> .ssh/config
parallel --slf my_cluster --nonall true
# Entfernen Sie die Deaktivierung von StrictHostKeyChecking
mv .ssh/config.backup .ssh/config

Die Server sind da .parallel/my_cluster werden nun hinzugefügt .ssh/known_hosts.

Zu rennen Echo on server.beispiel.com:

Folge 10 | parallel --sshlogin server.example.com Echo

Um Befehle auf mehr als einem Remotecomputer auszuführen, führen Sie Folgendes aus:

Folge 10 | parallel --sshlogin server.example.com,server2.example.net echo

Oder:

Folge 10 | parallel --sshlogin server.example.com \
--sshlogin server2.example.net Echo

Wenn der Login-Benutzername lautet foo on server2.example.net benutzen:

Folge 10 | parallel --sshlogin server.example.com \
--sshlogin [E-Mail geschützt] Echo

Wenn Ihre Hostliste lautet server1-88.example.net mit Login foo:

Folge 10 | parallel -Sfoo@server{1..88}.example.net echo

Um die Befehle an eine Liste von Computern zu verteilen, erstellen Sie eine Datei meine Computer mit allen
Computers:

server.beispiel.com
[E-Mail geschützt]
server3.example.com

Dann renne:

Folge 10 | parallel --sshloginfile mycomputers echo

Um den lokalen Computer einzuschließen, fügen Sie der Liste das spezielle sshlogin „:“ hinzu:

server.beispiel.com
[E-Mail geschützt]
server3.example.com
:

GNU Parallel wird versuchen, die Anzahl der CPU-Kerne auf jeder Fernbedienung zu ermitteln
Computern und führen Sie einen Job pro CPU-Kern aus – auch wenn die Remote-Computer nicht über diese Funktion verfügen
gleiche Anzahl an CPU-Kernen.

Wenn die Anzahl der CPU-Kerne auf den Remote-Computern nicht korrekt identifiziert wird, wird die Anzahl nicht korrekt ermittelt
Anzahl der CPU-Kerne können vorne hinzugefügt werden. Hier verfügt der Computer über 8 CPU-Kerne.

Folge 10 | parallel --sshlogin 8/server.example.com Echo

Beispiel: Übertragen of Dateien

Zum erneuten Komprimieren von gzip-Dateien mit bzip2 Verwenden Sie einen Remote-Computer, um Folgendes auszuführen:

find logs/ -name '*.gz' | \
parallel --sshlogin server.example.com \
--transfer "zcat {} | bzip2 -9 >{.}.bz2"

Dadurch werden die .gz-Dateien im aufgelistet Protokolle Verzeichnis und alle Verzeichnisse darunter. Dann wird es
Übertragen Sie die Dateien an server.beispiel.com in das entsprechende Verzeichnis in $HOME/logs. Auf
server.beispiel.com Die Datei wird mit erneut komprimiert zcat und bzip2 was zu der
entsprechende Datei mit gz Ersetzt mit . Bz2.

Wenn Sie möchten, dass die resultierende bz2-Datei zurück auf den lokalen Computer übertragen wird, fügen Sie hinzu
--Rückkehr {.}.bz2:

find logs/ -name '*.gz' | \
parallel --sshlogin server.example.com \
--transfer --return {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

Nachdem die Neukomprimierung abgeschlossen ist . Bz2-Datei wird zurück auf den lokalen Computer übertragen
und neben das Original legen gz-Datei.

Wenn Sie die übertragenen Dateien auf dem Remote-Computer löschen möchten, fügen Sie hinzu --Aufräumen. Dies
entfernt sowohl die auf den Remote-Computer übertragene Datei als auch die übertragenen Dateien
vom Remote-Computer:

find logs/ -name '*.gz' | \
parallel --sshlogin server.example.com \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"

Wenn Sie es auf mehreren Computern ausführen möchten, fügen Sie die Computer hinzu --sshlogin entweder mit ',' oder
mehrere --sshlogin:

find logs/ -name '*.gz' | \
parallel --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"

Sie können den lokalen Computer über hinzufügen --sshlogin :. Dadurch wird das Entfernen und deaktiviert
Nur für den lokalen Computer übertragen:

find logs/ -name '*.gz' | \
parallel --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--sshlogin : \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"

Häufig --Transfer, --Rückkehr und --Aufräumen werden zusammen verwendet. Sie können auf gekürzt werden
--trc:

find logs/ -name '*.gz' | \
parallel --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--sshlogin : \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

Mit der Datei meine Computer enthält die Liste der Computer und wird zu:

find logs/ -name '*.gz' | parallel --sshloginfile mycomputers \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

Wenn die Datei ~/.parallel/sshloginfile enthält die Liste der Computer mit der speziellen Kurzschrift
-S .. kann verwendet werden:

find logs/ -name '*.gz' | parallel -S .. \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

Beispiel: Verteilen Arbeit zu aus einer regionalen und entfernt Computer

Konvertieren Sie *.mp3 in *.ogg und führen Sie einen Prozess pro CPU-Kern auf dem lokalen Computer und Server2 aus:

parallel --trc {.}.ogg -S server2,: \
'mpg321 -w - {} | oggenc -q0 - -o {.}.ogg' ::: *.mp3

Beispiel: Laufen gleich Befehl on entfernt Computer

Um den Befehl auszuführen Betriebszeit Auf Remote-Computern können Sie Folgendes tun:

Parallel --Schild --nonall -S Server1, Server2 Betriebszeit

--nonall liest keine Argumente. Wenn Sie eine Liste von Jobs haben, die Sie auf jedem Computer ausführen möchten
tun können:

Parallel --Schild --onall -S Server1, Server2 Echo ::: 1 2 3

Entfernen --Schild wenn Sie nicht möchten, dass sshlogin vor der Ausgabe hinzugefügt wird.

Wenn Sie viele Hosts haben, verwenden Sie „-j0“, um parallel auf mehrere Hosts zuzugreifen.

Beispiel: Parallelisieren rsync

rsync ist ein großartiges Tool, aber manchmal füllt es die verfügbare Bandbreite nicht aus. Das ist
Oftmals ein Problem beim Kopieren mehrerer großer Dateien über Hochgeschwindigkeitsverbindungen.

Im Folgenden wird eins gestartet rsync pro große Datei in Quellverzeichnis zu Zielverzeichnis auf dem Server
Fooserver:

cd src-dir; gefunden . -Art f -Größe +100000 | Parallel -v ssh Fooserver mkdir -p
/dest-dir/{//}\;rsync -s -Havessh {} fooserver:/dest-dir/{}

Die erstellten Verzeichnisse verfügen möglicherweise über falsche Berechtigungen und kleinere Dateien werden nicht erstellt
übertragen. Um diese zu beheben, laufen Sie rsync ein letztes Mal:

rsync -Havessh src-dir/ fooserver:/dest-dir/

Wenn Sie keine Daten übertragen können, diese aber abrufen müssen und die Dateien „digits.png“ heißen
(z. B. 000000.png) können Sie möglicherweise Folgendes tun:

ff -w 0 99 | Parallel rsync -Havessh fooserver:src-path/*{}.png Zielverzeichnis/

Beispiel: Verwenden Sie die mehrere Eingänge in dank One Befehl

Kopieren Sie Dateien wie foo.es.ext nach foo.ext:

ls *.es.* | perl -Sport 'drucken; s/\.es//' | Parallel -N2 cp 1 {} 2 {}

Der Perl-Befehl gibt für jede Eingabe zwei Zeilen aus. GNU Parallel Nimmt 2 Eingaben entgegen (mit -N2)
und ersetzt {1} und {2} durch die Eingaben.

Binär zählen:

Parallel -k Echo ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1

Drucken Sie die Zahl auf die gegenüberliegenden Seiten eines sechsseitigen Würfels:

Parallel --xapply -a <(seq 6) -a <(seq 6 -1 1) Echo

Parallel --xapply Echo :::: <(seq 6) <(seq 6 -1 1)

Konvertieren Sie Dateien aus allen Unterverzeichnissen in PNG-Dateien mit fortlaufenden Nummern (nützlich für die Erstellung).
Eingabe von PNGs für ffmpeg):

Parallel --xapply -a <(finden . -Art f | Sortieren) -a <(seq $(finden . -Art f|wc -l)) verkaufen
1 {} {2}.png

Alternativversion:

gefunden . -Art f | sortieren | Parallel verkaufen {} {#}.png

Beispiel: Verwenden Sie die a Tabelle as Varianten des Eingangssignals:

Inhalt von table_file.tsv:

foo Bar
baz quux

Laufen:

cmd -o bar -i foo
cmd -o quux -i baz

Du kannst rennen:

Parallel -a table_file.tsv --colsep '\t' cmd -o 2 {} -i 1 {}

Hinweis: Die Standardeinstellung für GNU Parallel besteht darin, die Leerzeichen um die Spalten zu entfernen. Um das zu behalten
Leerzeichen:

Parallel -a table_file.tsv --trimmen n --colsep '\t' cmd -o 2 {} -i 1 {}

Beispiel: Führen Sie gleich Befehl 10 mal

Wenn Sie denselben Befehl mit denselben Argumenten zehnmal parallel ausführen möchten, können Sie dies tun
machen:

ff 10 | Parallel -n0 mein_befehl meine_Argumente

Beispiel: Arbeiten as Katze | Sch. Ressource preiswert Jobs & Karriere und Auswertung

GNU Parallel kann ähnlich funktionieren Katze | sh.

Ein ressourcenschonender Job ist ein Job, der sehr wenig CPU, Festplatten-E/A und Netzwerk-E/A beansprucht.
Ping ist ein Beispiel für einen ressourcenschonenden Job. wget gilt auch – wenn die Webseiten klein sind.

Der Inhalt der Datei jobs_to_run:

ping -c 1 10.0.0.1
wget http://example.com/status.cgi?ip=10.0.0.1
ping -c 1 10.0.0.2
wget http://example.com/status.cgi?ip=10.0.0.2
...
ping -c 1 10.0.0.255
wget http://example.com/status.cgi?ip=10.0.0.255

Um 100 Prozesse gleichzeitig auszuführen, gehen Sie wie folgt vor:

Parallel -j 100 < jobs_to_run

Da es keine gibt Befehl Die Jobs werden von der Shell ausgewertet.

Beispiel: In Bearbeitung a groß Datei Verwendung von mehr Kerne

Zum Verarbeiten einer großen Datei oder einer Ausgabe, die Sie verwenden können --Rohr um die Daten in Blöcke aufzuteilen
und leiten Sie die Blöcke an das Verarbeitungsprogramm weiter.

Wenn das Programm ist gzip -9 du kannst tun:

Katze große Datei | Parallel --Rohr --rezendiert '' -k gzip -9 >bigfile.gz

Das wird spalten große Datei in Blöcke von 1 MB aufteilen und diese an übergeben gzip -9 parallel zu. Eins gzip
wird pro CPU-Kern ausgeführt. Die Ausgabe von gzip -9 werden in Ordnung gehalten und gespeichert
bigfile.gz

gzip funktioniert gut, wenn die Ausgabe angehängt wird, aber einige Verarbeitungen funktionieren nicht so -
zum Beispiel Sortieren. Für dieses GNU Parallel kann die Ausgabe jedes Befehls in eine Datei schreiben.
Dadurch wird eine große Datei parallel sortiert:

Katze große Datei | Parallel --Rohr --Dateien sortieren | Parallel -Xj1 sortieren -m {} ';' rm {}
>bigfile.sort

Hier große Datei ist in Blöcke von etwa 1 MB aufgeteilt, wobei jeder Block mit „\n“ endet (das ist der
Standard für --rezendiert). Jeder Block wird an übergeben sortieren und die Ausgabe von sortieren wird gespeichert
Dateien. Diese Dateien werden an den zweiten übergeben Parallel das läuft sortieren -m auf den Dateien vorher
es entfernt die Dateien. Die Ausgabe wird unter gespeichert bigfile.sort.

GNU Parallel's --Rohr Die maximale Geschwindigkeit liegt bei etwa 100 MB/s, da jedes Byte kopiert werden muss
durch GNU Parallel. Aber falls große Datei ist eine echte (durchsuchbare) Datei GNU Parallel umgehen kann
das Kopieren und senden Sie die Teile direkt an das Programm:

Parallel --pipepart --Block 100m -a große Datei --Dateien sortieren | Parallel -Xj1 sortieren -m {} ';' rm
{} >bigfile.sort

Beispiel: Laufen mehr als 250 Jobs & Karriere Problemumgehung

Wenn Sie eine große Anzahl von Jobs parallel ausführen müssen, werden Sie wahrscheinlich an der richtigen Stelle sein
Dateihandle-Limit, das häufig bei etwa 250 Jobs liegt. Wenn Sie Superuser sind, können Sie die erhöhen
begrenzen /etc/security/limits.conf Sie können diesen Workaround aber auch nutzen. Das Dateihandle
Das Limit gilt pro Prozess. Das heißt, wenn Sie einfach mehr GNU hervorbringen Parallels dann jeder von
Sie können 250 Jobs ausführen. Dadurch entstehen bis zu 2500 Arbeitsplätze:

Katze meine Eingabe | Parallel --Rohr -N 50 --round-robin -j50 Parallel -j50 your_prg

Dadurch werden bis zu 62500 Jobs generiert (mit Vorsicht verwenden – Sie benötigen dafür 64 GB RAM).
Möglicherweise müssen Sie erhöhen /proc/sys/kernel/pid_max):

Katze meine Eingabe | Parallel --Rohr -N 250 --round-robin -j250 Parallel -j250 your_prg

Beispiel: Arbeiten as Mutex und Zählen Semaphor

Der Befehl SEM ist ein Alias ​​für Parallel --Semaphor.

Ein Zählsemaphor ermöglicht den Start einer bestimmten Anzahl von Jobs im Hintergrund.
Wenn die Anzahl der Jobs im Hintergrund ausgeführt wird, GNU SEM Ich werde auf eines davon warten
abgeschlossen sein, bevor ein anderer Befehl gestartet wird. SEM --Warten wird warten, bis alle Jobs abgeschlossen sind
abgeschlossen.

Führen Sie 10 Jobs gleichzeitig im Hintergrund aus:

für i in *.log ; Tun
echo $ i
sem -j10 gzip $i ";" Echo fertig
erledigt
sem --warte

Ein Mutex ist ein Zählsemaphor, der nur die Ausführung eines Jobs zulässt. Dadurch wird die Datei bearbeitet
meine Datei und stellt der Datei Zeilen mit den Nummern 1 bis 3 voran.

Folge 3 | parallel sem sed -i -e 'i{}' myfile

As meine Datei kann sehr groß sein. Es ist wichtig, dass nur ein Prozess gleichzeitig die Datei bearbeitet
Zeit.

Benennen Sie das Semaphor, damit mehrere verschiedene Semaphore gleichzeitig aktiv sind:

Folge 3 | parallel sem --id mymutex sed -i -e 'i{}' meine Datei

Beispiel: Startseite Herausgeber mit Dateinamen für Standard (Standard Eingang)

Sie können GNU verwenden Parallel So starten Sie interaktive Programme wie Emacs oder VI:

Katze Dateiliste | Parallel --tty -X Emacs

Katze Dateiliste | Parallel --tty -X vi

Wenn mehr Dateien vorhanden sind, als in eine einzelne Befehlszeile passen, wird der Editor gestartet
nochmal mit den restlichen Dateien.

Beispiel: Laufen sudo

sudo erfordert ein Passwort, um einen Befehl als Root auszuführen. Der Zugriff wird zwischengespeichert, sodass Sie ihn nur benötigen
um das Passwort erneut einzugeben, wenn Sie es noch nicht verwendet haben sudo für eine Weile.

Der Befehl:

parallel sudo echo ::: Das ist eine schlechte Idee

ist nicht gut, da Sie für jeden Job nach dem Sudo-Passwort gefragt werden. Du kannst
entweder tun:

sudo echo Dies
parallel sudo echo ::: ist eine gute Idee

oder:

sudo parallel echo ::: Das ist eine gute Idee

Auf diese Weise müssen Sie das Sudo-Passwort nur einmal eingeben.

Beispiel: GNU Parallel as Warteschlange System/Charge Manager

GNU Parallel kann als einfaches Job-Warteschlangensystem oder Batch-Manager fungieren. Die Idee ist zu setzen
die Jobs in eine Datei und haben GNU Parallel lese ständig daraus. Als GNU Parallel
stoppt am Ende der von uns verwendeten Datei Schwanz um weiterzulesen:

was immer dies auch sein sollte. >Jobwarteschlange; Schwanz -n+0 -f Jobwarteschlange | Parallel

So übermitteln Sie Ihre Aufträge an die Warteschlange:

Echo mein_befehl my_arg >> Jobwarteschlange

Kann man natürlich nutzen -S Um die Jobs auf Remote-Computer zu verteilen:

was immer dies auch sein sollte. >Jobwarteschlange; Schwanz -f Jobwarteschlange | Parallel -S ..

Bei der Verwendung von GNU gibt es ein kleines Problem Parallel als Warteschlangensystem/Batch-Manager: Sie haben
Geben Sie eine bestimmte Anzahl von Aufträgen an JobSlot ein, bevor diese beginnen. Anschließend können Sie einen Auftrag einreichen
Der Job wird jeweils sofort gestartet, wenn freie Slots verfügbar sind. Ausgabe aus dem
Laufende oder abgeschlossene Aufträge werden zurückgehalten und nur gedruckt, wenn mehr Aufträge vorhanden sind
wurde gestartet (es sei denn, Sie verwenden --ungroup oder -u, in diesem Fall wird die Ausgabe der Jobs angezeigt
werden sofort ausgedruckt). Wenn Sie beispielsweise 10 Job-Slots haben, erfolgt die Ausgabe vom ersten
Der abgeschlossene Auftrag wird erst gedruckt, wenn Auftrag 11 gestartet wurde, und die Ausgabe des zweiten
Der abgeschlossene Auftrag wird erst gedruckt, wenn Auftrag 12 gestartet wurde.

So verwenden Sie --eof um GNU zu machen Parallel Ausfahrt, Schwanz muss auch zum Beenden gezwungen werden:

tail -n+0 -f command-list.txt |
(parallel --eof=EXIT {}; echo Parallel ist jetzt fertig;
(seq 1000 >> command-list.txt &);
echo Fertig, Anhängen von Dummy-Daten, wodurch Tail zum Beenden gezwungen wird)

Beispiel: GNU Parallel as dir Prozessor

Wenn Sie ein Verzeichnis haben, in dem Benutzer Dateien ablegen, die verarbeitet werden müssen, können Sie dies tun
GNU/Linux (Wenn Sie wissen was innotifywait wird auf anderen Plattformen aufgerufen, einen Fehlerbericht einzureichen):

innotifywait -q -m -r -e UMGEZOGEN NACH -e CLOSE_WRITE --Format %w%f mein_dir | Parallel -u Echo

Dadurch wird der Befehl ausgeführt Echo für jede abgelegte Datei mein_dir oder Unterverzeichnisse von mein_dir.

Kann man natürlich nutzen -S Um die Jobs auf Remote-Computer zu verteilen:

innotifywait -q -m -r -e UMGEZOGEN NACH -e CLOSE_WRITE --Format %w%f mein_dir | Parallel -S .. -u
Echo

Wenn sich die zu verarbeitenden Dateien in einer TAR-Datei befinden, entpacken Sie eine Datei und verarbeiten Sie sie
Das sofortige Entpacken ist möglicherweise schneller als das erste Entpacken aller Dateien. Richten Sie den Dir-Prozessor ein als
oben und in das Verzeichnis entpacken.

Die Verwendung von GNU Parallel als Dir-Prozessor unterliegt denselben Einschränkungen wie die Verwendung von GNU Parallel als
Warteschlangensystem/Batch-Manager.

ZITIEREN

GNU Parallel ist sehr großzügig im Zitieren. Sie müssen nur Zeichen in Anführungszeichen setzen, die Folgendes haben
besondere Bedeutung in Shell:

( ) $ ` ' " < > ; | \

und je nach Kontext müssen diese auch zitiert werden:

~ & # ! ? Raum * {

Daher werden die meisten Menschen nie mehr Anführungszeichen benötigen, als „\“ vor das zu setzen
spezielle Charaktere.

Oftmals kann man einfach \' um jedes ' setzen:

perl -ne '/^\S+\s+\S+$/ und drucken Sie die Datei $ARGV,"\n"'

kann zitiert werden:

parallel perl -ne \''/^\S+\s+\S+$/ und drucken Sie die Datei $ARGV,"\n"'\' :::

Wenn Sie jedoch eine Shell-Variable verwenden möchten, müssen Sie das $-Zeichen in Anführungszeichen setzen. Hier ist ein
Beispiel mit $PARALLEL_SEQ. Diese Variable wird von GNU festgelegt Parallel sich selbst, also die
Die Auswertung des $ muss durch die von GNU gestartete Sub-Shell erfolgen Parallel:

ff 10 | Parallel -N2 Echo seq:\$PARALLEL_SEQ arg1:{1} arg2:{2}

Wenn die Variable vor GNU gesetzt ist Parallel beginnt, können Sie Folgendes tun:

VAR=this_is_set_before_starting

Echo Test | Parallel Echo {} $var

Drucke: Test this_is_set_before_starting

Etwas kniffliger wird es, wenn die Variable mehr als ein Leerzeichen hintereinander enthält:

VAR="zwei Räume zwischen jeder Wort"

Echo Test | Parallel Echo {} \'"$VAR"\'

Drucke: Test XNUMX Räume zwischen jeder Wort

Wenn die Variable nicht von der Shell ausgewertet werden soll, die GNU startet Parallel aber sei
ausgewertet von der von GNU gestarteten Sub-Shell Parallel, dann müssen Sie es zitieren:

Echo Test | Parallel VAR=this_is_set_after_starting \; Echo {} \$VAR

Drucke: Test this_is_set_after_starting

Etwas kniffliger ist es, wenn die Variable Leerzeichen enthält:

Echo Test | Parallel VAR='"zwei Räume zwischen jeder Wort"' Echo {} \'"$VAR"\'

Drucke: Test XNUMX Räume zwischen jeder Wort

$$ ist die Shell-Variable, die die Prozess-ID der Shell enthält. Dadurch wird das gedruckt
Prozess-ID der Shell, auf der GNU ausgeführt wird Parallel:

ff 10 | Parallel Echo $$

Dadurch werden die Prozess-IDs der von GNU gestarteten Sub-Shells gedruckt Parallel.

ff 10 | Parallel Echo \$\$

Wenn die Sonderzeichen nicht von der Sub-Shell ausgewertet werden sollen, müssen Sie dies tun
Schützen Sie es vor der Auswertung durch die Shell, die GNU startet Parallel und die Sub-Shell:

Echo Test | Parallel Echo {} \\\$VAR

Drucke: Test $var

GNU Parallel kann mit -q vor der Auswertung durch die Sub-Shell schützen:

Echo Test | Parallel -q Echo {} \$VAR

Drucke: Test $var

Dies ist besonders nützlich, wenn Sie viele Zitate haben. Wenn Sie ein Perl-Skript ausführen möchten
so was:

perl -ne '/^\S+\s+\S+$/ und drucken $ARGV,"\n"' Datei

Es muss wie folgt zitiert werden:

ls | Parallel perl -ne '/^\\S+\\s+\\S+\$/\ Und\ drucken\ \$ARGV,\"\\n\"' ls | Parallel perl
-ne \''/^\S+\s+\S+$/ und drucken $ARGV,"\n"'\'

Beachten Sie, dass Leerzeichen, „\“, „“ und „$“ in Anführungszeichen gesetzt werden müssen. GNU Parallel kann das Zitieren von erledigen
mit der Option -q:

ls | Parallel -q perl -ne '/^\S+\s+\S+$/ und drucken $ARGV,"\n"'

Dies bedeutet jedoch, dass Sie die Sub-Shell nicht dazu veranlassen können, Sonderzeichen zu interpretieren. Für
Beispiel wegen -q das wird NICHT FUNKTIONIEREN:

ls *.gz | Parallel -q „zcat {} >{.}"

ls *.gz | Parallel -q „zcat {} | bzip2 >{.}.bz2"

weil > und | müssen von der Sub-Shell interpretiert werden.

Wenn Sie Fehler erhalten wie:

sh: -c: Zeile 0: Syntaxfehler in der Nähe des unerwarteten Tokens
sh: Syntaxfehler: Nicht abgeschlossene Zeichenfolge in Anführungszeichen
sh: -c: Zeile 0: unerwartetes EOF bei der Suche nach passendem „“
sh: -c: Zeile 1: Syntaxfehler: Unerwartetes Ende der Datei

Dann könnten Sie es versuchen -q.

Wenn Sie bash Prozesssubstitution wie <(Kat foo) dann kannst du es vielleicht versuchen -q und
voranstellen Befehl mit bash -c:

ls | Parallel -q bash -c 'Toilette -c <(Echo {})'

Oder zum Ersetzen der Ausgabe:

ls | Parallel -q bash -c 'Teer c {} | Abschlag >(gzip >{}.tar.gz) | bzip2 >{}.tar.bz2'

Schlussfolgerung: Um die Zitierprobleme zu vermeiden, ist es möglicherweise einfacher, einfach eine zu schreiben
kleines Skript oder eine Funktion (denken Sie daran). exportieren -f die Funktion) und GNU haben Parallel rufen Sie uns an!
Das.

LISTE LAUFEN JOBS

Wenn Sie eine Liste der aktuell ausgeführten Jobs wünschen, können Sie Folgendes ausführen:

alle töten -USR1 Parallel

GNU Parallel druckt dann die aktuell ausgeführten Jobs auf stderr (Standardfehler).

KOMPLETT LAUFEN JOBS ABER DO NICHT Starte das Spiel NEUEN! JOBS

Wenn Sie es bereuen, viele Jobs begonnen zu haben, können Sie GNU einfach kaputt machen Parallel, aber wenn du willst
Stellen Sie sicher, dass Sie keine halbfertigen Aufträge haben, Sie sollten das Signal senden ZIELLAUFZEIT zu GNU
Parallel:

alle töten -BEGRIFF Parallel

Dies wird GNU mitteilen Parallel keine neuen Jobs starten, sondern bis zum aktuellen warten
Laufende Jobs werden vor dem Beenden beendet.

VARIABLEN

$PARALLEL_PID
Die Umgebungsvariable $PARALLEL_PID wird von GNU gesetzt Parallel und ist für sichtbar
Die Jobs wurden von GNU gestartet Parallel. Dies ermöglicht es den Arbeitsplätzen
direkt mit GNU kommunizieren Parallel. Denken Sie daran, das $ anzugeben, damit es funktioniert
von der richtigen Shell ausgewertet.

Ejemplo: Wenn jeder der Jobs eine Lösung testet und einer der Jobs die Lösung findet
Der Job kann GNU sagen Parallel nicht noch mehr Jobs anzufangen durch: töten -BEGRIFF
$PARALLEL_PID. Dies funktioniert nur auf dem lokalen Computer.

$PARALLEL_SHELL (Alpha-Test)
Verwenden Sie diese Shell, die Shell für die von GNU Parallel ausgeführten Befehle:

· $PARALLEL_SHELL. Wenn nicht definiert, verwenden Sie:

· Die Shell, die GNU Parallel gestartet hat. Wenn das nicht festgestellt werden kann:

· $SHELL. Wenn nicht definiert, verwenden Sie:

· / Bin / sh

$PARALLEL_SEQ
$PARALLEL_SEQ wird auf die Sequenznummer des laufenden Jobs gesetzt. Erinnere dich an
Setzen Sie das $ in Anführungszeichen, damit es von der richtigen Shell ausgewertet wird.

Ejemplo:

ff 10 | Parallel -N2 Echo seq:'$'PARALLEL_SEQ arg1:{1} arg2:{2}

$TMPDIR Verzeichnis für temporäre Dateien. Sehen: --tmpdir.

$PARALLEL
Die Umgebungsvariable $PARALLEL wird als Standardoption für GNU verwendet
Parallel. Wenn die Variable spezielle Shell-Zeichen enthält (z. B. $, * oder Leerzeichen)
dann müssen diese mit \ maskiert werden.

Ejemplo:

Katze Liste | Parallel -j1 -k -v ls

kann geschrieben werden als:

Katze Liste | PARALLEL="-kvj1" Parallel ls

Katze Liste | Parallel -j1 -k -v -S"myssh Benutzer@Server" ls

kann geschrieben werden als:

Katze Liste | PARALLEL='-kvj1 -S myssh\ Benutzer@Server' Parallel Echo

Beachten Sie, dass das \ in der Mitte benötigt wird, da „myssh“ und „user@server“ vorhanden sein müssen
ein Argument.

DEFAULT PROFIL (KONFIG DATEI)

Die globale Konfigurationsdatei /etc/parallel/config, gefolgt von der Benutzerkonfigurationsdatei
~/.parallel/config (früher bekannt als .parallelrc) werden der Reihe nach gelesen, wenn sie vorhanden sind.
Zeilen, die mit „#“ beginnen, werden ignoriert. Das Format kann dem der Umgebung folgen
Variable $PARALLEL, aber es ist oft einfacher, jede Option einfach in eine eigene Zeile zu setzen.

Optionen in der Befehlszeile haben Vorrang, gefolgt von der Umgebungsvariablen
$PARALLEL, Benutzerkonfigurationsdatei ~/.parallel/configund schließlich das Globale
Konfigurationsdatei /etc/parallel/config.

Beachten Sie, dass keine Datei, die für Optionen gelesen wird, noch die Umgebungsvariable $PARALLEL darf
enthalten ausgemusterte Optionen wie z --tollef.

PROFIL DATEIEN

If --Profil eingestellt, GNU Parallel liest das Profil aus dieser Datei und nicht aus dem globalen
oder Benutzerkonfigurationsdateien. Sie können mehrere haben --profile.

Beispiel: Profil zum Ausführen eines Befehls bei jedem SSH-Login ~/.ssh/sshlogins und voranstellen
die Ausgabe mit dem sshlogin:

echo --tag -S .. --nonall > ~/.parallel/n
parallel -Jn Betriebszeit

Beispiel: Profil zum Ausführen jedes Befehls mit -j-1 und schön

echo -j-1 schön > ~/.parallel/nice_profile
parallel -J nice_profile bzip2 -9 ::: *

Beispiel: Profil zum Ausführen eines Perl-Skripts vor jedem Befehl:

echo "perl -e '\$a=\$\$; print \$a,\" \",'\$PARALLEL_SEQ',\" \";';" > ~/.parallel/pre_perl
parallel -J pre_perl echo ::: *

Beachten Sie, dass $ und „ mit \ in Anführungszeichen gesetzt werden müssen.

Beispiel: Profil zum Ausführen verteilter Jobs mit schön auf den Remote-Computern:

echo -S .. nett > ~/.parallel/dist
parallel -J dist --trc {.}.bz2 bzip2 -9 ::: *

EXIT STATUS

If --halt-on-error 0 oder nicht angegeben:

0 Alle Jobs liefen ohne Fehler.

1-253 Einige der Jobs sind fehlgeschlagen. Der Exit-Status gibt die Anzahl der fehlgeschlagenen Jobs an

254 Mehr als 253 Jobs scheiterten.

255 Anderer Fehler.

If --halt-on-error 1 oder 2: Exit-Status des fehlgeschlagenen Jobs.

UNTERSCHIEDE ZWISCHEN GNU Parallel UND ALTERNATIVEN

Es gibt viele Programme mit einigen Funktionen von GNU Parallel. GNU Parallel
ist bestrebt, die beste Funktionalität zu bieten, ohne auf Benutzerfreundlichkeit zu verzichten.

ZUSAMMENFASSUNG TABELLE
Die folgenden Funktionen sind in einigen der vergleichbaren Tools enthalten:

Eingänge
I1. Argumente können von stdin gelesen werden
I2. Argumente können aus einer Datei gelesen werden
I3. Argumente können aus mehreren Dateien gelesen werden
I4. Argumente können über die Befehlszeile gelesen werden
I5. Argumente können aus einer Tabelle gelesen werden
I6. Argumente können mit # aus derselben Datei gelesen werden! (shebang)
I7. Standardmäßig zeilenorientierte Eingabe (Anführungszeichen von Sonderzeichen nicht erforderlich)

Manipulation von Eingaben
M1. Komponierter Befehl
M2. Mehrere Argumente können eine Ausführungszeile füllen
M3. Argumente können an einer beliebigen Stelle in der Ausführungszeile platziert werden
M4. Mehrere Argumente können an einer beliebigen Stelle in der Ausführungszeile platziert werden
M5. Argumente können durch Kontext ersetzt werden
M6. Die Eingabe kann als vollständige Ausführungszeile behandelt werden

Ausgänge
O1. Gruppieren Sie die Ausgabe, damit sich die Ausgabe verschiedener Jobs nicht vermischt
O2. Senden Sie stderr (Standardfehler) an stderr (Standardfehler)
O3. Senden Sie stdout (Standardausgabe) an stdout (Standardausgabe)
O4. Die Reihenfolge der Ausgabe kann mit der Reihenfolge der Eingabe übereinstimmen
O5. Stdout enthält nur stdout (Standardausgabe) des Befehls
O6. Stderr enthält nur stderr (Standardfehler) aus dem Befehl

Ausführung
E1. Parallele Ausführung von Jobs
E2. Laufende Jobs auflisten
E3. Beenden Sie laufende Jobs, starten Sie jedoch keine neuen Jobs
E4. Die Anzahl der ausgeführten Jobs kann von der Anzahl der CPUs abhängen
E5. Beenden Sie laufende Jobs, aber starten Sie nach dem ersten Fehler keine neuen Jobs
E6. Die Anzahl der laufenden Jobs kann während der Ausführung angepasst werden

Remote-Ausführung
R1. Jobs können auf Remote-Computern ausgeführt werden
R2. Basefiles können übertragen werden
R3. Argumentdateien können übertragen werden
R4. Ergebnisdateien können übertragen werden
R5. Bereinigung der übertragenen Dateien
R6. Keine Konfigurationsdateien erforderlich
R7. Führen Sie nicht mehr aus, als die MaxStartups von SSHD bewältigen können
R8. Konfigurierbarer SSH-Befehl
R9. Versuchen Sie es erneut, wenn die Verbindung gelegentlich unterbrochen wird

Semaphor
S1. Möglichkeit, als Mutex zu arbeiten
S2. Möglichkeit, als Zählsemaphor zu arbeiten

Legend
- = nein
x = nicht anwendbar
ID = ja

Da nicht jede neue Version der Programme getestet wird, ist die Tabelle möglicherweise veraltet. Bitte einreichen
einen Fehlerbericht, wenn Sie Fehler finden (siehe FEHLER MELDEN).

parallel: I1 I2 I3 I4 I5 I6 I7 M1 M2 M3 M4 M5 M6 O1 O2 O3 O4 O5 O6 E1 E2 E3 E4 E5 E6 R1 R2
R3 R4 R5 R6 R7 R8 R9 S1 S2

xargs: I1 I2 - - - - - - M2 M3 - - - - O2 O3 - O5 O6 E1 - - - - - - - - -
- X - - - - -

find -exec: - - - x - x - - M2 M3 - - - - - O2 O3 O4 O5 O6 - - - - - - -
- - - - - - - - - xx

make -j: - - - - - - - - - - - - - O1 O2 O3 - x O6 E1 - - - E5 - - - -
- - - - - - - -

ppss: I1 I2 - - - - I7 M1 - M3 - - M6 O1 - - x - - E1 E2 ?E3 E4 - - R1 R2 R3 R4
- - ?R7 ? ? - -

pexec: I1 I2 - I4 I5 - - M1 - M3 - - M6 O1 O2 O3 - O5 O6 E1 - - E4 - E6 R1 - -
- - R6 - - - S1 -

xjobs: TODO – Bitte reichen Sie einen Fehlerbericht ein, wenn Sie wissen, welche Funktionen xjobs unterstützt (siehe
FEHLER MELDEN).

prll: TODO – Bitte reichen Sie einen Fehlerbericht ein, wenn Sie wissen, welche Funktionen prll unterstützt (siehe
FEHLER MELDEN).

dxargs: TODO – Bitte reichen Sie einen Fehlerbericht ein, wenn Sie wissen, welche Funktionen dxargs unterstützt (siehe
FEHLER MELDEN).

mdm/middelman: TODO – Bitte reichen Sie einen Fehlerbericht ein, wenn Sie wissen, welche Funktionen mdm/middelman bietet
unterstützt (siehe FEHLERMELDUNG).

xapply: TODO – Bitte reichen Sie einen Fehlerbericht ein, wenn Sie wissen, welche Funktionen xapply unterstützt (siehe
FEHLER MELDEN).

paexec: TODO – Bitte reichen Sie einen Fehlerbericht ein, wenn Sie wissen, welche Funktionen paexec unterstützt (siehe
FEHLER MELDEN).

ladon: TODO – Bitte reichen Sie einen Fehlerbericht ein, wenn Sie wissen, welche Funktionen Ladon unterstützt (siehe
FEHLER MELDEN).

ClusterSSH: TODO – Bitte reichen Sie einen Fehlerbericht ein, wenn Sie wissen, welche Funktionen ClusterSSH unterstützt
(Siehe FEHLERMELDUNG).

UNTERSCHIEDE ZWISCHEN xargs UND GNU Parallel
xargs bietet einige der gleichen Möglichkeiten wie GNU Parallel.

xargs Kommt schlecht mit Sonderzeichen (wie Leerzeichen, ' und ") zurecht. Um das Problem zu sehen, versuchen Sie es
Dies:

Berühren Sie „wichtige_Datei“.
Tippen Sie auf „nicht wichtige_Datei“.
ls nicht* | xargs rm
mkdir -p „Die 12 Datensätze meines Bruders“
ls | xargs rmdir

Sie können angeben -0 or -d "\n", aber viele Eingabegeneratoren sind nicht für die Verwendung optimiert NUL
als Trennzeichen, sind aber dafür optimiert Neue Zeile als Trennzeichen. Z.B ganzer, Schwanz, awk, ls, Echo,
Durst, Teer -v, perl (-0 und \0 statt \n), lokalisieren (erfordert die Verwendung von -0), gefunden (erfordert
Verwendung von -print0), grep (Erfordert die Verwendung durch den Benutzer -z or -Z), sortieren (erfordert die Verwendung von -z).

Also GNU ParallelDie Zeilenumbruchtrennung von kann emuliert werden mit:

Katze | xargs -d "\n" -n1 Befehl

xargs kann eine bestimmte Anzahl von Jobs parallel ausführen, bietet jedoch keine Unterstützung für die Ausführung mehrerer Jobs.
of-cpu-cores-Jobs parallel ausführen.

xargs bietet keine Unterstützung für die Gruppierung der Ausgabe, daher kann die Ausgabe zusammen laufen, z. B. die
Die erste Hälfte einer Zeile stammt von einem Prozess und die letzte Hälfte der Zeile stammt von einem anderen
Verfahren. Das Beispiel Parallel grep lässt sich damit nicht zuverlässig bewerkstelligen xargs aus diesem Grund. Zu
Sehen Sie sich dies in Aktion an. Versuchen Sie:

parallel perl -e '\$a=\"1{}\"x10000000\;print\ \$a,\"\\n\"' '>' {} ::: abcdef
ls -labcdef
parallel -kP4 -n1 grep 1 > out.par ::: abcdef
echo abcdef | xargs -P4 -n1 grep 1 > out.xargs-unbuf
echo abcdef | xargs -P4 -n1 grep --line-buffered 1 > out.xargs-linebuf
echo abcdef | xargs -n1 grep 1 > out.xargs-serial
ls -l raus*
md5sum out*

xargs bietet keine Unterstützung für die Beibehaltung der Ausgabereihenfolge, daher beim Ausführen von Jobs
parallele Nutzung xargs Die Ausgabe des zweiten Jobs kann nicht auf den ersten Job verschoben werden
erledigt.

xargs bietet keine Unterstützung für die Ausführung von Jobs auf Remotecomputern.

xargs unterstützt keine Kontextersetzung, daher müssen Sie die Argumente erstellen.

Wenn Sie eine Ersetzungszeichenfolge verwenden xargs (-I) kann man nicht erzwingen xargs mehr als eine verwenden
Argument.

Zitieren in xargs funktioniert wie -q in GNU Parallel. Dies bedeutet zusammengesetzte Befehle und
Umleitung erfordert Verwendung bash -c.

ls | Parallel "Toilette {} > {}.Toilette"

wird (vorausgesetzt, Sie haben 8 Kerne)

ls | xargs -d "\n" -P8 -I {} bash -c "Toilette {} > {}.Toilette"

und

ls | Parallel "Echo {}; ls {}|wc"

wird (vorausgesetzt, Sie haben 8 Kerne)

ls | xargs -d "\n" -P8 -I {} bash -c "Echo {}; ls {}|wc"

UNTERSCHIEDE ZWISCHEN gefunden -Exec UND GNU Parallel
gefunden -Exec bieten einige der gleichen Möglichkeiten wie GNU Parallel.

gefunden -Exec Funktioniert nur bei Dateien. Dies gilt auch für die Verarbeitung anderer Eingaben (z. B. Hosts oder URLs).
erfordern die Erstellung dieser Eingaben als Dateien. gefunden -Exec bietet keine Unterstützung für die Ausführung von Befehlen in
parallel.

UNTERSCHIEDE ZWISCHEN um -j UND GNU Parallel
um -j kann Jobs parallel ausführen, erfordert hierfür jedoch ein gestaltetes Makefile. Das ergibt
in zusätzlichen Anführungszeichen, damit der Dateiname mit Zeilenumbruch korrekt funktioniert.

um -j unterstützt keine Gruppierung der Ausgabe, daher kann die Ausgabe zusammen laufen, z
Die erste Hälfte einer Zeile stammt von einem Prozess und die letzte Hälfte der Zeile stammt von einem anderen
Verfahren. Das Beispiel Parallel grep lässt sich damit nicht zuverlässig bewerkstelligen um -j deswegen.

(Sehr frühe Versionen von GNU Parallel wurden zufällig mit implementiert um -j).

UNTERSCHIEDE ZWISCHEN pss UND GNU Parallel
pss ist auch ein Tool zum parallelen Ausführen von Jobs.

Die Ausgabe von pss ist eine Statusinformation und eignet sich daher nicht als Eingabe für
ein weiterer Befehl. Die Ergebnisse der Jobs werden in Dateien abgelegt.

Der Argument-Ersetzungsstring ($ITEM) kann nicht geändert werden. Argumente müssen zitiert werden – also
Argumente, die Sonderzeichen (Leerzeichen '"&!*) enthalten, können Probleme verursachen. Mehr als eines
Argument wird nicht unterstützt. Dateinamen mit Zeilenumbrüchen werden nicht korrekt verarbeitet.
Beim Lesen von Eingaben aus einer Datei kann null nicht als Abschlusszeichen verwendet werden. pss muss das lesen
Überprüfen Sie die gesamte Eingabedatei, bevor Sie einen Auftrag starten.

Ausgabe- und Statusinformationen werden im ppss_dir gespeichert und müssen daher bereinigt werden, wenn
vollendet. Wenn das Verzeichnis vor der Ausführung nicht entfernt wird pss Auch hier kann es zu nichts führen
passieren als pss denkt, die Aufgabe sei bereits erledigt. GNU Parallel wird normalerweise nicht benötigt
Bereinigt, wenn es lokal ausgeführt wird, und muss nur bereinigt werden, wenn es abnormal gestoppt wird und
Remote ausführen (--Aufräumen wird möglicherweise nicht abgeschlossen, wenn er abnormal gestoppt wird. Das Beispiel Parallel
grep würde eine zusätzliche Nachbearbeitung erfordern, wenn es mit geschrieben würde pss.

Für Remote-Systeme erfordert PPSS drei Schritte: Konfigurieren, Bereitstellen und Starten. GNU Parallel einzige
erfordert einen Schritt.

Beispiele: AB pss MANUELL

Hier sind die Beispiele von pss's Handbuchseite mit dem Äquivalent unter Verwendung von GNU Parallel:

1 ./ppss.sh standalone -d /path/to/files -c 'gzip '

1 finde /path/to/files -type f | paralleles gzip

2 ./ppss.sh standalone -d /path/to/files -c 'cp "$ITEM" /destination/dir '

2 finde /path/to/files -type f | parallel cp {} /destination/dir

3 ./ppss.sh standalone -f list-of-urls.txt -c 'wget -q '

3 parallel -a list-of-urls.txt wget -q

4 ./ppss.sh standalone -f list-of-urls.txt -c 'wget -q "$ITEM"'

4 parallel -a list-of-urls.txt wget -q {}

5 ./ppss config -C config.cfg -c 'encode.sh ' -d /source/dir -m 192.168.1.100 -u ppss -k
ppss-key.key -S ./encode.sh -n nodes.txt -o /some/output/dir --upload --download ; ./ppss
Deploy -C config.cfg ; ./ppss start -C config

5 # Parallel verwendet keine Konfigurationen. Wenn Sie einen anderen Benutzernamen wünschen, geben Sie ihn in nodes.txt ein:
Benutzer@Hostname

5 finde Quelle/Verzeichnis -Typ f | parallel --sshloginfile nodes.txt --trc {.}.mp3 lame -a {} -o
{.}.mp3 --preset standard --quiet

6 ./ppss stop -C config.cfg

6 killall -TERM parallel

7 ./ppss pause -C config.cfg

7 Drücken Sie: STRG-Z oder killall -SIGTSTP parallel

8 ./ppss continue -C config.cfg

8 Geben Sie ein: fg oder killall -SIGCONT parallel

9 ./ppss.sh status -C config.cfg

9 killall -SIGUSR2 parallel

UNTERSCHIEDE ZWISCHEN pexec UND GNU Parallel
pexec ist auch ein Tool zum parallelen Ausführen von Jobs.

Beispiele: AB pexec MANUELL

Hier sind die Beispiele von pexec's Infoseite mit dem Äquivalent unter Verwendung von GNU Parallel:

1 pexec -o sqrt-%s.dat -p "$(seq 10)" -e NUM -n 4 -c -- \
'echo "scale=10000;sqrt($NUM)" | v. Chr.

1 Folge 10 | parallel -j4 'echo "scale=10000;sqrt({})" | bc > sqrt-{}.dat'

2 pexec -p "$(ls myfiles*.ext)" -i %s -o %s.sort -- sort

2 ls myfiles*.ext | parallele Sortierung {} ">{}.sort"

3 pexec -f image.list -n auto -e B -u star.log -c -- \
'fistar $B.fits -f 100 -F id,x,y,flux -o $B.star'

3 parallel -a image.list \
'fistar {}.fits -f 100 -F id,x,y,flux -o {}.star' 2>star.log

4 pexec -r *.png -e IMG -c -o - -- \
'konvertiere $IMG ${IMG%.png}.jpeg ; „echo $IMG: erledigt“‘

4 ls *.png | parallel 'convert {} {.}.jpeg; echo {}: erledigt'

5 pexec -r *.png -i %s -o %s.jpg -c 'pngtopnm | pnmtojpeg'

5 ls *.png | parallel 'pngtopnm < {} | pnmtojpeg > {}.jpg'

6 für p in *.png ; echo ${p%.png} ; erledigt | \
pexec -f - -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'

6 ls *.png | parallel 'pngtopnm < {} | pnmtojpeg > {.}.jpg'

7 LIST=$(for p in *.png ; echo ${p%.png} ; done)
pexec -r $LIST -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'

7 ls *.png | parallel 'pngtopnm < {} | pnmtojpeg > {.}.jpg'

8 pexec -n 8 -r *.jpg -y unix -e IMG -c \
'pexec -j -m blockread -d $IMG | \
jpegtopnm | pnmscale 0.5 | pnmtojpeg | \
pexec -j -m blockwrite -s th_$IMG'

8 GNU kombinieren Parallel und GNU SEM.

8 ls *jpg | parallel -j8 'sem --id blockread cat {} | jpegtopnm |' \
'pnmscale 0.5 | pnmtojpeg | sem --id blockwrite cat > th_{}'

8 Wenn das Lesen und Schreiben auf derselben Festplatte erfolgt, ist dies möglicherweise schneller als nur ein Vorgang
wird entweder lesen oder schreiben:

8 ls *jpg | parallel -j8 'sem --id diskio cat {} | jpegtopnm |' \
'pnmscale 0.5 | pnmtojpeg | sem --id diskio cat > th_{}'

UNTERSCHIEDE ZWISCHEN xjobs UND GNU Parallel
xjobs ist auch ein Tool zum parallelen Ausführen von Jobs. Es unterstützt nur die Ausführung von Jobs auf Ihrem
lokalen Computer.

xjobs geht genauso schlecht mit Sonderzeichen um xargs. Siehe Abschnitt UNTERSCHIEDE
ZWISCHEN xargs UND GNU Parallel.

Hier sind die Beispiele von xjobs's Manpage mit dem Äquivalent unter Verwendung von GNU Parallel:

1 ls -1 *.zip | xjobs entpacken

1 ls *.zip | parallel entpacken

2 ls -1 *.zip | xjobs -n entpacken

2 ls *.zip | parallel entpacken >/dev/null

3 finden . -name '*.bak' | xjobs gzip

3 finden . -name '*.bak' | paralleles gzip

4 ls -1 *.jar | sed 's/\(.*\)/\1 > \1.idx/' | xjobs jar tf

4 ls *.jar | parallel jar tf {} '>' {}.idx

5 xjobs -s-Skript

5 Katzenskript | parallel

6 mkfifo /var/run/my_named_pipe; xjobs -s /var/run/my_named_pipe & echo unzip 1.zip >>
/var/run/my_named_pipe; echo tar cf /backup/myhome.tar /home/me >> /var/run/my_named_pipe

6 mkfifo /var/run/my_named_pipe; cat /var/run/my_named_pipe | Parallel & Echo entpacken 1.zip
>> /var/run/my_named_pipe; echo tar cf /backup/myhome.tar /home/me >>
/var/run/my_named_pipe

UNTERSCHIEDE ZWISCHEN prll UND GNU Parallel
prll ist auch ein Tool zum parallelen Ausführen von Jobs. Das Ausführen von Jobs wird nicht unterstützt
Remote-Computer.

prll empfiehlt die Verwendung von BASH-Aliassen und BASH-Funktionen anstelle von Skripten. GNU Parallel
wird niemals die Ausführung von Aliasen unterstützen (siehe warum).
http://www.perlmonks.org/index.pl?node_id=484296). Allerdings können Skripte, zusammengesetzte Befehle oder
Funktionen exportiert mit exportieren -f funktioniert gut.

prll generiert viele Statusinformationen zu stderr (Standardfehler), die es ermöglichen
Es ist schwieriger, die stderr-Ausgabe (Standardfehler) des Jobs direkt als Eingabe für einen anderen Job zu verwenden


Hier ist das Beispiel von prll's Manpage mit dem Äquivalent unter Verwendung von GNU Parallel:

prll -s 'mogrify -flip $1' *.jpg

parallel mogrify -flip ::: *.jpg

UNTERSCHIEDE ZWISCHEN dxargs UND GNU Parallel
dxargs ist auch ein Tool zum parallelen Ausführen von Jobs.

dxargs kommt mit mehr gleichzeitigen Jobs nicht gut zurecht als SSHDs MaxStartups. dxargs is
Nur für Remote-Run-Jobs konzipiert, unterstützt jedoch nicht die Übertragung von Dateien.

UNTERSCHIEDE ZWISCHEN mdm/Mittelsmann UND GNU Parallel
Mittelsmann(mdm) ist auch ein Tool zum parallelen Ausführen von Jobs.

Hier sind die Shellscripts von http://mdm.berlios.de/usage.html auf GNU portiert Parallel:

ff 19 | Parallel buffon -o - | sortieren -n > Folge

Katze Dateien | Parallel cmd

gefunden dir -execdir SEM cmd {} \;

UNTERSCHIEDE ZWISCHEN xapply UND GNU Parallel
xapply kann Jobs parallel auf dem lokalen Computer ausführen.

Hier sind die Beispiele von xapply's Manpage mit dem Äquivalent unter Verwendung von GNU Parallel:

1 xapply '(cd %1 && make all)' */

1 parallel 'cd {} && make all' ::: */

2 xapply -f 'diff %1 ../version5/%1' manifest | mehr

2 parallel diff {} ../version5/{} < manifest | mehr

3 xapply -p/dev/null -f 'diff %1 %2' manifest1 checklist1

3 parallel --xapply diff {1} {2} :::: manifest1 checklist1

4 xapply 'indent' *.c

4 paralleler Einzug ::: *.c

5 finde ~ksb/bin -type f ! -perm -111 -print | xapply -f -v 'chmod a+x' -

5 finde ~ksb/bin -type f ! -perm -111 -print | parallel -v chmod a+x

6 find */ -... | fmt 960 1024 | xapply -f -i /dev/tty 'vi' -

6 sh <(find */ -... | parallel -s 1024 echo vi)

6 find */ -... | parallel -s 1024 -Xuj1 vi

7 finden ... | xapply -f -5 -i /dev/tty 'vi' - - - - -

7 sh <(find ... |parallel -n5 echo vi)

7 find ... |parallel -n5 -uj1 vi

8 xapply -fn "" / etc / passwd

8 parallel -k echo / etc / passwd

9 tr ':' '\012' / etc / passwd | xapply -7 -nf 'chown %1 %6' - - - - - - -

9 tr ':' '\012' / etc / passwd | parallel -N7 chown {1} {6}

10 xapply '[ -d %1/RCS ] || echo %1' */

10 parallel '[ -d {}/RCS ] || echo {}' ::: */

11 xapply -f '[ -f %1 ] && echo %1' Liste | ...

11 parallel '[ -f {} ] && echo {}' < Liste | ...

UNTERSCHIEDE ZWISCHEN paexec UND GNU Parallel
paexec kann Jobs parallel auf dem lokalen und dem Remote-Computer ausführen.

paexec erfordert Befehle, um als letzte Ausgabe eine Leerzeile auszugeben. Das bedeutet, dass Sie es tun werden
Für die meisten Programme muss ein Wrapper geschrieben werden.

paexec verfügt über eine Job-Abhängigkeitsfunktion, sodass ein Job von der Ausführung eines anderen Jobs abhängen kann
erfolgreich. Irgendwie ein armer Mann um.

Hier sind die Beispiele von paexecBeispielkatalog mit dem Äquivalent unter Verwendung von GNU
Parallel:

1_div_X_run:
../../paexec -s -l -c "`pwd`/1_div_X_cmd" -n +1 <
paralleles Echo {} '|' `pwd`/1_div_X_cmd <

all_substr_run:
../../paexec -lp -c "`pwd`/all_substr_cmd" -n +3 <
paralleles Echo {} '|' `pwd`/all_substr_cmd <

cc_wrapper_run:
../../paexec -c "env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd" \
-n 'host1 host2' \
-T '/usr/bin/ssh -x' <
paralleles Echo {} '|' "env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd" \
-S host1,host2 <
# Dies ist nicht genau dasselbe, vermeidet jedoch den Wrapper
parallel gcc -O2 -c -o {.}.o {} \
-S host1,host2 <

toupper_run:
../../paexec -lp -c "`pwd`/toupper_cmd" -n +10 <
paralleles Echo {} '|' ./toupper_cmd <
# Ohne den Wrapper:
paralleles Echo {} '| awk {print\ toupper\(\$0\)}' <

UNTERSCHIEDE ZWISCHEN Karte UND GNU Parallel
Karte sieht es als eine Funktion an, weniger Funktionen zu haben und behandelt dabei auch Ecken
Fälle falsch. Viel GNU ParallelDer Code von besteht darin, Eckfälle korrekt zu behandeln
Auf jeder Plattform ist dies möglich, sodass Sie keine böse Überraschung erleben, wenn ein Benutzer beispielsweise eine Datei speichert
namens: My Brüder 12" Records.txt

KarteDas Beispiel, das den Umgang mit Sonderzeichen zeigt, schlägt bei Sonderzeichen fehl:

echo „The Cure“ > Die 12 Aufzeichnungen meines Bruders

ls | map 'echo -n `gzip < "%" | wc -c`; echo -n '*100/'; wc -c < "%"' | v. Chr

Es funktioniert mit GNU Parallel:

ls | parallel 'echo -n `gzip < {} | wc -c`; echo -n '*100/'; wc -c < {}' | v. Chr

Und Sie können sogar den Dateinamen voranstellen lassen:

ls | parallel --tag '(echo -n `gzip < {} | wc -c`'*100/'; wc -c < {}) | v. Chr.

Karte hat keine Unterstützung für die Gruppierung. Dies führt also ohne Warnung zu falschen Ergebnissen:

parallel perl -e '\$a=\"1{}\"x10000000\;print\ \$a,\"\\n\"' '>' {} ::: abcdef
ls -labcdef
parallel -kP4 -n1 grep 1 > out.par ::: abcdef
map -p 4 'grep 1' abcdef > out.map-unbuf
map -p 4 'grep --line-buffered 1' abcdef > out.map-linebuf
map -p 1 'grep --line-buffered 1' abcdef > out.map-serial
ls -l raus*
md5sum out*

Die Dokumentation zeigt eine Problemumgehung, aber dadurch wird nicht nur stdout (Standardausgabe) gemischt.
mit stderr (Standardfehler) schlägt es bei bestimmten Jobs auch vollständig fehl (und kann sogar sein).
als weniger lesbar angesehen):

parallel echo -n {} ::: 1 2 3

map -p 4 'echo -n % 2>&1 | sed -e "s/^/$$:/"' 1 2 3 | sortieren | Schnitt -f2- -d:

Karte kann gebündelte Optionen nicht verarbeiten: Karte -vp 0 Echo fehlen uns die Worte. scheitert

Karte verfügt über kein Argumenttrennzeichen in der Befehlszeile, sondern verwendet das erste Argument
als Befehl. Dies erschwert das Zitieren, was wiederum die Lesbarkeit beeinträchtigen kann. Vergleichen:

map -p 2 perl\\\ -ne\\\ \\\'/^\\\\S+\\\\s+\\\\S+\\\$/\\\ and\\\ print\\\ \\\$ARGV,\\\"\\\\n\\\"\\\' *

parallel -q perl -ne '/^\S+\s+\S+$/ und print $ARGV,"\n"' ::: *

Karte kann mehrere Argumente mit Kontextersetzung ausführen, jedoch nicht ohne Kontextersetzung:

parallel --xargs echo 'BEGIN{'{}'}END' ::: 1 2 3

Karte legt den Exit-Wert nicht fest, je nachdem, ob einer der Jobs fehlgeschlagen ist:

parallel falsch ::: 1 || echo Job fehlgeschlagen

Karte falsch 1 || echo Niemals laufen

Karte erfordert Perl v5.10.0, was die Verwendung auf alten Systemen erschwert.

Karte hat keine Möglichkeit, % im Befehl zu verwenden (GNU Parallel hat -I, um einen anderen anzugeben
Ersatzzeichenfolge als {}).

Von Entwurf Karte ist die Option nicht kompatibel mit xargs, es gibt keine Remote-Jobausführung, a
Strukturierte Art der Ergebnisspeicherung, mehrere Eingabequellen, Fortschrittsanzeige, konfigurierbar
Datensatztrennzeichen (nur Feldtrennzeichen), Protokollierung ausgeführter Jobs mit Möglichkeit zur Fortsetzung,
Halten Sie die Ausgabe in der gleichen Reihenfolge wie die Eingabe, --pipe-Verarbeitung und dynamisch
Auszeiten.

UNTERSCHIEDE ZWISCHEN Ladon UND GNU Parallel
Ladon kann mehrere Jobs für Dateien parallel ausführen.

Ladon Funktioniert nur bei Dateien und die einzige Möglichkeit, Dateien anzugeben, ist die Verwendung einer Glob-Zeichenfolge in Anführungszeichen
(z. B. \*.jpg). Eine manuelle Auflistung der Dateien ist nicht möglich.

Als Ersatzzeichenfolgen werden FULLPATH DIRNAME BASENAME EXT RELDIR RELPATH verwendet

Diese können mit GNU simuliert werden Parallel indem du das einfügst ~/.parallel/config:

--rpl 'FULLPATH $_=::shell_quote($_);chomp($_=qx{readlink -f $_});'
--rpl 'DIRNAME $_=::shell_quote(::dirname($_));chomp($_=qx{readlink -f $_});'
--rpl 'BASISNAME s:.*/::;s:\.[^/.]+$::;'
--rpl 'EXT s:.*\.::'
--rpl 'RELDIR $_=::shell_quote($_);chomp(($_,$c)=qx{readlink -f $_;pwd});s:\Q$c/\E::; $_=::dirname($_);'
--rpl 'RELPATH $_=::shell_quote($_);chomp(($_,$c)=qx{readlink -f $_;pwd});s:\Q$c/\E::; '

Ladon Kommt schlecht mit Dateinamen zurecht, die „ und Newline“ enthalten, und schlägt bei größeren Ausgaben fehl
als 200:

ladon '*' - seq 36000 | Toilette

Beispiele: AB Ladon MANUELL

Es wird davon ausgegangen, dass die oben genannten '--rpl's eingefügt werden ~/.parallel/config und dass es ausgeführt wird
unter einer Shell, die '**' Globbing unterstützt (z. B zsh):

1 ladon „**/*.txt“ – echo RELPATH

1 paralleles Echo RELPATH ::: **/*.txt

2 ladon“~/Dokumente/**/*.pdf" -- shasum FULLPATH >hashes.txt

2 paralleles Shasum FULLPATH ::: ~/Dokumente/**/*.pdf >hashes.txt

3 ladon -m thumbs/RELDIR "**/*.jpg" loading="lazy" -- FULLPATH konvertieren -thumbnail 100x100^ -gravity
Mitte – Ausdehnung 100 x 100 Daumen/RELPATH

3 parallel mkdir -p thumbs/RELDIR\; FULLPATH konvertieren -Miniaturansicht 100x100^ -Schwerpunkt
-extent 100x100 Thumbs/RELPATH ::: **/*.jpg

4 ladon“~/Musik/*.wav" -- lame -V 2 FULLPATH DIRNAME/BASENAME.mp3

4 parallel lame -V 2 FULLPATH DIRNAME/BASENAME.mp3 ::: ~/Musik/* .wav

UNTERSCHIEDE ZWISCHEN ClusterSSH UND GNU Parallel
ClusterSSH löst ein anderes Problem als GNU Parallel.

ClusterSSH öffnet für jeden Computer ein Terminalfenster und kann über ein Hauptfenster ausgeführt werden
den gleichen Befehl auf allen Computern. Dies wird typischerweise für die Verwaltung mehrerer verwendet
Computer, die fast identisch sind.

GNU Parallel führt dieselben (oder verschiedene) Befehle mit unterschiedlichen Argumenten parallel aus
möglicherweise die Verwendung entfernter Computer, um die Datenverarbeitung zu unterstützen. Wenn mehr als ein Computer aufgeführt ist
-S GNU Parallel darf nur einen davon verwenden (z. B. wenn 8 Jobs ausgeführt werden sollen und einer
Computer hat 8 Kerne).

GNU Parallel kann als Armenversion von ClusterSSH verwendet werden:

Parallel --nonall -S Server-a, Server-b Sachen machen foo Bar

Nutzen Sie parallel online die Dienste von onworks.net