paralel - Online în Cloud

PROGRAM:

NUME

paralel - construiți și executați linii de comandă shell de la intrarea standard în paralel

REZUMAT

paralel [Opțiuni] [comandă [argumente]] < lista_de_argumente

paralel [Opțiuni] [comandă [argumente]] ( ::: argumente | :::: fișier(e) arg)...

paralel --semafor [opțiuni] comandă

#!/usr/bin/parallel --shebang [opțiuni] [comandă [argumente]]

DESCRIERE

GNU paralel este un instrument shell pentru executarea de joburi în paralel folosind unul sau mai multe computere. A
job poate fi o singură comandă sau un mic script care trebuie rulat pentru fiecare dintre liniile din
Intrarea. Intrarea tipică este o listă de fișiere, o listă de gazde, o listă de utilizatori, o listă
de adrese URL sau o listă de tabele. Un job poate fi, de asemenea, o comandă care citește dintr-o conductă. GNU
paralel apoi poate împărți intrarea în blocuri și introduce un bloc în fiecare comandă în
paralel.

Dacă folosiți xargs și tee astăzi, veți găsi GNU paralel foarte ușor de folosit ca GNU paralel
este scris pentru a avea aceleași opțiuni ca xargs. Dacă scrieți bucle în shell, veți găsi
GNU paralel poate fi capabil să înlocuiască majoritatea buclelor și să le facă să ruleze mai repede prin rulare
mai multe locuri de muncă în paralel.

GNU paralel se asigură că ieșirea din comenzi este aceeași ieșire pe care ați avea-o
executați comenzile secvenţial. Acest lucru face posibilă utilizarea rezultatelor din GNU paralel
ca intrare pentru alte programe.

Pentru fiecare linie de intrare GNU paralel va executa comandă cu linia drept argumente. Daca nu
comandă este dat, linia de intrare este executată. Mai multe linii vor fi rulate în paralel.
GNU paralel poate fi adesea folosit ca înlocuitor pentru xargs or pisică | pocni.

Al cititorului ghida
Începeți prin a viziona videoclipurile introductive pentru o introducere rapidă:
http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Atunci uită-te la EXEMPLUs după lista de OPŢIUNI. Asta vă va da o idee despre ce
GNU paralel este capabil de.

Apoi petreceți o oră parcurgând tutorialul (om tutorial_paralel). Linia ta de comandă
te va iubi pentru asta.

În cele din urmă, poate doriți să vă uitați la restul acestui manual dacă nu aveți nevoi speciale
deja acoperite.

OPŢIUNI

comandă Comanda de executat. Dacă comandă sau următoarele argumente conțin înlocuire
șiruri (cum ar fi {}) fiecare instanță va fi înlocuită cu intrarea.

If comandă este dat, GNU paralel rezolva aceleasi sarcini ca xargs. Dacă comandă is
nu este dat GNU paralel se va comporta similar cu pisică | sh.

comandă trebuie să fie un executabil, un script, o comandă compusă sau o funcție.

Dacă este o funcție Bash, trebuie exporturile -f funcția mai întâi. Pentru a folosi aliasuri
copiați întregul mediu așa cum este descris mai jos --env Și utilizarea env_parallel in schimb
of paralel.

Dacă este o funcție zsh, va trebui să utilizați această funcție de ajutor exportf la
exportați și pentru a seta $PARALLEL_SHELL la bash:

funcția exportf (){
export $(echo $1)="`de unde -f $1 | sed -e "s/$1 //" `"
}

function my_func(){
eco $1;
ecou „bună ziua”;
}

exportf my_func
PARALLEL_SHELL=/ bin / bash paralel „functia_mea {}” ::: 1 2

Comanda nu poate conține caracterul \257 (macron: X).

{} Linie de intrare. Acest șir de înlocuire va fi înlocuit cu o linie completă citită din
sursa de intrare. Sursa de intrare este în mod normal stdin (intrare standard), dar poate și
fi dat cu -a, :::, ::::.

Șirul de înlocuire {} poate fi schimbat cu -I.

Dacă linia de comandă nu conține șiruri de înlocuire, atunci {} va fi anexat la
linia de comandă.

{.} Linie de intrare fără extensie. Acest șir de înlocuire va fi înlocuit cu
intrare cu extensia eliminată. Dacă linia de intrare conține . după ultimul /
ultimul . până când capătul sforii va fi îndepărtat și {.} va fi înlocuit
cu restul. De exemplu foo.jpg devine foo, subdir/foo.jpg devine subdir/foo,
sub.dir/foo.jpg devine sub.dir/foo, sub.dir/bar rămășițe sub.dir/bar. Dacă
linia de intrare nu conține . va rămâne neschimbat.

Șirul de înlocuire {.} poate fi schimbat cu --eh.

Pentru a înțelege șirurile de înlocuire vezi {}.

{/} Numele de bază al liniei de intrare. Acest șir de înlocuire va fi înlocuit de intrare
cu partea de director eliminată.

Șirul de înlocuire {/} poate fi schimbat cu --basenamereplace.

Pentru a înțelege șirurile de înlocuire vezi {}.

