paralelo: en línea en la nube

PROGRAMA:

NOMBRE

paralelo: construye y ejecuta líneas de comando de shell desde la entrada estándar en paralelo

SINOPSIS

paralelo [opciones] [comando [argumentos]] <lista_de_argumentos

paralelo [opciones] [comando [argumentos]] ( ::: argumentos | :::: argfile (s)) ...

paralelo --semaphore [opciones] comando

#! / usr / bin / paralelo --shebang [opciones] [comando [argumentos]]

DESCRIPCIÓN

GNU paralelo es una herramienta de shell para ejecutar trabajos en paralelo utilizando una o más computadoras. A
El trabajo puede ser un solo comando o un pequeño script que debe ejecutarse para cada una de las líneas en
la entrada. La entrada típica es una lista de archivos, una lista de hosts, una lista de usuarios, una lista
de URL o una lista de tablas. Un trabajo también puede ser un comando que se lee en una tubería. ÑU
paralelo luego puede dividir la entrada en bloques y canalizar un bloque en cada comando en
paralela.

Si usa xargs y tee hoy, encontrará GNU paralelo muy fácil de usar como GNU paralelo
está escrito para tener las mismas opciones que xargs. Si escribe bucles en shell, encontrará
GNU paralelo puede ser capaz de reemplazar la mayoría de los bucles y hacerlos correr más rápido ejecutando
varios trabajos en paralelo.

GNU paralelo se asegura de que la salida de los comandos sea la misma que obtendría si tuviera
ejecuta los comandos secuencialmente. Esto hace posible utilizar la salida de GNU paralelo
como entrada para otros programas.

Para cada línea de entrada GNU paralelo ejecutará comando con la línea como argumentos. Si no
comando se da, se ejecuta la línea de entrada. Se ejecutarán varias líneas en paralelo.
GNU paralelo a menudo se puede utilizar como sustituto de xargs or gato | golpear.

Del lector guía
Comience viendo los videos de introducción para una introducción rápida:
http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Luego mira el EJEMPLOs después de la lista de OPCIONES. Eso te dará una idea de lo que
GNU paralelo es capaz de.

Luego, dedica una hora a recorrer el tutorial (hombre paralelo_tutorial). Tu linea de comando
te amaré por eso.

Por último, es posible que desee consultar el resto de este manual si tiene necesidades especiales que no
ya cubierto.

OPCIONES

comando Comando para ejecutar. Si comando o los siguientes argumentos contienen reemplazo
cadenas (como {}) cada instancia será sustituida por la entrada.

If comando se da, GNU paralelo resolver las mismas tareas que xargs. Si comando is
no dado GNU paralelo se comportará de forma similar a gato | sh.

La característica comando debe ser un ejecutable, un script, un comando compuesto o una función.

Si es una función Bash, necesita exportar -f la función primero. Para usar alias
Copie el entorno completo como se describe en --entorno y use entorno_paralelo
of paralelo.

Si es una función zsh, necesitará usar esta función auxiliar exportar a
exportar y configurar $ PARALLEL_SHELL para bash:

función exportf () {
export $ (echo $ 1) = "` de donde -f $ 1 | sed -e "s / $ 1 //" `"
}

function my_func () {
echo $ 1;
echo "hola";
}

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

El comando no puede contener el carácter \ 257 (macron: X).

{} Línea de entrada. Esta cadena de reemplazo será reemplazada por una línea completa leída del
fuente de entrada. La fuente de entrada es normalmente stdin (entrada estándar), pero también puede
ser dado con -a, ::: o ::::.

La cadena de reemplazo {} se puede cambiar con -I.

Si la línea de comando no contiene cadenas de reemplazo, entonces {} se agregará a
la línea de comando.

{.} Línea de entrada sin extensión. Esta cadena de reemplazo será reemplazada por la
entrada con la extensión eliminada. Si la línea de entrada contiene . despues del ultimo /
el último . hasta que el final de la cadena se eliminará y {.} será reemplazado
con el restante. P.ej foo.jpg se convierte en foo, subdir / foo.jpg se convierte en subdir / foo,
sub.dir / foo.jpg se convierte en sub.dir / foo, sub.dir / bar permanece sub.dir / bar. Si el
la línea de entrada no contiene . permanecerá sin cambios.

La cadena de reemplazo {.} se puede cambiar con --eh.

Para comprender las cadenas de reemplazo, consulte {}.

{/} Nombre base de la línea de entrada. Esta cadena de reemplazo será reemplazada por la entrada
con la parte del directorio eliminada.

La cadena de reemplazo {/} se puede cambiar con --basenamereplace.

Para comprender las cadenas de reemplazo, consulte {}.

{//} Dirname de la línea de entrada. Esta cadena de reemplazo será reemplazada por el directorio del
línea de entrada. Ver nombre de directorio(1).

La cadena de reemplazo {//} se puede cambiar con --dirnamereplace.

Para comprender las cadenas de reemplazo, consulte {}.

{/.} Nombre base de la línea de entrada sin extensión. Esta cadena de reemplazo será
reemplazado por la entrada con el directorio y la extensión eliminados. Es un
combinación de {/} y {.}.

La cadena de reemplazo {/.} se puede cambiar con --basenameextensionreplace.

Para comprender las cadenas de reemplazo, consulte {}.

{#} (prueba alfa)
Número de secuencia del trabajo a ejecutar. Esta cadena de reemplazo será reemplazada por
el número de secuencia del trabajo que se está ejecutando. Contiene el mismo número que
$ PARALLEL_SEQ.

La cadena de reemplazo {#} se puede cambiar con --seqreplace.

Para comprender las cadenas de reemplazo, consulte {}.

{%} (prueba alfa)
Número de puesto de trabajo. Esta cadena de reemplazo será reemplazada por la ranura del trabajo.
número entre 1 y número de trabajos para ejecutar en paralelo. Nunca habrá 2
trabajos que se ejecutan al mismo tiempo con el mismo número de puesto de trabajo.

La cadena de reemplazo {%} se puede cambiar con --espacio.

Para comprender las cadenas de reemplazo, consulte {}.

{n} Argumento de la fuente de entrada n o en el n'el argumento. Este reemplazo posicional
la cadena será reemplazada por la entrada de la fuente de entrada n (cuando se usa con -a or
::::) o con el n'th argumento (cuando se usa con -N) Si n es negativo se refiere
En el correo electrónico “Su Cuenta de Usuario en su Nuevo Sistema XNUMXCX”. n'el último argumento.

Para comprender las cadenas de reemplazo, consulte {}.

{n.} Argumento de la fuente de entrada n o en el n'th argumento sin extensión. Es un
combinación de {n} y {.}.

Esta cadena de reemplazo posicional será reemplazada por la entrada de la entrada
fuente n (cuando se usa con -a or ::::) o con el n'th argumento (cuando se usa con
-N). La entrada tendrá la extensión eliminada.

Para comprender las cadenas de reemplazo posicionales, consulte {n}.

{n/} Nombre base del argumento de la fuente de entrada n o en el n'el argumento. Es un
combinación de {n} y {/}.

Esta cadena de reemplazo posicional será reemplazada por la entrada de la entrada
fuente n (cuando se usa con -a or ::::) o con el n'th argumento (cuando se usa con
-N). La entrada tendrá el directorio (si lo hay) eliminado.

Para comprender las cadenas de reemplazo posicionales, consulte {n}.

{n//} Nombre de directorio del argumento de la fuente de entrada n o en el n'el argumento. Es un
combinación de {n} y {//}.

Esta cadena de reemplazo posicional será reemplazada por el directorio de la entrada de
fuente de entrada n (cuando se usa con -a or ::::) o con el n'th argumento (cuando se usa
con -N). Ver nombre de directorio(1).

Para comprender las cadenas de reemplazo posicionales, consulte {n}.

{n/.} Nombre base del argumento de la fuente de entrada n o en el n'th argumento sin extensión.
Es una combinacion de {n}, {/} y {.}.

Esta cadena de reemplazo posicional será reemplazada por la entrada de la entrada
fuente n (cuando se usa con -a or ::::) o con el n'th argumento (cuando se usa con
-N). La entrada tendrá el directorio (si lo hubiera) y la extensión eliminados.

Para comprender las cadenas de reemplazo posicionales, consulte {n}.

{=perl expresión=}
Reemplazar con calculado perl expresión. $_ contendrá lo mismo que {}. Después
evaluación perl expresión $_ se utilizará como valor. Se recomienda
solo cambia $ _ pero tienes acceso completo a todo GNU paraleloes interno
funciones y estructuras de datos.

La característica {=perl expresión=} debe darse como una sola cadena.

Ver también: --rpl --padres

{=n perl expresión=}
Equivalente posicional a {= perl expresión =}. Para entender posicional
cadenas de repuesto ver {n}.

Ver también: {= perl expresión =} {n}.

::: argumentos
Utilice argumentos de la línea de comando como fuente de entrada en lugar de stdin (estándar
aporte). A diferencia de otras opciones para GNU paralelo ::: se coloca después de la comando y
antes de los argumentos.

Los siguientes son equivalentes:

(echo archivo1; echo archivo2) | gzip paralelo
gzip paralelo ::: archivo1 archivo2
gzip paralelo {} ::: archivo1 archivo2
paralelo --arg-sep ,, gzip {} ,, archivo1 archivo2
paralelo --arg-sep ,, gzip ,, archivo1 archivo2
paralelo ::: "archivo gzip1" "archivo gzip2"

Para evitar tratar ::: como uso especial --arg-septiembre para establecer el separador de argumentos en
algo más. Ver también --arg-septiembre.

stdin (entrada estándar) se pasará a la primera ejecución del proceso.

Si es múltiple ::: se dan, cada grupo será tratado como una fuente de entrada, y todos
Se generarán combinaciones de fuentes de entrada. Ej .: ::: 1 2 ::: abc will
dan como resultado las combinaciones (1, a) (1, b) (1, c) (2, a) (2, b) (2, c). Esto es útil
para reemplazar bucles for anidados.

::: y :::: se puede mezclar. Entonces estos son equivalentes:

eco paralelo {1} {2} {3} ::: 6 7 ::: 4 5 ::: 1 2 3
eco paralelo {1} {2} {3} :::: <(seq 6 7) <(seq 4 5) :::: <(seq 1 3)
paralelo -a <(seq 6 7) echo {1} {2} {3} :::: <(seq 4 5) :::: <(seq 1 3)
paralelo -a <(seq 6 7) -a <(seq 4 5) echo {1} {2} {3} ::: 1 2 3
seq 6 7 | paralelo -a - -a <(seq 4 5) echo {1} {2} {3} ::: 1 2 3
seq 4 5 | eco paralelo {1} {2} {3} :::: <(seq 6 7) - ::: 1 2 3

:::: archivosarg
Otra forma de escribir -a archivoarg1 -a archivoarg2 ...

::: y :::: se puede mezclar.

See -a, ::: y --exactamente.

--nulo
-0 Utilice NUL como delimitador. Normalmente, las líneas de entrada terminarán en \ n (nueva línea). Si terminan
in \ 0 (NUL), luego use esta opción. Es útil para procesar argumentos que pueden
contener \ n (nueva línea).

--archivo -arg fichero de entrada
-a fichero de entrada
Utilizar fichero de entrada como fuente de entrada. Si usa esta opción, stdin (entrada estándar) es
dado a la primera ejecución del proceso. De lo contrario, se redirige stdin (entrada estándar)
desde / dev / null.

Si es múltiple -a se dan, cada uno fichero de entrada será tratado como una fuente de entrada, y
Se generarán todas las combinaciones de fuentes de entrada. Por ejemplo, el archivo foo contiene 1
2, el archivo de caramelos contiene a b c. -a foo -a de caramelos resultará en las combinaciones
(1, a) (1, b) (1, c) (2, a) (2, b) (2, c). Esto es útil para reemplazar anidadas for-
bucles

Vea también --exactamente y {n}.

--arg-archivo-sep sep-str
Utilizar sep-str en lugar de :::: como cadena de separación entre comando y argumento
archivos. Útil si :::: se usa para otra cosa por el comando.

Ver también: ::::.

--arg-septiembre sep-str
Utilizar sep-str en lugar de ::: como cadena de separación. Útil si ::: se utiliza para
algo más por el comando.

También es útil si usas comandos ::: pero aún quieres leer argumentos de
stdin (entrada estándar): simplemente cambie --arg-septiembre a una cuerda que no está en el
línea de comando.

Ver también: :::.

--bar Muestra el progreso como una barra de progreso. En la barra se muestra:% de trabajos completados,
segundos restantes estimados y número de trabajos iniciados.

Es compatible con zenidad:

seq 1000 | paralelo -j30 --bar '(echo {}; dormir 0.1)' 2>> (zenity --progress
--auto-kill) | WC

--archivo base presentar
--novio presentar
presentar se transferirá a cada sshlogin antes de que se inicie un trabajo. Será
eliminado si --limpiar está activo. El archivo puede ser una secuencia de comandos para ejecutar o algunos
base de datos necesarios para los trabajos. Múltiple --novio se puede especificar para transferir más
archivos base. los presentar será transferido de la misma manera que --transferir.

--basenamereplace reemplazar-str
--bnr reemplazar-str
Usa la cuerda de reemplazo reemplazar-str en lugar de {/} para el nombre base de la línea de entrada.

--basenameextensionreplace reemplazar-str
--bner reemplazar-str
Usa la cuerda de reemplazo reemplazar-str en lugar de {/.} para el nombre base de la línea de entrada
sin extensión.

--bg Ejecute el comando en segundo plano, así GNU paralelo no esperará a que se complete el
comando antes de salir. Este es el valor predeterminado si --semáforo se establece.

Ver también: --fg, hombre sin.

Implica --semáforo.

--bibtex Imprima la entrada BibTeX para GNU paralelo y deshabilitar el aviso de citación.

--cuadra tamaño
--tamaño de bloque tamaño
Tamaño del bloque en bytes. El tamaño puede fijarse con K, M, G, T, P, k, m, g, t,
op que multiplicaría el tamaño por 1024, 1048576, 1073741824, 1099511627776,
1125899906842624, 1000, 1000000, 1000000000, 1000000000000 o 1000000000000000
respectivamente.

GNU paralelo intenta alcanzar el tamaño del bloque, pero puede tener una diferencia de uno
registro. Por razones de rendimiento tamaño debe ser más grande que un solo registro.

tamaño el valor predeterminado es 1M.

See --tubo para el uso de esto.

--gato Crea un archivo temporal con contenido. Normalmente --tubo dará datos al
programa en stdin (entrada estándar). Con --gato GNU paralelo creará un
archivo temporal con el nombre en {}, por lo que puede hacer: paralelo --tubo --gato wc {}.

Vea también --fifo.

--limpiar
Eliminar archivos transferidos. --limpiar eliminará los archivos transferidos en el
computadora remota una vez finalizado el procesamiento.

buscar log -name '* gz' | paralelo \
--sshlogin server.example.com --transfer --return {.}. bz2 \
--cleanup "zcat {} | bzip -9> {.}. bz2"

Con --transferir el archivo transferido a la computadora remota se eliminará el
la computadora remota. Los directorios creados no se eliminarán, incluso si están
vacío.

Con --regreso el archivo transferido desde la computadora remota se eliminará el
la computadora remota. Los directorios creados no se eliminarán, incluso si están
vacío.

--limpiar se ignora cuando no se usa con --transferir or --regreso.

--colse regexp
-C regexp
Separador de columnas. La entrada se tratará como una tabla con regexp separando el
columnas. Se puede acceder a la enésima columna usando {n} or {n.}. P.ej 3 {} es el 3
columna.

--colse implica --podar rl.

regexp es una expresión regular de Perl: http://perldoc.perl.org/perlre.html

--comprimir
Comprime archivos temporales. Si la salida es grande y muy comprimible, esto
ocupa menos espacio en disco en $ TMPDIR y posiblemente sea más rápido debido a menos E / S de disco.

GNU paralelo intentará lzop, Pigz, gzip, pbzip2, por favor, bzip2, lzma, zip, xz in
ese orden, y use el primero disponible.

--programa de compresión PRG
- programa de descompresión PRG
Utilizar PRG para (des) comprimir archivos temporales. Se asume que PRG -corriente continua will
descomprimir stdin (entrada estándar) a stdout (salida estándar) a menos que
- programa de descompresión es dado.

--ctrlc Envía SIGINT a tareas que se ejecutan en equipos remotos, matándolos así.

--delimitador delimitar
-d delimitar Los elementos de entrada terminan con el carácter especificado. Las comillas y la barra invertida son
no especial; cada carácter de la entrada se toma literalmente. Desactiva el final
of-file string, que se trata como cualquier otro argumento. Esto se puede utilizar cuando
la entrada consiste simplemente en elementos separados por líneas nuevas, aunque es casi
Siempre es mejor diseñar su programa para usar --null donde sea posible. los
El delimitador especificado puede ser un solo carácter, un carácter de escape de estilo C como
\ n, o un código de escape octal o hexadecimal. Códigos de escape octal y hexadecimal
se entienden como para el comando printf. Los caracteres multibyte no son
soportado.

--dirnamereplace reemplazar-str
--dnr reemplazar-str
Usa la cuerda de reemplazo reemplazar-str en lugar de {//} para dirname de la línea de entrada.

-E eof-str
Establezca el final de la cadena del archivo en eof-str. Si el final de la cadena del archivo aparece como
línea de entrada, el resto de la entrada se ignora. Si ninguno -E ni -e es usado
no se utiliza una cadena de fin de archivo.

--demora segundos
Retrasar el inicio del siguiente trabajo segundos segundos. ÑU paralelo hará una pausa segundos segundos después
comenzando cada trabajo. segundos puede ser menos de 1 segundo.

- corrida en seco
Imprima el trabajo para que se ejecute en stdout (salida estándar), pero no ejecute el trabajo. Usar -v
-v para incluir el ajuste ssh / rsync si el trabajo se ejecutaría en un control remoto
computadora. Sin embargo, no cuente con esto literalmente, ya que el trabajo puede programarse para
otra computadora o la computadora local si: está en la lista.

--eof[=eof-str]
-e[eof-str]
Esta opción es sinónimo de -E opción. Usar -E en cambio, porque es POSIX
compatible con xargs mientras que esta opción no lo es. Si eof-str se omite, no hay
fin de la cadena del archivo. Si ninguno -E ni -e se utiliza, no se utiliza ninguna cadena de fin de archivo.

--entorno var (prueba alfa)
Copiar variable de entorno var. Esto copiará var al medio ambiente que el
se ejecuta el comando. Esto es especialmente útil para la ejecución remota.

En Bash var también puede ser una función Bash, solo recuerde exportar -f la
función, ver comando.

La variable '_' es especial. Copiará todas las variables de entorno excepto la
los mencionados en ~ / .parallel / ignored_vars.

Para copiar matrices Bash, necesita una función de importador, ya que las matrices Bash no se pueden
exportado:

importar_matriz () {
func local = $ 1; cambio;
export $ func = '() {
'"$ (para arr en $ @; hacer
declare -p $ arr | sed '1s / declare -./&g/'
hecho)"'
}'
}

declare -A assoc = '([uno] = "1" [dos] = "2")'
declare -a indexado = '([0] = "uno" [1] = "dos")'

import_array my_importer assoc indexado

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

Para copiar el entorno completo, utilice esta función (por ejemplo, poniéndola en .bashrc):

env_parallel () {
exportar entorno_bash_paralelo = '() {
'"$ (echo" shopt -s expand_aliases 2> / dev / null "; alias; typeset -p | grep -vFf <(solo lectura; echo GRUPOS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_; tipografía -f) "'
}'
# Ejecutar como: env_parallel [opciones paralelas normales]
`cual paralelo`" $ @ "
unset paralelo_bash_environment
}
# llamar como:
env_parallel [opciones paralelas normales]

Ver también: --record-env.

--eta Muestra el número estimado de segundos antes de terminar. Esto obliga a GNU paralelo
para leer todos los trabajos antes de comenzar a encontrar el número de trabajos. ÑU paralelo
normalmente solo lee el siguiente trabajo a ejecutar. Implica --Progreso.

--fg Ejecute el comando en primer plano, por lo tanto, GNU paralelo esperará a que se complete el
comando antes de salir.

Vea también --bg, hombre sin.

Implica --semáforo.

--fifo Crea un quince temporal con contenido. Normalmente --tubo dará datos al
programa en stdin (entrada estándar). Con --fifo GNU paralelo creará un
Fifo temporal con el nombre en {}, por lo que puede hacer: paralelo --tubo --fifo wc {}.

Atención: si no se leen los datos de la FIFO, el trabajo se bloqueará para siempre.

Vea también --gato.

--filtro-hosts
Eliminar hosts inactivos. Para cada host remoto: verifique que el inicio de sesión a través de ssh funcione. Si
no: no utilice este host.

Actualmente puedes No put --filtro-hosts en un perfil, $ PARALLEL,
/ etc / paralelo / config o similar. Esto se debe a que GNU paralelo usa GNU paralelo
para calcular esto, obtendrá un bucle infinito. Es probable que esto se solucione en un
versión posterior.

--ñu Compórtate como GNU paralelo. Históricamente, esta opción prevaleció sobre --peaje.
La característica --peaje La opción ahora está retirada y, por lo tanto, no se puede utilizar. --ñu se mantiene
por compatibilidad.

--grupo Salida de grupo. La salida de cada trabajo se agrupa y solo se imprime cuando
el comando está terminado. stderr (error estándar) primero seguido de stdout
(salida estándar). Esto lleva algo de tiempo de CPU. En situaciones raras GNU paralelo
toma mucho tiempo de CPU y si es aceptable que las salidas de diferentes
los comandos se mezclan, luego se deshabilita la agrupación con -u puede acelerar GNU
paralelo por un factor de 10.

--grupo es el predeterminado. Puede revertirse con -u.

Ver también: - búfer de línea --desagrupar

--ayuda
-h Imprima un resumen de las opciones a GNU paralelo y salir

--detener en caso de error val
--detener val
¿Cómo debería GNU paralelo terminar si uno o más trabajos fallan?

0 No se detenga si falla un trabajo. El estado de salida será el número de trabajos fallidos.
Este es el predeterminado.

1 No inicie nuevos trabajos si un trabajo falla, pero complete los trabajos en ejecución
incluida la limpieza. El estado de salida será el estado de salida del último
trabajo fallido.

2 Elimine todos los trabajos de inmediato y salga sin limpiar. El estado de salida
será el estado de salida del trabajo anómalo.

1-99% Si val% de los trabajos fallan y mínimo 3: No inicie nuevos trabajos, pero
completar los trabajos en ejecución, incluida la limpieza. El estado de salida será el
estado de salida del último trabajo anómalo.

--encabezamiento regexp
Utilice regexp como encabezado. Para un uso normal, el encabezado coincidente (normalmente el primero
línea: --encabezamiento '.*\norte') se dividirá usando --colse (que por defecto será '\ t')
y los nombres de las columnas se pueden usar como variables de reemplazo: {columna nombre}.

Para los ensayos clínicos de CRISPR, --tubo el encabezado coincidente se antepondrá a cada salida.

--encabezamiento : es un alias para --encabezamiento '.*\norte'.

If regexp es un número, coincidirá con esa cantidad de líneas.

-I reemplazar-str
Usa la cuerda de reemplazo reemplazar-str en lugar de {}.

--reemplazar[=reemplazar-str]
-i[reemplazar-str]
Esta opción es sinónimo de -Ireemplazar-str if reemplazar-str se especifica, y para
-I{} de lo contrario. Esta opción está obsoleta; usar -I preferiblemente.

- registro de trabajo archivo de registro
Archivo de registro para trabajos ejecutados. Guarde una lista de los trabajos ejecutados en archivo de registro en la sección de
siguiente formato separado por TAB: número de secuencia, sshlogin, hora de inicio en segundos
desde época, tiempo de ejecución en segundos, bytes en archivos transferidos, bytes en archivos
devuelto, estado de salida, señal y ejecución de comando.

Para convertir los tiempos en ISO-8601 estricto, haga lo siguiente:

perl -a -Pie" -n 'chomp ($ F [2] = `fecha -d \ @ $ F [2] +% FT% T`); Imprimir unirse ("\ t", @ F) '

Vea también --reanudar.

--trabajos N
-j N
--max-procs N
-P N Número de puestos de trabajo. Ejecute hasta N trabajos en paralelo. 0 significa tantos como sea posible.
El valor predeterminado es 100%, que ejecutará un trabajo por núcleo de CPU.

If --semáforo está configurado por defecto es 1, por lo que se convierte en un mutex.

--trabajos +N
-j +N
--max-procs +N
-P +N Agregue N al número de núcleos de CPU. Ejecute tantos trabajos en paralelo. Ver también
--use-cpus-en-lugar-de-núcleos.

--trabajos -N
-j -N
--max-procs -N
-P -N Reste N del número de núcleos de CPU. Ejecute tantos trabajos en paralelo. Si el
El número evaluado es menor que 1, entonces se usará 1. Ver también
--use-cpus-en-lugar-de-núcleos.

--trabajos N%
-j N%
--max-procs N%
-P N% Multiplique N% por el número de núcleos de CPU. Ejecute tantos trabajos en paralelo. Ver
tambien --use-cpus-en-lugar-de-núcleos.

--trabajos perfil
-j perfil
--max-procs perfil
-P perfil
Leer parámetro del archivo. Utilice el contenido de perfil como parámetro para -j. P.ej
perfil podría contener la cadena 100% o +2 o 10. Si perfil se cambia cuando un
el trabajo se completa, perfil se lee de nuevo y se calcula el nuevo número de trabajos. Si
el número es menor que antes, los trabajos en ejecución podrán finalizar, pero nuevos
los trabajos no se iniciarán hasta que se alcance el número deseado de trabajos. Esta
permite cambiar el número de trabajos en ejecución simultáneos mientras GNU
paralelo Esta corriendo.

--mantener el orden
-k Mantenga la secuencia de salida igual que el orden de entrada. Normalmente el resultado de un trabajo
se imprimirá tan pronto como se complete el trabajo. Prueba esto para ver la diferencia:

paralelo -j4 dormir {} \; echo {} ::: 2 1 4 3
paralelo -j4 -k dormir {} \; echo {} ::: 2 1 4 3

Si se usa con --en todo or --no todos la salida se agrupará por sshlogin en ordenados
orden.

-L lineas maximas
Cuando se usa con --tubo: Leer registros de lineas maximas.

Cuando se usa de otra manera: use como máximo lineas maximas líneas de entrada no en blanco por línea de comando.
Los espacios en blanco finales hacen que una línea de entrada continúe lógicamente en la siguiente entrada
la línea.

-L 0 significa leer una línea, pero insertar 0 argumentos en la línea de comando.

Implica -X a menos que -m, --xargs o --tubo se establece.

--lineas maximas[=lineas maximas]
-l[lineas maximas]
Cuando se usa con --tubo: Leer registros de lineas maximas.

Cuando se usa de otra manera: Sinónimo de -L opción. diferente a -L, lineas maximas
El argumento es opcional. Si lineas maximas no se especifica, por defecto es uno. los -l
La opción está en desuso ya que el estándar POSIX especifica -L preferiblemente.

-l 0 es un alias para -l 1.

Implica -X a menos que -m, --xargs o --tubo se establece.

- búfer de línea
Salida de búfer en base a la línea. --grupo mantendrá la salida unida durante todo un tiempo
trabajo. --desagrupar permite que la salida se confunda con media línea procedente de un trabajo y
media línea procedente de otro trabajo. - búfer de línea encaja entre estos dos: GNU
paralelo imprimirá una línea completa, pero permitirá mezclar líneas de diferentes
puestos de trabajo.

- búfer de línea toma más potencia de CPU que ambos --grupo y --desagrupar, pero puede
ser más rápido que --grupo si la CPU no es el factor limitante.

Ver también: --grupo --desagrupar

--carga carga maxima
No inicie nuevos trabajos en una computadora determinada a menos que el número de procesos en ejecución
en la computadora es menor que carga maxima. carga maxima usa la misma sintaxis que --trabajos,
so 100% para uno por CPU es un ajuste válido. La única diferencia es 0, que es
interpretado como 0.01.

--controlmaster
-M Utilice ControlMaster de ssh para hacer que las conexiones ssh sean más rápidas. Útil si los trabajos se ejecutan de forma remota
y son muy rápidos de ejecutar. Esto está deshabilitado para sshlogins que especifican sus propios
comando ssh.

--xargs Múltiples argumentos. Inserte tantos argumentos como permita la longitud de la línea de comando.

If {} no se usa, los argumentos se agregarán a la línea. Si {} se utiliza
varias veces cada uno {} será reemplazado con todos los argumentos.

Apoyo a --xargs con --sshlogin es limitado y puede fallar.

Vea también -X para reemplazo de contexto. En caso de duda utilice -X como eso probablemente hará
Qué se necesita.

-m Múltiples argumentos. Inserte tantos argumentos como permita la longitud de la línea de comando.
Si se ejecutan varios trabajos en paralelo: distribuya los argumentos uniformemente entre
los trabajos. Usar -j1 para evitar esto.

If {} no se usa, los argumentos se agregarán a la línea. Si {} se utiliza
varias veces cada uno {} será reemplazado con todos los argumentos.

Apoyo a -m con --sshlogin es limitado y puede fallar.

Vea también -X para reemplazo de contexto. En caso de duda utilice -X como eso probablemente hará
Qué se necesita.

--minversión versión
Imprime la versión GNU paralelo y salir. Si la versión actual de GNU paralelo
es menor que versión el código de salida es 255. De lo contrario, es 0.

Esto es útil para scripts que dependen de funciones que solo están disponibles en un determinado
versión de GNU paralelo.

--no todos (prueba beta)
--en todo sin argumentos. Ejecute el comando en todas las computadoras dadas con --sshlogin
pero no aceptes argumentos. ÑU paralelo iniciará sesión en --trabajos cantidad de computadoras en
paralelo y ejecute el trabajo en la computadora. -j ajusta cuántas computadoras registrar
en paralelo.

Esto es útil para ejecutar el mismo comando (por ejemplo, tiempo de actividad) en una lista de servidores.

--en todo (prueba beta)
Ejecute todos los trabajos en todas las computadoras dadas con --sshlogin. ÑU paralelo registrará
cobren --trabajos número de equipos en paralelo y ejecutar un trabajo a la vez en el
computadora. El orden de los trabajos no cambiará, pero es posible que algunas computadoras
terminar antes que los demás. -j ajusta cuántas computadoras iniciar sesión en paralelo.

Cuando use --grupo la salida se agrupará por cada servidor, por lo que toda la salida
de un servidor se agruparán.

--salida-como-archivos
--archivosdesalida
--archivos En lugar de imprimir la salida en stdout (salida estándar), la salida de cada trabajo
se guarda en un archivo y luego se imprime el nombre del archivo.

--tubo
--spreadstdin
Distribuya la entrada a los trabajos en stdin (entrada estándar). Leer un bloque de datos de stdin
(entrada estándar) y proporciona un bloque de datos como entrada para un trabajo.

El tamaño del bloque está determinado por --cuadra. Las cuerdas --reiniciar y --reciente tell
GNU paralelo cómo comienza y / o termina un registro. El bloque leído tendrá el final
registro parcial eliminado antes de que el bloque pase al trabajo. El parcial
el registro se antepondrá al siguiente bloque.

If --reiniciar se proporciona esto se utilizará para dividir al inicio del registro.

If --reciente se proporciona esto se utilizará para dividir al final del registro.

Si ambos --reiniciar y --reciente se dan ambos tendrán que coincidir para encontrar una división
.

Si ninguno --reiniciar ni --reciente son dados --reciente por defecto es '\ n'. Tener
sin uso de separador de registros --reciente "".

--archivos se usa a menudo con --tubo.

Ver también: --reiniciar, --reciente, --fifo, --gato, --parte de tubería.

--parte de tubería (prueba beta)
Canalice partes de un archivo físico. --parte de tubería funciona similar a --tubo, pero es mucho
más rápido. Tiene algunas limitaciones:

* El archivo debe ser un archivo físico (que se pueda buscar) y debe entregarse usando -a or
::::.

* Registro de conteo (-N) y recuento de líneas (-L/-l) No funcionan.

--sencillo Ignora cualquiera --perfil, $ PARALLEL y ~ / .parallel / config para tener el control total sobre
la línea de comando (utilizada por GNU paralelo internamente cuando se llama con --sshlogin).

--más Activar cadenas de reemplazo adicionales: {+ /} {+.} {+ ..} {+ ...} {..} {...} {/ ..}
{/ ...}. La idea es que '{+ foo}' coincide con el opuesto de '{foo}' y {} =
{+ /} / {/} = {.}. {+.} = {+ /} / {/.}. {+.} = {..}. {+ ..} = {+ /} / {/ ..}. {+ ..} =
{...}. {+ ...} = {+ /} / {/ ...}. {+ ...}

--Progreso
Muestre el progreso de los cálculos. Enumere las computadoras involucradas en la tarea con
número de núcleos de CPU detectados y número máximo de trabajos a ejecutar. Después de ese show
progreso para cada computadora: número de trabajos en ejecución, número de trabajos completados y
porcentaje de todos los trabajos realizados por esta computadora. El porcentaje solo será
disponible después de que todos los trabajos se hayan programado como GNU paralelo solo lee el siguiente
trabajo cuando esté listo para programarlo; esto es para evitar perder tiempo y memoria
leyendo todo al inicio.

Al enviar GNU paralelo SIGUSR2 puede alternar encendido / apagado --Progreso en un
ejecutando GNU paralelo .