{//} Dirname liniei de intrare. Acest șir de înlocuire va fi înlocuit cu directorul
linia de intrare. Vedea spune-mi(1).

Șirul de înlocuire {//} poate fi schimbat cu --dirnamereplace.

Pentru a înțelege șirurile de înlocuire vezi {}.

{/.} Numele de bază al liniei de intrare fără extensie. Acest șir de înlocuire va fi
înlocuit cu intrarea cu directorul și partea de extensie eliminate. Este un
combinatie de {/} și {.}.

Șirul de înlocuire {/.} poate fi schimbat cu --basenameextensionreplace.

Pentru a înțelege șirurile de înlocuire vezi {}.

{#} (testare alfa)
Numărul de secvență al jobului de rulat. Acest șir de înlocuire va fi înlocuit cu
numărul de ordine al jobului care se execută. Conține același număr ca
$PARALLEL_SEQ.

Șirul de înlocuire {#} poate fi schimbat cu --seqreplace.

Pentru a înțelege șirurile de înlocuire vezi {}.

{%} (testare alfa)
Numărul locului de muncă. Acest șir de înlocuire va fi înlocuit cu slotul jobului
numărul între 1 și numărul de joburi de rulat în paralel. Nu vor fi niciodată 2
joburi care rulează în același timp cu același număr de slot de job.

Șirul de înlocuire {%} poate fi schimbat cu --slotreplace.

Pentru a înțelege șirurile de înlocuire vezi {}.

{n} Argument de la sursa de intrare n sau nal-lea argument. Această înlocuire de poziție
șirul va fi înlocuit cu intrarea de la sursa de intrare n (atunci cand este folosit cu -a or
::::) sau cu nal-lea argument (când este folosit cu -N). dacă n este negativ la care se referă
la nUltimul argument.

Pentru a înțelege șirurile de înlocuire vezi {}.

{n.} Argument de la sursa de intrare n sau n'Argumentul fără extensie. Este un
combinatie de {n} și {.}.

Acest șir de înlocuire pozițională va fi înlocuit cu intrarea de la intrare
sursă n (atunci cand este folosit cu -a or ::::) sau cu nal-lea argument (când este folosit cu
-N). Intrarea va avea extensia eliminată.

Pentru a înțelege șirurile de înlocuire pozițională vezi {n}.

{n/} Numele de bază al argumentului din sursa de intrare n sau nal-lea argument. Este un
combinatie de {n} și {/}.

Acest șir de înlocuire pozițională va fi înlocuit cu intrarea de la intrare
sursă n (atunci cand este folosit cu -a or ::::) sau cu nal-lea argument (când este folosit cu
-N). Intrarea va avea directorul (dacă există) eliminat.

Pentru a înțelege șirurile de înlocuire pozițională vezi {n}.

{n//} Dirname argumentului din sursa de intrare n sau nal-lea argument. Este un
combinatie de {n} și {//}.

Acest șir de înlocuire pozițional va fi înlocuit cu directorul intrării de la
sursa de intrare n (atunci cand este folosit cu -a or ::::) sau cu nal-lea argument (când este folosit
implementate cu -N). Vedea spune-mi(1).

Pentru a înțelege șirurile de înlocuire pozițională vezi {n}.

{n/.} Numele de bază al argumentului din sursa de intrare n sau n'Argumentul fără extensie.
Este o combinație de {n}, {/} și {.}.

Acest șir de înlocuire pozițională va fi înlocuit cu intrarea de la intrare
sursă n (atunci cand este folosit cu -a or ::::) sau cu nal-lea argument (când este folosit cu
-N). Intrarea va avea directorul (dacă există) și extensia eliminate.

Pentru a înțelege șirurile de înlocuire pozițională vezi {n}.

{=perl expresie=}
Înlocuiți cu calculat perl expresie. $_ va contine la fel ca {}. După
evaluarea perl expresie $_ va fi folosită ca valoare. Se recomandă să
schimbați doar $_, dar aveți acces complet la tot GNU paraleleste intern
funcții și structuri de date.

{=perl expresie=} trebuie dat ca un singur șir.

Vezi de asemenea şi: --rpl --parinti

{=n perl expresie=}
Pozițional echivalent cu {= perl expresie =}. Pentru a înțelege pozițional
șiruri de schimb vezi {n}.

Vezi de asemenea şi: {= perl expresie =} {n}.

::: argumente
Utilizați argumente din linia de comandă ca sursă de intrare în loc de stdin (standard
intrare). Spre deosebire de alte opțiuni pentru GNU paralel ::: este plasat după comandă și
înaintea argumentelor.

Următoarele sunt echivalente:

(fișier ecou1; fișier ecou2) | paralel gzip
paralel gzip ::: fișier1 fișier2
paralel gzip {} ::: fișier1 fișier2
paralel --arg-sep ,, gzip {} ,, file1 file2
paralel --arg-sep ,, gzip ,, file1 file2
paralel ::: „fișier gzip1” „fișier gzip2”

Pentru a evita tratarea ::: ca utilizare specială --arg-sept pentru a seta separatorul de argumente la
altceva. Vezi si --arg-sept.

stdin (intrare standard) va fi transmisă la prima rulare a procesului.

Dacă este multiplu ::: sunt date, fiecare grup va fi tratat ca o sursă de intrare și toate
vor fi generate combinaţii de surse de intrare. De exemplu ::: 1 2 ::: abc va
rezultă combinațiile (1,a) (1,b) (1,c) (2,a) (2,b) (2,c). Acest lucru este util
pentru înlocuirea buclelor for imbricate.

::: și :::: poate fi amestecat. Deci acestea sunt echivalente:

ecou paralel {1} ​​{2} {3} ::: 6 7 ::: 4 5 ::: 1 2 3
ecou paralel {1} ​​{2} {3} :::: <(sev 6 7) <(seq 4 5) :::: <(seq 1 3)
paralel -a <(sev 6 7) ecou {1} {2} {3} :::: <(seq 4 5) :::: <(seq 1 3)
paralel -a <(sev 6 7) -a <(seq 4 5) ecou {1} {2} {3} ::: 1 2 3
secv 6 7 | paralel -a - -a <(seq 4 5) echo {1} {2} {3} ::: 1 2 3
secv 4 5 | ecou paralel {1} ​​{2} {3} :::: <(seq 6 7) - ::: 1 2 3

:::: argfiles
Un alt mod de a scrie -a argfile1 -a argfile2 ...

::: și :::: poate fi amestecat.

Vedea -a, ::: și --aplic.

--nul
-0 Utilizați NUL ca delimitator. În mod normal, liniile de intrare se vor termina în \n (linie nouă). Dacă se termină
în \0 (NUL), apoi utilizați această opțiune. Este util pentru procesarea argumentelor care pot
conţine \n (linie nouă).

--arg-file fișier de intrare
-a fișier de intrare
Utilizare fișier de intrare ca sursă de intrare. Dacă utilizați această opțiune, stdin (intrare standard) este
dat la prima rulare a procesului. În caz contrar, stdin (intrare standard) este redirecționat
din /dev/null.

Dacă este multiplu -a sunt date, fiecare fișier de intrare va fi tratată ca o sursă de intrare și
vor fi generate toate combinațiile de surse de intrare. De exemplu, dosarul foo conține 1
2, fișierul bar conține a b c. -a foo -a bar va rezulta combinatii
(1,a) (1,b) (1,c) (2,a) (2,b) (2,c). Acest lucru este util pentru înlocuirea imbricate pentru-
bucle.

Vezi si --aplic și {n}.

--arg-file-sept sep-str
Utilizare sep-str în loc de :::: ca șir separator între comandă și argument
fișiere. Util dacă :::: este folosit pentru altceva de către comandă.

Vezi de asemenea şi: ::::.

--arg-sept sep-str
Utilizare sep-str în loc de ::: ca șir separator. Util dacă ::: este folosit pentru
altceva prin comanda.

De asemenea, util dacă comandați utilizări ::: dar tot vrei să citești argumente din
stdin (intrare standard): Pur și simplu schimbați --arg-sept la un şir care nu este în
Linie de comanda.

Vezi de asemenea şi: :::.

--bar Afișați progresul ca bară de progres. În bară este afișat: % din lucrări finalizate,
secunde estimate rămase și numărul de lucrări începute.

Este compatibil cu zenitate:

secv 1000 | paralel -j30 --bar '(echo {};sleep 0.1)' 2> >(zenity --progress
--auto-kill) | WC

--basefile fişier
--bf fişier
fişier va fi transferat la fiecare sshlogin înainte ca un job să fie început. Va fi
înlăturat dacă --a curăța este activ. Fișierul poate fi un script de rulat sau ceva obișnuit
datele de bază necesare pentru locuri de muncă. Multiplu --bf poate fi specificat pentru a transfera mai mult
fişierele de bază. The fişier va fi transferat în același mod ca --transfer.

--basenamereplace înlocui-str
--bnr înlocui-str
Utilizați șirul de înlocuire înlocui-str în loc de {/} pentru numele de bază al liniei de intrare.

--basenameextensionreplace înlocui-str
--bner înlocui-str
Utilizați șirul de înlocuire înlocui-str în loc de {/.} pentru numele de bază al liniei de intrare
fără prelungire.

--bg Rulați comanda în fundal, astfel GNU paralel nu va aștepta finalizarea
comanda înainte de a ieși. Aceasta este valoarea implicită dacă --semafor este setat.

Vezi de asemenea şi: --fg, om fără.

implică --semafor.

--bibtex Tipăriți intrarea BibTeX pentru GNU paralel și dezactivați notificarea de citare.

--bloc mărimea
--dimensiunea blocului mărimea
Dimensiunea blocului în octeți. Mărimea poate fi postfixată cu K, M, G, T, P, k, m, g, t,
sau p care ar înmulți dimensiunea cu 1024, 1048576, 1073741824, 1099511627776,
1125899906842624, 1000, 1000000, 1000000000, 1000000000000 sau 1000000000000000
respectiv.

GNU paralel încearcă să îndeplinească dimensiunea blocului, dar poate fi oprit cu lungimea de unu
record. Din motive de performanță mărimea ar trebui să fie mai mare decât o singură înregistrare.

mărimea implicit la 1M.

Vedea --teava pentru utilizarea acestuia.

--pisică Creați un fișier temporar cu conținut. În mod normal --teava va da date la
program pe stdin (intrare standard). Cu --pisică GNU paralel va crea un
fișier temporar cu numele în {}, astfel încât să puteți face: paralel --teava --pisică wc {}.

Vezi si --fifo.

--a curăța
Eliminați fișierele transferate. --a curăța va elimina fișierele transferate de pe
computer la distanță după finalizarea procesării.

găsiți numele de jurnal „*gz” | paralel \
--sshlogin server.example.com --transfer --return {.}.bz2 \
--cleanup „zcat {} | bzip -9 >{.}.bz2”

cu --transfer fișierul transferat pe computerul de la distanță va fi eliminat
computerul de la distanță. Directoarele create nu vor fi eliminate - chiar dacă sunt
gol.

cu --întoarcere fișierul transferat de pe computerul de la distanță va fi eliminat
computerul de la distanță. Directoarele create nu vor fi eliminate - chiar dacă sunt
gol.

--a curăța este ignorat atunci când nu este utilizat cu --transfer or --întoarcere.

--colsep expresie regulată
-C expresie regulată
Separator de coloane. Intrarea va fi tratată ca un tabel cu expresie regulată separarea
coloane. A n-a coloană poate fi accesată folosind {n} or {n.}. De exemplu 3 {} este a 3-a
coloana.

--colsep implică --tunde rl.

expresie regulată este o expresie regulată Perl: http://perldoc.perl.org/perlre.html

--comprima
Comprimați fișierele temporare. Dacă rezultatul este mare și foarte compresibil, acest lucru va fi
ocupă mai puțin spațiu pe disc în $TMPDIR și poate fi mai rapid datorită I/O mai puține pe disc.

GNU paralel voi incerca lzop, pigz, gzip, pbzip2, plzip, bzip2, lzma, lzip, xz in
acea comandă și folosiți primul disponibil.

--comprimare-program prg
--program-decomprimare prg
Utilizare prg pentru (de)comprimarea fișierelor temporare. Se presupune că prg -DC voi
decomprimați stdin (intrare standard) în stdout (ieșire standard), dacă nu
--program-decomprimare este dată.

--ctrlc Trimite SIGINT la sarcinile care rulează pe computere la distanță, ucigându-le astfel.

--delimitator delim
-d delim Elementele de intrare sunt terminate cu caracterul specificat. Citatele și bara oblică inversă sunt
Nimic special; fiecare caracter din intrare este luat literal. Dezactivează finalul-
șir de fișier, care este tratat ca orice alt argument. Acesta poate fi folosit atunci când
intrarea constă din elemente pur și simplu separate de linie nouă, deși este aproape
întotdeauna mai bine să vă proiectați programul pentru a utiliza --null acolo unde acest lucru este posibil. The
delimitatorul specificat poate fi un singur caracter, un caracter de escape în stil C, cum ar fi
\n sau un cod de escape octal sau hexazecimal. Coduri de evadare octale și hexazecimale
sunt înțelese ca pentru comanda printf. Caracterele multibyte nu sunt
sprijinit.

--dirnamereplace înlocui-str
--dnr înlocui-str
Utilizați șirul de înlocuire înlocui-str în loc de {//} pentru dirname-ul liniei de intrare.

-E eof-str
Setați sfârșitul șirului de fișier la eof-str. Dacă sfârșitul șirului de fișier apare ca a
linia de intrare, restul intrării este ignorată. Dacă nici unul -E nici -e este folosit,
nu se folosește niciun capăt de șir de fișier.

--întârziere secunde
Întârziere începerea următoarei lucrări secunde secunde. GNU paralel se va întrerupe secunde secunde după
incepand fiecare job. secunde poate dura mai puțin de 1 secundă.

--funcție uscată
Imprimați lucrarea pentru a rula pe stdout (ieșire standard), dar nu executați lucrarea. Utilizare -v
-v pentru a include ssh/rsync wrapping-ul dacă jobul ar fi rulat pe o telecomandă
calculator. Totuși, nu te baza pe acest lucru, deoarece munca poate fi programată
alt computer sau computerul local dacă : este în listă.

--eof[=eof-str]
-e[eof-str]
Această opțiune este un sinonim pentru -E opțiune. Utilizare -E în schimb, pentru că este POSIX
conform pt xargs în timp ce această opțiune nu este. Dacă eof-str este omis, nu există
sfârşitul şirului de fişier. Dacă nici unul -E nici -e este folosit, nu este folosit niciun sfârşit de şir de fişier.

--env a fost (testare alfa)
Copiați variabila de mediu a fost. Aceasta se va copia a fost la mediul în care
comanda este rulată. Acest lucru este util în special pentru execuția de la distanță.

În Bash a fost poate fi, de asemenea, o funcție Bash - amintiți-vă exporturile -f il
funcție, vezi comandă.

Variabila „_” este specială. Va copia toate variabilele de mediu, cu excepția
cele menționate în ~/.paralel/ignored_vars.

Pentru a copia matricele Bash aveți nevoie de o funcție de importare, așa cum nu pot fi matricele Bash
exportat:

import_array () {
funcția locală=$1; schimb;
export $func='() {
'"$(pentru arr în $@; do
declare -p $arr|sed '1s/declare -./&g/'
Terminat)"'
}'
}

declara -A asoc='([one]="1" [dou]="2")'
declara -a indexat='([0]="unul" [1]="două")'

import_array my_importer asoc indexat

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

Pentru a copia întregul mediu, utilizați această funcție (de exemplu, introducând-o în .bashrc):

env_parallel() {
export parallel_bash_environment='() {
'"$(echo "shopt -s expand_aliases 2>/dev/null"; alias;typeset -p | grep -vFf <(numai citire; echo GROUPS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_;typeset -f)"'
}'
# Rulați ca: env_parallel [opțiuni paralele normale]
„care paralelă” „$@”
dezactivați parallel_bash_environment
}
# apel ca:
env_parallel [opțiuni paralele normale]

Vezi de asemenea şi: --record-env.

--eta Afișați numărul estimat de secunde înainte de a termina. Acest lucru forțează GNU paralel
pentru a citi toate locurile de muncă înainte de a începe să găsiți numărul de locuri de muncă. GNU paralel
în mod normal, citește doar următoarea lucrare de rulat. implică --progresa.

--fg Rulați comanda în prim-plan, astfel GNU paralel va aștepta finalizarea
comanda înainte de a ieși.

Vezi si --bg, om fără.

implică --semafor.

--fifo Creați un fifo temporar cu conținut. În mod normal --teava va da date la
program pe stdin (intrare standard). Cu --fifo GNU paralel va crea un
fifo temporar cu numele în {}, astfel încât să puteți face: paralel --teava --fifo wc {}.

Atenție: dacă datele nu sunt citite din fifo, lucrarea se va bloca pentru totdeauna.

Vezi si --pisică.

--filtre-gazde
Eliminați gazdele în jos. Pentru fiecare gazdă la distanță: verificați dacă autentificarea prin ssh funcționează. Dacă
nu: nu utilizați această gazdă.

Momentan poți nu pune --filtre-gazde într-un profil, $PARALLEL,
/etc/parallel/config sau similar. Acest lucru se datorează faptului că GNU paralel folosește GNU paralel
pentru a calcula acest lucru, astfel încât veți obține o buclă infinită. Acest lucru va fi probabil rezolvat într-un
eliberare ulterioară.

--gnu Comportați-vă ca GNU paralel. Din punct de vedere istoric, această opțiune a avut prioritate --tollef.
--tollef opțiunea este acum retrasă și, prin urmare, nu poate fi utilizată. --gnu este pastrat
pentru compatibilitate.

--grup Ieșire de grup. Ieșirea de la fiecare lucrare este grupată și este tipărită numai atunci când
comanda este terminată. stderr (eroare standard) urmată mai întâi de stdout
(ieșire standard). Acest lucru necesită ceva timp CPU. În situații rare, GNU paralel
ocupă mult timp CPU și dacă este acceptabil ca ieșirile de la diferite
comenzile sunt amestecate, apoi se dezactivează gruparea cu -u poate accelera GNU
paralel cu un factor de 10.

--grup este implicit. Poate fi inversat cu -u.

Vezi de asemenea şi: --line-buffer --degrupare

--Ajutor
-h Tipăriți un rezumat al opțiunilor pentru GNU paralel și ieșire.

--oprire-la-eroare val
--oprire val
Cum ar trebui GNU paralel reziliază dacă una dintre mai multe locuri de muncă eșuează?

0 Nu vă opriți dacă o lucrare eșuează. Starea de ieșire va fi numărul de lucrări eșuate.
Aceasta este valoarea implicită.

1 Nu începeți lucrări noi dacă o lucrare eșuează, ci finalizați lucrările în curs de desfășurare
inclusiv curățarea. Starea de ieșire va fi starea de ieșire din ultima
job eșuat.

2 Închideți imediat toate lucrările și părăsiți fără curățare. Starea de ieșire
va fi starea de ieșire din jobul eșuat.

1-99% Dacă val% dintre joburi eșuează și minim 3: Nu începeți noi joburi, dar
finalizați lucrările care rulează, inclusiv curățarea. Starea de ieșire va fi
starea de ieșire din ultimul job eșuat.

--antet expresie regulată
Utilizați regexp ca antet. Pentru utilizare normală antetul potrivit (de obicei primul
linia: --antet „.*\n”) va fi împărțit folosind --colsep (care va fi implicit „\t”)
și numele coloanelor pot fi folosite ca variabile de înlocuire: {coloană Nume}.

Pentru --teava antetul potrivit va fi adăugat înaintea fiecărei ieșiri.

--antet : este un alias pentru --antet „.*\n”.

If expresie regulată este un număr, se va potrivi cu atâtea rânduri.

-I înlocui-str
Utilizați șirul de înlocuire înlocui-str în loc de {}.

--a inlocui[=înlocui-str]
-i[înlocui-str]
Această opțiune este un sinonim pentru -Iînlocui-str if înlocui-str este specificat, iar pentru
-I{} in caz contrar. Această opțiune este depreciată; utilizare -I in schimb.

--jolog fișier jurnal
Fișier jurnal pentru joburile executate. Salvați o listă a joburilor executate în fișier jurnal în
următorul format separat TAB: numărul de secvență, sshlogin, ora de începere în secunde
din epoca, timpul de rulare în secunde, octeți în fișierele transferate, octeți în fișiere
revenit, starea de ieșire, semnalul și executarea comenzii.

Pentru a converti orele în ISO-8601 strict:

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

Vezi si --relua.

--locuri de munca N
-j N
--max-procs N
-P N Numărul de locuri de muncă. Rulați până la N joburi în paralel. 0 înseamnă cât mai multe.
Implicit este 100%, care va rula o lucrare per nucleu CPU.

If --semafor este setată implicit este 1, făcând astfel un mutex.

--locuri de munca +N
-j +N
--max-procs +N
-P +N Adăugați N la numărul de nuclee CPU. Rulați atât de multe joburi în paralel. Vezi si
--utilizați-cpus-în loc de nuclee.

--locuri de munca -N
-j -N
--max-procs -N
-P -N Scădeți N din numărul de nuclee CPU. Rulați atât de multe joburi în paralel. Dacă
numărul evaluat este mai mic de 1, atunci va fi folosit 1. Vezi si
--utilizați-cpus-în loc de nuclee.

--locuri de munca N%
-j N%
--max-procs N%
-P N% Înmulțiți N% cu numărul de nuclee CPU. Rulați atât de multe joburi în paralel. Vedea
de asemenea --utilizați-cpus-în loc de nuclee.

--locuri de munca profil
-j profil
--max-procs profil
-P profil
Citiți parametrul din fișier. Utilizați conținutul lui profil ca parametru pentru -j. De exemplu
profil ar putea conţine şirul 100% sau +2 sau 10. Dacă profil este schimbat când a
slujba terminata, profil se citește din nou și se calculează noul număr de locuri de muncă. Dacă
numărul este mai mic decât înainte, lucrările care rulează vor fi permise să se termine, dar noi
locurile de muncă nu vor fi începute până când nu va fi atins numărul dorit de locuri de muncă. Acest
face posibilă modificarea numărului de joburi care rulează simultan în timpul GNU
paralel rulează.

--ţine-ordinea
-k Păstrați secvența de ieșire aceeași cu ordinea de intrare. În mod normal, rezultatul unui job
va fi tipărită imediat ce lucrarea este finalizată. Încercați asta pentru a vedea diferența:

paralel -j4 somn {}\; ecou {} ::: 2 1 4 3
paralel -j4 -k somn {}\; ecou {} ::: 2 1 4 3

Dacă este folosit cu --în totalitate or --nontoate ieșirea va fi grupată după sshlogin în sortat
comandă.

-L linii max
Când este utilizat cu --teava: Citiți înregistrările linii max.

Când se utilizează altfel: Utilizați cel mult linii max linii de intrare neblanke pe linie de comandă.
Spațiile necompletate fac ca o linie de intrare să fie continuată în mod logic la următoarea intrare
linia.

-L 0 înseamnă că citiți o linie, dar introduceți 0 argumente pe linia de comandă.

implică -X dacă nu -m, --xargs, --teava este setat.

--max-linii[=linii max]
-l[linii max]
Când este utilizat cu --teava: Citiți înregistrările linii max.

Când se utilizează altfel: Sinonim pentru -L opțiune. Spre deosebire de -L, linii max
argumentul este optional. Dacă linii max nu este specificat, este implicit unul. The -l
opțiunea este depreciată deoarece standardul POSIX specifică -L in schimb.

-l 0 este un alias pentru -l 1.

implică -X dacă nu -m, --xargs, --teava este setat.

--line-buffer
Ieșire tampon pe linie. --grup va menține rezultatul împreună pentru un întreg
de locuri de muncă. --degrupare permite ieșirea să se amestece cu o jumătate de linie care provine dintr-o singură lucrare și
jumătate de linie care vine de la un alt loc de muncă. --line-buffer se încadrează între acestea două: GNU
paralel va imprima o linie completă, dar va permite amestecarea liniilor diferite
locuri de munca.

--line-buffer necesită mai multă putere CPU decât ambele --grup și --degrupare, Dar poate
fi mai rapid decât --grup dacă CPU nu este factorul limitativ.

Vezi de asemenea şi: --grup --degrupare

--sarcină incarcatura maxima
Nu porniți noi lucrări pe un anumit computer decât dacă numărul de procese care rulează
pe computer este mai mică decât incarcatura maxima. incarcatura maxima folosește aceeași sintaxă ca --locuri de munca,
so 100% pentru unul pe CPU este o setare validă. Singura diferență este 0 care este
interpretat ca 0.01.

--controlmaster
-M Utilizați ControlMaster al ssh pentru a face conexiuni ssh mai rapide. Util dacă lucrările rulează de la distanță
și rulează foarte repede. Acest lucru este dezactivat pentru sshlogin-urile care își specifică propriile
comanda ssh.

--xargs Argumente multiple. Introduceți atâtea argumente cât permite lungimea liniei de comandă.

If {} nu este folosit argumentele vor fi anexate la linie. Dacă {} este utilizat
de mai multe ori fiecare {} va fi înlocuit cu toate argumentele.

Suport pentru --xargs implementate cu --sshlogin este limitată și poate eșua.

Vezi si -X pentru context înlocuiți. Dacă aveți îndoieli, utilizați -X așa cum se va întâmpla cel mai probabil
ce e necesar.

-m Argumente multiple. Introduceți atâtea argumente cât permite lungimea liniei de comandă.
Dacă mai multe joburi sunt executate în paralel: distribuiți argumentele în mod egal
locurile de muncă. Utilizare -j1 pentru a evita acest lucru.

If {} nu este folosit argumentele vor fi anexate la linie. Dacă {} este utilizat
de mai multe ori fiecare {} va fi înlocuit cu toate argumentele.

Suport pentru -m implementate cu --sshlogin este limitată și poate eșua.

Vezi si -X pentru context înlocuiți. Dacă aveți îndoieli, utilizați -X așa cum se va întâmpla cel mai probabil
ce e necesar.

--minversiune versiune
Tipăriți versiunea GNU paralel si iesi. Dacă versiunea actuală a GNU paralel
e mai puțin decât versiune codul de ieșire este 255. În caz contrar, este 0.

Acest lucru este util pentru scripturile care depind de caracteristici disponibile numai de la o anumită
versiunea GNU paralel.

--nontoate (testare beta)
--în totalitate fara argumente. Rulați comanda pe toate computerele date cu --sshlogin
dar nu lua argumente. GNU paralel se va autentifica --locuri de munca numărul de calculatoare în
paralel și rulați lucrarea pe computer. -j ajustează câte computere să se înregistreze
în paralel.

Acest lucru este util pentru a rula aceeași comandă (de exemplu, timp de funcționare) pe o listă de servere.

--în totalitate (testare beta)
Rulați toate joburile pe toate computerele cu care sunt date --sshlogin. GNU paralel va log
în --locuri de munca număr de computere în paralel și rulează câte o lucrare pe rând pe
calculator. Ordinea lucrărilor nu va fi modificată, dar unele computere pot
termina inaintea altora. -j ajustează câte computere să se conecteze în paralel.

Atunci când se utilizează --grup ieșirea va fi grupată pe fiecare server, deci toată ieșirea
de la un server vor fi grupate.

--output-as-files
--outputasfiles
--fișiere În loc să imprimați rezultatul în stdout (ieșire standard), rezultatul fiecărei lucrări
este salvat într-un fișier și numele fișierului este apoi tipărit.

--teava
--spreadstdin
Răspândiți intrarea la joburi pe stdin (intrare standard). Citiți un bloc de date din stdin
(intrare standard) și dați un bloc de date ca intrare pentru un job.

Mărimea blocului este determinată de --bloc. Corzile --reporniți și --recent spune
GNU paralel cum începe și/sau se termină o înregistrare. Blocul citit va avea finala
înregistrarea parțială a fost eliminată înainte ca blocul să fie transmis locului de muncă. Parțialul
înregistrarea va fi adăugată la următorul bloc.

If --reporniți este dat, acesta va fi folosit pentru a împărți la începutul înregistrării.

If --recent este dat, acesta va fi folosit pentru a împărți la sfârșitul înregistrării.

Dacă ambele --reporniți și --recent sunt date ambele vor trebui să se potrivească pentru a găsi o despărțire
poziție.

Dacă nici unul --reporniți nici --recent sunt date --recent implicit la „\n”. A avea
nu se utilizează separatorul de înregistrări --recent "".

--fișiere este adesea folosit cu --teava.

Vezi de asemenea şi: --reporniți, --recent, --fifo, --pisică, --pipepart.

--pipepart (testare beta)
Conduceți părți ale unui fișier fizic. --pipepart funcționează similar cu --teava, dar este mult
Mai repede. Are câteva limitări:

* Fișierul trebuie să fie un fișier fizic (care poate fi căutat) și trebuie dat folosind -a or
::::.

* Numărarea înregistrărilor (-N) și numărarea liniilor (-L/-l) nu lucra.

--simplu Ignora orice --profil, $PARALEL și ~/.paralel/config pentru a obține controlul deplin asupra
linia de comandă (folosită de GNU paralel intern atunci când este sunat cu --sshlogin).

--Mai mult Activați șiruri suplimentare de înlocuire: {+/} {+.} {+..} {+...} {..} {...} {/ ..}
{/...}. Ideea este că „{+foo}” se potrivește cu opusul „{foo}” și {} =
{+/}/{/} = {.}.{+.} = {+/}/{/.}.{+.} = {..}.{+..} = {+/}/{/ ..}.{+..} =
{...}.{+...} = {+/}/{/...}.{+...}

--progresa
Afișați progresul calculelor. Enumerați computerele implicate în sarcină cu
numărul de nuclee CPU detectate și numărul maxim de joburi de rulat. După acel spectacol
progresul pentru fiecare computer: numărul de joburi care rulează, numărul de joburi finalizate și
procent din toate lucrările efectuate de acest computer. Procentul va fi doar
disponibil după ce toate joburile au fost programate ca GNU paralel citeste doar pe urmatorul
locul de muncă atunci când este gata să-l programați - acest lucru este pentru a evita pierderea timpului și a memoriei
citind totul la pornire.

Prin trimiterea GNU paralel SIGUSR2 puteți comuta pornirea/oprirea --progresa pe o
rulează GNU paralel proces.

Vezi si --eta.

--max-args=max-args
-n max-args
Utilizați cel mult max-args argumente pe linie de comandă. Mai puțin de max-args argumente
va fi folosit dacă dimensiunea (vezi -s opțiunea) este depășită, cu excepția cazului în care -x opțiunea este
dat, caz în care GNU paralel va ieși.

-n 0 înseamnă că citiți un argument, dar introduceți 0 argumente pe linia de comandă.

implică -X dacă nu -m este setat.

--max-replace-args=max-args
-N max-args
Utilizați cel mult max-args argumente pe linie de comandă. Ca -n dar și face
corzi de schimb 1 {} .. {max-args} care reprezintă argumentul 1.. max-args. Dacă
prea putine argumente {n} va fi goală.

-N 0 înseamnă că citiți un argument, dar introduceți 0 argumente pe linia de comandă.

Acest lucru va seta proprietarul homedir-ului la utilizator:

tr ':' '\n' < / Etc / passwd | paralel -7 N chown 1 {} 6 {}

implică -X dacă nu -m or --teava este setat.

Când este utilizat cu --teava -N este numărul de înregistrări de citit. Aceasta este oarecum
mai incet decat --bloc.

--lungime-max-linie-permisă
Imprimați numărul maxim de caractere permis pe linia de comandă și ieșiți (utilizat
de GNU paralel el însuși pentru a determina lungimea liniei pe computerele de la distanță).

--număr-de-procesoare
Imprimați numărul de procesoare fizice și ieșiți (utilizat de GNU paralel însuși la
determina numărul de procesoare fizice de pe computere la distanță).

--număr-de-nuclee
Imprimați numărul de nuclee CPU și ieșiți (utilizat de GNU paralel el însuşi să determine
numărul de nuclee CPU de pe computerele aflate la distanță).

--fara-aviz
Nu afișați notificarea de citare. O notificare de citare este tipărită pe stderr (standard
eroare) numai dacă stderr (eroare standard) este un terminal, utilizatorul nu a specificat
--fara-aviz, iar utilizatorul nu a rulat --bibtex o singura data.

--Grozav frumusețe
Rulați comanda la această bunătate. Pentru comenzi simple, puteți doar să adăugați frumos in
în fața comenzii. Dar dacă comanda constă din mai multe subcomenzi (cum ar fi:
ls|wc) apoi înaintea frumos nu va funcționa întotdeauna. --Grozav se va asigura că toate sub
comenzile sunt frumoase.

--interactiv
-p Solicitați utilizatorului dacă să ruleze fiecare linie de comandă și să citească o linie din
Terminal. Rulați linia de comandă numai dacă răspunsul începe cu „y” sau „Y”.
implică -t.

--parinti parentsstring
Utilizați pentru a defini parantezele de început și de sfârșit pentru {= perl expresie =}. Stânga și
paranteza dreaptă poate fi mai multe caractere și se presupune că sunt aceleași
lungime. Valoarea implicită este {==} oferindu- {= ca paranteză de început și =} ca final
paranteze.

O altă setare utilă este ,,,, ceea ce ar face atât paranteză ,,:

paralel --parens ,,,, echo foo este ,,s/I/O/g,, ::: FII

Vezi de asemenea şi: --rpl {= perl expresie =}

--profil Numele profilului
-J Numele profilului
Utilizați profilul Numele profilului pentru opțiuni. Acest lucru este util dacă doriți să aveți mai multe
profiluri. Ați putea avea un profil pentru a rula joburi în paralel pe local
computer și un profil diferit pentru executarea lucrărilor pe computere la distanță. Vezi
secțiunea FIȘIERE DE PROFIL pentru exemple.

Numele profilului corespunde dosarului ~/.paralel/Numele profilului.

Puteți da mai multe profiluri prin repetare --profil. Dacă părți ale profilelor
conflict, vor fi folosite cele mai târziu.

Implicit: config

--citat
-q Citat comandă. Aceasta va cita linia de comandă, astfel încât caracterele speciale nu sunt
interpretat de coajă. Vezi secțiunea CITATE. Majoritatea oamenilor nu vor avea niciodată nevoie
acest. Cotarea este dezactivată implicit.

--no-run-dacă-gol
-r Dacă stdin (intrarea standard) conține doar spații albe, nu rulați comanda.

Dacă este folosit cu --teava asta e lent.

--noswap Nu începeți lucrări noi pe un anumit computer dacă există atât interschimbarea, cât și schimbarea
activitate.

Activitatea de schimb este eșantionată numai la fiecare 10 secunde, deoarece eșantionarea durează 1 secundă
să facă.

Activitatea de swap este calculată ca (swap-in)*(swap-out), ceea ce în practică este un bun
valoare: schimbarea nu este o problemă, schimbarea nu este o problemă, ci ambele
schimbarea de intrare și de ieșire indică de obicei o problemă.

--record-env
Înregistrați variabilele de mediu curente în ~/.paralel/ignored_vars. Acest lucru este util
înainte de a utiliza --env _.

Vezi si --env.

--reporniți startstring
--recent șir de capăt
If --reporniți este dată startstring va fi folosit pentru a împărți la începutul înregistrării.

If --recent este dată șir de capăt va fi folosit pentru a împărți la sfârșitul înregistrării.

Dacă ambele --reporniți și --recent li se dă șirul combinat
endstringstartstring va trebui să se potrivească pentru a găsi o poziție divizată. Acest lucru este util
în cazul în care fie startstring or șir de capăt meci în mijlocul unui record.

Dacă nici unul --reporniți nici --recent sunt date atunci --recent implicit la „\n”. La
nu au nicio utilizare a separatorului de înregistrări --recent "".

--reporniți și --recent sunt folosite cu --teava.

Utilizare --regexp să interpreteze --reporniți și --recent ca expresii regulate. Aceasta este
încet, însă.

--regexp Utilizare --regexp să interpreteze --reporniți și --recent ca expresii regulate. Aceasta este
încet, însă.

--eliminare-rec-sept
--removerecsep
--rrs Eliminați textul potrivit cu --reporniți și --recent înainte de a-l conecta la
comanda.

Folosit doar cu --teava.

--rezultate prefix
--rez prefix
Salvați rezultatul în fișiere. Fișierele vor fi stocate într-un arbore de directoare cu rădăcină
at prefix. În cadrul acestui arbore de directoare, fiecare comandă va avea ca rezultat două fișiere:
prefix/ /stdout și prefix/ /stderr, unde este o succesiune de
directoare reprezentând antetul sursei de intrare (dacă se utilizează --antet :) Sau
numărul sursei de intrare și valorile corespunzătoare.

De exemplu:

paralel --header : --rezultate foo echo {a} {b} ::: a I II ::: b III IIII

va genera fișierele:

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

și

paralel --rezultate foo echo {1} {2} ::: I II ::: III IIII

va genera fișierele:

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

Vezi si --fișiere, --antet, --jolog.

--relua Reluează de la ultima lucrare neterminată. Citind --jolog sau --rezultate dir
GNU paralel își va da seama ultimul lucru neterminat și va continua de acolo. La fel de
GNU paralel se uită doar la numerele de ordine în --jolog apoi intrarea,
comandă și --jolog toate trebuie să rămână neschimbate; altfel GNU paralel Mai
rulați comenzi greșite.

Vezi si --jolog, --rezultate, --reluare-eșuat.

--reluare-eșuat
Reîncercați totul eșuat și reluați de la ultima lucrare neterminată. Citind --jolog GNU
paralel va descoperi joburile eșuate și le va rula din nou. După aceea va fi
reluați ultima lucrare neterminată și continuați de acolo. Ca GNU paralel se uita doar la
numerele de ordine în --jolog apoi intrarea, comanda și --jolog toate
trebuie să rămână neschimbate; altfel GNU paralel poate rula comenzi greșite.

Vezi si --jolog, --relua.

--reîncercă n
Dacă o lucrare eșuează, încercați din nou pe alt computer pe care nu a eșuat. Fa asta
n ori. Daca sunt mai putini de n calculatoare în --sshlogin GNU paralel va re-
folosește toate computerele. Acest lucru este util dacă unele lucrări eșuează fără un motiv aparent
(cum ar fi defecțiunea rețelei).

--întoarcere nume de fișier
Transferați fișiere de pe computere la distanță. --întoarcere este folosit cu --sshlogin când
argumentele sunt fișiere de pe computerele de la distanță. Când se termină procesarea fișierului
nume de fișier va fi transferat de pe computerul de la distanță folosind rsync si va fi pus
raportat la directorul implicit de conectare. De exemplu

echo foo/bar.txt | paralel \
--sshlogin server.example.com --return {.}.out atingeți {.}.out

Acest lucru va transfera fișierul $HOME/foo/bar.out de la calculator
server.example.com la dosar foo/bar.out după alergare atingeţi foo/bar.out on
server.example.com.

echo /tmp/foo/bar.txt | paralel \
--sshlogin server.example.com --return {.}.out atingeți {.}.out

Acest lucru va transfera fișierul /tmp/foo/bar.out de la calculator server.example.com
la dosar /tmp/foo/bar.out după alergare atingeţi /tmp/foo/bar.out on
server.example.com.

Mai multe fișiere pot fi transferate repetând opțiunile de mai multe ori:

echo /tmp/foo/bar.txt | \
paralel --sshlogin server.example.com \
--return {.}.out --return {.}.out2 atingeți {.}.out {.}.out2

--întoarcere este adesea folosit cu --transfer și --a curăța.

--întoarcere este ignorat atunci când este utilizat cu --sshlogin : sau atunci când nu este folosit cu --sshlogin.

--round-robin
--rundă În mod normal --teava va da un singur bloc fiecărei instanțe a comenzii. Cu
--round-robin toate blocurile vor fi scrise aleatoriu în comenzile care rulează deja.
Acest lucru este util dacă inițializarea comenzii durează mult.

--ţine-ordinea nu va lucra cu --round-robin deoarece este imposibil de urmărit care
blocului de intrare corespunde cărei ieșiri.

--rpl 'etichetă perl expresie'
Utilizare etichetă ca şir de înlocuire pentru perl expresie. Acest lucru face posibil să
definiți-vă propriile șiruri de schimb. GNU paralelCele 7 șiruri de schimb ale lui sunt
implementat ca:

--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:\.[^/.]+$::'

Dacă șirul de înlocuire definit de utilizator începe cu „{”, acesta poate fi folosit și ca a
șir de înlocuire pozițional (cum ar fi {2.}).

Este recomandat să schimbați doar $_, dar aveți acces deplin la tot GNU
paralelfuncțiile interne și structurile de date.

Iată câteva exemple:

Eliminați 2 extensii (de ex. .tar.gz)
--rpl '{..} s:\.[^/.]+$::;s:\.[^/.]+$::;'
Păstrați doar extensia
--rpl „{ext} s:.*\.::”
Secvența de lucrări este pară sau impară?
--rpl '{odd} $_=$job->seq()%2?"odd":"par"'

Vezi de asemenea şi: {= perl expresie =} --parinti

--max-cars=max-cars
-s max-cars
Utilizați cel mult max-cars caractere pe linie de comandă, inclusiv comanda și
argumentele inițiale și valorile nule de sfârșit la sfârșitul șirurilor de argumente.
Cea mai mare valoare permisă este dependentă de sistem și este calculată ca argument
limita de lungime pentru exec, mai puțin dimensiunea mediului dumneavoastră. Valoarea implicită este
maximul.

implică -X dacă nu -m este setat.

--arata-limitele
Afișați limitele lungimii liniei de comandă care sunt impuse de operare
sistemul și -s opțiune. Distribuiți intrarea din /dev/null (și poate specificați
--no-run-if-empty) dacă nu doriți GNU paralel a face orice.

--semafor
Lucrează ca un semafor de numărare. --semafor va provoca GNU paralel pentru a începe
comandă in fundal. Când se atinge numărul de joburi simultane, GNU
paralel va aștepta ca una dintre acestea să se termine înainte de a începe o altă comandă.

--semafor implică --bg dacă nu --fg este specificat.

--semafor implică --nume semafor `tty` dacă nu --nume semafor este specificat.

Folosit cu --fg, --aștepta și --nume semafor.

Comanda fără este un alias pentru paralel --semafor.

Vezi si om fără.

--nume semafor nume
--id nume
Utilizare nume ca denumirea semaforului. Implicit este numele companiei de control
(ieșire de la tty).

Valoarea implicită funcționează în mod normal conform așteptărilor atunci când este utilizată interactiv, dar când este utilizată în
Un script nume ar trebui setat. $$ or numele_sarcinii_mea sunt adesea o valoare bună.

Semaforul este stocat în ~/.paralel/semafore/

implică --semafor.

Vezi si om fără.

--semaphoretimeout secunde
Dacă semaforul nu este eliberat în câteva secunde, luați-l oricum.

implică --semafor.

Vezi si om fără.

--seqreplace înlocui-str
Utilizați șirul de înlocuire înlocui-str în loc de {#} pentru numărul de ordine de lucru.

-- shebang
--hashbang
GNU paralel poate fi apelat ca o comandă shebang (#!) ca prima linie a unui
scenariu. Conținutul fișierului va fi tratat ca sursă de intrare.

Asa:

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

foss.org.my
debian.org
freenetproject.org

-- shebang trebuie setat ca prima opțiune.

Pe FreeBSD env Este nevoie:

#!/usr/bin/env -S paralel --shebang -r traceroute

foss.org.my
debian.org
freenetproject.org

--shebang-wrap
GNU paralel poate paraleliza scripturile prin înfășurarea liniei shebang. Dacă programul
poate fi rulat astfel:

argumente pisica | paralel cu programul

atunci scriptul poate fi schimbat în:

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

De exemplu

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

Dacă programul poate fi rulat astfel:

date pisici | paralel --pipe the_program

atunci scriptul poate fi schimbat în:

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

De exemplu

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

--shebang-wrap trebuie setat ca prima opțiune.

--shellquote
Nu rulează comanda, ci o citează. Util pentru a face citat compus
comenzi pentru GNU paralel.

--salta-prima-linia
Nu utilizați prima linie de intrare (utilizată de GNU paralel în sine atunci când este chemat cu
-- shebang).

--sshdelay secunde
Întârziere începerea următoarei ssh cu secunde secunde. GNU paralel se va întrerupe secunde secunde
după pornirea fiecărui ssh. secunde poate dura mai puțin de 1 secundă.

-S [ncpu/]sshlogin[,[ncpu/]sshlogin[,...]]
--sshlogin [ncpu/]sshlogin[,[ncpu/]sshlogin[,...]]
Distribuiți locuri de muncă pe computere la distanță. Lucrările vor fi executate pe o listă de telecomandă
calculatoare. GNU paralel va determina numărul de nuclee CPU de pe telecomandă
computere și rulați numărul de joburi specificat de -j. Dacă numărul ncpu is
dat GNU paralel va folosi acest număr pentru numărul de nuclee CPU de pe gazdă.
În mod normal ncpu nu va fi nevoie.

An sshlogin este de forma:

[sshcommand [opțiuni]] [nume utilizator@]nume gazdă

sshlogin-ul nu trebuie să necesite o parolă.

sshlogin „:” este special, înseamnă „fără ssh” și, prin urmare, va rula pe
calculator local.

sshlogin „..” este special, citește sshlogin-uri de la ~/.parallel/sshloginfile

sshlogin „-” este de asemenea special, citește sshlogin-uri din stdin (intrare standard).

Pentru a specifica mai multe sshlogins, separați sshlogin-urile prin virgulă sau repetați opțiunile
de mai multe ori.

De exemplu: vezi --sshloginfile.

Gazda la distanță trebuie să aibă GNU paralel instalat.

--sshlogin se știe că cauzează probleme cu -m și -X.

--sshlogin este adesea folosit cu --transfer, --întoarcere, --a curăța și --trc.

--sshloginfile nume de fișier (testare beta)
--slf nume de fișier (testare beta)
Fișier cu sshlogins. Fișierul este format din sshlogin-uri pe linii separate. Gol
liniile și liniile care încep cu „#” sunt ignorate. Exemplu:

server.example.com
[e-mail protejat]
8/my-8-core-server.example.com
2/[e-mail protejat]
# Acest server are SSH care rulează pe portul 2222
ssh -p 2222 server.example.net
4/ssh -p 2222 quadserver.example.net
# Utilizați un alt program ssh
myssh -p 2222 -l myusername hexacpu.example.net
# Utilizați un alt program ssh cu un număr implicit de nuclee
//usr/local/bin/myssh -p 2222 -l myusername hexacpu.example.net
# Utilizați un alt program ssh cu 6 nuclee
6//usr/local/bin/myssh -p 2222 -l myusername hexacpu.example.net
# Să presupunem 16 nuclee pe computerul local
16/:

Când utilizați un alt program ssh, ultimul argument trebuie să fie numele de gazdă.

Multiplu --sshloginfile sunt permise.

GNU paralel va căuta mai întâi fișierul în directorul curent; daca asta nu reuseste uite
pentru dosarul in ~/.paralel.

Fișierul sshlogin „..” este special, citește sshlogin-urile din ~/.parallel/sshloginfile

Fișierul sshlogin '.' este special, citea sshlogin-uri de la
/etc/parallel/sshloginfile

Fișierul sshlogin „-” este, de asemenea, special, citește sshlogin-uri din stdin (standard
intrare).

Dacă fișierul sshlogin este modificat, acesta va fi recitit când o lucrare se termină, deși la
cel mai mult o dată pe secundă. Acest lucru face posibilă adăugarea și eliminarea gazdelor în timp ce
alergare.

Acest lucru poate fi folosit pentru a avea un daemon care actualizează fișierul sshlogin numai pentru a conține
servere activate:

cp original.slf tmp2.slf
în timp ce [1]; do
frumos paralel --nonall -j0 -k --slf original.slf --tag echo | perl 's/\t$//' > tmp.slf
if diff tmp.slf tmp2.slf; apoi
mv tmp.slf tmp2.slf
fi
Dormi 10
Terminat &
paralel --slf tmp2.slf ...

--slotreplace înlocui-str
Utilizați șirul de înlocuire înlocui-str în loc de {%} pentru numărul locului de muncă.

--tăcut Tăcut. Lucrarea care urmează să fie executată nu va fi tipărită. Aceasta este valoarea implicită. Poate fi
inversat cu -v.

--tty Deschideți terminalul tty. Dacă GNU paralel este folosit pentru pornirea unui program interactiv
atunci poate fi necesară această opțiune. Va începe o singură lucrare la un moment dat (de ex -j1),
nu tamponează ieșirea (de ex -u), și va deschide un tty pentru job. Când treaba
este gata, următoarea lucrare va primi tty.

--etichetă Etichete cu argumente. Fiecare linie de iesire va fi predata cu argumente
și TAB (\t). Când este combinat cu --în totalitate or --nontoate liniile vor fi predate
cu sshlogin în schimb.

--etichetă este ignorat la utilizare -u.

--tagstring str
Linii de etichetă cu un șir. Fiecare linie de iesire va fi predata cu str și TAB
(\t). str poate conține șiruri de caractere de înlocuire, cum ar fi {}.

--tagstring este ignorat la utilizare -u, --în totalitate și --nontoate.

--tmpdir spune-mi
Director pentru fișiere temporare. GNU paralel în mod normal tamponează ieşirea în
fișiere temporare în /tmp. Prin setare --tmpdir puteți folosi un alt director pentru
fișiere. Setare --tmpdir este echivalent cu setarea $TMPDIR.

--tmux Utilizare tmux pentru ieșire. Începe o tmux sesiune și rulați fiecare job într-o fereastră din aceea
sesiune. Nu se va produce nicio altă ieșire.

--pauză val
Timp expirat pentru comandă. Dacă comanda rulează mai mult decât val secunde va primi
ucis cu SIGTERM, urmat de SIGTERM 200 ms mai târziu, urmat de SIGKILL 200 ms
mai târziu.

If val este urmat de un %, apoi timeout-ul va fi calculat dinamic ca a
procent din durata medie de rulare. Numai valorile > 100% vor avea sens.

--verbos
-t Imprimați lucrarea care urmează să fie rulată pe stderr (eroare standard).

Vezi si -v, -p.

--transfer
Transferați fișiere pe computere la distanță. --transfer este folosit cu --sshlogin când
argumentele sunt fișiere și ar trebui transferate pe computerele de la distanță. Fișierele
va fi transferat folosind rsync și va fi pus în raport cu directorul de lucru implicit.
Dacă calea conține /./ calea rămasă va fi relativă la directorul de lucru.
De exemplu

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

Acest lucru va transfera fișierul foo/bar.txt la computer server.example.com la
fişier $HOME/foo/bar.txt înainte de a alerga wc foo/bar.txt on server.example.com.

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

Acest lucru va transfera fișierul foo/bar.txt la computer server.example.com la
fişier /tmp/foo/bar.txt înainte de a alerga wc /tmp/foo/bar.txt on server.example.com.

--transfer este adesea folosit cu --întoarcere și --a curăța.

--transfer este ignorat atunci când este utilizat cu --sshlogin : sau atunci când nu este folosit cu
--sshlogin.

--trc nume de fișier
Transfer, întoarcere, curățare. Mână scurtă pentru:

--transfer --întoarcere nume de fișier --a curăța

--tunde
Decupați spațiul alb în intrare.

n Fără tăiere. Intrarea nu este modificată. Aceasta este valoarea implicită.

l Trim stânga. Eliminați spațiul alb de la începutul introducerii. De exemplu, „a bc” -> „a bc”.

r Trim dreapta. Eliminați spațiul alb de la sfârșitul introducerii. De exemplu, „a bc” -> „a bc”.

lr
rl Ambele trim. Eliminați spațiul alb atât de la începutul cât și de la sfârșitul intrării. De exemplu, „a bc”
-> „a bc”. Aceasta este valoarea implicită dacă --colsep este folosit.

--degrupare
-u Degrupați ieșirea. Ieșirea este tipărită cât mai curând posibil și prin trecere GNU paralel
prelucrare internă. Acest lucru poate determina amestecarea rezultatelor de la diferite comenzi
astfel ar trebui să fie folosit numai dacă nu vă pasă de rezultat. Comparați acestea:

paralel -j0 'dormi {};ecou -n începe{};somn {};ecou {}Sfârşit' ::: 1 2 3 4

paralel -u -j0 'dormi {};ecou -n începe{};somn {};ecou {}Sfârşit' ::: 1 2 3 4

De asemenea, se dezactivează --etichetă. GNU paralel iese mai repede cu -u. Comparați viteza de
aceste:

paralel seq ::: 300000000 >/dev/null
paralel -u seq ::: 300000000 >>/dev/null
paralel --line-buffer seq ::: 300000000 >/dev/null

Poate fi inversat cu --grup.

Vezi de asemenea şi: --line-buffer --grup

--extensioninlocuire înlocui-str
--eh înlocui-str
Utilizați șirul de înlocuire înlocui-str în loc de {.} pentru linia de intrare fără
extensie.

--utilizați-cpus-în loc de nuclee
Numărați numărul de procesoare fizice în loc de nuclee de procesor. Când se calculează câte
job-urile să ruleze simultan în raport cu numărul de nuclee CPU pe care îl puteți cere GNU
paralel pentru a se uita în schimb la numărul de procesoare fizice. Acest lucru va avea sens pentru
computere care au hyperthreading ca două joburi care rulează pe un CPU cu
hyperthreading va rula mai lent decât două joburi care rulează pe două procesoare fizice. niste
CPU-urile cu mai multe nuclee pot rula mai repede dacă rulează un singur fir pe CPU fizic.
Majoritatea utilizatorilor nu vor avea nevoie de această opțiune.

-v Verbos. Imprimați lucrarea care urmează să fie rulată pe stdout (ieșire standard). Poate fi inversat
implementate cu --tăcut. Vezi si -t.

Utilizare -v -v pentru a imprima comanda wrapping ssh atunci când rulați de la distanță.

--versiune
-V Tipăriți versiunea GNU paralel și ieșire.

--workdir mydir
--wd mydir
Fișierele transferate folosind --transfer și --întoarcere va fi relativ la mydir on
computere la distanță, iar comanda va fi executată în directorul director mydir.

Specialul mydir valoare ... va crea directoare de lucru sub ~/.parallel/tmp/ on
calculatoarele de la distanță. Dacă --a curăța este dat aceste directori vor fi eliminate.

Specialul mydir valoare . folosește directorul curent de lucru. Dacă curentul de lucru
dir este sub dir acasă, valoarea . este tratată ca o cale relativă către dvs
home dir. Aceasta înseamnă că, dacă directorul dvs. de acasă este diferit pe computerele de la distanță (de ex
dacă datele dvs. de conectare sunt diferite) calea relativă va fi în continuare relativă la casa dvs
d.

Pentru a vedea diferența, încercați:

paralel -S serverul PWD ::: ""

paralel --wd . -S serverul PWD ::: ""

paralel --wd ... -S serverul PWD ::: ""

--aștepta Așteptați finalizarea tuturor comenzilor.

implică --semafor.

Vezi si om fără.

-X Argumente multiple cu context înlocuiesc. Introduceți atâtea argumente câte comanda
lungimea liniei permite. Dacă mai multe joburi sunt executate în paralel: distribuiți
argumente în mod egal între locuri de muncă. Utilizare -j1 pentru a evita acest lucru.

If {} nu este folosit argumentele vor fi anexate la linie. Dacă {} este folosit ca
parte dintr-un cuvânt (cum ar fi pic{}.jpg) atunci întregul cuvânt va fi repetat. Dacă {} is
folosit de mai multe ori fiecare {} vor fi înlocuite cu argumentele.

În mod normal -X va face ceea ce trebuie, în timp ce -m poate da rezultate neaşteptate dacă {}
este folosit ca parte a unui cuvânt.

Suport pentru -X implementate cu --sshlogin este limitată și poate eșua.

Vezi si -m.

--Ieșire
-x Ieșiți dacă dimensiunea (vezi -s opțiunea) este depășită.

--aplic Citiți mai multe surse de intrare, cum ar fi xapply. Dacă sunt date mai multe surse de intrare, una
argumentul va fi citit din fiecare dintre sursele de intrare. Argumentele pot fi
accesat în comanda ca 1 {} .. {n}, asa de 1 {} va fi o linie de la prima intrare
sursa, si 6 {} se va referi la linia cu același număr de linie din a 6-a
sursa de intrare.

Comparați aceste două:

ecou paralel {1} ​​{2} ::: 1 2 3 ::: abc
paralel --xapply echo {1} {2} ::: 1 2 3 ::: abc

Argumentele vor fi reciclate dacă o sursă de intrare are mai multe argumente decât sursa
alții:

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

Vezi si --antet.

EXEMPLU: De lucru as xargs -n1. Argument alăturarea

GNU paralel poate funcționa similar cu xargs -n1.

Pentru a comprima toate fișierele html folosind gzip alerga:

găsi . -Yam „*.html” | paralel gzip --Cel mai bun

Dacă numele fișierelor pot conține o linie nouă, utilizați -0. Înlocuiți FOO BAR cu FUBAR în toate fișierele
în acest director și subdir:

găsi . -Tip f -print0 | paralel -q0 perl -i -pe 's/FOO BAR/FUBAR/g'

notițe -q este necesar din cauza spațiului din „FOO BAR”.

EXEMPLU: Citind argumente din comandă linie

GNU paralel poate prelua argumentele din linia de comandă în loc de stdin (intrare standard).
Pentru a comprima toate fișierele html din directorul curent folosind gzip alerga:

paralel gzip --Cel mai bun ::: *.html

Pentru a converti *.wav în *.mp3 utilizând LAME care rulează un proces pentru fiecare rulare a nucleului procesorului:

paralel șchiop {} -o {.}.mp3 ::: * .wav

EXEMPLU: Se introduce multiplu argumente

Când mutați o mulțime de fișiere astfel: mv * .log destdir uneori vei primi eroarea:

Bash: /bin/mv: Argument listă de asemenea lung

pentru că sunt prea multe fișiere. În schimb, puteți face:

ls | grep -E „\.log$” | paralel mv {} destdir

Aceasta va rula mv pentru fiecare dosar. Se poate face mai repede dacă mv primeşte tot atâtea argumente încât
se va potrivi pe linie:

ls | grep -E „\.log$” | paralel -m mv {} destdir

EXEMPLU: Context înlocui

Pentru a elimina fișierele pict0000.jpg .. pict9999.jpg ai putea face:

urm -w 0 9999 | paralel rm pict{}.jpg

Ai putea face si:

urm -w 0 9999 | perl -pe 's/(.*)/pict$1.jpg/' | paralel -m rm

Primul va rula rm de 10000 de ori, în timp ce ultima va rula doar rm de câte ori este nevoie
păstrați lungimea liniei de comandă suficient de scurtă pentru a evita Argument listă de asemenea lung (de obicei
rulează de 1-2 ori).

De asemenea, puteți rula:

urm -w 0 9999 | paralel -X rm pict{}.jpg

Acesta va rula doar rm de câte ori este nevoie pentru a menține lungimea liniei de comandă scurtă
suficient.

EXEMPLU: Calcula intensiv de locuri de muncă și substituție

Dacă ImageMagick este instalat, aceasta va genera o miniatură a unui fișier jpg:

converti -geometrie 120 foo.jpg thumb_foo.jpg

Aceasta va rula cu joburi cu număr de nuclee CPU în paralel pentru toate fișierele jpg dintr-un director:

ls * .jpg | paralel converti -geometrie 120 {} deget mare_{}

Pentru a o face recursiv utilizați găsi:

găsi . -Yam „*.jpg” | paralel converti -geometrie 120 {} {}_thumb.jpg

Observați cum trebuie să înceapă argumentul {} as {} va include calea (de exemplu, rularea converti
-geometrie 120 ./foo/bar.jpg thumb_./foo/bar.jpg ar fi în mod clar greșit). Comanda va
generați fișiere precum ./foo/bar.jpg_thumb.jpg.

Utilizare {.} pentru a evita .jpg suplimentar în numele fișierului. Această comandă va face fișiere ca
./foo/bar_thumb.jpg:

găsi . -Yam „*.jpg” | paralel converti -geometrie 120 {} {.}_thumb.jpg

EXEMPLU: Înlocuire și redirecționare

Aceasta va genera o versiune necomprimată a fișierelor .gz lângă fișierul .gz:

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

Citarea > este necesară pentru a amâna redirecționarea. O altă soluție este citarea
întreaga comandă:

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

Alte caractere speciale de tip shell (cum ar fi * ; $ > < | >> <<) trebuie, de asemenea, puse între ghilimele,
deoarece acestea pot fi altfel interpretate de către shell și nu oferite lui GNU paralel.

EXEMPLU: Compusă comenzi

Un job poate consta din mai multe comenzi. Aceasta va imprima numărul de fișiere din fiecare
director:

ls | paralel 'ecou -n {}" "; ls {}|wc - eu

Pentru a pune rezultatul într-un fișier numit .dir:

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

Chiar și scripturile shell mici pot fi rulate de GNU paralel:

găsi . | paralel 'a={}; nume=${a##*/}; superior=$(echo „$nume” | tr "[:inferior:]"
"[:superior:]"); ecou „$nume - $sus"'

ls | paralel 'mv {} „$(echo {} | tr "[:superior:]" "[:inferior:]")"'

Având în vedere o listă de adrese URL, enumerați toate adresele URL care nu reușesc să se descarce. Tipăriți numărul rândului și
URL.

pisică urlfile | paralel „wget {} 2>/ Dev / null || grep -n {} URLfile"

Creați un director oglindă cu aceleași nume de fișiere, cu excepția faptului că toate fișierele și legăturile simbolice sunt goale
fișiere.

cp -rs /sursa/dir mirror_dir; găsi mirror_dir -Tip l | paralel -m rm {} „&&” atingeţi
{}

Găsiți fișierele într-o listă care nu există

pisică lista_fișiere | paralel 'dacă [ ! -e {} ] ; apoi ecou {}; fi

EXEMPLU: apel Bash funcții

Dacă comanda compusă este mai lungă decât o linie, devine greu de citit. În Bash poți
utilizați funcții. Doar amintiți-vă exporturile -f functia.

Fă-o() {
echo Făcând asta pentru $1
Dormi 2
echo Gata cu $1
}
export -f doit
paralel trebuie ::: 1 2 3

doubleit() {
echo Făcând asta pentru $1 $2
Dormi 2
echo Gata cu $1 $2
}
export -f doubleit
doubleit paralel ::: 1 2 3 ::: ab

Pentru a face acest lucru pe servere la distanță, trebuie să transferați funcția folosind --env:

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

Dacă mediul dvs. (alias-uri, variabile și funcții) este mic, puteți copia întregul
mediu fără a fi nevoie exporturile -f orice. Doar rulați mai întâi acest lucru:

env_parallel() {
export parallel_bash_environment='() {
'"$(echo "shopt -s expand_aliases 2>/dev/null"; alias;typeset -p | grep -vFf <(numai citire; echo GROUPS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_;typeset -f)"'
}'
# Rulați ca: env_parallel parallel_bash_environment "2>/dev/null;" ...
„care paralelă” „$@”
dezactivați parallel_bash_environment
}

Și apoi sunați ca:

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

EXEMPLU: Funcţie laborant

Pentru a testa un program cu diferiți parametri:

tester() {
if (eval "$@") >&/dev/null; apoi
perl -e 'printf "\033[30;102m[ OK ]\033[0m @ARGV\n"' "$@"
altfel
perl -e 'printf "\033[30;101m[FAIL]\033[0m @ARGV\n"' "$@"
fi
}
export -f tester
tester paralel my_program ::: arg1 arg2
ieșire tester paralel ::: 1 0 2 0

If programul_meu eșuează va fi imprimat un FAIL roșu urmat de comanda eșuată; in caz contrar
va fi imprimat un OK verde urmat de comanda.

EXEMPLU: Eliminarea fişier extensie cand prelucrare fișiere

Când procesați fișiere, eliminați extensia de fișier folosind {.} este adesea util.

Creați un director pentru fiecare fișier zip și dezarhivați-l în acel director:

paralel 'mkdir {.}; cd {.}; dezarhivați ../{}' ::: * .zip

Recomprimați toate fișierele .gz din directorul curent folosind bzip2 rulează 1 sarcină per nucleu CPU în
paralel:

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

Convertiți toate fișierele WAV în MP3 folosind LAME:

găsi sounddir -Tip f -Yam '*.wav' | paralel șchiop {} -o {.}.mp3

Pune toate convertite în același director:

găsi sounddir -Tip f -Yam '*.wav' | paralel șchiop {} -o mydir/{/.}.mp3

EXEMPLU: Eliminarea Două fişier extensii cand prelucrare fișiere

Dacă aveți un director cu fișiere tar.gz și doriți ca acestea să fie extrase în directorul corespunzător
(de exemplu, foo.tar.gz va fi extras în dir foo) puteți face:

paralel --Mai mult 'mkdir {..}; gudron -C {..} -xf {}' ::: *.tar.gz

EXEMPLU: Download 10 imagini pentru fiecare of il trecut 30 zile

Să presupunem că un site web stochează imagini precum:

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

unde AAAAMMZZ este data și ## este numărul 01-10. Acest lucru va descărca imagini pentru
ultimele 30 de zile:

paralel wget http://www.example.com/path/to/„$(data -d "astăzi -{1} zile"
+%Y%m%d)_{2}.jpg' ::: $(secv 30) ::: $(secv -w 10)

$(data -d "astăzi -{1} zile" +%Y%m%d) va da datele în AAAAMMZZ cu {1} zile
scazut.

EXEMPLU: Copiați fișiere as ultimul modificată data (ISO8601) implementate cu adăugat aleator cifre

găsi . | paralel 'cp {} ../destdir/{= $a = int(10000*rand); $_ = `data -r „$_”
+%FT%T"$a"`; chomp; =}'

EXEMPLU: Digtal ceas implementate cu "clipind" :

: într-un ceas digital clipește. Pentru a face ca orice altă linie să aibă un „:” iar restul un „ ” a
Expresia perl este folosită pentru a privi a treia sursă de intrare. Dacă valoarea modudo 3 este 2: Folosiți
":" în caz contrar utilizați " ":

paralel -k ecou {1}'{=3 $_=$_%2?":":" „=}”{2}{3} ::: {0..12} ::: {0..5} ::: {0..9}

EXEMPLU: Agregare conţinut of fișiere

Aceasta:

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

va genera fișierele x1y01z1 .. x5y10z5. Dacă doriți să agregați gruparea de ieșire
pe x și z puteți face asta:

evaluare paralelă „cat {=s/y01/y*/=} > {=s/y01//=}” ::: *y01*

Pentru toate valorile lui x și z rulează comenzi precum:

pisica x1y*z1 > x1z1

Deci ajungeți cu x1z1 .. x1z5 fiecare care conține conținutul tuturor valorilor lui y.

EXEMPLU: Lăţime primul paralel web crawler/oglindă

Acest script de mai jos va accesa cu crawlere și va oglindi o adresă URL în paralel. Descarcă primele pagini care
sunt 1 clic în jos, apoi 2 clicuri în jos, apoi 3; în loc de adâncimea normală mai întâi, unde
primul link de pe fiecare pagină este preluat primul.

Alergați așa:

PARALEL=-j100 ./crawl-paralel http://gatt.org.yeslab.org/

Scoateți wget parte dacă doriți doar un crawler web.

Funcționează prin preluarea unei pagini dintr-o listă de adrese URL și căutând link-uri în acea pagină care
sunt în aceeași adresă URL de pornire și care nu au fost deja văzute. Aceste link-uri sunt
adăugat la o nouă coadă. Când toate paginile din listă sunt terminate, noua coadă este mutată în
lista de adrese URL și procesul este reluat până când nu sunt găsite linkuri nevăzute.

#!/ bin / bash

# De exemplu http://gatt.org.yeslab.org/
URL=$1
# Rămâneți în directorul de pornire
BASEURL=$(echo $URL | perl -pe 's:#.*::; s:(//.*/)[^/]*:$1:')
URLLIST=$(mktemp urllist.XXXX)
URLLIST2=$(mktemp urllist.XXXX)
SEEN=$(mktemp văzut.XXXX)

# Spider pentru a obține adresele URL
echo $URL >$URLLIST
cp $URLLIST $SEEN

while [ -s $URLLIST ] ; do
pisica $URLLIST |
lynx paralel -listonly -image_links -dump {} \; wget -qm -l1 -Q1 {} \; echo Spidered: {} \>\&2 |
perl -ne 's/#.*//; s/\s+\d+.\s(\S+)$/$1/ și face { $seen{$1}++ sau print }' |
grep -F $BASEURL |
grep -v -x -F -f $VĂZUT | tee -a $SEEN > $URLLIST2
mv $URLLIST2 $URLLIST
făcut

rm -f $URLLIST $URLLIST2 $VIZUT

EXEMPLU: Proces fișiere din a gudron fişier în timp ce despachetarea

Dacă fișierele care urmează să fie procesate sunt într-un fișier tar, atunci despachetați un fișier și procesați-l
imediat poate fi mai rapid decât prima despachetare a tuturor fișierelor.

gudron xvf foo.tgz | perl - este 'imprimare $l;$l=$_;END{printare $l}' | paralel ecou

Perl one-liner este necesar pentru a evita condiția de cursă.

EXEMPLU: rescrierea a pentru buclă și a while-read-loop

bucle pentru ca aceasta:

(pentru x în `lista de pisici`; face
face_ceva $x
gata) | proces_ieșire

și while-read-bucle de genul acesta:

lista de pisici | (în timp ce citește x ; face
face_ceva $x
gata) | proces_ieșire

se poate scrie asa:

pisică listă | paralel Fă ceva | proces_ieșire

De exemplu: Găsiți ce nume de gazdă dintr-o listă are adresa IP 1.2.3 4:

pisică hosts.txt | paralel -P 100 gazdă | grep 1.2.3.4

Dacă procesarea necesită mai mulți pași, bucla for astfel:

(pentru x în `lista de pisici`; face
no_extension=${x%.*};
face_ceva $x scale $no_extension.jpg
do_step2 <$x $no_extension
gata) | proces_ieșire

și bucle while ca aceasta:

lista de pisici | (în timp ce citește x ; face
no_extension=${x%.*};
face_ceva $x scale $no_extension.jpg
do_step2 <$x $no_extension
gata) | proces_ieșire

se poate scrie asa:

pisică listă | paralel "Fă ceva {} scară {.}.jpg ; face_pasul2 <{} {.}" | proces_ieșire

EXEMPLU: rescrierea cuibărit for-bucle

Bucle for imbricate astfel:

(pentru x în `cat xlist`; do
pentru y în `cat ylist`; do
face_ceva $x $y
făcut
gata) | proces_ieșire

se poate scrie asa:

paralel Fă ceva 1 {} 2 {} :::: lista x ylist | proces_ieșire

Bucle for imbricate astfel:

(pentru gen în MF; nu
pentru marimea in SML XL XXL ; do
echo $gen $mărime
făcut
gata) | fel

se poate scrie asa:

paralel ecou 1 {} 2 {} ::: M F ::: S M L XL XXL | fel

EXEMPLU: Găsire il cel mai mic diferenţă între fișiere

dif este bun pentru a găsi diferențe în fișierele text. dif | wc -l dă un indiciu despre
mărimea diferenței. Pentru a găsi diferențele dintre toate fișierele din directorul curent
do:

paralel --etichetă 'dif 1 {} 2 {} | wc - eu ::: * ::: * | fel -nk3

În acest fel, este posibil să vedeți dacă unele fișiere sunt mai aproape de alte fișiere.

EXEMPLU: for-bucle implementate cu coloană nume

Când faceți mai multe bucle for imbricate, poate fi mai ușor să urmăriți variabila buclă
if is este numit în loc să aibă doar un număr. Utilizare --antet : să lase primul argument
să fie un alias numit pentru șirul de înlocuire pozițional:

paralel --header : echo {gen} {dimensiune} ::: gen MF ::: dimensiune SML XL XXL

Acest lucru funcționează și dacă fișierul de intrare este un fișier cu coloane:

agenda pisicii.tsv | paralel --colsep '\t' --header : echo {Nume} {Adresă de e-mail}

EXEMPLU: Conta il diferenţele între toate fișiere in a dir

Utilizarea --rezultate rezultatele sunt salvate în /tmp/diffcount*.

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

Pentru a vedea diferența dintre fișierul A și fișierul B, uitați-vă la fișierul „/tmp/diffcount/1/A/2/B”.

EXEMPLU: accelerare up rapid de locuri de muncă

Pornirea unei lucrări pe computerul local durează aproximativ 10 ms. Acest lucru poate fi o mare suprasarcină dacă
Lucrarea durează foarte puțini ms pentru a rula. Adesea puteți grupa lucrări mici împreună folosind -X care va
face ca cheltuielile generale să fie mai puțin semnificative. Comparați viteza acestora:

secv. -w 0 9999 | pictură tactilă paralelă{}.jpg

secv. -w 0 9999 | paralel -X atingere pict{}.jpg

Dacă programul dvs. nu poate accepta mai multe argumente, atunci puteți utiliza GNU paralel a depune icre
mai multe GNU paralels:

secv. -w 0 999999 | paralel -j10 --pipe paralel -j0 atinge pict{}.jpg

If -j0 generează în mod normal 252 de locuri de muncă, apoi cele de mai sus vor încerca să genereze 2520 de locuri de muncă. Într-un mod normal
Sistemul GNU/Linux puteți genera 32000 de joburi folosind această tehnică fără probleme. A creste
limita de 32000 de locuri de muncă crește /proc/sys/kernel/pid_max la 4194303.

EXEMPLU: Utilizarea coajă variabile

Când utilizați variabile de shell, trebuie să le citați corect, deoarece altfel ar putea fi împărțite
pe spații.

Observați diferența dintre:

V=(„Înregistrările de 12\” ale fratelui meu valorează <\$\$\$>"'!' Foo Bar)
parallel echo ::: ${V[@]} # Probabil că nu este ceea ce doriți

și:

V=(„Înregistrările de 12\” ale fratelui meu valorează <\$\$\$>"'!' Foo Bar)
ecou paralel ::: „${V[@]}”

Când utilizați variabile în comanda reală care conține caractere speciale (de exemplu, spațiu)
le puteți cita folosind „$VAR” sau folosind „'s și -q:

V="Iată două"
ecou paralel "'$V'" ::: spații
paralel -q echo "$V" ::: spații

EXEMPLU: grup producție linii

Când rulați joburi care scot date, adesea nu doriți ca rezultatul mai multor joburi
alergați împreună. GNU paralel implicit gruparea rezultatelor fiecărei lucrări, deci rezultatul este
tipărit când lucrarea se termină. Dacă doriți să fie imprimate linii întregi în timp ce lucrarea este
alergare pe care o poți folosi --line-buffer. Dacă doriți ca rezultatul să fie imprimat cât mai curând posibil
poți să folosești -u.

Comparați rezultatul:

paralel traceroute ::: foss.org.my debian.org freenetproject.org

la ieșirea de:

paralel --line-buffer traceroute ::: foss.org.my debian.org freenetproject.org

și:

paralel -u traceroute ::: foss.org.my debian.org freenetproject.org

EXEMPLU: Etichetă producție linii

GNU paralel grupează liniile de ieșire, dar poate fi greu de văzut unde sunt diferitele locuri de muncă
ÎNCEPE. --etichetă înaintează argumentul pentru a face acest lucru mai vizibil:

paralel --etichetă traceroute ::: foss.org.my debian.org freenetproject.org

--etichetă lucrări cu --line-buffer dar nu cu -u:

paralel --etichetă --line-buffer traceroute ::: foss.org.my debian.org freenetproject.org

Verificați timpul de funcționare al serverelor în ~/.parallel/sshloginfile:

paralel --etichetă -S .. --nontoate uptime

EXEMPLU: A pastra comandă of producție acelaşi as comandă of intrare

În mod normal, rezultatul unei lucrări va fi imprimat de îndată ce se finalizează. Uneori vrei
ordinea ieșirii să rămână aceeași cu ordinea intrării. Acest lucru este adesea
important, dacă ieșirea este folosită ca intrare pentru alt sistem. -k se va asigura de comanda
de ieșire va fi în aceeași ordine cu intrarea chiar dacă lucrările ulterioare se termină înainte de lucrările anterioare.

Adăugați un șir la fiecare linie dintr-un fișier text:

pisică fisier text | paralel -k ecou {} append_string

Dacă eliminați -k unele dintre rânduri pot apărea în ordine greșită.

Un alt exemplu este traceroute:

paralel traceroute ::: foss.org.my debian.org freenetproject.org

va oferi traceroute de foss.org.my, debian.org și freenetproject.org, dar va fi
sortate în funcție de ce lucrare finalizată mai întâi.

Pentru a menține ordinea aceeași cu rularea de intrare:

paralel -k traceroute ::: foss.org.my debian.org freenetproject.org

Acest lucru se va asigura că traseul către foss.org.my va fi imprimat mai întâi.

Un exemplu mai complex este descărcarea unui fișier uriaș în bucăți în paralel: Niște internet
conexiunile vor furniza mai multe date dacă descărcați fișiere în paralel. Pentru descărcare
fișiere în paralel vezi: „EXEMPLU: Descărcați 10 imagini pentru fiecare dintre ultimele 30 de zile”. Dar dacă
descărcați un fișier mare, puteți descărca fișierul în bucăți în paralel.

Pentru a descărca octetul 10000000-19999999 puteți folosi răsuci:

răsuci -r 10000000-19999999 http://example.com/the/big/file > dosar.partea

Pentru a descărca un fișier de 1 GB avem nevoie de 100 de bucăți de 10 MB descărcate și combinate în modul corect
comandă.

urm 0 99 | paralel -k răsuci -r \
{}0000000-{}9999999 http://example.com/the/big/file > fişier

EXEMPLU: Paralel grep

grep -r greps recursiv prin directoare. Pe procesoarele multicore GNU paralel poate de multe ori
grăbiți acest lucru.

găsi . -Tip f | paralel -k -j150% -n 1000 -m grep -H -n STRING {}

Aceasta va rula 1.5 job per nucleu și va oferi 1000 de argumente grep.

EXEMPLU: Grepping n linii pentru m regulat expresii.

Cea mai simplă soluție pentru a grep un fișier mare pentru o mulțime de expresii regulate este:

grep -f regexps.txt bigfile

Sau dacă expresiile regulate sunt șiruri fixe:

grep -F -f regexps.txt bigfile

Există 2 factori limitatori: CPU și disc I/O. CPU este ușor de măsurat: Dacă grep-ul ia
>90% CPU (de exemplu, când rulează de sus), atunci CPU este un factor limitator și paralelizare
va accelera acest lucru. Dacă nu, atunci I/O pe disc este factorul limitativ și, în funcție de
sistemul de discuri poate fi mai rapid sau mai lent de paralelizat. Singura modalitate de a ști sigur este
a masura.

Dacă CPU-ul este factorul limitator, paralelizarea ar trebui făcută pe expresiile regulate:

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

Dacă o linie se potrivește cu mai multe expresii regulate, linia poate fi duplicată. Comanda va porni unul
grep per CPU și citiți bigfile o dată pe CPU, dar deoarece acest lucru se face în paralel, toate citesc
cu excepția faptului că primul va fi stocat în cache în RAM. În funcție de dimensiunea regexp.txt poate fi
mai rapid de utilizat --bloc 10m în loc de -L1000. Dacă regexp.txt este prea mare pentru a încăpea în RAM,
scoateți --round-robin și reglați -L1000. Acest lucru va face ca bigfile să fie citit de mai multe ori.

Unele sisteme de stocare funcționează mai bine atunci când citesc mai multe bucăți în paralel. Asta este adevărat
pentru unele sisteme RAID și pentru unele sisteme de fișiere din rețea. Pentru a paralela citirea de
bigfile:

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

Acest lucru va împărți bigfile în bucăți de 100 MB și va rula grep pe fiecare dintre aceste bucăți. La
paralelizați atât citirea bigfile, cât și regexp.txt combinați cele două folosind --fifo:

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

Dacă o linie se potrivește cu mai multe expresii regulate, linia poate fi duplicată.

EXEMPLU: Utilizarea la distanta Calculatoare

Pentru a rula comenzi pe un computer la distanță, trebuie configurat SSH și trebuie să vă puteți autentifica
fără a introduce o parolă (Comenzile ssh-copy-id și agent ssh te poate ajuta să faci asta).

Dacă trebuie să vă conectați la un întreg cluster, de obicei nu doriți să acceptați cheia gazdă
pentru fiecare gazdă. Vrei să le accepți prima dată și să fii avertizat dacă vor fi vreodată
schimbat. Pentru a face asta:

# Adăugați serverele la fișierul sshlogin
(echo servera; echo serverb) > .parallel/my_cluster
# Asigurați-vă că există .ssh/config
atingeți .ssh/config
cp .ssh/config .ssh/config.backup
# Dezactivați temporar StrictHostKeyChecking
(echo 'Host *'; echo StrictHostKeyChecking nu) >> .ssh/config
paralel --slf my_cluster --nonall adevărat
# Eliminați dezactivarea StrictHostKeyChecking
mv .ssh/config.backup .ssh/config

Serverele din .paralel/clusterul_meu sunt acum adăugate .ssh/cunoscute_gazde.

A alerga ecou on server.example.com:

secv. 10 | paralel --sshlogin server.example.com echo

Pentru a rula comenzi pe mai multe computere la distanță, executați:

secv. 10 | paralel --sshlogin server.example.com,server2.example.net echo

Sau:

secv. 10 | paralel --sshlogin server.example.com \
--sshlogin server2.example.net echo

Dacă numele de utilizator de conectare este foo on server2.example.net utilizați:

secv. 10 | paralel --sshlogin server.example.com \
--sshlogin [e-mail protejat] ecou

Dacă lista dvs. de gazde este server1-88.example.net cu autentificare foo:

secv. 10 | paralel -Sfoo@server{1..88}.example.net echo

Pentru a distribui comenzile unei liste de computere, creați un fișier calculatoarele mele cu toate
calculatoare:

server.example.com
[e-mail protejat]
server3.example.com

Apoi rulați:

secv. 10 | paralel --sshloginfile mycomputers echo

Pentru a include computerul local, adăugați sshlogin-ul special „:” la listă:

server.example.com
[e-mail protejat]
server3.example.com
:

GNU paralel va încerca să determine numărul de nuclee CPU de pe fiecare telecomandă
computere și rulați o lucrare per nucleu CPU - chiar dacă computerele de la distanță nu au
același număr de nuclee CPU.

Dacă numărul de nuclee CPU de pe computerele de la distanță nu este identificat corect, numărul
de nuclee CPU pot fi adăugate în față. Aici computerul are 8 nuclee CPU.

secv. 10 | paralel --sshlogin 8/server.example.com echo

EXEMPLU: transferare of fișiere

Pentru a recomprima fișierele gzipped cu bzip2 folosind un computer de la distanță rulați:

găsiți jurnalele/ -name „*.gz” | \
paralel --sshlogin server.example.com \
--transfer „zcat {} | bzip2 -9 >{.}.bz2”

Aceasta va lista fișierele .gz din fișierul busteni director și toate directoarele de mai jos. Atunci va fi
transferați fișierele la server.example.com în directorul corespunzător în $HOME/jurnal. Pe
server.example.com fișierul va fi recomprimat folosind zcat și bzip2 rezultând în
fisierul corespunzator cu .gz inlocuit cu .bz2.

Dacă doriți ca fișierul bz2 rezultat să fie transferat înapoi pe computerul local, adăugați
--întoarcere {.}.bz2:

găsiți jurnalele/ -name „*.gz” | \
paralel --sshlogin server.example.com \
--transfer --retur {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

După ce se face recomprimarea .bz2-fișierul este transferat înapoi pe computerul local
si pune langa original .gz-fişier.

Dacă doriți să ștergeți fișierele transferate de pe computerul de la distanță, adăugați --a curăța. Acest
va elimina atât fișierul transferat pe computerul de la distanță, cât și fișierele transferate
de la computerul de la distanță:

găsiți jurnalele/ -name „*.gz” | \
paralel --sshlogin server.example.com \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"

Dacă doriți să rulați pe mai multe computere, adăugați computerele la --sshlogin fie folosind „,” sau
multiplu --sshlogin:

găsiți jurnalele/ -name „*.gz” | \
paralel --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"

Puteți adăuga computerul local folosind --sshlogin :. Acest lucru va dezactiva eliminarea și
transfer numai pentru computerul local:

găsiți jurnalele/ -name „*.gz” | \
paralel --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--sshlogin : \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"

De multe ori --transfer, --întoarcere și --a curăța sunt folosite împreună. Ele pot fi scurtate la
--trc:

găsiți jurnalele/ -name „*.gz” | \
paralel --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--sshlogin : \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

Cu dosarul calculatoarele mele conținând lista calculatoarelor devine:

găsiți jurnalele/ -name „*.gz” | paralel --sshloginfile computerele mele \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

Dacă dosarul ~/.parallel/sshloginfile conține lista de calculatoare cu mâna scurtă specială
-S .. poate fi folosit:

găsiți jurnalele/ -name „*.gz” | paralel -S .. \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

EXEMPLU: distribuirea muncă la local și la distanta Calculatoare

Convertiți *.mp3 în *.ogg care rulează un proces pentru fiecare nucleu CPU pe computerul local și server2:

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

EXEMPLU: Alergare il acelaşi comandă on la distanta Calculatoare

Pentru a rula comanda uptime pe computere la distanță puteți face:

paralel --etichetă --nontoate -S server1,server2 uptime

--nontoate nu citește argumente. Dacă aveți o listă de joburi pe care doriți să le executați pe fiecare computer pe care îl aveți
pot face:

paralel --etichetă --în totalitate -S server1,server2 ecou ::: 1 2 3

Elimină --etichetă dacă nu doriți ca sshlogin-ul să fie adăugat înainte de ieșire.

Dacă aveți o mulțime de gazde, utilizați „-j0” pentru a accesa mai multe gazde în paralel.

EXEMPLU: Paralelizând rsync

rsync este un instrument grozav, dar uneori nu va umple lățimea de bandă disponibilă. Aceasta este
adesea o problemă la copierea mai multor fișiere mari prin conexiuni de mare viteză.

Următoarele vor începe unul rsync per fișier mare în src-dir la dest-dir pe server
fooserver:

cd src-dir; găsi . -Tip f -mărimea +100000 | paralel -v ssh fooserver mkdir -p
/dest-dir/{//}\;rsync -s -Havessh {} fooserver:/dest-dir/{}

Dir-urile create pot avea permisiuni greșite și fișierele mai mici nu sunt disponibile
transferat. Pentru a repara acele alergări rsync o ultimă oară:

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

Dacă nu puteți trimite date, dar trebuie să le extrageți și fișierele se numesc digits.png
(de ex. 000000.png) ați putea face:

urm -w 0 99 | paralel rsync -Havessh fooserver:src-path/*{}.png destdir/

EXEMPLU: Utilizare multiplu intrări in unu comandă

Copiați fișiere precum foo.es.ext în foo.ext:

ls *.es.* | perl -pe 'imprimare; s/\.es//' | paralel -2 N cp 1 {} 2 {}

Comanda perl scuipă 2 linii pentru fiecare intrare. GNU paralel are 2 intrări (folosind -2 N)
și înlocuiește {1} și {2} cu intrările.

Numărați în binar:

paralel -k ecou ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1

Tipăriți numărul pe părțile opuse ale unui zar cu șase fețe:

paralel --aplic -a <(secv 6) -a <(secv 6 -1 1) ecou

paralel --aplic ecou :::: <(secv 6) <(secv 6 -1 1)

Convertiți fișierele din toate subdir-urile în fișiere PNG cu numere consecutive (utile pentru crearea
introduceți PNG-uri pentru FFMPEG):

paralel --aplic -a <(găsiți . -Tip f | fel) -a <(secv $(găsiți . -Tip f|wc -l)) converti
1 {} {2}.png

Versiune alternativa:

găsi . -Tip f | fel | paralel converti {} {#}.png

EXEMPLU: Utilizare a tabel as intrare

Conținutul table_file.tsv:

foo bar
baz quux

A alerga:

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

poti rula:

paralel -a fişier_tabel.tsv --colsep '\t' cmd -o 2 {} -i 1 {}

Notă: Valoarea implicită pentru GNU paralel este să eliminați spațiile din jurul coloanelor. Pentru a păstra
spatii:

paralel -a fişier_tabel.tsv --tunde n --colsep '\t' cmd -o 2 {} -i 1 {}

EXEMPLU: Alerga il acelaşi comandă 10 ori

Dacă doriți să rulați aceeași comandă cu aceleași argumente de 10 ori în paralel, puteți
do:

urm 10 | paralel -n0 comanda_mea my_args

EXEMPLU: De lucru as pisică | SH. Resursă ieftin de locuri de muncă și evaluare

GNU paralel poate funcționa similar cu pisică | sh.

O lucrare ieftină din resurse este o sarcină care necesită foarte puțin CPU, I/O pe disc și I/O în rețea.
Ping este un exemplu de muncă ieftină din resurse. wget este și el - dacă paginile web sunt mici.

Conținutul fișierului 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

Pentru a rula 100 de procese simultan, faceți:

paralel -j 100 < joburi_de_rulat

Cum nu există o comandă locurile de muncă vor fi evaluate de shell.

EXEMPLU: Prelucrare a mare fişier folosind mai mult miezuri

Pentru a procesa un fișier mare sau o ieșire pe care o puteți utiliza --teava pentru a împărți datele în blocuri
și introduceți blocurile în programul de procesare.

Dacă programul este gzip -9 poti sa faci:

pisică bigfile | paralel --teava --recent '' -k gzip -9 >bigfile.gz

Aceasta se va împărți bigfile în blocuri de 1 MB și transmiteți-l la gzip -9 în paralel. unu gzip
va fi rulat pentru fiecare nucleu al procesorului. Ieșirea de gzip -9 va fi păstrat în ordine și salvat în
bigfile.gz

gzip funcționează bine dacă rezultatul este adăugat, dar unele procesări nu funcționează așa -
de exemplu sortarea. Pentru acest GNU paralel poate pune ieșirea fiecărei comenzi într-un fișier.
Acest lucru va sorta un fișier mare în paralel:

pisică bigfile | paralel --teava --fișiere fel | paralel -Xj1 fel -m {} ';' rm {}
>bigfile.sort

Aici bigfile este împărțit în blocuri de aproximativ 1 MB, fiecare bloc se termină în „\n” (care este
implicit pentru --recent). Fiecare bloc este transmis fel iar ieșirea de la fel este salvat în
fişiere. Aceste fișiere sunt transmise celui de-al doilea paralel care rulează fel -m pe dosarele de dinainte
elimină fișierele. Ieșirea este salvată în bigfile.sort.

GNU paralel's --teava atinge o viteză maximă de aproximativ 100 MB/s, deoarece fiecare octet trebuie copiat
prin GNU paralel. Dar dacă bigfile este un fișier real (de căutare) GNU paralel poate ocoli
copierea și trimiterea pieselor direct în program:

paralel --pipepart --bloc 100m -a bigfile --fișiere fel | paralel -Xj1 fel -m {} ';' rm
{} >bigfile.sort

EXEMPLU: Alergare mai mult decât 250 de locuri de muncă workaround

Dacă trebuie să rulați o cantitate masivă de joburi în paralel, atunci probabil că veți atinge
limita filehandle care este adesea în jur de 250 de locuri de muncă. Dacă sunteți super utilizator, puteți ridica valoarea
limita in /etc/security/limits.conf dar puteți folosi și această soluție. Mânerul fișierului
limita este pe proces. Asta înseamnă că dacă ai generat mai mult GNU paralels apoi fiecare din
pot rula 250 de locuri de muncă. Acest lucru va genera până la 2500 de locuri de muncă:

pisică intrarea mea | paralel --teava -N 50 --round-robin -j50 paralel -j50 your_prg

Acest lucru va genera până la 62500 de joburi (utilizați cu precauție - aveți nevoie de 64 GB RAM pentru a face acest lucru și
poate fi necesar să crești /proc/sys/kernel/pid_max):

pisică intrarea mea | paralel --teava -N 250 --round-robin -j250 paralel -j250 your_prg

EXEMPLU: De lucru as mutex și socoteală semafor

Comanda fără este un alias pentru paralel --semafor.

Un semafor de numărare va permite începerea unui anumit număr de lucrări în fundal.
Când numărul de joburi rulează în fundal, GNU fără va aștepta unul dintre acestea
pentru a finaliza înainte de a începe o altă comandă. fără --aștepta va aștepta până la toate locurile de muncă
complet.

Rulați 10 lucrări simultan în fundal:

pentru i în *.log ; do
ecou $ i
sem -j10 gzip $i ";" ecou gata
făcut
sem --așteaptă

Un mutex este un semafor de numărare care permite rularea unui singur job. Aceasta va edita fișierul
Dosarul meu și adaugă fișierul cu linii cu numerele de la 1 la 3.

secv. 3 | paralel sem sed -i -e 'i{}' myfile

As Dosarul meu poate fi foarte mare este important doar un singur proces editează fișierul în același timp
timp.

Denumiți semaforul pentru a avea mai multe semafore diferite active în același timp:

secv. 3 | parallel sem --id mymutex sed -i -e 'i{}' myfile

EXEMPLU: acasă editor implementate cu nume de fișiere din stdin (standard intrare)

Puteți folosi GNU paralel pentru a porni programe interactive precum emacs sau vi:

pisică lista de fișiere | paralel --tty -X emacs

pisică lista de fișiere | paralel --tty -X vi

Dacă există mai multe fișiere decât pot încăpea pe o singură linie de comandă, editorul va fi pornit
din nou cu fișierele rămase.

EXEMPLU: Alergare sudo

sudo necesită o parolă pentru a rula o comandă ca root. Memorează în cache accesul, așa că aveți nevoie doar
pentru a introduce parola din nou dacă nu ați folosit-o sudo pentru o vreme.

Comanda:

paralel sudo echo ::: Aceasta este o idee proastă

nu este bun, deoarece vi se va solicita parola sudo pentru fiecare dintre sarcini. Puteți
fie faci:

sudo echo Aceasta
paralel sudo echo ::: este o idee bună

sau:

sudo parallel echo ::: Aceasta este o idee bună

În acest fel, trebuie să introduceți o singură dată parola sudo.

EXEMPLU: GNU Paralel as coadă sistem/lot manager

GNU paralel poate funcționa ca un simplu sistem de coadă de joburi sau ca manager de loturi. Ideea este de a pune
locurile de muncă într-un fișier și au GNU paralel citeste din asta continuu. Ca GNU paralel
se va opri la sfârșitul fișierului pe care îl folosim coadă pentru a continua lectura:

adevărat >coada de locuri de muncă; coadă -n+0 -f coada de locuri de muncă | paralel

Pentru a trimite joburile dvs. la coadă:

ecou comanda_mea my_arg >> coada de locuri de muncă

Desigur, puteți folosi -S pentru a distribui joburile pe computere la distanță:

adevărat >coada de locuri de muncă; coadă -f coada de locuri de muncă | paralel -S ..

Există o mică problemă când utilizați GNU paralel ca sistem de cozi/manager de loturi: Ai
pentru a trimite un număr JobSlot de joburi înainte ca acestea să înceapă, iar după aceea, puteți trimite unul
la un moment dat, iar munca va începe imediat dacă sunt disponibile sloturi gratuite. Ieșire din
lucrările executate sau finalizate sunt reținute și vor fi tipărite numai atunci când JobSlots mai multe lucrări
a fost pornit (cu excepția cazului în care utilizați --ungroup sau -u, caz în care rezultatul din joburi
sunt imprimate imediat). De exemplu, dacă aveți 10 locuri de muncă, atunci rezultatul din primul
lucrarea finalizată va fi tipărită numai când lucrarea 11 a început, iar rezultatul celui de-al doilea
lucrarea finalizată va fi tipărită numai când lucrarea 12 a început.

A folosi --eof pentru a face GNU paralel Ieșire, coadă de asemenea, trebuie forțat să iasă:

coada -n+0 -f listă-comandă.txt |
(parallel --eof=EXIT {}; echo Paralel este acum gata;
(seq 1000 >> command-list.txt &);
echo. Adăugarea datelor false, forțând coada să iasă)

EXEMPLU: GNU Paralel as dir procesor

Dacă aveți un director în care utilizatorii plasează fișiere care trebuie procesate, puteți face acest lucru
GNU/Linux (dacă știți ce inotifywait este apelat pe alte platforme, înregistrează un raport de eroare):

inotifywait -q -m -r -e MUTAT LA -e CLOSE_WRITE --format %w%f my_dir | paralel -u ecou

Aceasta va rula comanda ecou pe fiecare fișier introdus în my_dir sau subdirs de my_dir.

Desigur, puteți folosi -S pentru a distribui joburile pe computere la distanță:

inotifywait -q -m -r -e MUTAT LA -e CLOSE_WRITE --format %w%f my_dir | paralel -S .. -u
ecou

Dacă fișierele care urmează să fie procesate sunt într-un fișier tar, atunci despachetați un fișier și procesați-l
imediat poate fi mai rapid decât prima despachetare a tuturor fișierelor. Configurați procesorul dir ca
de mai sus și despachetați în dir.

Utilizarea GNU Parallel ca procesor dir are aceleași limitări ca și utilizarea GNU Parallel ca
sistem de cozi/manager de loturi.

CITAREA

GNU paralel este foarte liberal în a cita. Trebuie doar să citați personaje care au
semnificație specială în coajă:

( ) $ ` ' " < > ; | \

și, în funcție de context, trebuie citate și acestea:

~ & # ! ? spatiu * {

Prin urmare, majoritatea oamenilor nu vor avea niciodată nevoie de mai multe citate decât de punerea „\” în fața
caractere speciale.

Adesea puteți pune pur și simplu \' în jurul fiecărui ':

perl -ne '/^\S+\s+\S+$/ și tipăriți fișierul $ARGV,"\n"'

pot fi citate:

paralel perl -ne \''/^\S+\s+\S+$/ și tipăriți fișierul $ARGV,"\n"'\' :::

Cu toate acestea, când doriți să utilizați o variabilă shell, trebuie să citați semnul $. Iată un
exemplu folosind $PARALLEL_SEQ. Această variabilă este setată de GNU paralel în sine, deci
evaluarea $ trebuie să fie făcută de subshell-ul pornit de GNU paralel:

urm 10 | paralel -2 N ecou seq:\$PARALLEL_SEQ arg1:{1} arg2:{2}

Dacă variabila este setată înainte de GNU paralel începe, puteți face asta:

VAR=this_is_set_before_starting

ecou test | paralel ecou {} $var

Tipărituri: test acesta_este_setat_inainte_de_pornire

Este puțin mai complicat dacă variabila conține mai mult de un spațiu pe rând:

VAR="două spații între fiecare cuvânt"

ecou test | paralel ecou {} \'"$VAR"\'

Tipărituri: test Două spații între fiecare cuvânt

Dacă variabila nu trebuie evaluată de shell-ul care pornește GNU paralel dar fii
evaluat de subshell-ul început de GNU paralel, atunci trebuie să o citați:

ecou test | paralel VAR=acesta_este_setat_după_pornire \; ecou {} \$VAR

Tipărituri: test acesta_este_setat_după_pornire

Este puțin mai complicat dacă variabila conține spațiu:

ecou test | paralel VAR='"două spații între fiecare cuvânt"' ecou {} \'"$VAR"\'

Tipărituri: test Două spații între fiecare cuvânt

$$ este variabila shell care conține id-ul de proces al shell-ului. Aceasta va imprima
ID-ul de proces al shell-ului care rulează GNU paralel:

urm 10 | paralel ecou $$

Și aceasta va tipări ID-urile de proces ale subshell-urilor începute de GNU paralel.

urm 10 | paralel ecou \$\$

Dacă caracterele speciale nu ar trebui să fie evaluate de subshell, atunci trebuie
protejați-l împotriva evaluării atât din shell-ul pornind GNU paralel și sub shell:

ecou test | paralel ecou {} \\\$VAR

Tipărituri: test $var

GNU paralel poate proteja împotriva evaluării de către subshell folosind -q:

ecou test | paralel -q ecou {} \$VAR

Tipărituri: test $var

Acest lucru este util în special dacă aveți multe citate. Dacă doriți să rulați un script perl
asa:

perl - este '/^\S+\s+\S+$/ și imprima $ARGV,"\n"' fişier

Trebuie citat astfel:

ls | paralel perl - este '/^\\S+\\s+\\S+\$/\ și\ imprimare\ \$ARGV,\"\\n\"' ls | paralel perl
- este \''/^\S+\s+\S+$/ și imprima $ARGV,"\n"'\'

Observați cum spațiile, \, " și $ trebuie să fie citate. GNU paralel poate face citarea prin
folosind opțiunea -q:

ls | paralel -q perl - este '/^\S+\s+\S+$/ și imprima $ARGV,"\n"'

Cu toate acestea, aceasta înseamnă că nu puteți face ca subshell-ul să interpreteze caractere speciale. Pentru
exemplu din cauza -q aceasta NU VA FUNCȚIONA:

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

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

deoarece > și | trebuie interpretate de subshell.

Dacă primești erori precum:

sh: -c: linia 0: eroare de sintaxă aproape de simbolul neașteptat
sh: Eroare de sintaxă: șir între ghilimele neterminate
sh: -c: linia 0: EOF neașteptat în timp ce se caută `'' care se potrivește
sh: -c: linia 1: eroare de sintaxă: sfârșit neașteptat al fișierului

atunci s-ar putea să încerci să folosești -q.

Dacă utilizați pocni înlocuirea procesului ca <(cat foo) atunci poti incerca -q și
precedând comandă implementate cu pocni -c:

ls | paralel -q pocni -c 'WC -c <(ecou {})'

Sau pentru înlocuirea ieșirii:

ls | paralel -q pocni -c 'gudron c {} | reper >(gzip >{}.tar.gz) | bzip2 >{}.tar.bz2'

Concluzie : Pentru a evita problemele de citare, poate fi mai ușor să scrieți a
script mic sau o funcție (nu uitați să exporturile -f funcția) și au GNU paralel apel
acea.

LISTA ALERGARE LOCURI DE MUNCĂ

Dacă doriți o listă a joburilor care rulează în prezent, puteți rula:

omoara-i pe toti -USR1 paralel

GNU paralel va imprima apoi lucrările care rulează în prezent pe stderr (eroare standard).

COMPLET ALERGARE LOCURI DE MUNCĂ DAR DO NU START NOU LOCURI DE MUNCĂ

Dacă regretați că ați început o mulțime de locuri de muncă, puteți pur și simplu să rupeți GNU paralel, dar dacă vrei
asigurați-vă că nu aveți joburi pe jumătate finalizate, ar trebui să trimiteți semnalul TERMEN ȚINTĂ la GNU
paralel:

omoara-i pe toti -TERMEN paralel

Acest lucru va spune GNU paralel pentru a nu începe niciun loc de muncă nou, ci așteptați până la momentul actual
lucrările care rulează sunt terminate înainte de a ieși.

MEDIUL VARIABILE

$PARALLEL_PID
Variabila de mediu $PARALLEL_PID este setată de GNU paralel și este vizibil pentru
locurile de muncă au început de la GNU paralel. Acest lucru face posibil pentru locuri de muncă să
comunica direct cu GNU paralel. Nu uitați să citați $, astfel încât să primească
evaluat de învelișul corect.

Exemplu: Dacă fiecare dintre joburi testează o soluție și unul dintre joburi găsește soluția
locul de muncă poate spune GNU paralel să nu înceapă mai multe locuri de muncă prin: ucide -TERMEN
$PARALLEL_PID. Acest lucru funcționează numai pe computerul local.

$PARALLEL_SHELL (testare alfa)
Utilizați acest shell pentru comenzile rulate de GNU Parallel:

· $PARALLEL_SHELL. Dacă este nedefinit, utilizați:

· Shell-ul care a pornit GNU Parallel. Dacă acest lucru nu poate fi determinat:

· $SHELL. Dacă este nedefinit, utilizați:

· / Bin / sh

$PARALLEL_SEQ
$PARALLEL_SEQ va fi setat la numărul de secvență al jobului care rulează. A își aminti să
citați $, astfel încât să fie evaluat de shell-ul corect.

Exemplu:

urm 10 | paralel -2 N ecou seq:'$'PARALLEL_SEQ arg1:{1} arg2:{2}

Director $TMPDIR pentru fișiere temporare. Vedea: --tmpdir.

$PARALEL
Variabila de mediu $PARALLEL va fi folosită ca opțiuni implicite pentru GNU
paralel. Dacă variabila conține caractere shell speciale (de exemplu, $, * sau spațiu)
atunci acestea trebuie să fie scăpate cu \.

Exemplu:

pisică listă | paralel -j1 -k -v ls

poate fi scris ca:

pisică listă | PARALLEL="-kvj1" paralel ls

pisică listă | paralel -j1 -k -v -S"myssh utilizator@server" ls

poate fi scris ca:

pisică listă | PARALEL='-kvj1 -S myssh\ utilizator@server' paralel ecou

Observați că \ din mijloc este necesar deoarece „myssh” și „user@server” trebuie să fie
un singur argument.

DEFAULT PROFIL (CONFIG FIŞIER)

Fișierul de configurare globală /etc/parallel/config, urmat de fișierul de configurare a utilizatorului
~/.paralel/config (cunoscute anterior ca .parallelrc) vor fi citite pe rând dacă există.
Liniile care încep cu „#” vor fi ignorate. Formatul îl poate urma pe cel al mediului
variabilă $PARALLEL, dar este adesea mai ușor să puneți pur și simplu fiecare opțiune pe propria linie.

Opțiunile de pe linia de comandă au prioritate, urmate de variabila de mediu
$PARALLEL, fișier de configurare a utilizatorului ~/.paralel/config, și în sfârșit global
fișierul de configurare /etc/parallel/config.

Rețineți că niciun fișier care este citit pentru opțiuni și nici variabila de mediu $PARALLEL poate
conțin opțiuni retrase, cum ar fi --tollef.

PROFIL DOSARE

If --profil set, GNU paralel va citi profilul din acel fișier, mai degrabă decât cel global
sau fișierele de configurare a utilizatorului. Puteți avea mai multe --profile.

Exemplu: Profil pentru rularea unei comenzi la fiecare sshlogin în ~/.ssh/sshlogins și antecedente
ieșirea cu sshlogin:

echo --tag -S .. --nonall > ~/.paralel/n
paralel -Jn uptime

Exemplu: Profil pentru rularea fiecărei comenzi cu -j-1 și frumos

echo -j-1 frumos > ~/.parallel/nice_profile
paralel -J nice_profile bzip2 -9 ::: *

Exemplu: Profil pentru rularea unui script perl înainte de fiecare comandă:

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

Observați cum $ și " trebuie să fie citate folosind \.

Exemplu: Profil pentru rularea joburilor distribuite cu frumos pe computerele de la distanță:

ecou -S .. frumos > ~/.paralel/dist
paralel -J dist --trc {.}.bz2 bzip2 -9 ::: *

EXIT STAREA

If --oprire-la-eroare 0 sau nespecificat:

0 Toate joburile au rulat fără eroare.

1-253 Unele dintre lucrări au eșuat. Starea de ieșire indică numărul de joburi eșuate

254 Mai mult de 253 de locuri de muncă au eșuat.

255 Altă eroare.

If --oprire-la-eroare 1 sau 2: starea de ieșire a jobului eșuat.

DIFERENȚE ÎNTRE GNU Paralel AND ALTERNATIVE

Există o mulțime de programe cu unele dintre funcționalitățile GNU paralel. GNU paralel
se străduiește să includă cele mai bune funcționalități fără a sacrifica ușurința de utilizare.

REZUMAT TABEL
Următoarele caracteristici se află în unele dintre instrumentele comparabile:

Intrări
I1. Argumentele pot fi citite din stdin
I2. Argumentele pot fi citite dintr-un fișier
I3. Argumentele pot fi citite din mai multe fișiere
I4. Argumentele pot fi citite din linia de comandă
I5. Argumentele pot fi citite dintr-un tabel
I6. Argumentele pot fi citite din același fișier folosind #! (sebang)
I7. Intrare orientată pe linie implicită (nu este necesară citarea caracterelor speciale)

Manipularea intrării
M1. Comandă compusă
M2. Mai multe argumente pot umple o linie de execuție
M3. Argumentele pot fi puse oriunde în linia de execuție
M4. Mai multe argumente pot fi puse oriunde în linia de execuție
M5. Argumentele pot fi înlocuite cu context
M6. Intrarea poate fi tratată ca linie de execuție completă

ieşiri
O1. Gruparea ieșirilor astfel încât rezultatele de la diferite lucrări să nu se amestece
O2. Trimiteți stderr (eroare standard) către stderr (eroare standard)
O3. Trimite stdout (ieșire standard) la stdout (ieșire standard)
O4. Ordinea de ieșire poate fi aceeași cu ordinea de intrare
O5. Stdout conține doar stdout (ieșire standard) din comandă
O6. Stderr conține doar stderr (eroare standard) din comandă

Execuție
E1. Rularea joburilor în paralel
E2. Enumerați joburile care rulează
E3. Finalizați executarea lucrărilor, dar nu începeți lucrări noi
E4. Numărul de joburi care rulează poate depinde de numărul de CPU
E5. Finalizați executarea lucrărilor, dar nu începeți lucrări noi după primul eșec
E6. Numărul de lucrări care rulează poate fi ajustat în timpul rulării

Execuție de la distanță
R1. Lucrările pot fi executate pe computere la distanță
R2. Fișierele de bază pot fi transferate
R3. Fișierele argument pot fi transferate
R4. Fișierele cu rezultate pot fi transferate
R5. Curățarea fișierelor transferate
R6. Nu sunt necesare fișiere de configurare
R7. Nu rulați mai mult decât poate suporta MaxStartups de la SSHD
R8. Comanda SSH configurabilă
R9. Reîncercați dacă conexiunea se întrerupe ocazional

semafor
S1. Posibilitatea de a lucra ca mutex
S2. Posibilitatea de a lucra ca semafor de numărare

Legendă
- = nu
x = nu se aplică
ID = da

Deoarece fiecare versiune nouă a programelor nu este testată, tabelul poate fi depășit. Vă rugăm să înregistrați
un raport de eroare dacă găsiți erori (Consultați RAPORTAREA ERRORELOR).

paralel: 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

face -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 - Vă rugăm să trimiteți un raport de eroare dacă știți ce caracteristici suportă xjobs (vezi
RAPORTAREA ERRORELOR).

prll: TODO - Vă rugăm să trimiteți un raport de eroare dacă știți ce caracteristici acceptă prll (vezi
RAPORTAREA ERRORELOR).

dxargs: TODO - Vă rugăm să trimiteți un raport de eroare dacă știți ce caracteristici suportă dxargs (vezi
RAPORTAREA ERRORELOR).

mdm/middelman: TODO - Vă rugăm să trimiteți un raport de eroare dacă știți ce caracteristici mdm/middelman
suporturi (vezi RAPORTAREA ERRORELOR).

xapply: TODO - Vă rugăm să trimiteți un raport de eroare dacă știți ce caracteristici suportă xapply (vezi
RAPORTAREA ERRORELOR).

paexec: TODO - Vă rugăm să trimiteți un raport de eroare dacă știți ce caracteristici suportă paexec (vezi
RAPORTAREA ERRORELOR).

ladon: TODO - Vă rugăm să trimiteți un raport de eroare dacă știți ce caracteristici suportă ladon (vezi
RAPORTAREA ERRORELOR).

ClusterSSH: TODO - Vă rugăm să trimiteți un raport de eroare dacă știți ce caracteristici acceptă ClusterSSH
(Consultați RAPORTAREA EROARELOR).

DIFERENȚE ÎNTRE xargs AND GNU Paralel
xargs oferă unele dintre aceleași posibilități ca și GNU paralel.

xargs se ocupă prost cu caracterele speciale (cum ar fi spațiu, ' și "). Pentru a vedea problema, încercați
acest:

atingeți important_file
atingeți „fișier_nu-important”
nu e* | xargs rm
mkdir -p „Înregistrările 12 ale fratelui meu”
ls | xargs rmdir

Puteți specifica -0 or -d "\n", dar multe generatoare de intrare nu sunt optimizate pentru utilizare nul
ca separator dar sunt optimizate pentru linie nouă ca separator. De exemplu cap, coadă, Wow, ls, ecou,
sete, gudron -v, perl (-0 și \0 în loc de \n), localiza (necesită utilizarea -0), găsi (necesită
folosind -print0), grep (necesită utilizatorului să folosească -z or -Z), fel (necesită utilizarea -z).

Deci GNU paralelSepararea de linie nouă a lui poate fi emulată cu:

pisică | xargs -d "\n" -n1 comandă

xargs poate rula un anumit număr de joburi în paralel, dar nu are suport pentru rularea numărului-
of-cpu-cores locuri de muncă în paralel.

xargs nu are suport pentru gruparea ieșirii, prin urmare ieșirea poate rula împreună, de ex
prima jumătate a unei linii este dintr-un proces, iar ultima jumătate a liniei este de la altul
proces. Exemplul Paralel grep nu se poate face în mod fiabil cu xargs din acest motiv. La
vezi asta in actiune incearca:

paralel perl -e '\$a=\"1{}\"x10000000\;print\ \$a,\"\\n\"' '>' {} ::: abcdef
ls -labcdef
paralel -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 out*
ieșire suma md5*

xargs nu are suport pentru păstrarea ordinii de ieșire, prin urmare dacă rulează joburi în
folosind paralel xargs ieșirea celui de-al doilea job nu poate fi amânată până la primul job
este gata.

xargs nu are suport pentru executarea de joburi pe computere la distanță.

xargs nu are suport pentru înlocuirea contextului, așa că va trebui să creați argumentele.

Dacă utilizați un șir de înlocuire în xargs (-I) nu poți forța xargs a folosi mai mult de unul
a susținut.

Citând în xargs funcționează ca. -q în GNU paralel. Aceasta înseamnă comenzi compuse și
redirecționarea necesită utilizarea pocni -c.

ls | paralel "WC {} > {}.WC"

devine (presupunând că aveți 8 nuclee)

ls | xargs -d "\n" - P8 -I {} pocni -c "WC {} > {}.WC"

și

ls | paralel "ecou {}; ls {}|wc"

devine (presupunând că aveți 8 nuclee)

ls | xargs -d "\n" - P8 -I {} pocni -c "ecou {}; ls {}|wc"

DIFERENȚE ÎNTRE găsi -exec AND GNU Paralel
găsi -exec oferă unele dintre aceleași posibilități ca și GNU paralel.

găsi -exec funcționează doar pe fișiere. Deci, procesarea altor intrări (cum ar fi gazde sau URL-uri) va fi
necesită crearea acestor intrări ca fișiere. găsi -exec nu are suport pentru rularea comenzilor în
paralel.

DIFERENȚE ÎNTRE face -j AND GNU Paralel
face -j poate rula joburi în paralel, dar necesită un Makefile creat pentru a face acest lucru. Asta rezultă
în ghilimele suplimentare pentru ca numele fișierului care conține noua linie să funcționeze corect.

face -j nu are suport pentru gruparea ieșirii, prin urmare ieșirea poate rula împreună, de ex
prima jumătate a unei linii este dintr-un proces, iar ultima jumătate a liniei este de la altul
proces. Exemplul Paralel grep nu se poate face în mod fiabil cu face -j din cauza asta.

(Versiunile foarte timpurii ale GNU paralel au fost implementate coincident folosind face -j).

DIFERENȚE ÎNTRE ppss AND GNU Paralel
ppss este, de asemenea, un instrument pentru rularea joburilor în paralel.

Rezultatul ppss este informație de stare și, prin urmare, nu este utilă pentru utilizare ca intrare pentru
altă comandă. Ieșirile din joburi sunt plasate în fișiere.

Argumentul de înlocuire a șirului ($ITEM) nu poate fi modificat. Argumentele trebuie citate – astfel
argumentele care conțin caractere speciale (spațiul „"&!*) pot cauza probleme. Mai multe
argumentul nu este susținut. Numele de fișiere care conțin linii noi nu sunt procesate corect.
Când citiți intrarea dintr-un fișier, nulul nu poate fi folosit ca terminator. ppss trebuie să citească
întregul fișier de intrare înainte de a începe orice lucrare.

Informațiile de ieșire și de stare sunt stocate în ppss_dir și, prin urmare, necesită curățare când
efectuat. Dacă directorul nu este eliminat înainte de a rula ppss din nou nu poate cauza nimic
se întâmplă ca ppss crede că sarcina este deja făcută. GNU paralel în mod normal nu va avea nevoie
curățarea dacă rulează local și va avea nevoie doar de curățare dacă este oprită anormal și
rulează la distanță (--a curăța poate să nu se termine dacă este oprit anormal). Exemplul Paralel
grep ar necesita o postprocesare suplimentară dacă este scris folosind ppss.

Pentru sistemele de la distanță, PPSS necesită 3 pași: configurare, implementare și pornire. GNU paralel
necesită un pas.

EXEMPLE DIN ppss MANUAL

Iată exemplele din ppsspagina de manual a lui cu echivalentul folosind GNU paralel:

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

1 găsiți /calea/către/fișiere -tip f | paralel gzip

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

2 găsiți /calea/către/fișiere -tip f | paralel cp {} /destinație/dir

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

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

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

4 paralel -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 # paralel nu folosește configurații. Dacă doriți un alt nume de utilizator, puneți-l în nodes.txt:
utilizator@nume gazdă

5 găsi sursă/dir -tip f | paralel --sshloginfile nodes.txt --trc {.}.mp3 lame -a {} -o
{.}.mp3 --standard presetat --liniștit

6 ./ppss stop -C config.cfg

6 killall -TERM paralel

7 ./ppss pauză -C config.cfg

7 Apăsați: CTRL-Z sau killall -SIGTSTP paralel

8 ./ppss continua -C config.cfg

8 Introduceți: fg sau killall -SIGCONT paralel

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

9 killall -SIGUSR2 paralel

DIFERENȚE ÎNTRE pexec AND GNU Paralel
pexec este, de asemenea, un instrument pentru rularea joburilor în paralel.

EXEMPLE DIN pexec MANUAL

Iată exemplele din pexecpagina de informații a lui cu echivalentul folosind GNU paralel:

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

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

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

2 ls myfiles*.ext | sortare paralelă {} ">{}.sortare"

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

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

4 pexec -r *.png -e IMG -c -o - -- \
'convert $IMG ${IMG%.png}.jpeg ; "echo $IMG: terminat"'

4 ls *.png | paralel 'convertit {} {.}.jpeg; ecou {}: gata'

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

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

6 pentru p în *.png; do echo ${p%.png} ; terminat | \
pexec -f - -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'

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

7 LIST=$(pentru p în *.png; face eco ${p%.png}; gata)
pexec -r $LIST -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'

7 ls *.png | paralel '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 Combinând GNU paralel și GNU fără.

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

8 Dacă citirea și scrierea se face pe același disc, acest lucru poate fi mai rapid ca un singur proces
va fi fie citit, fie scris:

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

DIFERENȚE ÎNTRE xjobs AND GNU Paralel
xjobs este, de asemenea, un instrument pentru rularea joburilor în paralel. Acceptă numai executarea de joburi pe dvs
calculator local.

xjobs se ocupă prost cu personajele speciale la fel ca xargs. Vezi secțiunea DIFERENȚE
ÎNTRE xargs AND GNU Paralel.

Iată exemplele din xjobspagina de manual a lui cu echivalentul folosind GNU paralel:

1 ls -1 *.zip | xjobs dezarhivați

1 ls *.zip | dezarhivare paralelă

2 ls -1 *.zip | xjobs -n dezarhivați

2 ls *.zip | dezarhivare paralelă >/dev/null

3 găsi . -nume '*.bak' | xjobs gzip

3 găsi . -nume '*.bak' | paralel gzip

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

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

5 scriptul xjobs -s

5 script pisica | paralel

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 | paralel & echo dezarhivare 1.zip
>> /var/run/my_named_pipe; echo tar cf /backup/myhome.tar /home/me >>
/var/run/my_named_pipe

DIFERENȚE ÎNTRE prll AND GNU Paralel
prll este, de asemenea, un instrument pentru rularea joburilor în paralel. Nu acceptă executarea de joburi
calculatoare la distanță.

prll încurajează utilizarea aliasurilor BASH și a funcțiilor BASH în loc de scripturi. GNU paralel
nu va suporta niciodată rularea alias-urilor (vedeți de ce
http://www.perlmonks.org/index.pl?node_id=484296). Cu toate acestea, scripturi, comenzi compuse sau
funcții exportate cu exporturile -f funcționează bine.

prll generează o mulțime de informații de stare pe stderr (eroare standard), ceea ce o face
mai greu de folosit ieșirea stderr (eroare standard) a jobului direct ca intrare pentru altul
programul.

Iată exemplul de la prllpagina de manual a lui cu echivalentul folosind GNU paralel:

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

paralel mogrify -flip ::: *.jpg

DIFERENȚE ÎNTRE dxargs AND GNU Paralel
dxargs este, de asemenea, un instrument pentru rularea joburilor în paralel.

dxargs nu se descurcă bine cu mai multe joburi simultane decât MaxStartups de la SSHD. dxargs is
construit numai pentru joburi de rulare la distanță, dar nu acceptă transferul de fișiere.

DIFERENȚE ÎNTRE mdm/intermediar AND GNU Paralel
intermediar(mdm) este, de asemenea, un instrument pentru rularea joburilor în paralel.

Iată shellscript-urile http://mdm.berlios.de/usage.html portat la GNU paralel:

urm 19 | paralel bufon -o - | fel -n > rezultat

pisică fișiere | paralel cmd

găsi dir -execdir fără cmd {} \;

DIFERENȚE ÎNTRE xapply AND GNU Paralel
xapply poate rula joburi în paralel pe computerul local.

Iată exemplele din xapplypagina de manual a lui cu echivalentul folosind GNU paralel:

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

1 paralel „cd {} && make all” ::: */

2 xapply -f „diff %1 ../version5/%1” manifest | Mai mult

2 parallel diff {} ../version5/{} < manifest | Mai mult

3 xapply -p/dev/null -f „diff %1 %2” manifest1 lista de verificare1

3 paralel --xapply diff {1} {2} :::: listă de verificare manifest1

4 xapply 'indent' *.c

4 liniuță paralelă ::: *.c

5 găsiți ~ksb/bin -type f ! -perm -111 -print | xapply -f -v 'chmod a+x' -

5 găsiți ~ksb/bin -type f ! -perm -111 -print | paralel -v chmod a+x

6 găsi */ -... | fmt 960 1024 | xapply -f -i /dev/tty 'vi' -

6 sh <(găsește */ -... | paralel -s 1024 echo vi)

6 găsi */ -... | paralel -s 1024 -Xuj1 vi

7 găsi... | xapply -f -5 -i /dev/tty 'vi' - - - - -

7 sh <(găsește ... |paralel -n5 echo vi)

7 găsi ... |paralel -n5 -uj1 vi

8 xapply -fn "" / Etc / passwd

8 paralel -k ecou / Etc / passwd

9 tr ':' '\012' / Etc / passwd | xapply -7 -nf 'chown %1 %6' - - - - - - -

9 tr ':' '\012' / Etc / passwd | paralel -N7 chown {1} {6}

10 xapply '[ -d %1/RCS ] || ecou %1' */

10 paralel '[ -d {}/RCS ] || ecou {}' ::: */

11 xapply -f '[ -f %1 ] && echo %1' Lista | ...

11 paralel '[ -f {} ] && echo {}' < Listă | ...

DIFERENȚE ÎNTRE paexec AND GNU Paralel
paexec poate rula joburi în paralel atât pe computerele locale, cât și pe computerele de la distanță.

paexec necesită comenzi pentru a imprima o linie goală ca ultima ieșire. Asta înseamnă că vei face
trebuie să scrie un wrapper pentru majoritatea programelor.

paexec are o facilitate de dependență de job, astfel încât un job poate depinde de un alt job care urmează să fie executat
cu succes. Un fel de sărac face.

Iată exemplele din paexecExemplul de catalog cu echivalentul folosind GNU
paralel:

1_div_X_run:
../../paexec -s -l -c "`pwd`/1_div_X_cmd" -n +1 <
ecou paralel {} '|' `pwd`/1_div_X_cmd <

all_substr_run:
../../paexec -lp -c "`pwd`/all_substr_cmd" -n +3 <
ecou paralel {} '|' `pwd`/all_substr_cmd <

cc_wrapper_run:
../../paexec -c "env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd" \
-n „gazdă1 gazdă2” \
-t '/usr/bin/ssh -x' <
ecou paralel {} '|' „env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd” \
-S gazdă1,gazdă2 <
# Acesta nu este exact același, dar evită ambalajul
paralel gcc -O2 -c -o {.}.o {} \
-S gazdă1,gazdă2 <

toupper_run:
../../paexec -lp -c "`pwd`/toupper_cmd" -n +10 <
ecou paralel {} '|' ./toupper_cmd <
# Fără ambalaj:
ecou paralel {} '| awk {printare\ toupper\(\$0\)}' <

DIFERENȚE ÎNTRE Hartă AND GNU Paralel
Hartă consideră că este o caracteristică de a avea mai puține caracteristici și, făcând acest lucru, se ocupă și de colț
cazuri incorect. Mult GNU paralelCodul lui este să gestioneze corect cazurile de colț
fiecare platformă, deci nu veți primi o surpriză urâtă dacă, de exemplu, un utilizator salvează un fișier
numit: My a fratelui 12 " records.txt

HartăExemplul lui care arată cum să faceți față caracterelor speciale eșuează cu caracterele speciale:

echo "The Cure" > Înregistrările\ 12\"\ ale fratelui meu

ls | harta 'echo -n `gzip < "%" | wc -c`; echo -n '*100/'; wc -c < "%"' | bc

Funcționează cu GNU paralel:

ls | paralel 'echo -n `gzip < {} | wc -c`; echo -n '*100/'; wc -c < {}' | bc

Și puteți chiar să puneți numele fișierului înainte:

ls | paralel --tag '(echo -n `gzip < {} | wc -c`'*100/'; wc -c < {}) | bc'

Hartă nu are suport pentru grupare. Deci, acest lucru dă rezultate greșite fără niciun avertisment:

paralel perl -e '\$a=\"1{}\"x10000000\;print\ \$a,\"\\n\"' '>' {} ::: abcdef
ls -labcdef
paralel -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 out*
ieșire suma md5*

Documentația arată o soluție, dar nu numai că amestecul stdout (ieșire standard)
cu stderr (eroare standard), de asemenea, eșuează complet pentru anumite joburi (și poate chiar să fie
considerată mai puțin lizibilă):

ecou paralel -n {} ::: 1 2 3

harta -p 4 'echo -n % 2>&1 | sed -e "s/^/$$:/"' 1 2 3 | sortare | tăiați -f2- -d:

Hartă nu poate gestiona opțiunile grupate: Hartă -vp 0 ecou acest eșuează

Hartă nu are un separator de argumente pe linia de comandă, dar folosește primul argument
ca comanda. Acest lucru îngreunează citarea, ceea ce poate afecta din nou lizibilitatea. Comparaţie:

harta -p 2 perl\\\ -ne\\\ \\\'/^\\\\S+\\\\s+\\\\S+\\\$/\\\ și\\\ print\\\ \\\$ARGV,\\\"\\\\n\\\"\\\' *

paralel -q perl -ne '/^\S+\s+\S+$/ și tipăriți $ARGV,"\n"' ::: *

Hartă poate face mai multe argumente cu înlocuirea contextului, dar nu fără înlocuirea contextului:

paralel --xargs echo 'BEGIN{'{}'}END' ::: 1 2 3

Hartă nu setează valoarea de ieșire în funcție de faptul dacă una dintre sarcini a eșuat:

paralel fals ::: 1 || echo Job a eșuat

harta falsă 1 || ecou Nu alerga niciodată

Hartă necesită Perl v5.10.0, ceea ce face mai greu de utilizat pe sisteme vechi.

Hartă nu are nicio modalitate de a folosi % în comandă (GNU Parallel are -I pentru a specifica un altul
șir de înlocuire decât {}).

De proiectare Hartă este opțiune incompatibilă cu xargs, nu are execuție la distanță a jobului, a
modalitate structurată de salvare a rezultatelor, surse multiple de intrare, indicator de progres, configurabil
delimitator de înregistrare (doar delimitator de câmp), înregistrarea lucrărilor rulate cu posibilitate de reluare,
menținerea ieșirii în aceeași ordine ca intrarea, procesarea --pipe și dinamic
timeout-uri.

DIFERENȚE ÎNTRE Ladon AND GNU Paralel
Ladon poate rula mai multe joburi pe fișiere în paralel.

Ladon funcționează numai pe fișiere și singura modalitate de a specifica fișiere este utilizarea unui șir global între ghilimele
(cum ar fi \*.jpg). Nu este posibilă listarea manuală a fișierelor.

Ca șiruri de înlocuire, folosește FULLPATH DIRNAME BASENAME EXT RELDIR RELPATH

Acestea pot fi simulate folosind GNU paralel prin introducerea asta ~/.paralel/config:

--rpl 'FULLPATH $_=::shell_quote($_);chomp($_=qx{readlink -f $_});'
--rpl 'DIRNAME $_=::shell_quote(::dirname($_));chomp($_=qx{readlink -f $_});'
--rpl 'BASENAME 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 se ocupă prost cu numele de fișiere care conțin „ și newline și nu reușește pentru o ieșire mai mare
peste 200k:

ladon '*' -- seq 36000 | WC

EXEMPLE DIN Ladon MANUAL

Se presupune că „--rpl-urile de mai sus sunt introduse ~/.paralel/config și că este rulat
sub o carcasă care acceptă „**” globbing (cum ar fi zsh):

1 ladon "**/*.txt" -- echo RELPATH

1 ecou paralel RELPATH ::: **/*.txt

2 ladon"~/Documente/**/*.pdf" -- shasum FULLPATH >hashes.txt

2 paralel shasum FULLPATH ::: ~/Documente/**/*.pdf >hashes.txt

3 ladon -m thumbs/RELDIR "**/*.jpg" loading="lazy" -- convert FULLPATH -thumbnail 100x100^ -gravity
center -extent 100x100 thumbs/RELPATH

3 paralel mkdir -p thumbs/RELDIR\; converti FULLPATH -thumbnail 100x100^ -centrul de gravitație
-extent 100x100 thumbs/RELPATH ::: **/*.jpg

4 ladon"~/Muzică/*.wav" -- lame -V 2 FULLPATH DIRNAME/BASENAME.mp3

4 parallel lame -V 2 FULLPATH DIRNAME/BASENAME.mp3 ::: ~/Muzică/* .wav

DIFERENȚE ÎNTRE ClusterSSH AND GNU Paralel
ClusterSSH rezolvă o problemă diferită de GNU paralel.

ClusterSSH deschide o fereastră de terminal pentru fiecare computer și, folosind o fereastră principală, puteți rula
aceeași comandă pe toate computerele. Acesta este de obicei folosit pentru administrarea mai multor
calculatoare care sunt aproape identice.

GNU paralel rulează aceleași (sau diferite) comenzi cu argumente diferite în paralel
posibil folosind computere la distanță pentru a ajuta la calcul. Dacă sunt listate mai multe computere în
-S GNU paralel poate folosi doar una dintre acestea (de exemplu, dacă sunt 8 lucrări de executat și una
calculatorul are 8 nuclee).

GNU paralel poate fi folosit ca versiune pentru un om sărac a ClusterSSH:

paralel --nontoate -S server-a,server-b face_lucruri foo bar

Utilizați paralel online folosind serviciile onworks.net