Vea también --eta.

--max-argumentos=argumentos máximos
-n argumentos máximos
Usar como máximo argumentos máximos argumentos por línea de comando. Menos que argumentos máximos argumentos
se utilizará si el tamaño (ver el -s opción) se excede, a menos que la -x opción es
dado, en cuyo caso GNU paralelo saldrá

-n 0 significa leer un argumento, pero insertar 0 argumentos en la línea de comando.

Implica -X a menos que -m se establece.

--max-reemplazar-argumentos=argumentos máximos
-N argumentos máximos
Usar como máximo argumentos máximos argumentos por línea de comando. Igual que -n pero tambien hace
cadenas de repuesto 1 {} .. {argumentos máximos} que representa el argumento 1 .. argumentos máximos. Si
muy pocos argumentos el {n} estará vacío

-N 0 significa leer un argumento, pero insertar 0 argumentos en la línea de comando.

Esto establecerá el propietario del homedir en el usuario:

tr ':' '\norte' < / Etc / passwd | paralelo -N7 chown 1 {} 6 {}

Implica -X a menos que -m or --tubo se establece.

Cuando se usa con --tubo -N es el número de registros a leer. Esto es algo
más lento que --cuadra.

--longitud-máxima-de-línea-permitida
Imprima el número máximo de caracteres permitidos en la línea de comando y salga (usado
por GNU paralelo para determinar la longitud de la línea en equipos remotos).

--número de cpus
Imprima el número de CPU físicas y salga (utilizado por GNU paralelo sí mismo a
determinar la cantidad de CPU físicas en equipos remotos).

--numero de nucleos
Imprima el número de núcleos de CPU y salga (utilizado por GNU paralelo a sí mismo para determinar
el número de núcleos de CPU en equipos remotos).

--no aviso
No muestre el aviso de citación. Se imprime un aviso de citación en stderr (estándar
error) solo si stderr (error estándar) es un terminal, el usuario no ha especificado
--no aviso, y el usuario no ha ejecutado --bibtex una vez.

--bonito amabilidad
Ejecute el comando con esta amabilidad. Para comandos simples, simplemente puede agregar agradable in
frente al comando. Pero si el comando consta de más subcomandos (como:
ls | wc) luego anteponiendo agradable no siempre funcionará. --bonito se asegurará de que todos los sub
los comandos son agradables.

--interactivo
-p Preguntar al usuario si debe ejecutar cada línea de comando y leer una línea del
Terminal. Solo ejecute la línea de comando si la respuesta comienza con 'y' o 'Y'.
Implica -t.

--padres cadena paréntesis
Úselo para definir paréntesis de inicio y finalización para {= perl expresión =}. La izquierda y
el paréntesis derecho puede tener varios caracteres y se supone que son los mismos
largo. El valor predeterminado es {==} dando {= como el paréntesis de inicio y =} como el final
paréntesis.

Otro escenario útil es ,,,, lo que haría ambos paréntesis ,,:

paralelo --parens ,,,, echo foo es ,, s / I / O / g ,, ::: FII

Ver también: --rpl {= perl expresión =}

--perfil nombre de perfil
-J nombre de perfil
Usar perfil nombre de perfil para opciones. Esto es útil si desea tener varios
perfiles. Podría tener un perfil para ejecutar trabajos en paralelo en el local
computadora y un perfil diferente para ejecutar trabajos en computadoras remotas. Ver el
sección ARCHIVOS DE PERFIL para ejemplos.

nombre de perfil corresponde al archivo ~ / .parallel /nombre de perfil.

Puede dar varios perfiles repitiendo --perfil. Si partes de los perfiles
conflicto, se utilizarán los posteriores.

Predeterminado: config

--cita
-q Contacto comando. Esto citará la línea de comando para que los caracteres especiales no sean
interpretado por el caparazón. Consulte la sección COTIZACIÓN. La mayoría de la gente nunca necesitará
esta. La cotización está deshabilitada de forma predeterminada.

--no-ejecutar-si-vacio
-r Si stdin (entrada estándar) solo contiene espacios en blanco, no ejecute el comando.

Si se usa con --tubo esto es lento.

--noscambiar No inicie nuevos trabajos en una computadora determinada si hay intercambio de entrada y salida
actividad.

La actividad de intercambio solo se muestrea cada 10 segundos ya que el muestreo toma 1 segundo
que hacer.

La actividad de swap se calcula como (swap-in) * (swap-out) que en la práctica es una buena
valor: el intercambio no es un problema, el intercambio no es un problema, pero ambos
el cambio de entrada y salida suele indicar un problema.

--record-env
Registre las variables del entorno actual en ~ / .parallel / ignored_vars. Esto es útil
antes de usar --entorno _.

Vea también --entorno.

--reiniciar cuerda de inicio
--reciente cuerda final
If --reiniciar es dado cuerda de inicio se utilizará para dividir al inicio del registro.

If --reciente es dado cuerda final se utilizará para dividir al final del registro.

Si ambos --reiniciar y --reciente se les da la cadena combinada
cadena de inicio tendrá que coincidir para encontrar una posición dividida. Esto es útil
si alguno cuerda de inicio or cuerda final Coincidir en medio de un récord.

Si ninguno --reiniciar ni --reciente se dan entonces --reciente por defecto es '\ n'. Para
no tiene uso de separador de registros --reciente "".

--reiniciar y --reciente se utilizan con --tubo.

Utilizar --expresa regular interpretar --reiniciar y --reciente como expresiones regulares. Este es
lento, sin embargo.

--expresa regular Utilizar --expresa regular interpretar --reiniciar y --reciente como expresiones regulares. Este es
lento, sin embargo.

--remove-rec-sep
--removerecsep
--rrs Eliminar el texto que coincide con --reiniciar y --reciente antes de conectarlo a la
mando.

Solo se usa con --tubo.

--resultados prefijo
--res prefijo
Guarde la salida en archivos. Los archivos se almacenarán en un árbol de directorios arraigado
at prefijo. Dentro de este árbol de directorios, cada comando dará como resultado dos archivos:
prefijo/ / stdout y prefijo/ / stderr, donde es una secuencia de
directorios que representan el encabezado de la fuente de entrada (si se usa --encabezamiento :) o
el número de la fuente de entrada y los valores correspondientes.

Por ejemplo:

paralelo --encabezado: --resultados foo echo {a} {b} ::: a I II ::: b III IIII

generará los archivos:

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

y

paralelo --resultados foo echo {1} {2} ::: I II ::: III IIII

generará los archivos:

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

Vea también --archivos, --encabezamiento, - registro de trabajo.

--reanudar Se reanuda desde el último trabajo sin terminar. Leyendo - registro de trabajo o en el --resultados dir
GNU paralelo averiguará el último trabajo sin terminar y continuará desde allí. Como
GNU paralelo solo mira los números de secuencia en - registro de trabajo luego la entrada, la
comando, y - registro de trabajo todos deben permanecer sin cambios; de lo contrario GNU paralelo pueden
ejecutar comandos incorrectos.

Vea también - registro de trabajo, --resultados, - reanudar-fallido.

- reanudar-fallido
Reintentar todo fallido y reanudar desde el último trabajo sin terminar. Leyendo - registro de trabajo GNU
paralelo averiguará los trabajos fallidos y los ejecutará de nuevo. Después de eso, lo hará
reanudar el último trabajo sin terminar y continuar desde allí. Como GNU paralelo solo mira
los números de secuencia en - registro de trabajo luego la entrada, el comando y - registro de trabajo que todas
tiene que permanecer sin cambios; de lo contrario GNU paralelo puede ejecutar comandos incorrectos.

Vea también - registro de trabajo, --reanudar.

--reintentos n
Si un trabajo falla, vuelva a intentarlo en otra computadora en la que no haya fallado. Hacer esto
n veces. Si hay menos de n computadoras en --sshlogin GNU paralelo se volverá a
utilizar todas las computadoras. Esto es útil si algunos trabajos fallan sin motivo aparente.
(como falla de la red).

--regreso nombre de archivo
Transfiera archivos desde computadoras remotas. --regreso se usa con --sshlogin cuando
los argumentos son archivos en las computadoras remotas. Cuando se procesa el archivo
nombre de archivo será transferido desde la computadora remota usando rsync y se pondrá
relativo al directorio de inicio de sesión predeterminado. P.ej

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

Esto transferirá el archivo $ HOME / foo / bar.out desde el ordenador
servidor.ejemplo.com al archivo foo / bar.out despues de correr contacto foo / bar.out on
servidor.ejemplo.com.

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

Esto transferirá el archivo /tmp/foo/bar.fuera desde el ordenador servidor.ejemplo.com
al archivo /tmp/foo/bar.fuera despues de correr contacto /tmp/foo/bar.fuera on
servidor.ejemplo.com.

Se pueden transferir varios archivos repitiendo las opciones varias veces:

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

--regreso se usa a menudo con --transferir y --limpiar.

--regreso se ignora cuando se usa con --sshlogin : o cuando no se usa con --sshlogin.

- round-robin
--ronda Normalmente --tubo le dará un solo bloque a cada instancia del comando. Con
- round-robin todos los bloques se escribirán aleatoriamente en comandos que ya se estén ejecutando.
Esto es útil si el comando tarda mucho en inicializarse.

--mantener el orden no funcionará con - round-robin ya que es imposible rastrear cuál
El bloque de entrada corresponde a qué salida.

--rpl 'etiqueta perl expresión'
Utilizar etiqueta como una cadena de reemplazo para perl expresión. Esto hace posible
defina sus propias cadenas de reemplazo. ÑU paraleloLas 7 cadenas de repuesto son
implementado como:

--rpl '{}'
--rpl '{#} 1 $ _ = $ trabajo-> seq ()'
--rpl '{%} 1 $ _ = $ trabajo-> espacio ()'
--rpl '{/} s:. * / ::'
--rpl '{//} $ Global :: use {"Archivo :: Nombre base"} || = eval "use Archivo :: Nombre base; 1;"; $ _ = dirname ($ _); '
--rpl '{/.} s:.*/::; s: \. [^/.] + $ ::; '
--rpl '{.} s: \. [^/.] + $ :: '

Si la cadena de reemplazo definida por el usuario comienza con '{', también se puede usar como
cadena de reemplazo posicional (como {2.}).

Se recomienda cambiar solo $ _ pero tiene acceso completo a todo GNU
paraleloFunciones internas y estructuras de datos.

Aquí algunos ejemplos:

Eliminar 2 extensiones (por ejemplo, .tar.gz)
--rpl '{..} s: \. [^/.] + $ ::; s: \. [^/.] + $ ::; '
Conserva solo la extensión
--rpl '{ext} s:. * \. ::'
¿La secuencia de trabajo es par o impar?
--rpl '{impar} $ _ = $ trabajo-> seq ()% 2? "impar": "par"'

Ver también: {= perl expresión =} --padres

--max-caracteres=max-caracteres
-s max-caracteres
Usar como máximo max-caracteres caracteres por línea de comando, incluido el comando y
argumentos-iniciales y los nulos finales al final de las cadenas de argumentos.
El mayor valor permitido depende del sistema y se calcula como el argumento
límite de longitud para el ejecutivo, menos el tamaño de su entorno. El valor predeterminado es
el maximo.

Implica -X a menos que -m se establece.

- mostrar-límites
Muestre los límites en la longitud de la línea de comando que son impuestos por la operación
sistema y el -s opción. Canalice la entrada desde / dev / null (y tal vez especifique
--no-run-if-empty) si no quiere GNU paralelo hacer cualquier cosa.

--semáforo
Trabaja como un semáforo de conteo. --semáforo causará GNU paralelo para iniciar
comando en el fondo. Cuando se alcanza el número de trabajos simultáneos, GNU
paralelo esperará a que se complete uno de estos antes de iniciar otro comando.

--semáforo implica --bg a menos que --fg está especificado.

--semáforo implica --nombre del semáforo `tty` a menos que --nombre del semáforo está especificado.

Usado con --fg, --Espere y --nombre del semáforo.

El comando sin es un alias para paralelo --semáforo.

Vea también hombre sin.

--nombre del semáforo nombre
--identificación nombre
Utilizar nombre como el nombre del semáforo. El valor predeterminado es el nombre del tty controlador
(salida de tty).

El valor predeterminado normalmente funciona como se esperaba cuando se usa de forma interactiva, pero cuando se usa en
un guión nombre debe establecerse. $$ or mi_tarea_nombre suelen tener un buen valor.

El semáforo se almacena en ~ / .parallel / semaphores /

Implica --semáforo.

Vea también hombre sin.

--semáforotiempo de espera segundos
Si el semáforo no se libera en segundos, tómalo de todos modos.

Implica --semáforo.

Vea también hombre sin.

--seqreplace reemplazar-str
Usa la cuerda de reemplazo reemplazar-str en lugar de {#} para el número de secuencia del trabajo.

--el asunto
--hashbang
GNU paralelo se puede llamar como un comando shebang (#!) como la primera línea de un
texto. El contenido del archivo se tratará como fuente de entrada.

Me gusta:

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

foss.org.my
debian.org
freenetproject.org

--el asunto debe establecerse como la primera opción.

En FreeBSD env es necesario:

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

foss.org.my
debian.org
freenetproject.org

--hebang-wrap
GNU paralelo puede paralelizar scripts envolviendo la línea shebang. Si el programa
se puede ejecutar así:

argumentos de gato | paralelo el_programa

entonces la secuencia de comandos se puede cambiar a:

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

P.ej

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

Si el programa se puede ejecutar así:

datos de gatos | paralelo - tubería the_program

entonces la secuencia de comandos se puede cambiar a:

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

P.ej

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

--hebang-wrap debe establecerse como la primera opción.

--shellquote
No ejecuta el comando pero lo cita. Útil para hacer comillas compuestas
comandos para GNU paralelo.

--saltar-primera-línea
No utilice la primera línea de entrada (utilizada por GNU paralelo sí mismo cuando se llama con
--el asunto).

--sshretraso segundos
Retrasar el inicio del siguiente ssh por segundos segundos. ÑU paralelo hará una pausa segundos segundos
después de iniciar cada ssh. segundos puede ser menos de 1 segundo.

-S [ncpu /] sshlogin [, [ncpu /] sshlogin [, ...]]
--sshlogin [ncpu /] sshlogin [, [ncpu /] sshlogin [, ...]]
Distribuya trabajos a computadoras remotas. Los trabajos se ejecutarán en una lista de
ordenadores. ÑU paralelo determinará el número de núcleos de CPU en el control remoto
computadoras y ejecutar el número de trabajos especificado por -j. Si el numero ncpu is
dado GNU paralelo utilizará este número para el número de núcleos de CPU en el host.
Normalmente ncpu no será necesario.

An iniciar sesión es de la forma:

[sshcommand [opciones]] [nombre de usuario @] nombre de host

El sshlogin no debe requerir una contraseña.

El sshlogin ':' es especial, significa 'no ssh' y por lo tanto se ejecutará en el
computadora local.

El sshlogin '..' es especial, lee sshlogins de ~ / .parallel / sshloginfile

El sshlogin '-' también es especial, lee sshlogins desde stdin (entrada estándar).

Para especificar más sshlogins, separe los sshlogins por comas o repita las opciones
varias veces.

Por ejemplo: vea --ssharchivo de inicio de sesión.

El host remoto debe tener GNU paralelo instalado.

--sshlogin se sabe que causa problemas con -m y -X.

--sshlogin se usa a menudo con --transferir, --regreso, --limpiar y --trc.

--ssharchivo de inicio de sesión nombre de archivo (prueba beta)
--slf nombre de archivo (prueba beta)
Archivo con sshlogins. El archivo consta de sshlogins en líneas separadas. Vacío
las líneas y las líneas que comienzan con '#' se ignoran. Ejemplo:

servidor.ejemplo.com
[email protected]
8 / my-8-core-server.example.com
2/[email protected]
# Este servidor tiene SSH ejecutándose en el puerto 2222
ssh -p 2222 servidor.ejemplo.net
4 / ssh -p 2222 quadserver.example.net
# Utilice un programa ssh diferente
myssh -p 2222 -l mi nombre de usuario hexacpu.example.net
# Use un programa ssh diferente con el número predeterminado de núcleos
// usr / local / bin / myssh -p 2222 -l myusername hexacpu.example.net
# Use un programa ssh diferente con 6 núcleos
6 // usr / local / bin / myssh -p 2222 -l myusername hexacpu.example.net
# Suponga 16 núcleos en la computadora local
dieciséis/:

Cuando se usa un programa ssh diferente, el último argumento debe ser el nombre de host.

Múltiple --ssharchivo de inicio de sesión están permitidos.

GNU paralelo primero buscará el archivo en el directorio actual; si eso falla mira
para el archivo en ~ / .parallel.

El sshloginfile '..' es especial, lee sshlogins de ~ / .parallel / sshloginfile

El archivo sshlogin '.' es especial, lee sshlogins de
/ etc / paralelo / sshloginfile

El sshloginfile '-' también es especial, lee sshlogins de stdin (estándar
entrada).

Si se cambia el archivo sshlogin, se volverá a leer cuando finalice un trabajo, aunque en
la mayoría una vez por segundo. Esto hace posible agregar y eliminar hosts mientras
funcionando.

Esto se puede usar para tener un demonio que actualice el archivo sshlogin para que solo contenga
servidores que están activos:

cp original.slf tmp2.slf
mientras que [1]; hacer
bonito paralelo --nonall -j0 -k --slf original.slf --tag echo | perl 's / \ t $ //'> tmp.slf
if diff tmp.slf tmp2.slf; luego
mv tmp.slf tmp2.slf
fi
sueño 10
hecho &
paralelo --slf tmp2.slf ...

--espacio reemplazar-str
Usa la cuerda de reemplazo reemplazar-str en lugar de {%} para el número de puesto de trabajo.

--silencio Silencio. El trabajo que se va a ejecutar no se imprimirá. Este es el predeterminado. Puede ser
invertido con -v.

--tty Abra el terminal tty. Si GNU paralelo se utiliza para iniciar un programa interactivo
entonces esta opción puede ser necesaria. Comenzará solo un trabajo a la vez (es decir, -j1),
no almacenar en búfer la salida (es decir -u) y abrirá un tty para el trabajo. Cuando el trabajo
está hecho, el siguiente trabajo obtendrá el tty.

--etiqueta Etiquetar líneas con argumentos. Cada línea de salida se antepondrá con los argumentos
y TAB (\ t). Cuando se combina con --en todo or --no todos las líneas se antepondrán
con el sshlogin en su lugar.

--etiqueta se ignora cuando se usa -u.

--etiqueta str
Marque las líneas con una cuerda. Cada línea de salida se antepondrá con str y TAB
(\ t). str puede contener cadenas de reemplazo como {}.

--etiqueta se ignora cuando se usa -u, --en todo y --no todos.

--tmpdir nombre de directorio
Directorio de archivos temporales. ÑU paralelo normalmente almacena la salida en
archivos temporales en / tmp. Configurando --tmpdir puede usar un directorio diferente para el
archivos. Configuración --tmpdir es equivalente a configurar $ TMPDIR.

--tmux Utilizar tmux para la salida. Empezar un tmux sesión y ejecute cada trabajo en una ventana en ese
sesión. No se producirá ningún otro resultado.

--se acabó el tiempo val
Tiempo de espera para el mando. Si el comando se ejecuta durante más de val segundos obtendrá
asesinado con SIGTERM, seguido de SIGTERM 200 ms después, seguido de SIGKILL 200 ms
más tarde.

If val va seguido de un%, entonces el tiempo de espera se calculará dinámicamente como un
porcentaje del tiempo de ejecución medio medio. Solo los valores> 100% tendrán sentido.

--verboso
-t Imprima el trabajo que se ejecutará en stderr (error estándar).

Vea también -v, -p.

--transferir
Transfiera archivos a computadoras remotas. --transferir se usa con --sshlogin cuando
Los argumentos son archivos y deben transferirse a las computadoras remotas. Los archivos
será transferido usando rsync y se pondrá en relación con el directorio de trabajo predeterminado.
Si la ruta contiene /./ la ruta restante será relativa al directorio de trabajo.
P.ej

echo foo / bar.txt | paralelo \
--sshlogin servidor.ejemplo.com --transfer wc

Esto transferirá el archivo foo / bar.txt a la computadora servidor.ejemplo.com En el correo electrónico “Su Cuenta de Usuario en su Nuevo Sistema XNUMXCX”.
presentar $ INICIO / foo / bar.txt antes de correr wc foo / bar.txt on servidor.ejemplo.com.

echo /tmp/foo/bar.txt | paralelo \
--sshlogin servidor.ejemplo.com --transfer wc

Esto transferirá el archivo foo / bar.txt a la computadora servidor.ejemplo.com En el correo electrónico “Su Cuenta de Usuario en su Nuevo Sistema XNUMXCX”.
presentar /tmp/foo/bar.txt antes de correr wc /tmp/foo/bar.txt on servidor.ejemplo.com.

--transferir se usa a menudo con --regreso y --limpiar.

--transferir se ignora cuando se usa con --sshlogin : o cuando no se usa con
--sshlogin.

--trc nombre de archivo
Transferencia, devolución, limpieza. Mano corta para:

--transferir --regreso nombre de archivo --limpiar

--podar
Recorta el espacio en blanco en la entrada.

n Sin recorte. La entrada no se modifica. Este es el predeterminado.

l Embellecedor izquierdo. Elimina los espacios en blanco del inicio de la entrada. Por ejemplo, "a bc" -> "a bc".

r Trim derecho. Elimina los espacios en blanco del final de la entrada. Por ejemplo, "a bc" -> "a bc".

lr
rl Ambos recortan. Elimina los espacios en blanco tanto del inicio como del final de la entrada. Por ejemplo, "a bc"
-> "a bc". Este es el valor predeterminado si --colse se utiliza.

--desagrupar
-u Desagrupar salida. La salida se imprime lo antes posible y por pasadas GNU paralelo
procesamiento interno. Esto puede hacer que la salida de diferentes comandos se mezcle
por lo tanto, solo debe usarse si no le importa la salida. Compare estos:

paralelo -j0 'dormir {};eco -n empezar {}; dormir {};eco {}fin' ::: 1 2 3 4

paralelo -u -j0 'dormir {};eco -n empezar {}; dormir {};eco {}fin' ::: 1 2 3 4

También deshabilita --etiqueta. ÑU paralelo salidas más rápido con -u. Compara la velocidad de
estas:

secuencia paralela ::: 300000000> / dev / null
paralelo -u seq ::: 300000000> / dev / null
paralelo --line-buffer seq ::: 300000000> / dev / null

Puede revertirse con --grupo.

Ver también: - búfer de línea --grupo

--extensiónreemplazar reemplazar-str
--eh reemplazar-str
Usa la cuerda de reemplazo reemplazar-str en lugar de {.} para la línea de entrada sin
extensión.

--use-cpus-en-lugar-de-núcleos
Cuente la cantidad de CPU físicas en lugar de núcleos de CPU. Al calcular cuántos
que los trabajos se ejecuten simultáneamente en relación con la cantidad de núcleos de CPU que puede pedir a GNU
paralelo en su lugar, mirar el número de CPU físicas. Esto tendrá sentido para
computadoras que tienen hyperthreading como dos trabajos que se ejecutan en una CPU con
hyperthreading se ejecutará más lento que dos trabajos que se ejecutan en dos CPU físicas. Algunos
Las CPU de varios núcleos pueden ejecutarse más rápido si solo se ejecuta un subproceso por CPU física.
La mayoría de los usuarios no necesitarán esta opción.

-v Verboso. Imprima el trabajo que se ejecutará en stdout (salida estándar). Se puede revertir
con --silencio. Vea también la -t.

Utilizar -v -v para imprimir el comando de envoltura ssh cuando se ejecuta de forma remota.

--versión
-V Imprime la versión GNU paralelo y salir

--dirección de trabajo midir
--wd midir
Archivos transferidos usando --transferir y --regreso será relativo a midir on
computadoras remotas, y el comando se ejecutará en el directorio midir.

El especial midir valor ... creará directorios de trabajo bajo ~ / .parallel / tmp / on
las computadoras remotas. Si --limpiar recibe estos directorios se eliminarán.

El especial midir valor . usa el directorio de trabajo actual. Si el trabajo actual
dir está debajo de su directorio de inicio, el valor . se trata como la ruta relativa a su
dir. casa Esto significa que si su directorio personal es diferente en computadoras remotas (p. Ej.
si su inicio de sesión es diferente) la ruta relativa seguirá siendo relativa a su hogar
d.

Para ver la diferencia, intente:

paralelo -S servidor pwd ::: ""

paralelo --wd . -S servidor pwd ::: ""

paralelo --wd ... -S servidor pwd ::: ""

--Espere Espere a que se completen todos los comandos.

Implica --semáforo.

Vea también hombre sin.

-X Reemplazo de múltiples argumentos con contexto. Inserte tantos argumentos como el comando
la longitud de la línea lo permite. Si se ejecutan varios trabajos en paralelo: distribuya el
argumentos de manera uniforme entre los puestos de trabajo. Usar -j1 para evitar esto.

If {} no se usa, los argumentos se agregarán a la línea. Si {} se usa como
parte de una palabra (como imagen {}. jpg) entonces se repetirá toda la palabra. Si {} is
utilizado varias veces cada uno {} será reemplazado por los argumentos.

Normalmente -X hará lo correcto, mientras que -m puede dar resultados inesperados si {}
se utiliza como parte de una palabra.

Apoyo a -X con --sshlogin es limitado y puede fallar.

Vea también -m.

--Salida
-x Salga si el tamaño (ver el -s opción) se excede.

--exactamente Leer múltiples fuentes de entrada como xaplicar. Si se dan varias fuentes de entrada, una
El argumento se leerá de cada una de las fuentes de entrada. Los argumentos pueden ser
accedido en el comando como 1 {} .. {n}, asi que 1 {} será una línea de la primera entrada
fuente, y 6 {} se referirá a la línea con el mismo número de línea desde el 6
fuente de entrada.

Compare estos dos:

eco paralelo {1} {2} ::: 1 2 3 ::: abc
paralelo --xaplicar echo {1} {2} ::: 1 2 3 ::: abc

Los argumentos se reciclarán si una fuente de entrada tiene más argumentos que la
otros:

paralelo --xaplicar echo {1} {2} {3} ::: 1 2 ::: I II III ::: abcdefg

Vea también --encabezamiento.

Ejemplo: Acoplar as xargs -n1. Argumento adjuntando

GNU paralelo puede funcionar similar a xargs -N1.

Para comprimir todos los archivos html usando gzip correr:

find . -nombre '* .html' | paralelo gzip --mejor

Si los nombres de los archivos pueden contener una nueva línea, utilice -0. Sustituya FOO BAR por FUBAR en todos los archivos
en este directorio y subdirectorios:

find . Tipo f -imprimir0 | paralelo -q0 perl -i -Educación física 's / FOO BAR / FUBAR / g '

Nota: -q es necesario debido al espacio en 'FOO BAR'.

Ejemplo: Reading argumentos Desde comando línea

GNU paralelo puede tomar los argumentos de la línea de comando en lugar de stdin (entrada estándar).
Para comprimir todos los archivos html en el directorio actual usando gzip correr:

paralelo gzip --mejor ::: * .html

Para convertir * .wav a * .mp3 usando LAME ejecutando un proceso por ejecución de núcleo de CPU:

paralelo paralítico {} -o {.}. mp3 ::: * .wav

Ejemplo: Inserción una variedad argumentos

Al mover muchos archivos como este: mv * .log destino a veces obtendrá el error:

intento: / bin / mv: Argumento lista demasiado long

porque hay demasiados archivos. En su lugar, puede hacer:

ls | grep -E '\ .log $' | paralelo mv {} destino

Esto se ejecutará mv para cada archivo. Se puede hacer más rápido si mv obtiene tantos argumentos que
cabrá en la línea:

ls | grep -E '\ .log $' | paralelo -m mv {} destino

Ejemplo: Contexto reemplazar

Para eliminar los archivos foto0000.jpg .. foto9999.jpg Podrías hacerlo:

ss -w 0 9999 | paralelo rm imagen {}. jpg

También puedes hacer:

ss -w 0 9999 | perl -Educación física 's /(.*)/ pict $ 1.jpg /' | paralelo -m rm

El primero correrá rm 10000 veces, mientras que la última solo se ejecutará rm tantas veces sea necesario
Mantenga la longitud de la línea de comando lo suficientemente corta para evitar Argumento lista demasiado long (normalmente
corre 1-2 veces).

También puedes ejecutar:

ss -w 0 9999 | paralelo -X rm imagen {}. jpg

Esto también solo se ejecutará rm tantas veces como sea necesario para mantener corta la longitud de la línea de comando
suficiente.

Ejemplo: Calcular intensivo recibas nuevas vacantes en tu correo y sustitución

Si ImageMagick está instalado, esto generará una miniatura de un archivo jpg:

convertir -geometría 120 foo.jpg pulgar_foo.jpg

Esto se ejecutará con trabajos de número de cpu-cores en paralelo para todos los archivos jpg en un directorio:

ls * .jpg | paralelo convertir -geometría 120 {} pulgar_{}

Para hacerlo recursivamente usa find:

find . -nombre '* .jpg' | paralelo convertir -geometría 120 {} {} _thumb.jpg

Observe cómo el argumento tiene que comenzar con {} as {} incluirá la ruta (por ejemplo, corriendo convertir
-geometría 120 ./foo/bar.jpg pulgar_./foo/bar.jpg claramente estaría mal). El comando
generar archivos como ./foo/bar.jpg_thumb.jpg.

Utilizar {.} para evitar el .jpg adicional en el nombre del archivo. Este comando creará archivos como
./foo/bar_pulgar.jpg:

find . -nombre '* .jpg' | paralelo convertir -geometría 120 {} {.} _ thumb.jpg

Ejemplo: Sustitución y redirección

Esto generará una versión sin comprimir de los archivos .gz junto al archivo .gz:

paralelo zcat {} ">"{.} ::: * .gz

Citar> es necesario para posponer la redirección. Otra solución es citar el
comando completo:

paralelo "zcat {} >{.} " ::: * .gz

Otros caracteres especiales de shell (como *; $> <| >> <<) también deben ponerse entre comillas,
ya que de lo contrario pueden ser interpretados por el shell y no entregados a GNU paralelo.

Ejemplo: Compuesto comandos

Un trabajo puede constar de varios comandos. Esto imprimirá el número de archivos en cada
directorio:

ls | paralelo 'eco -n {} " "; ls {} | wc -l '

Para poner la salida en un archivo llamado .dir:

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

GNU puede ejecutar incluso pequeños scripts de shell paralelo:

find . | paralelo 'a = {}; nombre = $ {a ## * /}; superior = $ (eco "$ nombre" | tr "[:más bajo:]"
"[:superior:]"); echo "$ nombre - $ superior "'

ls | paralelo 'mv {} "$ (echo {} | tr "[:superior:]" "[:más bajo:]")"'

Dada una lista de URL, enumere todas las URL que no se descargan. Imprima el número de línea y el
URL.

gato archivo de URL | paralelo "wget {} 2>/ dev / null || grep -n {} urlfile "

Cree un directorio espejo con los mismos nombres de archivo, excepto que todos los archivos y enlaces simbólicos están vacíos
archivos.

cp -rs / the / source / dir espejo_dir; find espejo_dir Tipo l | paralelo -m rm {} '&&' contacto
{}

Encuentra los archivos en una lista que no existen

gato lista_de_archivos | paralelo 'si [ ! -e {} ] ; y luego echo {}; fi '

Ejemplo: llamar Bash funciones

Si el comando compuesto es más largo que una línea, se vuelve difícil de leer. En Bash puedes
funciones de uso. Solo recuerda exportar -f la función.

hazlo() {
echo Haciéndolo por $ 1
sueño 2
echo Hecho con $ 1
}
exportar -f doit
Doit paralelo ::: 1 2 3

doubleit () {
echo Haciéndolo por $ 1 $ 2
sueño 2
echo Hecho con $ 1 $ 2
}
exportar -f doubleit
doubleit paralelo ::: 1 2 3 ::: ab

Para hacer esto en servidores remotos, necesita transferir la función usando --entorno:

paralelo --env doit -S servidor doit ::: 1 2 3
paralelo --env doubleit -S servidor doubleit ::: 1 2 3 ::: ab

Si su entorno (alias, variables y funciones) es pequeño, puede copiar todo el
medio ambiente sin tener que exportar -f cualquier cosa. Solo ejecuta esto primero:

env_parallel () {
exportar entorno_bash_paralelo = '() {
'"$ (echo" shopt -s expand_aliases 2> / dev / null "; alias; typeset -p | grep -vFf <(solo lectura; echo GRUPOS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_; tipografía -f) "'
}'
# Ejecutar como: env_parallel parallel_bash_environment "2>/dev/null;" ...
`cual paralelo`" $ @ "
unset paralelo_bash_environment
}

Y luego llamar como:

env_parallel hacer ::: 1 2 3
env_parallel doubleit ::: 1 2 3 ::: ab
env_parallel -S servidor doit ::: 1 2 3
env_parallel -S servidor doubleit ::: 1 2 3 ::: ab

Ejemplo: Función probador

Para probar un programa con diferentes parámetros:

probador() {
si (eval "$@") >&/dev/null; luego
perl -e 'printf "\033[30;102m[ Aceptar ]\033[0m @ARGV\n"' "$@"
más
perl -e 'printf "\033[30;101m[FALLO]\033[0m @ARGV\n"' "$@"
fi
}
exportar -f probador
probador paralelo mi_programa ::: arg1 arg2
salida del probador paralelo ::: 1 0 2 0

If mi programa falla, se imprimirá un FALLO rojo seguido del comando fallido; de lo contrario
se imprimirá un OK verde seguido del comando.

Ejemplo: Extracción presentar extensión when tratamiento archivos

Al procesar archivos eliminando la extensión de archivo usando {.} a menudo es útil.

Cree un directorio para cada archivo zip y descomprímalo en ese directorio:

paralelo 'mkdir {.}; cd {.}; abrir la cremallera ../{}' ::: *.cremallera

Vuelva a comprimir todos los archivos .gz en el directorio actual usando bzip2 ejecutando 1 trabajo por núcleo de CPU en
paralela:

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

Convierta todos los archivos WAV a MP3 usando LAME:

find dirección de sonido Tipo f -nombre '*.wav' | paralelo paralítico {} -o {.}. mp3

Ponga todo convertido en el mismo directorio:

find dirección de sonido Tipo f -nombre '*.wav' | paralelo paralítico {} -o midir/{/.}.mp3

Ejemplo: Extracción two presentar extensiones when tratamiento archivos

Si tiene un directorio con archivos tar.gz y desea que estos se extraigan en el directorio correspondiente
(por ejemplo, foo.tar.gz se extraerá en el directorio foo) puedes hacer:

paralelo --más 'mkdir {..}; alquitrán -C {..} -xf {} ' ::: * .tar.gz

Ejemplo: Descargar 10 imágenes para cada una of la pasado 30 días

Supongamos que un sitio web almacena imágenes como:

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

donde AAAAMMDD es la fecha y ## es el número 01-10. Esto descargará imágenes para el
últimos 30 días:

paralelo wget http://www.example.com/path/to/'$(fecha -d "hoy dia -{1} dias"
+%Y%m%d)_{2}.jpg' ::: $ (seq 30). ::: $ (seq -w 10).

$(fecha -d "hoy dia -{1} dias" +%Y%m%d) dará las fechas en AAAAMMDD con {1} días
restado.

Ejemplo: Copiar archivos as pasado modificado datos (ISO 8601) con adicional azar dígitos

find . | paralelo 'cp {} ../direccióndestino/{= $a = int(10000*rand); $_ = `fecha -r PS
+%FT%T"$a"`; masticar =}'

Ejemplo: digitales reloj con "parpadeo" :

El : en un reloj digital parpadea. Para hacer que cada otra línea tenga un ':' y el resto un ' ' a
La expresión perl se usa para mirar la tercera fuente de entrada. Si el valor modudo 3 es 2: Usar
":" de lo contrario use " ":

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

Ejemplo: Agregando contenido of archivos

Esta:

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

generará los archivos x1y01z1 .. x5y10z5. Si desea agregar la agrupación de salida
en x y z puedes hacer esto:

evaluación paralela 'gato {=s/y01/y*/=} > {=s/y01//=}' ::: *y01*

Para todos los valores de x y z, ejecuta comandos como:

gato x1y*z1 > x1z1

Entonces terminas con x1z1 .. x1z5, cada uno con el contenido de todos los valores de y.

Ejemplo: Amplitud first paralelo web rastreador/espejo

Este script a continuación rastreará y reflejará una URL en paralelo. Descarga primeras páginas que
son 1 clic hacia abajo, luego 2 clics hacia abajo, luego 3; en lugar de la profundidad normal primero, donde el
El primer enlace de enlace en cada página se obtiene primero.

Ejecutar así:

PARALELO=-j100 ./rastreo paralelo http://gatt.org.yeslab.org/

Eliminar el wget parte si solo quieres un rastreador web.

Funciona obteniendo una página de una lista de URL y buscando enlaces en esa página que
están dentro de la misma URL de inicio y que aún no se han visto. Estos enlaces son
añadido a una nueva cola. Cuando se completan todas las páginas de la lista, la nueva cola se mueve a
la lista de URL y el proceso se inicia de nuevo hasta que no se encuentran enlaces ocultos.

#!/ bin / bash

# P.ej http://gatt.org.yeslab.org/
URL=$1
# Permanecer dentro del directorio de inicio
BASEURL=$(echo $URL | perl -pe 's:#.*::; s:(//.*/)[^/]*:$1:')
URLLIST=$(mktemp lista de direcciones URL.XXXX)
URLLIST2=$(mktemp lista de direcciones URL.XXXX)
VISTO=$(mktemp visto.XXXX)

# Araña para obtener las URL
echo $URL >$LISTAURL
cp $URLIST $VISTO

while [-s $URLIST]; hacer
gato $URLLIST |
lince paralelo -listonly -image_links -dump {} \; wget -qm -l1 -Q1 {} \; echo Araña: {} \>\&2 |
perl -ne 's/#.*//; s/\s+\d+.\s(\S+)$/$1/ y hacer { $visto{$1}++ o imprimir }' |
grep -F $URLBASE |
grep -v -x -F -f $VISTO | tee -a $VISTO > $URLIST2
mv $LISTAURL2 $LISTAURL
done

rm -f $LISTAURL $LISTAURL2 $VISTO

Ejemplo: Proceso archivos Desde a alquitrán presentar mientras desempacar

Si los archivos a procesar están en un archivo tar, desempaquetar un archivo y procesarlo
inmediatamente puede ser más rápido que descomprimir primero todos los archivos.

alquitrán F foo.tgz | perl -n 'impresión $l;$l=$_;END{imprimir $l}' | paralelo echo

Se necesita la frase de Perl para evitar la condición de carrera.

Ejemplo: Reescritura a en bucle y a bucle mientras-leer

bucles for como este:

(para x en `lista de gatos`; hacer
hacer_algo $x
hecho) | proceso_salida

y while-read-loops como este:

lista de gatos | (mientras lee x ; haz
hacer_algo $x
hecho) | proceso_salida

se puede escribir así:

gato lista | paralelo hacer algo | proceso_salida

Por ejemplo: Encuentre qué nombre de host en una lista tiene la dirección IP 1.2.3 4:

gato hosts.txt | paralelo -P 100 host | grep 1.2.3.4

Si el procesamiento requiere más pasos, el ciclo for es así:

(para x en `lista de gatos`; hacer
sin_extensión=${x%.*};
hacer_algo $escala x $sin_extensión.jpg
do_step2 <$x $sin_extensión
hecho) | proceso_salida

y bucles while como este:

lista de gatos | (mientras lee x ; haz
sin_extensión=${x%.*};
hacer_algo $escala x $sin_extensión.jpg
do_step2 <$x $sin_extensión
hecho) | proceso_salida

se puede escribir así:

gato lista | paralelo "hacer algo {} escala {.}.jpg ; hacer_paso2 <{} {.} " | proceso_salida

Ejemplo: Reescritura anidado for-bucles

Bucles for anidados como este:

(para x en `cat xlist` ; hacer
para y en `cat ylist`; hacer
hacer_algo $x $y
done
hecho) | proceso_salida

se puede escribir así:

paralelo hacer algo 1 {} 2 {} :::: lista x lista | proceso_salida

Bucles for anidados como este:

(para género en MF ; hacer
para talla en SML XL XXL; hacer
echo $género $tamaño
done
hecho) | clasificar

se puede escribir así:

paralelo echo 1 {} 2 {} ::: M F ::: S M L XL XXL | sort

Ejemplo: Encontrar la más bajo la diferencia entre archivos

diff es bueno para encontrar diferencias en archivos de texto. diff | wc -l da una indicación de
el tamaño de la diferencia. Para encontrar las diferencias entre todos los archivos en el directorio actual
hacer:

paralelo --etiqueta 'diferencia 1 {} 2 {} | wc -l ' ::: * ::: * | sort -nk3

De esta manera, es posible ver si algunos archivos están más cerca de otros archivos.

Ejemplo: for-bucles con visión de conjunto nombres

Al hacer múltiples bucles for anidados, puede ser más fácil realizar un seguimiento de la variable de bucle.
si se nombra en lugar de tener solo un número. Utilizar --encabezamiento : dejar el primer argumento
Sea un alias con nombre para la cadena de reemplazo posicional:

paralelo --header : echo {género} {tamaño} ::: género MF ::: tamaño SML XL XXL

Esto también funciona si el archivo de entrada es un archivo con columnas:

libreta de direcciones gato.tsv | paralelo --colsep '\t' --header : echo {Nombre} {Dirección de correo electrónico}

Ejemplo: Contar la diferencias entre que todas archivos in a dir

Usando --resultados los resultados se guardan en /tmp/diffcount*.

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

Para ver la diferencia entre el archivo A y el archivo B, mire el archivo '/tmp/diffcount/1/A/2/B'.

Ejemplo: Exceso de velocidad up fast recibas nuevas vacantes en tu correo

Iniciar un trabajo en la máquina local toma alrededor de 10 ms. Esto puede ser una gran sobrecarga si el
El trabajo tarda muy pocos ms en ejecutarse. A menudo, puede agrupar trabajos pequeños usando -X que lo hará
hacer que los gastos generales sean menos significativos. Compara la velocidad de estos:

secuencia -w 0 9999 | foto táctil paralela{}.jpg

secuencia -w 0 9999 | paralelo -X toque pict{}.jpg

Si su programa no puede tomar múltiples argumentos, entonces puede usar GNU paralelo para desovar
múltiples GNU paralelos:

secuencia -w 0 999999 | paralelo -j10 --pipe paralelo -j0 toque pict{}.jpg

If -j0 normalmente genera 252 trabajos, entonces el anterior intentará generar 2520 trabajos. en una normalidad
Sistema GNU/Linux puede generar 32000 trabajos utilizando esta técnica sin problemas. elevar
el aumento del límite de 32000 puestos de trabajo /proc/sys/kernel/pid_max a 4194303.

Ejemplo: Usando shell las variables

Cuando use variables de shell, debe citarlas correctamente, ya que de lo contrario pueden dividirse
en los espacios.

Note la diferencia entre:

V=("Los 12\" registros de mi hermano valen <\$\$\$>"'!' Foo Bar)
echo paralelo ::: ${V[@]} # Esto probablemente no es lo que quieres

y:

V=("Los 12\" registros de mi hermano valen <\$\$\$>"'!' Foo Bar)
eco paralelo ::: "${V[@]}"

Al usar variables en el comando real que contiene caracteres especiales (por ejemplo, espacio)
puedes citarlos usando '"$VAR"' o usando "'s y -q:

V="Aquí hay dos"
eco paralelo "'$V'" ::: espacios
paralelo -q echo "$V" ::: espacios

Ejemplo: Grupo procesos salida líneas

Cuando ejecuta trabajos que generan datos, a menudo no desea que la salida de varios trabajos
correr juntos. ÑU paralelo el valor predeterminado es agrupar la salida de cada trabajo, por lo que la salida es
se imprime cuando finaliza el trabajo. Si desea que se impriman líneas completas mientras se realiza el trabajo
corriendo puedes usar - búfer de línea. Si desea que la salida se imprima lo antes posible
puedes usar -u.

Compare la salida de:

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

a la salida de:

paralelo - búfer de línea traceroute ::: foss.org.my debian.org freenetproject.org

y:

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

Ejemplo: Etiqueta salida líneas

GNU paralelo agrupa las líneas de salida, pero puede ser difícil ver dónde están los diferentes trabajos.
empezar. --etiqueta antepone el argumento para hacerlo más visible:

paralelo --etiqueta traceroute ::: foss.org.my debian.org freenetproject.org

--etiqueta con obras - búfer de línea pero no con -u:

paralelo --etiqueta - búfer de línea traceroute ::: foss.org.my debian.org freenetproject.org

Compruebe el tiempo de actividad de los servidores en ~ / .parallel / sshloginfile:

paralelo --etiqueta -S .. --no todos el tiempo de actividad

Ejemplo: Guardar solicite of salida mismo as solicite of Las opciones de entrada

Normalmente, la salida de un trabajo se imprimirá tan pronto como se complete. a veces quieres
el orden de la salida sigue siendo el mismo que el orden de la entrada. esto es a menudo
importante, si la salida se utiliza como entrada para otro sistema. -k se asegurará de que el pedido
de salida estará en el mismo orden que la entrada incluso si los trabajos posteriores finalizan antes que los trabajos anteriores.

Agregue una cadena a cada línea en un archivo de texto:

gato Archivo de texto | paralelo -k echo {} cadena_añadida

Si quitas -k algunas de las líneas pueden aparecer en el orden incorrecto.

Otro ejemplo es traceroute:

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

dará traceroute de foss.org.my, debian.org y freenetproject.org, pero será
ordenados según el trabajo que se completó primero.

Para mantener el orden igual que la ejecución de entrada:

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

Esto asegurará que traceroute a foss.org.my se imprima primero.

Un ejemplo un poco más complejo es descargar un archivo enorme en fragmentos en paralelo: algunos datos de Internet
Las conexiones entregarán más datos si descarga archivos en paralelo. para descargar
archivos en paralelo ver: "EJEMPLO: Descargar 10 imágenes para cada uno de los últimos 30 días". Pero si
está descargando un archivo grande, puede descargar el archivo en fragmentos en paralelo.

Para descargar el byte 10000000-19999999 puedes usar rizo:

rizo -r 10000000 - 19999999 http://example.com/the/big/file > archivo.parte

Para descargar un archivo de 1 GB, necesitamos 100 fragmentos de 10 MB descargados y combinados en la forma correcta.
orden.

ss 0 99 | paralelo -k rizo -r \
{}0000000-{}9999999 http://example.com/the/big/file > presentar

Ejemplo: Paralelo grep

grep -r greps recursivamente a través de directorios. En CPUs multinúcleo GNU paralelo a menudo puede
acelerar esto.

find . Tipo f | paralelo -k -j150% -n 1000 -m grep -H -n CADENA {}

Esto ejecutará 1.5 trabajos por núcleo y dará 1000 argumentos a grep.

Ejemplo: grepping n líneas para m regular expresiones

La solución más simple para grep un archivo grande para muchas expresiones regulares es:

grep -f regexps.txt archivo grande

O si las expresiones regulares son cadenas fijas:

grep -F -f regexps.txt archivo grande

Hay 2 factores limitantes: CPU y E/S de disco. La CPU es fácil de medir: si el grep toma
>90 % de CPU (p. ej., cuando se ejecuta en la parte superior), entonces la CPU es un factor limitante y la paralelización
acelerará esto. De lo contrario, la E/S del disco es el factor limitante y, dependiendo de la
sistema de disco puede ser más rápido o más lento para paralelizar. La única manera de saber con certeza es
para medir.

Si la CPU es el factor limitante, la paralelización se debe realizar en las expresiones regulares:

gato expresión regular.txt | paralelo --pipe -L1000 --round-robin grep -f - bigfile

Si una línea coincide con varias expresiones regulares, la línea puede estar duplicada. El comando iniciará una
grep por CPU y leer bigfile una vez por CPU, pero como se hace en paralelo, todas las lecturas
excepto que el primero se almacenará en caché en la RAM. Dependiendo del tamaño de regexp.txt puede ser
más rápido de usar --block 10m en lugar de -L1000. Si regexp.txt es demasiado grande para caber en la RAM,
elimine --round-robin y ajuste -L1000. Esto hará que bigfile se lea más veces.

Algunos sistemas de almacenamiento funcionan mejor cuando leen varios fragmentos en paralelo. Esto es verdad
para algunos sistemas RAID y para algunos sistemas de archivos de red. Para paralelizar la lectura de
archivo grande:

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

Esto dividirá bigfile en fragmentos de 100 MB y ejecutará grep en cada uno de estos fragmentos. Para
paralelice la lectura de bigfile y regexp.txt combine los dos usando --fifo:

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

Si una línea coincide con varias expresiones regulares, la línea puede estar duplicada.

Ejemplo: Usando sanaciones computadoras

Para ejecutar comandos en una computadora remota, se debe configurar SSH y debe poder iniciar sesión
sin ingresar una contraseña (Los comandos ssh-copy-id y ssh-agent puede ayudarte a hacerlo).

Si necesita iniciar sesión en un clúster completo, normalmente no querrá aceptar la clave de host
para cada anfitrión. Desea aceptarlos la primera vez y ser advertido si alguna vez lo son.
cambió. Para hacer eso:

# Agregue los servidores al archivo sshloginfile
(echo servera; echo serverb) > .parallel/my_cluster
# Asegúrese de que exista .ssh/config
toque .ssh/config
cp .ssh/config .ssh/config.backup
# Deshabilitar StrictHostKeyChecking temporalmente
(echo 'Host *'; echo StrictHostKeyChecking no) >> .ssh/config
paralelo --slf mi_cluster --nonall verdadero
# Eliminar la desactivación de StrictHostKeyChecking
mv .ssh/config.backup .ssh/config

Los servidores en .parallel/mi_clúster ahora se agregan en .ssh/hosts_conocidos.

Correr echo on servidor.ejemplo.com:

secuencia 10 | paralelo --sshlogin server.example.com echo

Para ejecutar comandos en más de una computadora remota, ejecute:

secuencia 10 | paralelo --sshlogin server.example.com,server2.example.net echo

o:

secuencia 10 | paralelo --sshlogin servidor.ejemplo.com \
--sshlogin servidor2.ejemplo.net echo

Si el nombre de usuario de inicio de sesión es foo on servidor2.ejemplo.net utilizar:

secuencia 10 | paralelo --sshlogin servidor.ejemplo.com \
--sshlogin [email protected] echo

Si su lista de anfitriones es servidor1-88.ejemplo.net con inicio de sesión foo:

secuencia 10 | paralelo -Sfoo@servidor{1..88}.ejemplo.net echo

Para distribuir los comandos a una lista de computadoras, haga un archivo miscomputadoras con todos los
ordenadores:

servidor.ejemplo.com
[email protected]
server3.example.com

Entonces corre:

secuencia 10 | paralelo --sshloginfile mycomputers echo

Para incluir la computadora local, agregue el sshlogin especial ':' a la lista:

servidor.ejemplo.com
[email protected]
server3.example.com
:

GNU paralelo intentará determinar el número de núcleos de CPU en cada uno de los remotos
computadoras y ejecutar un trabajo por núcleo de CPU, incluso si las computadoras remotas no tienen la
mismo número de núcleos de CPU.

Si el número de núcleos de CPU en las computadoras remotas no se identifica correctamente, el número
de núcleos de CPU se pueden agregar al frente. Aquí la computadora tiene 8 núcleos de CPU.

secuencia 10 | paralelo --sshlogin 8/server.example.com echo

Ejemplo: Transferencia of archivos

Para volver a comprimir archivos comprimidos con gzip bzip2 usando una computadora remota ejecute:

encontrar registros/ -nombre '*.gz' | \
paralelo --sshlogin server.example.com \
--transferir "zcat {} | bzip2 -9 >{.}.bz2"

Esto enumerará los archivos .gz en el los registros directorio y todos los directorios a continuación. Entonces lo hará
transferir los archivos a servidor.ejemplo.com al directorio correspondiente en $INICIO/registros. En
servidor.ejemplo.com el archivo será recomprimido usando zcat y bzip2 resultando en el
archivo correspondiente con .gz reemplazadas con . Bz2.

Si desea que el archivo bz2 resultante se vuelva a transferir a la computadora local, agregue
--regreso {.}.bz2:

encontrar registros/ -nombre '*.gz' | \
paralelo --sshlogin server.example.com \
--transfer --return {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

Una vez realizada la recompresión, el . Bz2-el archivo se transfiere de nuevo a la computadora local
y poner al lado del original .gz-archivo.

Si desea eliminar los archivos transferidos en la computadora remota, agregue --limpiar. Esto
eliminará tanto el archivo transferido a la computadora remota como los archivos transferidos
desde la computadora remota:

encontrar registros/ -nombre '*.gz' | \
paralelo --sshlogin server.example.com \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"

Si desea ejecutar en varias computadoras, agregue las computadoras a --sshlogin ya sea usando ',' o
una variedad --sshlogin:

encontrar registros/ -nombre '*.gz' | \
paralelo --sshlogin servidor.ejemplo.com,servidor2.ejemplo.com \
--sshlogin servidor3.ejemplo.com \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"

Puede agregar la computadora local usando --sshlogin :. Esto deshabilitará la eliminación y
transfiriendo solo para la computadora local:

encontrar registros/ -nombre '*.gz' | \
paralelo --sshlogin servidor.ejemplo.com,servidor2.ejemplo.com \
--sshlogin servidor3.ejemplo.com \
--sshiniciar sesión: \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"

A menudo --transferir, --regreso y --limpiar se usan juntos. Se pueden acortar a
--trc:

encontrar registros/ -nombre '*.gz' | \
paralelo --sshlogin servidor.ejemplo.com,servidor2.ejemplo.com \
--sshlogin servidor3.ejemplo.com \
--sshiniciar sesión: \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

Con el archivo miscomputadoras que contiene la lista de computadoras se convierte en:

encontrar registros/ -nombre '*.gz' | paralelo --sshloginfile miscomputadoras \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

Si el archivo ~ / .parallel / sshloginfile contiene la lista de computadoras la abreviatura especial
-S .. puede ser usado:

encontrar registros/ -nombre '*.gz' | paralelo -S .. \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

Ejemplo: Distribuido Trabaja a local y sanaciones computadoras

Convierta *.mp3 a *.ogg ejecutando un proceso por núcleo de CPU en la computadora local y el servidor2:

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

Ejemplo: Correr la mismo comando on sanaciones computadoras

Para ejecutar el comando el tiempo de actividad en computadoras remotas puedes hacer:

paralelo --etiqueta --no todos -S servidor1, servidor2 el tiempo de actividad

--no todos no lee argumentos. Si tiene una lista de trabajos que desea ejecutar en cada computadora que
puede hacer:

paralelo --etiqueta --en todo -S servidor1, servidor2 echo ::: 1 2 3

Eliminar --etiqueta si no desea que se agregue el sshlogin antes de la salida.

Si tiene muchos hosts, use '-j0' para acceder a más hosts en paralelo.

Ejemplo: Paralelizar rsync

rsync es una gran herramienta, pero a veces no llenará el ancho de banda disponible. Esto es
a menudo es un problema cuando se copian varios archivos grandes a través de conexiones de alta velocidad.

Lo siguiente comenzará uno rsync por archivo grande en dir-src a destino-dir en el servidor
servidor de foos:

cd dir-src; find . Tipo f -Talla +100000 | paralelo -v ssh servidor de foos mkdir -p
/directorio-destino/{//}\;rsync -s -Havessh {} fooserver:/dir-destino/{}

Los directorios creados pueden terminar con permisos incorrectos y los archivos más pequeños no se están
transferido. Para arreglar esos ejecutar rsync una última vez:

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

Si no puede enviar datos, pero necesita extraerlos y los archivos se llaman digits.png
(por ejemplo, 000000.png) es posible que pueda hacer:

ss -w 0 99 | paralelo rsync -Havessh fooserver:ruta-src/*{}.png destdir /

Ejemplo: Utilizar una variedad entradas in uno comando

Copie archivos como foo.es.ext a foo.ext:

ls *.es.* | perl -Educación física 'imprimir; s/\.es//' | paralelo -N2 cp 1 {} 2 {}

El comando perl escupe 2 líneas para cada entrada. ÑU paralelo toma 2 entradas (usando -N2)
y reemplaza {1} y {2} con las entradas.

Contar en binario:

paralelo -k echo ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1

Imprime el número en los lados opuestos de un dado de seis caras:

paralelo --exactamente -a <(siguiente 6) -a <(siguiente 6 -1 1) echo

paralelo --exactamente echo :::: <(siguiente 6) <(siguiente 6 -1 1)

Convierta archivos de todos los subdirectorios a archivos PNG con números consecutivos (útil para hacer
ingrese PNG para ffmpeg):

paralelo --exactamente -a <(buscar . Tipo f | clasificar) -a <(siguiente $(buscar . Tipo f|wc -l)) convertir
1 {} {2}.png

Versión alternativa:

find . Tipo f | sort | paralelo convertir {} {#}.png

Ejemplo: Utilizar a mesa as Las opciones de entrada

Contenido de table_file.tsv:

Foo bar
baz quux

Correr:

cmd -o barra -i foo
cmd -o quux -i baz

Tu puedes correr:

paralelo -a archivo_tabla.tsv --colse '\ t' cmd -o 2 {} -i 1 {}

Nota: el valor predeterminado para GNU paralelo es eliminar los espacios alrededor de las columnas. Para mantener la
espacios:

paralelo -a archivo_tabla.tsv --podar n --colse '\ t' cmd -o 2 {} -i 1 {}

Ejemplo: Ejecutar la mismo comando 10 veces

Si desea ejecutar el mismo comando con los mismos argumentos 10 veces en paralelo, puede
hacer:

ss 10 | paralelo -N0 mi_comando mis_argumentos

Ejemplo: Acoplar as gato | sh. Recursos restaurantes económicos. recibas nuevas vacantes en tu correo y evaluación

GNU paralelo puede funcionar similar a gato | sh.

Un trabajo económico en recursos es un trabajo que requiere muy poca CPU, E/S de disco y E/S de red.
Ping es un ejemplo de un trabajo económico en recursos. wget también lo es, si las páginas web son pequeñas.

El contenido del archivo jobs_to_run:

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

Para ejecutar 100 procesos simultáneamente, haga lo siguiente:

paralelo -j 100 < trabajos_a_ejecutar

Como no hay un comando los trabajos serán evaluados por el shell.

Ejemplo: Tratamiento a a lo grande presentar usando Saber más núcleos

Para procesar un archivo grande o alguna salida, puede usar --tubo para dividir los datos en bloques
y canalice los bloques en el programa de procesamiento.

Si el programa es gzip -9 tu puedes hacer:

gato archivo grande | paralelo --tubo --reciente '' -k gzip -9 >archivogrande.gz

Esto se dividirá archivo grande en bloques de 1 MB y pasar eso a gzip -9 en paralelo. Una gzip
se ejecutará por núcleo de CPU. la salida de gzip -9 se mantendrán en orden y se guardarán en
archivogrande.gz

gzip funciona bien si se agrega la salida, pero algunos procesamientos no funcionan así:
por ejemplo clasificar. Para este GNU paralelo puede poner la salida de cada comando en un archivo.
Esto ordenará un archivo grande en paralelo:

gato archivo grande | paralelo --tubo --archivos sort | paralelo -Xj1 sort -m {} ';' rm {}
>bigfile.ordenar

Aquí archivo grande se divide en bloques de alrededor de 1 MB, cada bloque termina en '\n' (que es el
predeterminado para --reciente). Cada bloque se pasa a sort y la salida de sort se guarda en
archivos Estos archivos se pasan al segundo paralelo que corre sort -m en los archivos antes
elimina los archivos. La salida se guarda en bigfile.ordenar.

GNU paralelo's --tubo alcanza un máximo de alrededor de 100 MB/s porque cada byte tiene que ser copiado
a través de GNU paralelo. Pero si archivo grande es un archivo real (buscable) GNU paralelo puede pasar por alto
la copia y enviar las piezas directamente al programa:

paralelo --parte de tubería --cuadra 100m -a archivo grande --archivos sort | paralelo -Xj1 sort -m {} ';' rm
{} >bigfile.ordenar

Ejemplo: Correr Saber más than 250 recibas nuevas vacantes en tu correo solución alternativa

Si necesita ejecutar una gran cantidad de trabajos en paralelo, es probable que llegue al
límite de identificador de archivo que suele rondar los 250 trabajos. Si eres superusuario puedes subir el
límite en /etc/security/limits.conf pero también puede usar esta solución. El identificador de archivo
el límite es por proceso. Eso significa que si generas más GNU paraleloentonces cada uno de
pueden ejecutar 250 trabajos. Esto generará hasta 2500 trabajos:

gato mi entrada | paralelo --tubo -N 50 - round-robin -j50 paralelo -j50 tu_prg

Esto generará hasta 62500 trabajos (úselo con precaución: necesita 64 GB de RAM para hacer esto, y
es posible que deba aumentar /proc/sys/kernel/pid_max):

gato mi entrada | paralelo --tubo -N 250 - round-robin -j250 paralelo -j250 tu_prg

Ejemplo: Acoplar as exclusión mutua y contando semáforo

El comando sin es un alias para paralelo --semáforo.

Un semáforo de conteo permitirá iniciar un número determinado de trabajos en segundo plano.
Cuando la cantidad de trabajos se ejecuta en segundo plano, GNU sin esperare a uno de estos
para completar antes de iniciar otro comando. sin --Espere esperará a que todos los trabajos
completa.

Ejecute 10 trabajos simultáneamente en segundo plano:

para i en * .log; hacer
echo $ i
sem -j10 gzip $i ";" eco hecho
done
sem --esperar

Un mutex es un semáforo de conteo que permite que solo se ejecute un trabajo. Esto editará el archivo.
mi archivo y antepone el archivo con líneas con los números del 1 al 3.

secuencia 3 | paralelo sem sed -i -e 'i{}' miarchivo

As mi archivo puede ser muy grande es importante que solo un proceso edite el archivo al mismo tiempo
en las transacciones.

Nombre el semáforo para tener múltiples semáforos diferentes activos al mismo tiempo:

secuencia 3 | sem paralelo --id mymutex sed -i -e 'i{}' miarchivo

Ejemplo: Sus datos Aqui editor con nombres de archivo Desde stdin (norma entrada)

Puedes usar GNU paralelo para iniciar programas interactivos como emacs o vi:

gato lista de archivos | paralelo --tty -X emacs

gato lista de archivos | paralelo --tty -X vi

Si hay más archivos de los que caben en una sola línea de comando, se iniciará el editor
de nuevo con los archivos restantes.

Ejemplo: Correr sudo

sudo requiere una contraseña para ejecutar un comando como root. Guarda en caché el acceso, por lo que solo necesita
para introducir la contraseña de nuevo si no ha utilizado sudo por un momento.

El comando:

sudo echo paralelo ::: Esta es una mala idea

no es bueno, ya que se le pedirá la contraseña de sudo para cada uno de los trabajos. Puede
o hacer:

sudo echo Esto
sudo echo paralelo ::: es una buena idea

o bien:

sudo paralelo echo ::: Esta es una buena idea

De esta manera, solo tiene que ingresar la contraseña de sudo una vez.

Ejemplo: GNU Paralelo as cola sistema/lote gerente

GNU paralelo puede funcionar como un simple sistema de colas de trabajos o como un administrador de lotes. La idea es poner
los trabajos en un archivo y tener GNU paralelo leer de eso continuamente. como GNU paralelo
se detendrá al final del archivo que usamos cola para seguir leyendo:

su verdadero >cola de trabajos; cola -n+0 -f cola de trabajos | paralelo

Para enviar sus trabajos a la cola:

echo mi_comando mi_arg >> cola de trabajos

Por supuesto que puedes usar -S para distribuir los trabajos a equipos remotos:

su verdadero >cola de trabajos; cola -f cola de trabajos | paralelo -S ..

Hay un pequeño problema al usar GNU paralelo como sistema de colas/gestor de lotes: tiene
para enviar JobSlot número de trabajos antes de que comiencen, y después de eso puede enviar uno
a la vez, y el trabajo comenzará de inmediato si hay espacios libres disponibles. Salida de la
los trabajos en ejecución o completados se retienen y solo se imprimirán cuando JobSlots tenga más trabajos.
se ha iniciado (a menos que use --ungroup o -u, en cuyo caso la salida de los trabajos
se imprimen inmediatamente). Por ejemplo, si tiene 10 espacios de trabajo, la salida del primero
el trabajo completado solo se imprimirá cuando el trabajo 11 haya comenzado, y la salida del segundo
el trabajo completado solo se imprimirá cuando se haya iniciado el trabajo 12.

Para utilizar --eof para hacer GNU paralelo salida, cola también necesita ser forzado a salir:

cola -n+0 -f lista-comandos.txt |
(parallel --eof=EXIT {}; echo Parallel ahora está listo;
(seq 1000 >> lista-comandos.txt &);
echo Terminado agregando datos ficticios forzando la cola a salir)

Ejemplo: GNU Paralelo as dir procesador

Si tiene un directorio en el que los usuarios colocan archivos que deben procesarse, puede hacerlo en
GNU/Linux (si sabes lo que esperar se llama en otras plataformas para presentar un informe de error):

esperar -q -m -r -e TRASLADADO A -e CLOSE_WRITE --formato %w%f mi_dir | paralelo -u echo

Esto ejecutará el comando echo en cada archivo puesto en mi_dir o subdirecciones de mi_dir.

Por supuesto que puedes usar -S para distribuir los trabajos a equipos remotos:

esperar -q -m -r -e TRASLADADO A -e CLOSE_WRITE --formato %w%f mi_dir | paralelo -S .. -u
echo

Si los archivos a procesar están en un archivo tar, desempaquetar un archivo y procesarlo
inmediatamente puede ser más rápido que descomprimir primero todos los archivos. Configure el procesador dir como
arriba y descomprimir en el dir.

El uso de GNU Parallel como procesador de directorios tiene las mismas limitaciones que el uso de GNU Parallel como
sistema de colas/administrador de lotes.

COTIZAR

GNU paralelo es muy liberal al citar. Solo necesita citar caracteres que tengan
significado especial en shell:

( ) $ ` ' " < > ; | \

y dependiendo del contexto, estos también deben citarse:

~&#! ? espacio * {

Por lo tanto, la mayoría de las personas nunca necesitarán más comillas que poner '\' delante del
caracteres especiales.

A menudo, simplemente puede poner \' alrededor de cada ':

perl -ne '/^\S+\s+\S+$/ e imprime el archivo $ARGV,"\n"'

se puede citar:

perl paralelo -ne \''/^\S+\s+\S+$/ e imprime $ARGV,"\n"'\' ::: archivo

Sin embargo, cuando desee utilizar una variable de shell, debe citar el signo $. Aquí hay un
ejemplo usando $PARALLEL_SEQ. Esta variable está establecida por GNU paralelo en sí mismo, por lo que el
la evaluación del $ debe ser realizada por el sub shell iniciado por GNU paralelo:

ss 10 | paralelo -N2 echo secuencia:\$PARALLEL_SEQ argumento1:{1} argumento2:{2}

Si la variable se establece antes de GNU paralelo comienza puedes hacer esto:

VAR=esto_está_configurado_antes_de_empezar

echo compruébalo | paralelo echo {} $var

Huellas dactilares: compruébalo esto_está_configurado_antes_de_comenzar

Es un poco más complicado si la variable contiene más de un espacio seguido:

VAR="dos Espacios entre cada una palabra"

echo compruébalo | paralelo echo {} \'"$VAR"\'

Huellas dactilares: compruébalo two Espacios entre cada una palabra clave

Si la variable no debe ser evaluada por el shell iniciando GNU paralelo pero tenga
evaluado por el sub shell iniciado por GNU paralelo, entonces necesitas citarlo:

echo compruébalo | paralelo VAR=this_is_set_after_starting \; echo {} \$var

Huellas dactilares: compruébalo this_is_set_after_starting

Es un poco más complicado si la variable contiene espacio:

echo compruébalo | paralelo VAR='"dos Espacios entre cada una palabra"' echo {} \'"$VAR"\'

Huellas dactilares: compruébalo two Espacios entre cada una palabra clave

$$ es la variable de shell que contiene la identificación del proceso del shell. Esto imprimirá el
ID de proceso del shell que ejecuta GNU paralelo:

ss 10 | paralelo echo $$

Y esto imprimirá las identificaciones de proceso de las subcapas iniciadas por GNU paralelo.

ss 10 | paralelo echo \$\$

Si los caracteres especiales no deben ser evaluados por el sub shell, entonces necesita
protéjalo contra la evaluación tanto del shell que inicia GNU paralelo y la subcapa:

echo compruébalo | paralelo echo {} \\\$var

Huellas dactilares: compruébalo $var

GNU paralelo puede proteger contra la evaluación por parte del sub shell usando -q:

echo compruébalo | paralelo -q echo {} \$var

Huellas dactilares: compruébalo $var

Esto es particularmente útil si tiene muchas citas. Si desea ejecutar un script de perl
Me gusta esto:

perl -n '/^\S+\s+\S+$/ y Imprimir $ARGV,"\n"' presentar

Debe citarse así:

ls | paralelo perl -n '/^\\S+\\s+\\S+\$/\ y\ imprimir\ \$ARGV,\"\\n\"' ls | paralelo perl
-n \''/^\S+\s+\S+$/ y Imprimir $ARGV,"\n"'\'

Observe cómo se deben citar los espacios, \'s, "'s y $'s. GNU paralelo puede hacer la cita por
usando la opción -q:

ls | paralelo -q perl -n '/^\S+\s+\S+$/ y Imprimir $ARGV,"\n"'

Sin embargo, esto significa que no puede hacer que el shell secundario interprete caracteres especiales. Para
ejemplo debido a -q Esto no funcionará:

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

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

porque > y | necesita ser interpretado por el sub shell.

Si obtiene errores como:

sh: -c: línea 0: error de sintaxis cerca de token inesperado
sh: error de sintaxis: cadena entrecomillada no terminada
sh: -c: línea 0: EOF inesperado mientras busca coincidencias `''
sh: -c: línea 1: error de sintaxis: final inesperado del archivo

entonces podrías intentar usar -q.

Si utilizas conexiones golpear proceso de sustitución como <(gato Foo) entonces puedes intentarlo -q y
anteponiendo comando con golpear -c:

ls | paralelo -q golpear -c 'baño -c <(eco {})'

O para sustituir la salida:

ls | paralelo -q golpear -c 'alquitrán c {} | tee >(gzip >{}.tar.gz) | bzip2 >{}.tar.bz2'

Conclusión: Para evitar tener que lidiar con los problemas de cotización, puede ser más fácil simplemente escribir un
pequeño script o una función (recuerde exportar -f la función) y tener GNU paralelo llamar al
ese.

Anuncia RUNNING TRABAJO

Si desea una lista de los trabajos que se están ejecutando actualmente, puede ejecutar:

Mátalos a todos -USR1 paralelo

GNU paralelo luego imprimirá los trabajos actualmente en ejecución en stderr (error estándar).

COMPLETA RUNNING TRABAJO PERO DO EMPIEZA NUEVO TRABAJO

Si te arrepientes de comenzar muchos trabajos, simplemente puedes romper GNU paralelo, pero si quieres
asegúrese de no tener trabajos a medio terminar, debe enviar la señal SIGNO a GNU
paralelo:

Mátalos a todos -TÉRMINO paralelo

Esto le dirá a GNU paralelo para no comenzar ningún nuevo trabajo, sino esperar hasta el actual
los trabajos en ejecución finalizan antes de salir.

MEDIO AMBIENTE VARIABLES

$PARALLEL_PID
GNU establece la variable de entorno $PARALLEL_PID paralelo y es visible para
los trabajos comenzaron desde GNU paralelo. Esto hace posible que los trabajos
comunicarse directamente con GNU paralelo. Recuerde citar el $, para que se
evaluado por el shell correcto.

Ejemplo: Si cada uno de los trabajos prueba una solución y uno de los trabajos encuentra la solución
el trabajo puede decirle a GNU paralelo para no empezar más trabajos por: matar -TÉRMINO
$PARALLEL_PID. Esto solo funciona en la computadora local.

$PARALLEL_SHELL (prueba alfa)
Use este shell para los comandos ejecutados por GNU Parallel:

· $PARALLEL_SHELL. Si no está definido, use:

· El shell que inició GNU Parallel. Si no se puede determinar:

· $SHELL. Si no está definido, use:

· / Bin / sh

$PARALLEL_SEQ
$PARALLEL_SEQ se establecerá en el número de secuencia del trabajo en ejecución. Recuerda
cite el $, para que sea evaluado por el shell correcto.

Ejemplo:

ss 10 | paralelo -N2 echo secuencia:'$'PARALLEL_SEQ argumento1:{1} argumento2:{2}

$TMPDIR Directorio para archivos temporales. Ver: --tmpdir.

$PARALELO
La variable de entorno $PARALLEL se utilizará como opción predeterminada para GNU
paralelo. Si la variable contiene caracteres especiales de shell (por ejemplo, $, * o espacio)
entonces estos deben ser escapados con \.

Ejemplo:

gato lista | paralelo -j1 -k -v ls

Se puede escribir como:

gato lista | PARALELO="-kvj1" paralelo ls

gato lista | paralelo -j1 -k -v -S"misssh usuario@servidor" ls

Se puede escribir como:

gato lista | PARALELO='-kvj1 -S missss\ usuario@servidor' paralelo echo

Observe que se necesita \ en el medio porque 'myssh' y 'user@server' deben ser
un argumento.

DEFAULT PERFIL (CONFIGURAR EXPEDIENTE)

El archivo de configuración global /etc/parallel/config, seguido del archivo de configuración del usuario
~ / .parallel / config (anteriormente conocido como .parallelrc) se leerán a su vez si existen.
Las líneas que comiencen con '#' serán ignoradas. El formato puede seguir el del entorno.
variable $PARALLEL, pero a menudo es más fácil poner cada opción en su propia línea.

Las opciones en la línea de comando tienen prioridad, seguidas de la variable de entorno
$PARALLEL, archivo de configuración de usuario ~ / .parallel / config, y finalmente el mundial
archivo de configuración /etc/parallel/config.

Tenga en cuenta que ningún archivo que se lea para opciones, ni la variable de entorno $PARALLEL, puede
contienen opciones retiradas como --peaje.

PERFIL ARCHIVOS

If --perfil conjunto, GNU paralelo leerá el perfil de ese archivo en lugar del global
o archivos de configuración de usuario. Puedes tener múltiples --perfiles.

Ejemplo: perfil para ejecutar un comando en cada sshlogin en ~/.ssh/sshlogins y anteponer
la salida con el sshlogin:

echo --tag -S .. --nonall > ~/.paralelo/n
paralelo -Jn tiempo de actividad

Ejemplo: Perfil para ejecutar cada comando con -j-1 y agradable

echo -j-1 agradable > ~/.paralelo/perfil_agradable
paralelo -J perfil_bonito bzip2 -9 ::: *

Ejemplo: Perfil para ejecutar un script perl antes de cada comando:

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

Tenga en cuenta que $ y " deben citarse usando \.

Ejemplo: perfil para ejecutar trabajos distribuidos con agradable en los equipos remotos:

echo -S .. agradable > ~/.paralelo/distancia
paralelo -J dist --trc {.}.bz2 bzip2 -9 ::: *

SALIR ESTADO

If --detener en caso de error 0 o no especificado:

0 Todos los trabajos se ejecutaron sin errores.

1-253 Algunos de los trabajos fallaron. El estado de salida da el número de trabajos fallidos

254 Más de 253 trabajos fallaron.

255 Otro error.

If --detener en caso de error 1 o 2: estado de salida del trabajo anómalo.

DIFERENCIAS ENTRE GNU Paralelo Y ALTERNATIVAS

Hay muchos programas con algunas de las funciones de GNU. paralelo. ÑU paralelo
se esfuerza por incluir lo mejor de la funcionalidad sin sacrificar la facilidad de uso.

RESUMEN MESA DE NOCHE
Las siguientes características se encuentran en algunas de las herramientas comparables:

Ingresos
I1. Los argumentos se pueden leer desde stdin
I2. Los argumentos se pueden leer desde un archivo.
I3. Los argumentos se pueden leer desde varios archivos.
I4. Los argumentos se pueden leer desde la línea de comando
I5. Los argumentos se pueden leer de una tabla.
I6. Los argumentos se pueden leer desde el mismo archivo usando #! (el asunto)
I7. Entrada orientada a la línea por defecto (no es necesario citar caracteres especiales)

Manipulación de entrada
M1. comando compuesto
M2. Múltiples argumentos pueden llenar una línea de ejecución
M3. Los argumentos se pueden colocar en cualquier lugar de la línea de ejecución.
M4. Se pueden colocar varios argumentos en cualquier lugar de la línea de ejecución.
M5. Los argumentos pueden ser reemplazados por contexto.
M6. La entrada se puede tratar como una línea de ejecución completa

Recursos
O1. Agrupar la salida para que la salida de diferentes trabajos no se mezcle
O2. Enviar stderr (error estándar) a stderr (error estándar)
O3. Enviar stdout (salida estándar) a stdout (salida estándar)
O4. El orden de salida puede ser el mismo que el orden de entrada
O5. Stdout solo contiene stdout (salida estándar) del comando
O6. Stderr solo contiene stderr (error estándar) del comando

Ejecución
E1. Ejecutar trabajos en paralelo
E2. Listar trabajos en ejecución
E3. Finalice los trabajos en ejecución, pero no inicie nuevos trabajos
E4. El número de trabajos en ejecución puede depender del número de CPU
E5. Finalice los trabajos en ejecución, pero no inicie nuevos trabajos después del primer error
E6. El número de trabajos en ejecución se puede ajustar mientras se ejecuta

Ejecución remota
R1. Los trabajos se pueden ejecutar en equipos remotos
R2. Los archivos base se pueden transferir
R3. Los archivos de argumentos se pueden transferir
R4. Los archivos de resultados se pueden transferir
R5. Limpieza de archivos transferidos
R6. No se necesitan archivos de configuración
R7. No ejecute más de lo que MaxStartups de SSHD puede manejar
R8. Comando SSH configurable
R9. Vuelva a intentarlo si la conexión se interrumpe ocasionalmente

Semáforo
S1. Posibilidad de trabajar como mutex
S2. Posibilidad de trabajar como semáforo de conteo

Leyenda
- = no
x = no aplicable
identificación = sí

Como cada nueva versión de los programas no se prueba, la tabla puede estar desactualizada. Por favor presente
un informe de errores si encuentra errores (consulte INFORMES DE ERRORES).

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

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

hacer -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: envíe un informe de error si sabe qué funciones admite xjobs (consulte
REPORTE DE ERRORES).

prll: TODO: envíe un informe de error si sabe qué funciones admite prll (consulte
REPORTE DE ERRORES).

dxargs: TODO: envíe un informe de error si sabe qué funciones admite dxargs (consulte
REPORTE DE ERRORES).

mdm/middelman: TODO - Presente un informe de error si sabe qué características tiene mdm/middelman
admite (Ver REPORTE DE ERRORES).

xapply: TODO: envíe un informe de error si sabe qué funciones admite xapply (consulte
REPORTE DE ERRORES).

paexec: TODO: envíe un informe de error si sabe qué funciones admite paexec (consulte
REPORTE DE ERRORES).

ladon: TODO - Presente un informe de error si sabe qué funciones admite ladon (consulte
REPORTE DE ERRORES).

ClusterSSH: TODO: envíe un informe de error si sabe qué funciones admite ClusterSSH
(Ver REPORTE DE ERRORES).

DIFERENCIAS ENTRE xargs Y GNU Paralelo
xargs ofrece algunas de las mismas posibilidades que GNU paralelo.

xargs trata mal los caracteres especiales (como espacio, ' y "). Para ver el problema, intente
modo:

toque archivo_importante
toque 'archivo_no_importante'
no es* | xargs rm
mkdir -p "Los 12\" registros de mi hermano"
ls | xargs rmdir

Puede especificar -0 or -d "\norte", pero muchos generadores de entrada no están optimizados para usar NUL
como separador pero están optimizados para nueva línea como separador. P.ej cabeza, cola, awk, ls, echo,
SED, alquitrán -v, perl (-0 y \0 en lugar de \n), localizar (requiere usar -0), find (requiere
usando -imprimir0), grep (requiere que el usuario use -z or -Z), sort (requiere usar -z).

Así que GNU paraleloLa separación de nueva línea se puede emular con:

gato | xargs -d "\norte" -N1 comando

xargs puede ejecutar un número determinado de trabajos en paralelo, pero no tiene soporte para ejecutar número-
of-cpu-cores trabajos en paralelo.

xargs no tiene soporte para agrupar la salida, por lo tanto, la salida puede ejecutarse junta, por ejemplo, la
la primera mitad de una línea es de un proceso y la última mitad de la línea es de otro
proceso. El ejemplo Paralelo grep no se puede hacer de forma fiable con xargs Debido a esto. Para
ver esto en acción intente:

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

xargs no tiene soporte para mantener el orden de la salida, por lo tanto, si se ejecutan trabajos en
uso paralelo xargs la salida del segundo trabajo no se puede posponer hasta el primer trabajo
está hecho.

xargs no tiene soporte para ejecutar trabajos en computadoras remotas.

xargs no tiene soporte para reemplazo de contexto, por lo que tendrá que crear los argumentos.

Si usa una cadena de reemplazo en xargs (-I) no puedes forzar xargs usar más de uno
argumento.

Citando en xargs funciona como -q en GNU paralelo. Esto significa comandos compuestos y
la redirección requiere usar golpear -c.

ls | paralelo "baño {} > {}.baño"

se convierte (asumiendo que tienes 8 núcleos)

ls | xargs -d "\norte" -P8 -I {} golpear -c "baño {} > {}.baño"

y

ls | paralelo "eco {}; ls {}|wc"

se convierte (asumiendo que tienes 8 núcleos)

ls | xargs -d "\norte" -P8 -I {} golpear -c "eco {}; ls {}|wc"

DIFERENCIAS ENTRE find Exec- Y GNU Paralelo
find Exec- ofrecen algunas de las mismas posibilidades que GNU paralelo.

find Exec- solo funciona en archivos. Por lo tanto, procesar otra entrada (como hosts o URL)
requieren la creación de estas entradas como archivos. find Exec- no tiene soporte para ejecutar comandos en
paralela.

DIFERENCIAS ENTRE “piensen de nuevo sobre los incrementos de precio” -j Y GNU Paralelo
“piensen de nuevo sobre los incrementos de precio” -j puede ejecutar trabajos en paralelo, pero requiere un Makefile diseñado para hacerlo. Eso resulta
en comillas adicionales para que el nombre de archivo que contiene la nueva línea funcione correctamente.

“piensen de nuevo sobre los incrementos de precio” -j no tiene soporte para agrupar la salida, por lo tanto, la salida puede ejecutarse junta, por ejemplo
la primera mitad de una línea es de un proceso y la última mitad de la línea es de otro
proceso. El ejemplo Paralelo grep no se puede hacer de forma fiable con “piensen de nuevo sobre los incrementos de precio” -j Debido a esto.

(Versiones muy tempranas de GNU paralelo fueron implementados coincidentemente usando “piensen de nuevo sobre los incrementos de precio” -j).

DIFERENCIAS ENTRE pps Y GNU Paralelo
pps es también una herramienta para ejecutar trabajos en paralelo.

La salida de pps es información de estado y, por lo tanto, no es útil para usar como entrada para
otro comando. Los resultados de los trabajos se colocan en archivos.

La cadena de reemplazo del argumento ($ITEM) no se puede cambiar. Los argumentos deben ser citados - por lo tanto
argumentos que contengan caracteres especiales (espacio '"&!*) pueden causar problemas. Más de uno
el argumento no es compatible. Los nombres de archivo que contienen saltos de línea no se procesan correctamente.
Cuando se lee la entrada de un archivo, el valor nulo no se puede utilizar como terminador. pps necesita leer el
archivo de entrada completo antes de iniciar cualquier trabajo.

La información de salida y estado se almacena en ppss_dir y, por lo tanto, requiere limpieza cuando
terminado. Si el directorio no se elimina antes de ejecutar pps de nuevo puede que no cause nada
suceder como pps cree que la tarea ya está hecha. ÑU paralelo normalmente no necesitará
limpieza si se ejecuta localmente y solo necesitará limpieza si se detiene anormalmente y
corriendo a distancia (--limpiar puede no completarse si se detiene de manera anormal). El ejemplo Paralelo
grep requeriría un procesamiento posterior adicional si se escribiera usando pps.

Para sistemas remotos, PPSS requiere 3 pasos: configuración, implementación e inicio. ÑU paralelo only
requiere un paso.

EJEMPLOS DESDE pps MANUAL

Aquí están los ejemplos de ppspágina del manual con el equivalente usando GNU paralelo:

1 ./ppss.sh standalone -d /ruta/a/archivos -c 'gzip'

1 encontrar /ruta/a/los/archivos -tipo f | gzip paralelo

2 ./ppss.sh standalone -d /ruta/a/archivos -c 'cp "$ITEM" /destination/dir '

2 encontrar /ruta/a/los/archivos -tipo f | cp paralelo {} /destino/dir

3 ./ppss.sh autónomo -f lista-de-urls.txt -c 'wget -q '

3 paralelo -una lista-de-urls.txt wget -q

4 ./ppss.sh independiente -f lista-de-urls.txt -c 'wget -q "$ITEM"'

4 paralelo -una lista-de-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 ; ./pps
desplegar -C config.cfg ; ./ppss inicio -C config

5 # paralelo no usa configuraciones. Si desea un nombre de usuario diferente, póngalo en nodes.txt:
usuario @ nombre de host

5 encontrar fuente/directorio -tipo f | paralelo --sshloginfile nodos.txt --trc {.}.mp3 lame -a {} -o
{.}.mp3 --estándar predeterminado --silencioso

6 ./ppss detener -C config.cfg

6 killall -TERM paralelo

7 ./ppss pausa -C config.cfg

7 Presiona: CTRL-Z o killall -SIGTSTP paralelo

8 ./ppss continuar -C config.cfg

8 Introduzca: fg o killall -SIGCONT paralelo

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

9 killall -SIGUSR2 paralelo

DIFERENCIAS ENTRE pexec Y GNU Paralelo
pexec es también una herramienta para ejecutar trabajos en paralelo.

EJEMPLOS DESDE pexec MANUAL

Aquí están los ejemplos de pexecpágina de información con el equivalente usando GNU paralelo:

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

1 secuencia 10 | paralelo -j4 'echo "escala=10000;raíz cuadrada({})" | bc > sqrt-{}.dat'

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

2 ls misarchivos*.ext | clasificación paralela {} ">{}.sort"

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

3 paralelo -a imagen.lista \
'fistar {}.fits -f 100 -F id,x,y,flux -o {}.star' 2>star.log

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

4 ls *.png | paralelo 'convertir {} {.}.jpeg; eco {}: hecho'

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

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

6 para p en *.png; haz echo ${p%.png} ; hecho | \
pexec -f - -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'

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

7 LIST=$(para p en *.png ; haz echo ${p%.png} ; hecho)
pexec -r $LISTA -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'

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

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

8 Combinando GNU paralelo y GNU sin.

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

8 Si la lectura y la escritura se realizan en el mismo disco, esto puede ser más rápido como un solo proceso
será leer o escribir:

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

DIFERENCIAS ENTRE xtrabajos Y GNU Paralelo
xtrabajos es también una herramienta para ejecutar trabajos en paralelo. Solo admite la ejecución de trabajos en su
computadora local.

xtrabajos trata mal con caracteres especiales como xargs. Ver la sección DIFERENCIAS
ENTRE xargs Y GNU Paralelo.

Aquí están los ejemplos de xtrabajosLa página de manual de con el equivalente usando GNU paralelo:

1 ls-1 *.zip | xjobs descomprimir

1 ls*.zip | descomprimir en paralelo

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

2 ls*.zip | descomprimir en paralelo >/dev/null

3 encontrar . -nombre '*.bak' | xjobs gzip

3 encontrar . -nombre '*.bak' | gzip paralelo

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

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

5 script xjobs -s

5 guion de gato | paralela

6 mkfifo /var/run/my_named_pipe; xjobs -s /var/run/my_named_pipe & echo descomprimir 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 | paralelo y eco descomprimir 1.zip
>> /var/run/my_named_pipe; echo tar cf /copia de seguridad/micasa.tar /casa/yo >>
/var/run/mi_tubería_con nombre

DIFERENCIAS ENTRE por favor Y GNU Paralelo
por favor es también una herramienta para ejecutar trabajos en paralelo. No es compatible con la ejecución de trabajos en
computadoras remotas.

por favor fomenta el uso de alias BASH y funciones BASH en lugar de scripts. ÑU paralelo
nunca admitirá la ejecución de alias (vea por qué
http://www.perlmonks.org/index.pl?node_id=484296). Sin embargo, las secuencias de comandos, los comandos compuestos o
funciones exportadas con exportar -f funciona bien

por favor genera una gran cantidad de información de estado en stderr (error estándar) que lo hace
más difícil usar la salida stderr (error estándar) del trabajo directamente como entrada para otro
.

Aquí está el ejemplo de por favorLa página de manual de con el equivalente usando GNU paralelo:

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

mogrify paralelo -flip ::: *.jpg

DIFERENCIAS ENTRE dxargs Y GNU Paralelo
dxargs es también una herramienta para ejecutar trabajos en paralelo.

dxargs no trata bien con más trabajos simultáneos que MaxStartups de SSHD. dxargs is
solo está diseñado para trabajos de ejecución remota, pero no admite la transferencia de archivos.

DIFERENCIAS ENTRE mdm/intermediario Y GNU Paralelo
intermediario(mdm) también es una herramienta para ejecutar trabajos en paralelo.

Aquí están los shellscripts de http://mdm.berlios.de/usage.html portado a GNU paralelo:

ss 19 | paralelo buffon -o - | sort -n > resultado

gato archivos | paralelo cmd

find dir -ejecdir sin cmd {} \;

DIFERENCIAS ENTRE xaplicar Y GNU Paralelo
xaplicar puede ejecutar trabajos en paralelo en la computadora local.

Aquí están los ejemplos de xaplicarLa página de manual de con el equivalente usando GNU paralelo:

1 xapply '(cd %1 && hacer todo)' */

1 paralelo 'cd {} && hacer todo' ::: */

2 xapply -f 'diff %1 ../version5/%1' manifiesto | más

2 diferencia paralela {} ../version5/{} < manifiesto | más

3 xapply -p/dev/null -f 'diff %1 %2' manifest1 checklist1

3 paralelo --xapply diff {1} {2} :::: manifest1 checklist1

4 xapply 'sangría' *.c

4 sangría paralela ::: *.c

5 encuentra ~ksb/bin -tipo f! -perm -111 -estampado | xapply -f -v 'chmod a+x' -

5 encuentra ~ksb/bin -tipo f! -perm -111 -estampado | paralelo -v chmod a+x

6 buscar */ -... | FM 960 1024 | xapply -f -i /dev/tty 'vi' -

6 sh <(buscar */ -... | paralelo -s 1024 echo vi)

6 buscar */ -... | paralelo -s 1024 -Xuj1 vi

7 encontrar... | xapply -f -5 -i /dev/tty 'vi' - - - - -

7 sh <(buscar... |paralelo -n5 echo vi)

7 encontrar ... |paralelo -n5 -uj1 vi

8 xaplicar -fn "" / Etc / passwd

8 paralelo -k eco / Etc / passwd

9 tr ':' '\012' / Etc / passwd | xapply -7 -nf 'chown %1 %6' - - - - - - -

9 tr ':' '\012' / Etc / passwd | paralelo -N7 chown {1} {6}

10 aplicaciónx '[ -d %1/RCS ] || eco %1' */

10 paralelo '[ -d {}/RCS ] || eco {}' ::: */

11 xapply -f '[ -f %1 ] && echo %1' Lista | ...

11 paralelo '[ -f {} ] && echo {}' < Lista | ...

DIFERENCIAS ENTRE paexec Y GNU Paralelo
paexec puede ejecutar trabajos en paralelo en las computadoras locales y remotas.

paexec requiere comandos para imprimir una línea en blanco como última salida. Esto significa que lo harás
tiene que escribir un contenedor para la mayoría de los programas.

paexec tiene una función de dependencia de trabajo, por lo que un trabajo puede depender de otro trabajo para ejecutarse
exitosamente. Una especie de hombre pobre “piensen de nuevo sobre los incrementos de precio”.

Aquí están los ejemplos de paexeccatálogo de ejemplo con el equivalente usando GNU
paralelo:

1_div_X_ejecutar:
../../paexec -s -l -c "`pwd`/1_div_X_cmd" -n +1 <
eco paralelo {} '|' `pwd`/1_div_X_cmd <

all_substr_run:
../../paexec -lp -c "`pwd`/all_substr_cmd" -n +3 <
eco paralelo {} '|' `pwd`/all_substr_cmd <

cc_wrapper_run:
../../paexec -c "env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd" \
-n 'host1 host2' \
-t'/ usr / bin / ssh -x' <
eco paralelo {} '|' "env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd" \
-S anfitrión1, anfitrión2 <
# Esto no es exactamente lo mismo, pero evita el envoltorio
paralelo gcc -O2 -c -o {.}.o {} \
-S anfitrión1, anfitrión2 <

topper_run:
../../paexec -lp -c "`pwd`/toupper_cmd" -n +10 <
eco paralelo {} '|' ./toupper_cmd <
# Sin el envoltorio:
eco paralelo {} '| awk {imprimir\ topper\(\$0\)}' <

DIFERENCIAS ENTRE mapa Y GNU Paralelo
mapa lo ve como una característica para tener menos características y, al hacerlo, también maneja la esquina
casos incorrectamente. Mucho GNU paraleloEl código de es manejar los casos de esquina correctamente en
todas las plataformas, por lo que no se llevará una sorpresa desagradable si un usuario, por ejemplo, guarda un archivo
llamado: My hermano 12" registros.txt

mapaEl ejemplo de cómo tratar con caracteres especiales falla en caracteres especiales:

echo "The Cure" > Los discos de 12\"\ de mi hermano

ls | mapa 'echo -n `gzip < "%" | wc -c`; eco -n '*100/'; wc -c < "%"' | antes de Cristo

Funciona con GNU paralelo:

ls | paralelo 'echo -n `gzip < {} | wc -c`; eco -n '*100/'; wc -c < {}' | antes de Cristo

E incluso puede obtener el nombre del archivo antepuesto:

ls | paralelo --tag '(echo -n `gzip < {} | wc -c`'*100/'; wc -c < {}) | antes de Cristo'

mapa no tiene soporte para agrupar. Así que esto da los resultados incorrectos sin ninguna advertencia:

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

La documentación muestra una solución alternativa, pero no solo mezcla stdout (salida estándar)
con stderr (error estándar) también falla por completo para ciertos trabajos (e incluso puede ser
considerado menos legible):

eco paralelo -n {} ::: 1 2 3

mapa -p 4 'eco -n % 2>&1 | sed -e "s/^/$$:/"' 1 2 3 | ordenar | cortar -f2- -d:

mapa no puede manejar opciones agrupadas: mapa -vicepresidente 0 echo este vídeo falla

mapa no tiene un separador de argumentos en la línea de comando, pero usa el primer argumento
como comando. Esto hace que citar sea más difícil, lo que nuevamente puede afectar la legibilidad. Comparar:

mapa -p 2 perl\\\ -ne\\\ \\\'/^\\\\S+\\\\s+\\\\S+\\\$/\\\ y\\\ imprimir\\\ \\\$ARGV,\\\"\\\\n\\\"\\\' *

paralelo -q perl -ne '/^\S+\s+\S+$/ e imprime $ARGV,"\n"' ::: *

mapa puede hacer múltiples argumentos con reemplazo de contexto, pero no sin reemplazo de contexto:

paralelo --xargs echo 'COMIENZO{'{}'}FIN' ::: 1 2 3

mapa no establece el valor de salida según si uno de los trabajos falló:

paralelo falso ::: 1 || trabajo de eco fallido

mapa falso 1 || echo Nunca corras

mapa requiere Perl v5.10.0, lo que dificulta su uso en sistemas antiguos.

mapa no tiene forma de usar % en el comando (GNU Parallel tiene -I para especificar otro
cadena de reemplazo que {}).

Por diseño mapa es la opción incompatible con xargs, no tiene ejecución remota de trabajos, un
forma estructurada de guardar resultados, múltiples fuentes de entrada, indicador de progreso, configurable
delimitador de registro (solo delimitador de campo), registro de trabajos ejecutados con posibilidad de reanudar,
manteniendo la salida en el mismo orden que la entrada, procesamiento --pipe y dinámicamente
tiempos de espera.

DIFERENCIAS ENTRE Ladón Y GNU Paralelo
Ladón puede ejecutar múltiples trabajos en archivos en paralelo.

Ladón solo funciona en archivos y la única forma de especificar archivos es usando una cadena global entre comillas
(como \*.jpg). No es posible listar los archivos manualmente.

Como cadenas de reemplazo usa FULLPATH DIRNAME BASENAME EXT RELDIR RELPATH

Estos se pueden simular usando GNU paralelo al poner esto en ~ / .parallel / config:

--rpl 'RUTA COMPLETA $_=::shell_quote($_);chomp($_=qx{readlink -f $_});'
--rpl 'DIRNAME $_=::shell_quote(::dirname($_));chomp($_=qx{readlink -f $_});'
--rpl 'NOMBREBASE 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::; '

Ladón trata mal los nombres de archivo que contienen " y salto de línea, y falla para una salida más grande
de 200k:

ladon '*' -- sec 36000 | WC

EJEMPLOS DESDE Ladón MANUAL

Se supone que los '--rpl's anteriores se colocan en ~ / .parallel / config y que se ejecuta
debajo de un caparazón que admite '**' globbing (como zsh):

1 ladon "**/*.txt" -- echo RELPATH

1 eco paralelo RELPATH ::: **/*.txt

2 ladón "~/Documentos/**/*.pdf" -- shasum FULLPATH >hashes.txt

2 shasum paralelo FULLPATH ::: ~/Documentos/**/*.pdf >hashes.txt

3 ladon -m thumbs/RELDIR "**/*.jpg" loading="lazy" -- convert FULLPATH -miniatura 100x100^ -gravity
centro -extensión 100x100 pulgares/RELPATH

3 paralelo mkdir -p pulgares/RELDIR\; convertir FULLPATH -miniatura 100x100^ -centro de gravedad
-extensión 100x100 pulgares/RELPATH ::: **/*.jpg

4 ladón "~/Música/*.wav" -- lame -V 2 RUTA COMPLETA DIRNAME/BASENAME.mp3

4 paralelo lame -V 2 FULLPATH DIRNAME/BASENAME.mp3 ::: ~/Música/* .wav

DIFERENCIAS ENTRE ClústerSSH Y GNU Paralelo
ClusterSSH resuelve un problema diferente al de GNU paralelo.

ClusterSSH abre una ventana de terminal para cada computadora y usando una ventana maestra puede ejecutar
el mismo comando en todas las computadoras. Normalmente se utiliza para administrar varios
computadoras que son casi idénticas.

GNU paralelo ejecuta los mismos (o diferentes) comandos con diferentes argumentos en paralelo
posiblemente usando computadoras remotas para ayudar a la computación. Si hay más de un equipo en la lista
-S GNU paralelo solo puede usar uno de estos (por ejemplo, si hay 8 trabajos para ejecutar y uno
computadora tiene 8 núcleos).

GNU paralelo se puede usar como una versión pobre de ClusterSSH:

paralelo --no todos -S servidor-a,servidor-b hacer cosas foo de caramelos

Use paralelo en línea usando los servicios de onworks.net