paralelo - online na nuvem

PROGRAMA:

NOME

paralelo - constrói e executa linhas de comando shell a partir da entrada padrão em paralelo

SINOPSE

paralelo [opções] [comando [argumentos]] <lista_de_argumentos

paralelo [opções] [comando [argumentos]] ( ::: argumentos | :::: argfile (s)) ...

paralelo --semaphore [opções] comando

#! / usr / bin / parallel --shebang [opções] [comando [argumentos]]

DESCRIÇÃO

GNU paralelo é uma ferramenta shell para executar trabalhos em paralelo usando um ou mais computadores. UMA
trabalho pode ser um único comando ou um pequeno script que deve ser executado para cada uma das linhas em
a entrada. A entrada típica é uma lista de arquivos, uma lista de hosts, uma lista de usuários, uma lista
de URLs ou uma lista de tabelas. Um trabalho também pode ser um comando que lê de um tubo. GNU
paralelo pode então dividir a entrada em blocos e canalizar um bloco para cada comando em
paralelo.

Se você usar xargs e tee hoje, encontrará o GNU paralelo muito fácil de usar como GNU paralelo
foi escrito para ter as mesmas opções que xargs. Se você escrever loops no shell, você encontrará
GNU paralelo pode ser capaz de substituir a maioria dos loops e torná-los mais rápidos executando
vários trabalhos em paralelo.

GNU paralelo certifica-se de que a saída dos comandos é a mesma que você teria
você executa os comandos sequencialmente. Isso torna possível usar a saída do GNU paralelo
como entrada para outros programas.

Para cada linha de entrada GNU paralelo irá executar comando com a linha como argumentos. Se não
comando é fornecido, a linha de entrada é executada. Várias linhas serão executadas em paralelo.
GNU paralelo muitas vezes pode ser usado como um substituto para xargs or gato | bater.

Leitor guia
Comece assistindo aos vídeos de introdução para uma introdução rápida:
http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Então olhe para o EXEMPLOs depois da lista de OPÇÕES. Isso vai lhe dar uma ideia do que
GNU paralelo é capaz de.

Em seguida, passe uma hora percorrendo o tutorial (homem tutorial_paralelo) Sua linha de comando
vou te amar por isso.

Finalmente, você pode querer olhar para o resto deste manual se você tiver necessidades especiais não
já coberto.

OPÇÕES

comando Comando para executar. Se comando ou os seguintes argumentos contêm substituição
strings (como {}) cada instância será substituída pela entrada.

If comando é fornecido, GNU paralelo resolva as mesmas tarefas que xargs. Se comando is
não fornecido GNU paralelo vai se comportar de forma semelhante a gato | sh.

A comando deve ser um executável, um script, um comando composto ou uma função.

Se for uma função Bash, você precisa exportar -f a função primeiro. Para usar apelidos
copie o ambiente completo conforme descrito em --env E use env_parallel em vez disso
of paralelo.

Se for uma função zsh, você precisará usar esta função auxiliar exportação para
exportar e definir $ PARALLEL_SHELL para bash:

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

function my_func () {
echo $ 1;
echo "olá";
}

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

O comando não pode conter o caractere \ 257 (macron: X).

{} Linha de entrada. Esta string de substituição será substituída por uma linha completa lida do
fonte de entrada. A fonte de entrada é normalmente stdin (entrada padrão), mas também pode
ser dado com -a, :::ou ::::.

A string de substituição {} pode ser mudado com -I.

Se a linha de comando não contiver strings de substituição, então {} será anexado a
a linha de comando.

{.} Linha de entrada sem extensão. Esta string de substituição será substituída pelo
entrada com a extensão removida. Se a linha de entrada contém . depois do último /
a última . até o final da corda será removido e {.} será substituído
com o restante. Por exemplo foo.jpg torna-se Foo, subdir / foo.jpg torna-se subdir / foo,
sub.dir / foo.jpg torna-se sub.dir / foo, sub.dir / bar permanece sub.dir / bar. Se o
linha de entrada não contém . ele permanecerá inalterado.

A string de substituição {.} pode ser mudado com --er.

Para entender as strings de substituição, consulte {}.

† Nome de base da linha de entrada. Esta string de substituição será substituída pela entrada
com a parte do diretório removida.

A string de substituição † pode ser mudado com --basenamesubstituir.

Para entender as strings de substituição, consulte {}.

† Nome do diretório da linha de entrada. Esta string de substituição será substituída pelo dir do
linha de entrada. Ver Conte-me(1).

A string de substituição † pode ser mudado com --dirnamesubstituir.

Para entender as strings de substituição, consulte {}.

{/.} Nome de base da linha de entrada sem extensão. Esta string de substituição será
substituído pela entrada com o diretório e parte da extensão removidos. É um
combinação de † e {.}.

A string de substituição {/.} pode ser mudado com --basenameextensionreplace.

Para entender as strings de substituição, consulte {}.

{#} (teste alfa)
Número de sequência do trabalho a ser executado. Esta string de substituição será substituída por
o número de sequência do trabalho que está sendo executado. Ele contém o mesmo número que
$ PARALLEL_SEQ.

A string de substituição {#} pode ser mudado com --seqreplace.

Para entender as strings de substituição, consulte {}.

{%} (teste alfa)
Número do slot de trabalho. Esta string de substituição será substituída pelo slot do trabalho
número entre 1 e número de trabalhos a serem executados em paralelo. Nunca haverá 2
trabalhos em execução ao mesmo tempo com o mesmo número de slot de trabalho.

A string de substituição {%} pode ser mudado com --slotreplace.

Para entender as strings de substituição, consulte {}.

{n} Argumento da fonte de entrada n ou de n'º argumento. Esta substituição posicional
string será substituída pela entrada da fonte de entrada n (quando usado com -a or
::::) ou com o n'º argumento (quando usado com -N). Se n é negativo se refere
ao n'último argumento.

Para entender as strings de substituição, consulte {}.

{n.} Argumento da fonte de entrada n ou de n'º argumento sem extensão. É um
combinação de {n} e {.}.

Esta string de substituição posicional será substituída pela entrada da entrada
fonte n (quando usado com -a or ::::) ou com o n'º argumento (quando usado com
-N) A entrada terá a extensão removida.

Para entender as strings de substituição posicional, consulte {n}.

{n/} Nome de base do argumento da fonte de entrada n ou de n'º argumento. É um
combinação de {n} e †.

Esta string de substituição posicional será substituída pela entrada da entrada
fonte n (quando usado com -a or ::::) ou com o n'º argumento (quando usado com
-N) A entrada terá o diretório (se houver) removido.

Para entender as strings de substituição posicional, consulte {n}.

{n//} Dirname do argumento da fonte de entrada n ou de n'º argumento. É um
combinação de {n} e †.

Esta string de substituição posicional será substituída pelo dir da entrada de
fonte de entrada n (quando usado com -a or ::::) ou com o n'º argumento (quando usado
com -N). Vejo Conte-me(1).

Para entender as strings de substituição posicional, consulte {n}.

{n/.} Nome de base do argumento da fonte de entrada n ou de n'º argumento sem extensão.
É uma combinação de {n}, † e {.}.

Esta string de substituição posicional será substituída pela entrada da entrada
fonte n (quando usado com -a or ::::) ou com o n'º argumento (quando usado com
-N) A entrada terá o diretório (se houver) e a extensão removidos.

Para entender as strings de substituição posicional, consulte {n}.

{=perl expressão=}
Substitua por calculado perl expressão. $_ conterá o mesmo que {}. Depois de
avaliação perl expressão $_ será usado como o valor. É recomendado para
apenas mude $ _, mas você tem acesso total a todo GNU paraleloé interno
funções e estruturas de dados.

A {=perl expressão=} deve ser fornecido como uma única string.

Veja também: --rpl --parentes

{=n perl expressão=}
Posicional equivalente a {= perl expressão =}. Para entender posicional
strings de substituição ver {n}.

Veja também: {= perl expressão =} {n}.

::: argumentos
Use os argumentos da linha de comando como fonte de entrada em vez de stdin (padrão
entrada). Ao contrário de outras opções para GNU paralelo ::: é colocado após o comando e
antes dos argumentos.

Os seguintes são equivalentes:

(arquivo de eco1; arquivo de eco2) | gzip paralelo
paralelo gzip ::: arquivo1 arquivo2
paralelo gzip {} ::: arquivo1 arquivo2
paralelo --arg-sep ,, gzip {} ,, arquivo1 arquivo2
paralelo --arg-sep ,, gzip ,, arquivo1 arquivo2
paralelo ::: "gzip arquivo1" "gzip arquivo2"

Para evitar o tratamento ::: como uso especial --arg-setembro para definir o separador de argumento para
algo mais. Veja também --arg-setembro.

stdin (entrada padrão) será passado para a primeira execução do processo.

Se múltiplo ::: são fornecidos, cada grupo será tratado como uma fonte de entrada, e todos
combinações de fontes de entrada serão geradas. Por exemplo: ::: 1 2 ::: abc will
resultar nas combinações (1, a) (1, b) (1, c) (2, a) (2, b) (2, c). Isso é útil
para substituir for-loops aninhados.

::: e :::: pode ser misturado. Portanto, são 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

:::: arquivos arg
Outra forma de escrever -a arquivoarg1 -a arquivoarg2 ...

::: e :::: pode ser misturado.

See -a, ::: e --xapply.

--nulo
-0 Use NUL como delimitador. Normalmente as linhas de entrada terminam em \ n (nova linha). Se eles acabarem
in \ 0 (NUL), então use esta opção. É útil para processar argumentos que podem
contém \ n (nova linha).

--arg-arquivo Arquivo de entrada
-a Arquivo de entrada
Use Arquivo de entrada como fonte de entrada. Se você usar esta opção, stdin (entrada padrão) é
dado à primeira execução do processo. Caso contrário, stdin (entrada padrão) é redirecionado
de / dev / null.

Se múltiplo -a são dados, cada Arquivo de entrada será tratado como uma fonte de entrada, e
todas as combinações de fontes de entrada serão geradas. Por exemplo, o arquivo Foo contém 1
2, o arquivo Barra contém a b c. -a Foo -a Barra resultará nas combinações
(1, a) (1, b) (1, c) (2, a) (2, b) (2, c). Isso é útil para substituir aninhados por-
rotações.

Veja também --xapply e {n}.

--arg-arquivo-sep set-str
Use set-str em vez de :::: como string separadora entre o comando e o argumento
arquivos. Útil se :::: é usado para outra coisa pelo comando.

Veja também: ::::.

--arg-setembro set-str
Use set-str em vez de ::: como string separadora. Útil se ::: é usado para
algo mais pelo comando.

Também é útil se o seu comando usa ::: mas você ainda quer ler os argumentos de
stdin (entrada padrão): basta alterar --arg-setembro a uma string que não está no
linha de comando.

Veja também: :::.

--Barra Mostra o progresso como uma barra de progresso. Na barra é mostrado:% de trabalhos concluídos,
segundos estimados restantes e número de trabalhos iniciados.

É compatível com zenidade:

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

--basefile lima
--bf lima
lima será transferido para cada sshlogin antes que um trabalho seja iniciado. Será
removido se --limpar está ativo. O arquivo pode ser um script a ser executado ou algum
dados básicos necessários para os trabalhos. Múltiplo --bf pode ser especificado para transferir mais
arquivos de base. o lima será transferido da mesma forma que --transferir.

--basenamesubstituir substituir-str
--bnr substituir-str
Use a string de substituição substituir-str em vez de † para o nome de base da linha de entrada.

--basenameextensionreplace substituir-str
--bner substituir-str
Use a string de substituição substituir-str em vez de {/.} para o nome de base da linha de entrada
sem extensão.

--bg Execute o comando em segundo plano, portanto, GNU paralelo não vai esperar pela conclusão do
comando antes de sair. Este é o padrão se --semáforo é definido.

Veja também: --fg, homem este.

Implica --semáforo.

--bibtex Imprime a entrada BibTeX para GNU paralelo e desabilite o aviso de citação.

--bloquear tamanho
--tamanho do bloco tamanho
Tamanho do bloco em bytes. O tamanho pode ser pós-fixado com K, M, G, T, P, k, m, g, t,
ou p que multiplicaria o tamanho por 1024, 1048576, 1073741824, 1099511627776,
1125899906842624, 1000, 1000000, 1000000000, 1000000000000 ou 1000000000000000
respectivamente.

GNU paralelo tenta atingir o tamanho do bloco, mas pode estar errado pelo comprimento de um
registro. Por motivos de desempenho tamanho deve ser maior do que um único registro.

tamanho o padrão é 1M.

See --tubo para uso deste.

--gato Crie um arquivo temporário com conteúdo. Normalmente --tubo dará dados para o
programa em stdin (entrada padrão). Com --gato GNU paralelo criará um
arquivo temporário com o nome em {}, para que você possa fazer: paralelo --tubo --gato wc {}.

Veja também --fifo.

--limpar
Remova os arquivos transferidos. --limpar irá remover os arquivos transferidos no
computador remoto após a conclusão do processamento.

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

Com --transferir o arquivo transferido para o computador remoto será removido em
o computador remoto. Os diretórios criados não serão removidos - mesmo que sejam
esvaziar.

Com --Retorna o arquivo transferido do computador remoto será removido em
o computador remoto. Os diretórios criados não serão removidos - mesmo que sejam
esvaziar.

--limpar é ignorado quando não usado com --transferir or --Retorna.

--colsep regexp
-C regexp
Separador de coluna. A entrada será tratada como uma tabela com regexp separando o
colunas. A enésima coluna pode ser acessada usando {n} or {n.}. Por exemplo 3 {} é o 3º
coluna.

--colsep implica --aparar rl.

regexp é uma expressão regular Perl: http://perldoc.perl.org/perlre.html

--comprimir
Compactar arquivos temporários. Se a saída for grande e muito compactável, isso
ocupar menos espaço em disco em $ TMPDIR e possivelmente ser mais rápido devido a menos E / S de disco.

GNU paralelo vai tentar lzop, Pigz, gzip, pbzip2, por favor, bzip2, lzma, zip, xz in
esse pedido e use o primeiro disponível.

--compress-programa prg
--descompress-programa prg
Use prg para (des) compactar arquivos temporários. É assumido que prg -cc precisarão
descompacte stdin (entrada padrão) em stdout (saída padrão), a menos que
--descompress-programa é dada.

--ctrlc Envia SIGINT para tarefas em execução em computadores remotos, matando-os assim.

--delimitador delim
-d delim Os itens de entrada são encerrados pelo caractere especificado. Aspas e barra invertida são
não especial; cada caractere na entrada é interpretado literalmente. Desativa o fim
string de arquivo, que é tratada como qualquer outro argumento. Isso pode ser usado quando
a entrada consiste simplesmente em itens separados por nova linha, embora seja quase
é sempre melhor projetar seu programa para usar --null onde for possível. o
delimitador especificado pode ser um único caractere, um escape de caractere de estilo C, como
\ n, ou um código de escape octal ou hexadecimal. Códigos de escape octais e hexadecimais
são entendidos como para o comando printf. Caracteres multibyte não são
suportado.

--dirnamesubstituir substituir-str
--dnr substituir-str
Use a string de substituição substituir-str em vez de † para dirname da linha de entrada.

-E eof-str
Defina o final da string do arquivo como eof-str. Se o final da string de arquivo ocorrer como um
linha de entrada, o resto da entrada é ignorado. Se nenhum -E nem -e é usado,
nenhuma string de fim de arquivo é usada.

--atraso seg
Atraso no início do próximo trabalho seg segundos. GNU paralelo vai fazer uma pausa seg segundos depois
começando cada trabalho. seg pode ser inferior a 1 segundo.

--funcionamento a seco
Imprima o trabalho para executar em stdout (saída padrão), mas não execute o trabalho. Usar -v
-v para incluir o encapsulamento ssh / rsync se o trabalho for executado em um remoto
computador. Não conte com isso literalmente, pois o trabalho pode ser agendado em
outro computador ou o computador local se: estiver na lista.

--eof[=eof-str]
-e[eof-str]
Esta opção é um sinônimo para o -E opção. Usar -E em vez disso, porque é POSIX
compatível com xargs enquanto esta opção não é. Se eof-str é omitido, não há
fim da string do arquivo. Se nenhum -E nem -e é usado, nenhuma string de fim de arquivo é usada.

--env var (teste alfa)
Copiar variável de ambiente var. Isto irá copiar var para o meio ambiente que o
o comando é executado. Isso é especialmente útil para execução remota.

Em Bash var também pode ser uma função Bash - lembre-se de exportar -f da
função, ver comando.

A variável '_' é especial. Ele irá copiar todas as variáveis ​​de ambiente, exceto para o
aqueles mencionados em ~ / .parallel / ignore_vars.

Para copiar matrizes Bash, você precisa de uma função de importador, pois matrizes Bash não podem ser
exportado:

import_array() {
função local = $ 1; mudança;
export $ func = '() {
'"$ (para chegar em $ @; faça
declare -p $ arr | sed '1s / declare -./&g/'
feito)"'
}'
}

declare -A assoc = '([um] = "1" [dois] = "2")'
declare -a indexed = '([0] = "um" [1] = "dois")'

import_array my_importer assoc indexado

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

Para copiar o ambiente completo, use esta função (por exemplo, colocando-o em .bashrc):

env_parallel () {
export parallel_bash_environment = '() {
'"$ (echo" shopt -s expand_aliases 2> / dev / null "; alias; typeset -p | grep -vFf <(somente leitura; echo GROUPS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_; typeset -f) "'
}'
# Executar como: env_parallel [opções paralelas normais]
`qual paralelo`" $ @ "
não definir o parallel_bash_environment
}
# ligue como:
env_parallel [opções paralelas normais]

Veja também: --record-env.

--eta Mostra o número estimado de segundos antes de terminar. Isso força o GNU paralelo
para ler todos os empregos antes de começar a encontrar o número de empregos. GNU paralelo
normalmente só lê o próximo trabalho a ser executado. Implica --progresso.

--fg Execute o comando em primeiro plano, portanto, GNU paralelo vai esperar a conclusão do
comando antes de sair.

Veja também --bg, homem este.

Implica --semáforo.

--fifo Crie um fifo temporário com conteúdo. Normalmente --tubo dará dados para o
programa em stdin (entrada padrão). Com --fifo GNU paralelo criará um
fifo temporário com o nome em {}, para que você possa fazer: paralelo --tubo --fifo wc {}.

Cuidado: se os dados não forem lidos do fifo, o trabalho será bloqueado para sempre.

Veja também --gato.

--filtro-hosts
Remova hosts inativos. Para cada host remoto: verifique se o login por meio do ssh funciona. Se
não: não use este host.

Atualmente você pode não colocar --filtro-hosts em um perfil, $ PARALLEL,
/ etc / parallel / config ou similar. Isso ocorre porque o GNU paralelo usa GNU paralelo
para calcular isso, você obterá um loop infinito. Isso provavelmente será corrigido em um
lançamento posterior.

--gnu Comporte-se como GNU paralelo. Esta opção historicamente teve precedência sobre --tollef.
A --tollef a opção está desativada e, portanto, não pode ser usada. --gnu é mantido
para compatibilidade.

--grupo Saída do grupo. A saída de cada trabalho é agrupada e só é impressa quando
o comando foi concluído. stderr (erro padrão) primeiro seguido por stdout
(saída padrão). Isso leva algum tempo de CPU. Em raras situações GNU paralelo
consome muito tempo da CPU e se for aceitável que as saídas de diferentes
comandos são misturados, desativando o agrupamento com -u pode acelerar GNU
paralelo por um fator de 10.

--grupo é o padrão. Pode ser revertido com -u.

Veja também: --line-buffer --desagrupar

--Socorro
-h Imprime um resumo das opções do GNU paralelo e sair.

--parada no erro onda
--parar onda
Como deve o GNU paralelo terminar se um ou mais jobs falhar?

0 Não pare se um trabalho falhar. O status de saída será o número de trabalhos com falha.
Este é o padrão.

1 Não inicie novos trabalhos se um deles falhar, mas conclua os trabalhos em execução
incluindo limpeza. O status de saída será o status de saída do último
trabalho com falha.

2 Elimine todos os trabalhos imediatamente e saia sem limpeza. O status de saída
será o status de saída do trabalho com falha.

1-99% se onda% dos trabalhos falham e no mínimo 3: não inicia novos trabalhos, mas
conclua os trabalhos em execução, incluindo a limpeza. O status de saída será o
status de saída do último trabalho com falha.

--cabeçalho regexp
Use regexp como cabeçalho. Para uso normal, o cabeçalho correspondente (normalmente o primeiro
linha: --cabeçalho '. * \ n') será dividido usando --colsep (que será o padrão '\ t')
e os nomes das colunas podem ser usados ​​como variáveis ​​de substituição: {coluna nome}.

Para a --tubo o cabeçalho correspondente será anexado a cada saída.

--cabeçalho : é um apelido para --cabeçalho '. * \ n'.

If regexp é um número, ele corresponderá a esse número de linhas.

-I substituir-str
Use a string de substituição substituir-str ao invés de {}.

--substituir[=substituir-str]
-i[substituir-str]
Esta opção é sinônimo de -Isubstituir-str if substituir-str é especificado, e para
-I{} de outra forma. Esta opção está obsoleta; usar -I ao invés.

--joblog arquivo de log
Arquivo de log para trabalhos executados. Salve uma lista das tarefas executadas em arquivo de log no
seguinte formato separado por TAB: número de sequência, sshlogin, hora de início em segundos
desde a época, tempo de execução em segundos, bytes em arquivos transferidos, bytes em arquivos
retornado, status de saída, sinal e execução de comando.

Para converter os tempos em ISO-8601 estrito, faça:

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

Veja também --retomar.

--empregos N
-j N
--max-procs N
-P N Número de jobslots. Execute até N jobs em paralelo. 0 significa o máximo possível.
O padrão é 100%, o que executará um trabalho por núcleo da CPU.

If --semáforo é definido o padrão é 1, portanto, criando um mutex.

--empregos +N
-j +N
--max-procs +N
-P +N Adicione N ao número de núcleos da CPU. Execute tantos trabalhos em paralelo. Veja também
--use-cpus-ao invés-de-núcleos.

--empregos -N
-j -N
--max-procs -N
-P -N Subtraia N do número de núcleos da CPU. Execute tantos trabalhos em paralelo. Se o
o número avaliado for menor que 1, então 1 será usado. Veja também
--use-cpus-ao invés-de-núcleos.

--empregos N%
-j N%
--max-procs N%
-P N% Multiplique N% pelo número de núcleos da CPU. Execute tantos trabalhos em paralelo. Ver
tb --use-cpus-ao invés-de-núcleos.

--empregos arquivo de processo
-j arquivo de processo
--max-procs arquivo de processo
-P arquivo de processo
Leia o parâmetro do arquivo. Use o conteúdo de arquivo de processo como parâmetro para -j. Por exemplo
arquivo de processo pode conter a string 100% ou +2 ou 10. Se arquivo de processo é alterado quando um
trabalho concluído, arquivo de processo é lido novamente e o novo número de trabalhos é calculado. Se
o número é menor do que antes, os trabalhos em execução terão permissão para terminar, mas novos
os trabalhos não serão iniciados até que o número desejado de trabalhos seja alcançado. Esse
torna possível alterar o número de trabalhos em execução simultânea enquanto o GNU
paralelo está correndo.

--Manter a ordem
-k Mantenha a sequência de saída igual à ordem de entrada. Normalmente, a saída de um trabalho
será impresso assim que o trabalho for concluído. Experimente para ver a diferença:

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

Se usado com --em todos or --nonall a saída será agrupada por sshlogin em classificados
ordem.

-L linhas máximas
Quando usado com --tubo: Leia os registros de linhas máximas.

Quando usado de outra forma: Use no máximo linhas máximas linhas de entrada não vazias por linha de comando.
Espaços em branco finais fazem com que uma linha de entrada continue logicamente na próxima entrada
linha.

-L 0 significa ler uma linha, mas inserir 0 argumentos na linha de comando.

Implica -X a menos que -m, --xargsou --tubo é definido.

--max-linhas[=linhas máximas]
-l[linhas máximas]
Quando usado com --tubo: Leia os registros de linhas máximas.

Quando usado de outra forma: Sinônimo para o -L opção. diferente -L, linhas máximas
argumento é opcional. Se linhas máximas não for especificado, o padrão é um. o -l
opção está obsoleta porque o padrão POSIX especifica -L ao invés.

-l 0 é um apelido para -l 1.

Implica -X a menos que -m, --xargsou --tubo é definido.

--line-buffer
Saída de buffer em linha. --grupo irá manter a saída junta para um todo
trabalho. --desagrupar permite que a saída se misture com meia linha proveniente de um trabalho e
meia linha vinda de outro trabalho. --line-buffer se encaixa entre estes dois: GNU
paralelo imprimirá uma linha completa, mas permitirá a mistura de linhas de diferentes
empregos.

--line-buffer consome mais energia da CPU do que ambos --grupo e --desagrupar, mas pode
seja mais rápido que --grupo se a CPU não for o fator limitante.

Veja também: --grupo --desagrupar

--carga carregamento máximo
Não inicie novos trabalhos em um determinado computador, a menos que o número de processos em execução
no computador é menor que carregamento máximo. carregamento máximo usa a mesma sintaxe que --empregos,
so 100% para um por CPU é uma configuração válida. A única diferença é 0, que é
interpretado como 0.01.

--controlmaster
-M Use o ControlMaster do ssh para tornar as conexões ssh mais rápidas. Útil se os trabalhos forem executados remotamente
e são muito rápidos de executar. Isto está desabilitado para sshlogins que especificam seus próprios
comando ssh.

--xargs Vários argumentos. Insira quantos argumentos o comprimento da linha de comando permitir.

If {} não for usado, os argumentos serão acrescentados à linha. Se {} é usado
várias vezes cada {} será substituído por todos os argumentos.

Suporte para --xargs com --sshlogin é limitado e pode falhar.

Veja também -X para substituir o contexto. Em caso de dúvida, use -X como isso provavelmente fará
o que é preciso.

-m Vários argumentos. Insira quantos argumentos o comprimento da linha de comando permitir.
Se vários trabalhos estiverem sendo executados em paralelo: distribua os argumentos uniformemente entre
os trabalhos. Usar -j1 para evitar isso.

If {} não for usado, os argumentos serão acrescentados à linha. Se {} é usado
várias vezes cada {} será substituído por todos os argumentos.

Suporte para -m com --sshlogin é limitado e pode falhar.

Veja também -X para substituir o contexto. Em caso de dúvida, use -X como isso provavelmente fará
o que é preciso.

--minversão versão
Imprima a versão GNU paralelo e saia. Se a versão atual do GNU paralelo
é inferior a versão o código de saída é 255. Caso contrário, é 0.

Isso é útil para scripts que dependem de recursos disponíveis apenas em um determinado
versão do GNU paralelo.

--nonall (teste beta)
--em todos sem argumentos. Execute o comando em todos os computadores fornecidos com --sshlogin
mas não aceite argumentos. GNU paralelo vai entrar em --empregos número de computadores em
em paralelo e execute o trabalho no computador. -j ajusta quantos computadores registrar
em paralelo.

Isso é útil para executar o mesmo comando (por exemplo, tempo de atividade) em uma lista de servidores.

--em todos (teste beta)
Execute todos os trabalhos em todos os computadores fornecidos com --sshlogin. GNU paralelo logará
para dentro --empregos número de computadores em paralelo e executar um trabalho de cada vez no
computador. A ordem dos trabalhos não será alterada, mas alguns computadores podem
termine antes de outros. -j ajusta quantos computadores devem ser conectados em paralelo.

Ao usar --grupo a saída será agrupada por cada servidor, então toda a saída
de um servidor serão agrupados.

--saída como arquivos
--outputasfiles
--arquivos Em vez de imprimir a saída em stdout (saída padrão), a saída de cada trabalho
é salvo em um arquivo e o nome do arquivo é impresso.

--tubo
--spreadstdin
Divulgue a entrada para trabalhos em stdin (entrada padrão). Leia um bloco de dados de stdin
(entrada padrão) e fornece um bloco de dados como entrada para um trabalho.

O tamanho do bloco é determinado por --bloquear. As cordas --recstart e --receber dizer
GNU paralelo como um registro começa e / ou termina. O bloco lido terá o final
registro parcial removido antes que o bloco seja passado para o trabalho. O parcial
registro será anexado ao próximo bloco.

If --recstart é fornecido, ele será usado para dividir no início do registro.

If --receber é fornecido, ele será usado para dividir no final do registro.

Se ambos --recstart e --receber são fornecidos, ambos terão que corresponder para encontrar uma divisão
posição.

Se nenhum --recstart nem --receber são dados --receber o padrão é '\ n'. Ter
nenhum separador de registro usa --receber "".

--arquivos é freqüentemente usado com --tubo.

Veja também: --recstart, --receber, --fifo, --gato, --pipepart.

--pipepart (teste beta)
Pipe partes de um arquivo físico. --pipepart funciona semelhante a --tubo, mas é muito
mais rápido. Tem algumas limitações:

* O arquivo deve ser um arquivo físico (pesquisável) e deve ser fornecido usando -a or
::::.

* Contagem de registros (-N) e contagem de linha (-L/-l) não funciona.

--plano Ignorar qualquer --perfil, $ PARALLEL e ~ / .parallel / config para obter controle total sobre
a linha de comando (usada pelo GNU paralelo internamente quando chamado com --sshlogin).

--mais Ative strings de substituição adicionais: {+ /} {+.} {+ ..} {+ ...} {..} {...} {/ ..}
{/ ...}. A ideia é que '{+ foo}' corresponde ao oposto de '{foo}' e {} =
{+ /} / {/} = {.}. {+.} = {+ /} / {/.}. {+.} = {..}. {+ ..} = {+ /} / {/ ..}. {+ ..} =
{...}. {+ ...} = {+ /} / {/ ...}. {+ ...}

--progresso
Mostra o progresso dos cálculos. Liste os computadores envolvidos na tarefa com
número de núcleos de CPU detectados e o número máximo de trabalhos a serem executados. Depois daquele show
progresso para cada computador: número de trabalhos em execução, número de trabalhos concluídos e
porcentagem de todos os trabalhos realizados por este computador. A porcentagem será apenas
disponível após todos os trabalhos terem sido agendados como GNU paralelo só leia o próximo
trabalho quando estiver pronto para agendá-lo - isso evita perda de tempo e memória
lendo tudo na inicialização.

Enviando GNU paralelo SIGUSR2 você pode alternar entre ligar / desligar --progresso com um
executando GNU paralelo processo.

Veja também --eta.

--max-args=max-args
-n max-args
Use no máximo max-args argumentos por linha de comando. Menos que max-args argumentos
será usado se o tamanho (veja o -s opção) é excedido, a menos que o -x opção
dado, caso em que GNU paralelo vai sair.

-n 0 significa ler um argumento, mas inserir 0 argumentos na linha de comando.

Implica -X a menos que -m é definido.

--max-substituir-args=max-args
-N max-args
Use no máximo max-args argumentos por linha de comando. Gostar -n mas também faz
strings de substituição 1 {} .. {max-args} que representa o argumento 1 .. max-args. Se
muito poucos argumentos o {n} estará vazio.

-N 0 significa ler um argumento, mas inserir 0 argumentos na linha de comando.

Isso definirá o proprietário do homedir para o usuário:

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

Implica -X a menos que -m or --tubo é definido.

Quando usado com --tubo -N é o número de registros a serem lidos. Isso é um pouco
Mais lento que --bloquear.

- max-line-length-allowed
Imprime o número máximo de caracteres permitidos na linha de comando e sai (usado
por GNU paralelo para determinar o comprimento da linha em computadores remotos).

--número-de-cpus
Imprime o número de CPUs físicas e sai (usado pelo GNU paralelo para
determinar o número de CPUs físicas em computadores remotos).

--Número de núcleos
Imprime o número de núcleos da CPU e sai (usado pelo GNU paralelo para determinar
o número de núcleos de CPU em computadores remotos).

--sem aviso
Não exiba aviso de citação. Um aviso de citação é impresso em stderr (padrão
erro) somente se stderr (erro padrão) for um terminal, o usuário não especificou
--sem aviso, e o usuário não executou --bibtex uma vez.

--legais gentileza
Execute o comando neste niceness. Para comandos simples, você pode apenas adicionar agradável in
frente do comando. Mas se o comando consistir em mais subcomandos (como:
ls | wc), em seguida, anexando agradável nem sempre funcionará. --legais irá certificar-se de que todos os sub
os comandos são interessantes.

--interativo
-p Pergunte ao usuário se deseja executar cada linha de comando e ler uma linha do
terminal. Execute a linha de comando apenas se a resposta começar com 'y' ou 'Y'.
Implica -t.

--parentes parênteses
Use para definir parênteses inicial e final para {= perl expressão =}. A esquerda e
o parêntese certo pode ter vários caracteres e é considerado o mesmo
comprimento. O padrão é {==} dando {= como o parêntese inicial e =} como o fim
parêntese.

Outra configuração útil é ,,,, o que faria ambos os parênteses ,,:

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

Veja também: --rpl {= perl expressão =}

--perfil nome do perfil
-J nome do perfil
Use o perfil nome do perfil para opções. Isso é útil se você deseja ter vários
perfis. Você poderia ter um perfil para executar trabalhos em paralelo no local
computador e um perfil diferente para executar trabalhos em computadores remotos. Veja o
seção ARQUIVOS DE PERFIL para exemplos.

nome do perfil corresponde ao arquivo ~ / .parallel /nome do perfil.

Você pode fornecer vários perfis, repetindo --perfil. Se partes dos perfis
conflito, os últimos serão usados.

Padrão: config

--citar
-q Parâmetros comando. Isso irá citar a linha de comando para que os caracteres especiais não sejam
interpretado pelo shell. Veja a seção CITAÇÕES. A maioria das pessoas nunca vai precisar
isto. As citações estão desabilitadas por padrão.

--no-run-if-vazio
-r Se o stdin (entrada padrão) contiver apenas espaços em branco, não execute o comando.

Se usado com --tubo isso é lento.

--noswap Não inicie novos trabalhos em um determinado computador se houver swap-in e swap-out
atividade.

A atividade de troca é apenas amostrada a cada 10 segundos, pois a amostragem leva 1 segundo
para fazer.

A atividade de troca é calculada como (troca) * (troca) que na prática é uma boa
valor: trocar não é um problema, trocar dentro não é um problema, mas ambos
trocar dentro e fora geralmente indica um problema.

--record-env
Registre as variáveis ​​de ambiente atuais em ~ / .parallel / ignore_vars. Isso é útil
antes de usar --env _.

Veja também --env.

--recstart começa a corda
--receber corda final
If --recstart é dada começa a corda será usado para dividir no início do registro.

If --receber é dada corda final será usado para dividir no final do registro.

Se ambos --recstart e --receber recebem a string combinada
string inicialstring inicial terá que corresponder para encontrar uma posição de divisão. Isso é útil
se qualquer um começa a corda or corda final coincidir no meio de um registro.

Se nenhum --recstart nem --receber são dados então --receber o padrão é '\ n'. Para
não tem uso de separador de registro --receber "".

--recstart e --receber são usados ​​com --tubo.

Use --regexp interpretar --recstart e --receber como expressões regulares. Isto é
lento, no entanto.

--regexp Use --regexp interpretar --recstart e --receber como expressões regulares. Isto é
lento, no entanto.

--remove-rec-sep
--removerecsep
--rrs Remova o texto correspondido por --recstart e --receber antes de canalizá-lo para o
comando.

Usado apenas com --tubo.

--resultados prefixo
--res prefixo
Salve a saída em arquivos. Os arquivos serão armazenados em uma árvore de diretórios enraizada
at prefixo. Dentro desta árvore de diretório, cada comando resultará em dois arquivos:
prefixo/ / stdout e prefixo/ / stderr, onde é uma sequência de
diretórios que representam o cabeçalho da fonte de entrada (se estiver usando --cabeçalho :) ou
o número da fonte de entrada e os valores correspondentes.

Por exemplo:

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

irá gerar os arquivos:

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

e

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

irá gerar os arquivos:

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

Veja também --arquivos, --cabeçalho, --joblog.

--retomar Currículos do último trabalho inacabado. Pela leitura --joblog ou de --resultados dir
GNU paralelo descobrirá o último trabalho inacabado e continuará a partir daí. Como
GNU paralelo apenas olha para os números de sequência em --joblog então a entrada, o
comando, e --joblog todos devem permanecer inalterados; caso contrário GNU paralelo pode
execute comandos errados.

Veja também --joblog, --resultados, --resume-falhou.

--resume-falhou
Tente novamente todas as falhas e retome a partir do último trabalho inacabado. Pela leitura --joblog GNU
paralelo descobrirá os trabalhos com falha e os executará novamente. Depois disso vai
retome o último trabalho inacabado e continue a partir daí. Como GNU paralelo só olha para
os números de sequência em --joblog então a entrada, o comando e --joblog todos os
tem que permanecer inalterado; caso contrário GNU paralelo pode executar comandos errados.

Veja também --joblog, --retomar.

- tentativas n
Se um trabalho falhar, tente novamente em outro computador no qual não tenha falhado. Fazem isto
n vezes. Se houver menos de n computadores em --sshlogin GNU paralelo vai voltar
usar todos os computadores. Isso é útil se alguns trabalhos falharem sem motivo aparente
(como falha de rede).

--Retorna nome do arquivo
Transfira arquivos de computadores remotos. --Retorna é usado com --sshlogin quando o
argumentos são arquivos nos computadores remotos. Quando o processamento estiver concluído, o arquivo
nome do arquivo será transferido do computador remoto usando rsync e será colocado
em relação ao diretório de login padrão. Por exemplo

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

Isso irá transferir o arquivo $ HOME / foo / bar.out a partir do computador
servidor.exemplo.com para o arquivo foo / bar.out depois de correr contacto foo / bar.out on
servidor.exemplo.com.

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

Isso irá transferir o arquivo /tmp/foo/bar.out a partir do computador servidor.exemplo.com
para o arquivo /tmp/foo/bar.out depois de correr contacto /tmp/foo/bar.out on
servidor.exemplo.com.

Vários arquivos podem ser transferidos repetindo as opções várias vezes:

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

--Retorna é freqüentemente usado com --transferir e --limpar.

--Retorna é ignorado quando usado com --sshlogin : ou quando não é usado com --sshlogin.

--round-robin
--volta Normalmente --tubo dará um único bloco para cada instância do comando. Com
--round-robin todos os blocos serão escritos aleatoriamente em comandos já em execução.
Isso é útil se o comando levar muito tempo para inicializar.

--Manter a ordem não vai funcionar com --round-robin pois é impossível rastrear qual
bloco de entrada corresponde a qual saída.

--rpl 'etiqueta perl expressão'
Use etiqueta como uma string de substituição para perl expressão. Isto torna possível
defina suas próprias strings de substituição. GNU paralelo7 strings de substituição são
implementado como:

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

Se a string de substituição definida pelo usuário começar com '{', ela também pode ser usada como um
string de substituição posicional (como {2.}).

É recomendado mudar apenas $ _, mas você tem acesso total a todo o GNU
paralelofunções internas e estruturas de dados da.

Aqui estão alguns exemplos:

Remova 2 extensões (por exemplo, .tar.gz)
--rpl '{..} s: \. [^/.] + $ ::; s: \. [^/.] + $ ::; '
Mantenha apenas a extensão
--rpl '{ext} s:. * \. ::'
A sequência de tarefas é par ou ímpar?
--rpl '{ímpar} $ _ = $ job-> seq ()% 2? "ímpar": "par"'

Veja também: {= perl expressão =} --parentes

--max-caracteres=máximo de caracteres
-s máximo de caracteres
Use no máximo máximo de caracteres caracteres por linha de comando, incluindo o comando e
argumentos iniciais e os nulos de terminação nas extremidades das strings de argumento.
O maior valor permitido depende do sistema e é calculado como o argumento
limite de comprimento para exec, menos o tamanho do seu ambiente. o valor padrão é
o máximo.

Implica -X a menos que -m é definido.

--mostrar-limites
Exibe os limites do comprimento da linha de comando que são impostos pelo operador
sistema e o -s opção. Canalize a entrada de / dev / null (e talvez especifique
--no-run-if-empty) se você não quer GNU paralelo para fazer qualquer coisa.

--semáforo
Funciona como um semáforo de contagem. --semáforo irá causar GNU paralelo para iniciar
comando no fundo. Quando o número de trabalhos simultâneos é alcançado, GNU
paralelo irá aguardar a conclusão de um deles antes de iniciar outro comando.

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

--semáforo implica --semaphorename `tty` a menos que --semaphorename é especificado.

Usado com --fg, --esperar e --semaphorename.

O comando este é um apelido para paralelo --semáforo.

Veja também homem este.

--semaphorename nome
--Eu iria nome
Use nome como o nome do semáforo. O padrão é o nome do tty de controle
(saída de tty).

O padrão normalmente funciona conforme o esperado quando usado interativamente, mas quando usado em
um roteiro nome deve ser definido. $$ or minha_tarefa_nome geralmente são um bom valor.

O semáforo é armazenado em ~ / .parallel / semáforos /

Implica --semáforo.

Veja também homem este.

--semaphoretimeout seg
Se o semáforo não for liberado em segundos, use-o mesmo assim.

Implica --semáforo.

Veja também homem este.

--seqreplace substituir-str
Use a string de substituição substituir-str em vez de {#} para número de sequência de trabalho.

--shebang
--hashbang
GNU paralelo pode ser chamado de comando shebang (#!) como a primeira linha de um
roteiro. O conteúdo do arquivo será tratado como fonte de entrada.

Gosto disto:

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

foss.org.my
debian.org
freenetproject.org

--shebang deve ser definido como a primeira opção.

No FreeBSD env é preciso:

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

foss.org.my
debian.org
freenetproject.org

--shebang-wrap
GNU paralelo pode paralelizar scripts envolvendo a linha shebang. Se o programa
pode ser executado assim:

argumentos do gato | paralelo ao_programa

então o script pode ser alterado para:

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

Por exemplo

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

Se o programa pode ser executado assim:

dados do gato | paralelo --pipe the_program

então o script pode ser alterado para:

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

Por exemplo

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

--shebang-wrap deve ser definido como a primeira opção.

--shellquote
Não executa o comando, mas o cita. Útil para fazer citações compostas
comandos para GNU paralelo.

--skip-primeira linha
Não use a primeira linha de entrada (usada pelo GNU paralelo a si mesmo quando chamado com
--shebang).

--sshdelay seg
Atrasar o início do próximo ssh por seg segundos. GNU paralelo vai fazer uma pausa seg segundo
depois de iniciar cada ssh. seg pode ser inferior a 1 segundo.

-S [ncpu /] sshlogin [, [ncpu /] sshlogin [, ...]]
--sshlogin [ncpu /] sshlogin [, [ncpu /] sshlogin [, ...]]
Distribua trabalhos para computadores remotos. Os trabalhos serão executados em uma lista de remotos
computadores. GNU paralelo irá determinar o número de núcleos de CPU no controle remoto
computadores e executar o número de trabalhos conforme especificado por -j. Se o número CPU is
dado GNU paralelo usará esse número para o número de núcleos da CPU no host.
Normalmente CPU não será necessário.

An login é da forma:

[sshcommand [opções]] [nome de usuário @] nome do host

O sshlogin não deve exigir uma senha.

O sshlogin ':' é especial, significa 'no ssh' e, portanto, será executado no
computador local.

O sshlogin '..' é especial, ele lê sshlogins de ~ / .parallel / sshloginfile

O sshlogin '-' também é especial, ele lê sshlogins de stdin (entrada padrão).

Para especificar mais sshlogins separe os sshlogins por vírgulas ou repita as opções
várias vezes.

Para exemplos: veja --sshloginfile.

O host remoto deve ter GNU paralelo instalado.

--sshlogin é conhecido por causar problemas com -m e -X.

--sshlogin é freqüentemente usado com --transferir, --Retorna, --limpar e --trc.

--sshloginfile nome do arquivo (teste beta)
--slf nome do arquivo (teste beta)
Arquivo com sshlogins. O arquivo consiste em sshlogins em linhas separadas. Vazio
linhas e linhas que começam com '#' são ignoradas. Exemplo:

servidor.exemplo.com
[email protegido]
8 / my-8-core-server.example.com
2/[email protegido]
# Este servidor tem SSH em execução na porta 2222
ssh -p 2222 servidor.exemplo.net
4 / ssh -p 2222 quadserver.example.net
# Use um programa ssh diferente
myssh -p 2222 -l meunomedeusuario hexacpu.example.net
# Use um programa ssh diferente com número padrão de núcleos
// usr / local / bin / myssh -p 2222 -l meu nome de usuário hexacpu.example.net
# Use um programa ssh diferente com 6 núcleos
6 // usr / local / bin / myssh -p 2222 -l meunomedeusuario hexacpu.example.net
# Suponha que 16 núcleos no computador local
16 /:

Ao usar um programa ssh diferente, o último argumento deve ser o nome do host.

Múltiplo --sshloginfile são autorizadas.

GNU paralelo irá primeiro procurar o arquivo no diretório atual; se isso falhar, olhe
para o arquivo em ~ / .parallel.

O sshloginfile '..' é especial, ele lê sshlogins de ~ / .parallel / sshloginfile

O sshloginfile '.' é especial, lê sshlogins de
/ etc / parallel / sshloginfile

O sshloginfile '-' é especial também, ele lê sshlogins de stdin (padrão
entrada).

Se o sshloginfile for alterado, ele será relido quando um trabalho terminar em
mais uma vez por segundo. Isso torna possível adicionar e remover hosts enquanto
execução.

Isso pode ser usado para ter um daemon que atualiza o sshloginfile para conter apenas
servidores que estão ativos:

cp original.slf tmp2.slf
enquanto [1]; Faz
bom paralelo --nonall -j0 -k --slf original.slf --tag echo | perl 's / \ t $ //'> tmp.slf
if diff tmp.slf tmp2.slf; então
mv tmp.slf tmp2.slf
fi
dormir 10
feito &
paralelo --slf tmp2.slf ...

--slotreplace substituir-str
Use a string de substituição substituir-str em vez de {%} para o número do slot de trabalho.

- silencioso Silencioso. O trabalho a ser executado não será impresso. Este é o padrão. Pode ser
revertido com -v.

--tty Abra o terminal tty. Se GNU paralelo é usado para iniciar um programa interativo
então esta opção pode ser necessária. Vai começar apenas um trabalho de cada vez (ou seja, -j1),
não buffer a saída (ou seja, -u), e ele abrirá um tty para o trabalho. Quando o trabalho
estiver pronto, o próximo trabalho obterá o tty.

--marcação Linhas de tag com argumentos. Cada linha de saída será anexada com os argumentos
e TAB (\ t). Quando combinado com --em todos or --nonall as linhas serão prefixadas
com o sshlogin.

--marcação é ignorado ao usar -u.

--tagstring str
Linhas de tag com uma string. Cada linha de saída será anexada com str e TAB
(\ t). str pode conter cadeias de caracteres de substituição, como {}.

--tagstring é ignorado ao usar -u, --em todos e --nonall.

--tmpdir Conte-me
Diretório para arquivos temporários. GNU paralelo normalmente armazena a saída em
arquivos temporários em / tmp. Pela configuração --tmpdir você pode usar um diretório diferente para o
arquivos. Configuração --tmpdir é equivalente a definir $ TMPDIR.

--tmux Use tmux para saída. Começar um tmux sessão e executar cada trabalho em uma janela naquele
sessão. Nenhuma outra saída será produzida.

--tempo esgotado onda
Tempo limite para o comando. Se o comando for executado por mais de onda segundos vai chegar
morto com SIGTERM, seguido por SIGTERM 200 ms depois, seguido por SIGKILL 200 ms
mais tarde.

If onda é seguido por%, então o tempo limite será dinamicamente calculado como um
porcentagem do tempo médio de execução médio. Somente valores> 100% farão sentido.

--verbose
-t Imprima o trabalho a ser executado em stderr (erro padrão).

Veja também -v, -p.

--transferir
Transfira arquivos para computadores remotos. --transferir é usado com --sshlogin quando o
argumentos são arquivos e devem ser transferidos para os computadores remotos. Os arquivos
será transferido usando rsync e será colocado em relação ao diretório de trabalho padrão.
Se o caminho contém /./ o caminho restante será relativo ao diretório de trabalho.
Por exemplo

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

Isso irá transferir o arquivo foo / bar.txt para o computador servidor.exemplo.com ao
lima $ HOME / foo / bar.txt antes de correr wc foo / bar.txt on servidor.exemplo.com.

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

Isso irá transferir o arquivo foo / bar.txt para o computador servidor.exemplo.com ao
lima /tmp/foo/bar.txt antes de correr wc /tmp/foo/bar.txt on servidor.exemplo.com.

--transferir é freqüentemente usado com --Retorna e --limpar.

--transferir é ignorado quando usado com --sshlogin : ou quando não é usado com
--sshlogin.

--trc nome do arquivo
Transferência, devolução, limpeza. Mão abreviada para:

--transferir --Retorna nome do arquivo --limpar

--aparar
Corte o espaço em branco na entrada.

n Sem corte. A entrada não é modificada. Este é o padrão.

l Trim esquerdo. Remova o espaço em branco do início da entrada. Por exemplo, "a bc" -> "a bc".

r Corte direito. Remova o espaço em branco do final da entrada. Por exemplo, "a bc" -> "a bc".

lr
rl Ambos trim. Remova os espaços em branco do início e do final da entrada. Por exemplo, "a bc"
-> "a bc". Este é o padrão se --colsep é usado.

--desagrupar
-u Desagrupar a saída. A saída é impressa o mais rápido possível e ignora GNU paralelo
processamento interno. Isso pode fazer com que a saída de diferentes comandos seja misturada
portanto, só deve ser usado se você não se importar com a saída. Compare estes:

paralelo -j0 'dormir {};eco -n iniciar {}; dormir {};eco {}fim' ::: 1 2 3 4

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

Também desativa --marcação. GNU paralelo produz mais rápido com -u. Compare a velocidade de
estes:

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

Pode ser revertido com --grupo.

Veja também: --line-buffer --grupo

--extensão substituir substituir-str
--er substituir-str
Use a string de substituição substituir-str em vez de {.} para linha de entrada sem
extensão.

--use-cpus-ao invés-de-núcleos
Conte o número de CPUs físicas em vez de núcleos de CPU. Ao calcular quantos
trabalhos a serem executados simultaneamente em relação ao número de núcleos de CPU que você pode pedir ao GNU
paralelo em vez disso, observe o número de CPUs físicas. Isso fará sentido para
computadores que têm hyperthreading como dois trabalhos em execução em uma CPU com
o hyperthreading será executado mais lentamente do que duas tarefas em execução em duas CPUs físicas. Algum
CPUs multi-core podem rodar mais rápido se apenas um thread estiver rodando por CPU física.
A maioria dos usuários não precisará dessa opção.

-v Detalhado. Imprima o trabalho a ser executado em stdout (saída padrão). Pode ser revertido
com - silencioso. Veja também -t.

Use -v -v para imprimir o comando ssh de embrulho ao executar remotamente.

--versão
-V Imprima a versão GNU paralelo e sair.

--workdir meudir
--wd meudir
Arquivos transferidos usando --transferir e --Retorna será relativo a meudir on
computadores remotos, e o comando será executado no diretório meudir.

O especial meudir valor ... irá criar diretórios de trabalho em ~ / .parallel / tmp / on
os computadores remotos. Se --limpar é fornecido, esses diretórios serão removidos.

O especial meudir valor . usa o diretório de trabalho atual. Se o atual estiver funcionando
dir está abaixo de seu dir home, o valor . é tratado como o caminho relativo para o seu
home dir. Isso significa que se o seu diretório doméstico for diferente em computadores remotos (por exemplo
se o seu login for diferente) o caminho relativo ainda será relativo à sua casa
d.

Para ver a diferença, tente:

paralelo -S servidor pwd ::: ""

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

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

--esperar Aguarde a conclusão de todos os comandos.

Implica --semáforo.

Veja também homem este.

-X Vários argumentos com substituição de contexto. Insira tantos argumentos quanto o comando
comprimento de linha permite. Se vários trabalhos estiverem sendo executados em paralelo: distribua o
argumentos uniformemente entre os empregos. Usar -j1 para evitar isso.

If {} não for usado, os argumentos serão acrescentados à linha. Se {} é usado como
parte de uma palavra (como pic {}. jpg) então a palavra inteira será repetida. Se {} is
usado várias vezes cada {} será substituído pelos argumentos.

Normalmente -X fará a coisa certa, enquanto -m pode dar resultados inesperados se {}
é usado como parte de uma palavra.

Suporte para -X com --sshlogin é limitado e pode falhar.

Veja também -m.

--saída
-x Saia se o tamanho (veja o -s opção) é excedido.

--xapply Leia várias fontes de entrada como xaplicar. Se várias fontes de entrada forem fornecidas, uma
argumento será lido de cada uma das fontes de entrada. Os argumentos podem ser
acessado no comando como 1 {} .. {n}, assim 1 {} será uma linha da primeira entrada
fonte, e 6 {} irá referir-se à linha com o mesmo número de linha do 6º
fonte de entrada.

Compare estes dois:

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

Os argumentos serão reciclados se uma fonte de entrada tiver mais argumentos do que o
outras:

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

Veja também --cabeçalho.

EXEMPLO: Trabalho as xargs -n1. Argumento acrescentando

GNU paralelo pode funcionar semelhante a xargs -n1.

Para compactar todos os arquivos html usando gzip corre:

find . -nome '* .html' | paralelo gzip --melhor

Se os nomes dos arquivos podem conter uma nova linha, use -0. Substitua FOO BAR por FUBAR em todos os arquivos
neste dir e subdiretórios:

find . -Tipo f -imprimir0 | paralelo -q0 perl -i -educaçao Fisica 's / FOO BAR / FUBAR / g '

Note -q é necessário devido ao espaço em 'FOO BAR'.

EXEMPLO: Leitura argumentos da comando linha

GNU paralelo pode receber os argumentos da linha de comando em vez de stdin (entrada padrão).
Para compactar todos os arquivos html no diretório atual usando gzip corre:

paralelo gzip --melhor ::: * .html

Para converter * .wav em * .mp3 usando LAME executando um processo por execução do núcleo da CPU:

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

EXEMPLO: inserindo múltiplo argumentos

Ao mover muitos arquivos como este: mv * .log destino você às vezes obterá o erro:

Bash: / bin / mv: Argumento Lista também longo

porque há muitos arquivos. Em vez disso, você pode fazer:

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

Isso vai rodar mv para cada arquivo. Isso pode ser feito mais rápido se mv obtém tantos argumentos que
vai caber na linha:

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

EXEMPLO: Contexto substituir

Para remover os arquivos pict0000.jpg .. pict9999.jpg você poderia fazer:

seq -w 0 9999 | paralelo rm pict {}. jpg

Você também pode fazer:

seq -w 0 9999 | perl -educaçao Fisica 's /(.*)/ pict $ 1.jpg /' | paralelo -m rm

O primeiro vai correr rm 10000 vezes, enquanto a última só funcionará rm quantas vezes forem necessárias para
mantenha o comprimento da linha de comando curto o suficiente para evitar Argumento Lista também longo (normalmente
corre 1-2 vezes).

Você também pode executar:

seq -w 0 9999 | paralelo -X rm pict {}. jpg

Isso também só funcionará rm quantas vezes forem necessárias para manter o comprimento da linha de comando curto
suficiente.

EXEMPLO: Computar intensivo empregos e substituição

Se o ImageMagick estiver instalado, ele irá gerar uma miniatura de um arquivo jpg:

converter -geometria 120 foo.jpg polegar_foo.jpg

Isso será executado com jobs number-of-cpu-cores em paralelo para todos os arquivos jpg em um diretório:

ls * .jpg | paralelo converter -geometria 120 {} dedão_{}

Para fazer isso recursivamente, use find:

find . -nome '* .jpg' | paralelo converter -geometria 120 {} {} _thumb.jpg

Observe como o argumento deve começar com {} as {} irá incluir o caminho (por exemplo, executando converter
-geometria 120 ./foo/bar.jpg polegar_./foo/bar.jpg estaria claramente errado). O comando vai
gere arquivos como ./foo/bar.jpg_thumb.jpg.

Use {.} para evitar o .jpg extra no nome do arquivo. Este comando fará arquivos como
./foo/bar_thumb.jpg:

find . -nome '* .jpg' | paralelo converter -geometria 120 {} {.} _ thumb.jpg

EXEMPLO: Substituição e redirecionamento

Isso irá gerar uma versão descompactada de arquivos .gz ao lado do arquivo .gz:

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

Citar> é necessário para adiar o redirecionamento. Outra solução é citar o
comando inteiro:

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

Outros caracteres especiais de shell (como *; $> <| >> <<) também precisam ser colocados entre aspas,
pois podem ser interpretados de outra forma pelo shell e não fornecidos ao GNU paralelo.

EXEMPLO: Composto comandos

Um trabalho pode consistir em vários comandos. Isso imprimirá o número de arquivos em cada
diretório:

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

Para colocar a saída em um arquivo chamado .dir:

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

Mesmo pequenos scripts de shell podem ser executados pelo GNU paralelo:

find . | paralelo 'a = {}; nome = $ {a ## * /}; superior = $ (eco "$ name" | tr "[:diminuir:]"
"[:superior:]"); eco "$ name - $ upper "'

ls | paralelo 'mv {} "$ (eco {} | tr "[:superior:]" "[:diminuir:]")"'

Dada uma lista de URLs, liste todos os URLs cujo download falhou. Imprima o número da linha e o
URL.

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

Crie um diretório espelho com os mesmos nomes de arquivo, exceto que todos os arquivos e links simbólicos estão vazios
arquivos.

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

Encontre os arquivos em uma lista que não existe

gato lista_arquivo | paralelo 'E se [ ! -e {} ] ; então eco {}; fi '

EXEMPLO: chamada Bater funções

Se o comando composto for mais longo do que uma linha, torna-se difícil de ler. No Bash você pode
usar funções. Apenas lembre-se de exportar -f a função.

faça() {
echo Fazendo isso por $ 1
dormir 2
echo Feito com $ 1
}
exportar -f doit
paralelo doit ::: 1 2 3

doubleit () {
echo Fazendo isso por $ 1 $ 2
dormir 2
echo Feito com $ 1 $ 2
}
exportar -f duplicar
doubleit paralelo ::: 1 2 3 ::: ab

Para fazer isso em servidores remotos, você precisa transferir a função usando --env:

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

Se o seu ambiente (apelidos, variáveis ​​e funções) for pequeno, você pode copiar o completo
ambiente sem ter que exportar -f nada. Basta executar isto primeiro:

env_parallel () {
export parallel_bash_environment = '() {
'"$ (echo" shopt -s expand_aliases 2> / dev / null "; alias; typeset -p | grep -vFf <(somente leitura; echo GROUPS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_; typeset -f) "'
}'
# Execute como: env_parallel parallel_bash_environment "2> / dev / null;" ...
`qual paralelo`" $ @ "
não definir o parallel_bash_environment
}

E então chame como:

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

EXEMPLO: função testador

Para testar um programa com parâmetros diferentes:

testador () {
if (eval "$ @")> & / dev / null; então
perl -e 'printf "\ 033 [30; 102m [OK] \ 033 [0m @ARGV \ n"' "$ @"
outro
perl -e 'printf "\ 033 [30; 101m [FALHA] \ 033 [0m @ARGV \ n"' "$ @"
fi
}
export -f testador
testador paralelo meu_programa ::: arg1 arg2
saída do testador paralelo ::: 1 0 2 0

If meu_programa falha, uma FALHA vermelha será impressa seguida pelo comando com falha; de outra forma
um OK verde será impresso seguido pelo comando.

EXEMPLO: remoção lima extensão quando em processamento arquivos

Ao processar arquivos, remover a extensão do arquivo usando {.} muitas vezes é útil.

Crie um diretório para cada arquivo zip e descompacte-o nesse diretório:

paralelo 'mkdir {.}; cd {.}; descompactar ../ {} ' ::: *.fecho eclair

Recompactar todos os arquivos .gz no diretório atual usando bzip2 executando 1 trabalho por núcleo de CPU em
paralelo:

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

Converta todos os arquivos WAV para MP3 usando LAME:

find diretório de som -Tipo f -nome '* .wav' | paralelo paralítico {} -o {.}. mp3

Coloque todos os convertidos no mesmo diretório:

find diretório de som -Tipo f -nome '* .wav' | paralelo paralítico {} -o mydir / {/.} .mp3

EXEMPLO: remoção dois lima extensões quando em processamento arquivos

Se você tiver um diretório com arquivos tar.gz e quiser que eles sejam extraídos no diretório correspondente
(por exemplo, foo.tar.gz será extraído no dir foo), você pode fazer:

paralelo --mais 'mkdir {..}; alcatrão -C {..} -xf {} ' ::: * .tar.gz

EXEMPLO: Baixar 10 imagens for cada of da passado 30 dias

Suponhamos que um site armazene imagens como:

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

onde AAAAMMDD é a data e ## é o número 01-10. Isso fará o download de imagens para o
últimos 30 dias:

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

$ (data -d "hoje - {1} dias" +% Y% m% d) dará as datas em AAAAMMDD com {1} dias
subtraído.

EXEMPLO: Copiar arquivos as último modificada dados (ISO 8601) com adicionado acaso dígitos

find . | paralelo 'cp {} ../destino/{= $a = int (10000 * rand); $_ = `data -r "$ _"
+% FT% T "$ a" `; mastigar; =} '

EXEMPLO: Digital relógio com "piscando" :

O: em um relógio digital pisca. Para fazer com que todas as outras linhas tenham um ':' e o resto um '' a
A expressão perl é usada para ver a 3ª fonte de entrada. Se o valor modudo 2 for 1: use
":" caso contrário, use "":

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

EXEMPLO: Agregador conteúdo of arquivos

Este:

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

irá gerar os arquivos x1y01z1 .. x5y10z5. Se você deseja agregar o agrupamento de saída
em x e z você pode fazer isso:

eval paralelo 'cat {= s / y01 / y * / =}> {= s / y01 // =}' ::: * y01 *

Para todos os valores de x e z, ele executa comandos como:

cat x1y * z1> x1z1

Então você acaba com x1z1 .. x1z5 cada um contendo o conteúdo de todos os valores de y.

EXEMPLO: Largura primeiro paralelo web rastreador / espelho

O script abaixo rastreará e espelhará um URL em paralelo. Ele baixa as primeiras páginas que
são 1 clique para baixo, 2 cliques para baixo e 3; em vez da profundidade normal primeiro, onde o
o primeiro link de cada página é obtido primeiro.

Corra assim:

PARALLEL = -j100 ./rastreamento paralelo http://gatt.org.yeslab.org/

Remover o wget parte se você quiser apenas um rastreador da web.

Ele funciona buscando uma página de uma lista de URLs e procurando por links nessa página que
estão dentro do mesmo URL inicial e que ainda não foram vistos. Esses links são
adicionado a uma nova fila. Quando todas as páginas da lista são concluídas, a nova fila é movida para
a lista de URLs e o processo são reiniciados até que nenhum link invisível seja encontrado.

#!/ bin / bash

# Por exemplo http://gatt.org.yeslab.org/
URL = $ 1
# Fique dentro da direção de partida
BASEURL = $ (echo $ URL | perl -pe 's: #. * ::; s: (//.* /) [^ /] *: $ 1: ')
URLLIST = $ (mktemp urllist.XXXX)
URLLIST2 = $ (mktemp urllist.XXXX)
VISTO = $ (mktemp visto.XXXX)

# Spider para obter os URLs
echo $ URL> $ URLLIST
cp $ URLLIST $ SEEN

enquanto [-s $ URLLIST]; Faz
cat $ URLLIST |
lince paralelo -listonly -image_links -dump {} \; wget -qm -l1 -Q1 {} \; echo com aranha: {} \> \ & 2 |
perl -ne 's /#.*//; s / \ s + \ d +. \ s (\ S +) $ / $ 1 / e {$ visto {$ 1} ++ ou impressão} '|
grep -F $ BASEURL |
grep -v -x -F -f $ SEEN | tee -a $ SEEN> $ URLLIST2
mv $ URLLIST2 $ URLLIST
feito

rm -f $ URLLIST $ URLLIST2 $ SEEN

EXEMPLO: Extração arquivos da a alcatrão lima enquanto desempacotando

Se os arquivos a serem processados ​​estiverem em um arquivo tar, descompacte um arquivo e processe-o
imediatamente pode ser mais rápido do que descompactar todos os arquivos.

alcatrão f foo.tgz | perl -um 'imprimir $ l; $ l = $ _; END {imprimir $ l} ' | paralelo eco

O perl one-liner é necessário para evitar condições de corrida.

EXEMPLO: Reescrevendo a loop for e a loop de leitura

for-loops como este:

(para x na `lista de gatos`; faça
do_something $ x
feito) | process_output

e enquanto-read-loops como este:

lista de gatos | (enquanto leia x; faça
do_something $ x
feito) | process_output

pode ser escrito assim:

gato Lista | paralelo faça alguma coisa | saída_processo

Por exemplo: Encontre qual nome de host em uma lista tem o endereço IP 1.2.3 4:

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

Se o processamento exigir mais etapas, o loop for como este:

(para x na `lista de gatos`; faça
sem_extensão = $ {x%. *};
do_something $ x scale $ no_extension.jpg
do_step2 <$ x $ no_extension
feito) | process_output

e enquanto loops como este:

lista de gatos | (enquanto leia x; faça
sem_extensão = $ {x%. *};
do_something $ x scale $ no_extension.jpg
do_step2 <$ x $ no_extension
feito) | process_output

pode ser escrito assim:

gato Lista | paralelo "faça alguma coisa {} escada {.}. jpg ; do_step2 <{} {.} " | saída_processo

EXEMPLO: Reescrevendo aninhada loops for

Loops for aninhados como este:

(para x em `cat xlist`; faça
para y em `cat ylist`; Faz
fazer algo $ x $ y
feito
feito) | process_output

pode ser escrito assim:

paralelo faça alguma coisa 1 {} 2 {} :::: xlista lista | saída_processo

Loops for aninhados como este:

(para gênero em MF; faça
para tamanho em SML XL XXL; Faz
echo $ gender $ size
feito
feito) | organizar

pode ser escrito assim:

paralelo eco 1 {} 2 {} ::: M F ::: S M L XL XXL | tipo

EXEMPLO: Descoberta da menor diferença entre arquivos

diff é bom para encontrar diferenças em arquivos de texto. diff | wc -l dá uma indicação de
o tamanho da diferença. Para encontrar as diferenças entre todos os arquivos no diretório atual
Faz:

paralelo --marcação 'diff 1 {} 2 {} | wc -eu' ::: * ::: * | tipo -nk3

Desta forma, é possível verificar se alguns arquivos estão mais próximos de outros arquivos.

EXEMPLO: loops for com coluna nomes

Ao fazer múltiplos for-loops aninhados pode ser mais fácil manter o controle da variável de loop
if é nomeado em vez de apenas ter um número. Usar --cabeçalho : deixar o primeiro argumento
ser um alias nomeado para a string de substituição posicional:

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

Isso também funciona se o arquivo de entrada for um arquivo com colunas:

cat addressbook.tsv | paralelo --colsep '\ t' --header: echo {Nome} {endereço de e-mail}

EXEMPLO: Contar da diferenças entre todos os arquivos in a dir

utilização --resultados os resultados são salvos em / tmp / diffcount *.

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

Para ver a diferença entre o arquivo A e o arquivo B, examine o arquivo '/ tmp / diffcount / 1 / A / 2 / B'.

EXEMPLO: Acelerando up rápido empregos

Iniciar um trabalho na máquina local leva cerca de 10 ms. Isso pode ser uma grande sobrecarga se o
trabalho leva muito poucos ms para ser executado. Freqüentemente, você pode agrupar pequenos trabalhos usando -X qual vai
tornar a sobrecarga menos significativa. Compare a velocidade destes:

seq -w 0 9999 | imagem de toque paralela {}. jpg

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

Se o seu programa não pode aceitar vários argumentos, então você pode usar GNU paralelo Aparecer
GNU múltiplo paralelos:

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

If -j0 normalmente gera 252 empregos, então o descrito acima tentará gerar 2520 empregos. Em um normal
No sistema GNU / Linux, você pode gerar 32000 trabalhos usando esta técnica sem problemas. Criar
o aumento do limite de 32000 empregos / proc / sys / kernel / pid_max para 4194303.

EXEMPLO: utilização concha variáveis

Ao usar variáveis ​​de shell vocêprecisa de citá-las corretamente, pois podem ser divididas de outra forma
nos espaços.

Observe a diferença entre:

V = (os registros de "12 \" do meu irmão valem <\ $ \ $ \ $> "'!' Foo Bar)
paralelo echo ::: $ {V [@]} # Provavelmente não é o que você quer

e:

V = (os registros de "12 \" do meu irmão valem <\ $ \ $ \ $> "'!' Foo Bar)
eco paralelo ::: "$ {V [@]}"

Ao usar variáveis ​​no comando real que contém caracteres especiais (por exemplo, espaço)
você pode citá-los usando '"$ VAR"' ou usando "'s e -q:

V = "Aqui estão dois"
eco paralelo "'$ V'" ::: espaços
paralelo -q echo "$ V" ::: espaços

EXEMPLO: Grupo saída linhas

Ao executar trabalhos que geram dados, muitas vezes você não quer a saída de vários trabalhos para
correr juntos. GNU paralelo o padrão é agrupar a saída de cada trabalho, então a saída é
impresso quando o trabalho termina. Se você deseja que linhas completas sejam impressas enquanto o trabalho é
correndo você pode usar --line-buffer. Se você deseja que a saída seja impressa o mais rápido possível
você pode usar -u.

Compare a saída de:

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

para a saída de:

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

e:

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

EXEMPLO: etiqueta saída linhas

GNU paralelo agrupa as linhas de saída, mas pode ser difícil ver onde os diferentes trabalhos
início. --marcação precede o argumento para torná-lo mais visível:

paralelo --marcação traceroute ::: foss.org.my debian.org freenetproject.org

--marcação trabalha com --line-buffer mas não com -u:

paralelo --marcação --line-buffer traceroute ::: foss.org.my debian.org freenetproject.org

Verifique o tempo de atividade dos servidores em ~ / .parallel / sshloginfile:

paralelo --marcação -S .. --nonall uptime

EXEMPLO: Guarda ordem of saída mesmo as ordem of entrada

Normalmente, a saída de um trabalho será impressa assim que for concluída. Às vezes você quer
a ordem da saída deve permanecer a mesma que a ordem da entrada. Isso é frequente
importante, se a saída for usada como entrada para outro sistema. -k vai garantir o pedido
da saída estará na mesma ordem que a entrada, mesmo se os trabalhos posteriores terminarem antes dos trabalhos anteriores.

Anexe uma string a cada linha em um arquivo de texto:

gato arquivo de texto | paralelo -k eco {} anexar_string

Se você remover -k algumas das linhas podem sair na ordem errada.

Outro exemplo é traceroute:

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

dará traceroute de foss.org.my, debian.org e freenetproject.org, mas será
classificados de acordo com o trabalho concluído primeiro.

Para manter a ordem igual à execução de entrada:

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

Isso garantirá que o traceroute para foss.org.my seja impresso primeiro.

Um exemplo um pouco mais complexo é o download de um arquivo enorme em partes em paralelo: alguns
conexões fornecerão mais dados se você baixar arquivos em paralelo. Para baixar
arquivos em paralelo veja: "EXEMPLO: Baixe 10 imagens para cada um dos últimos 30 dias". Mas se
você está baixando um arquivo grande, pode baixar o arquivo em partes em paralelo.

Para baixar o byte 10000000-19999999, você pode usar enrolar:

enrolar -r 10000000-19999999 http://example.com/the/big/file > arquivo.parte

Para baixar um arquivo de 1 GB, precisamos de 100 pedaços de 10 MB baixados e combinados na
ordem.

seq 0 99 | paralelo -k enrolar -r \
{} 0000000 - {} 9999999 http://example.com/the/big/file > lima

EXEMPLO: Paralelo grep

grep -r greps recursivamente por meio de diretórios. Em CPUs GNU multicore paralelo pode, muitas vezes
acelerar isso.

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

Isso executará 1.5 trabalho por núcleo e fornecerá 1000 argumentos para grep.

EXEMPLO: Grepping n linhas for m regular expressões.

A solução mais simples para executar um grep em um arquivo grande para várias expressões regulares é:

grep -f regexps.txt arquivo grande

Ou se as expressões regulares forem strings fixas:

grep -F -f regexps.txt arquivo grande

Existem 2 fatores limitantes: CPU e E / S de disco. CPU é fácil de medir: Se o grep leva
> 90% da CPU (por exemplo, quando executando top), então a CPU é um fator limitante e paralelização
vai acelerar isso. Caso contrário, a E / S do disco é o fator limitante e, dependendo do
sistema de disco pode ser mais rápido ou mais lento para paralelizar. A única maneira de saber com certeza é
medir.

Se a CPU for o fator limitante, a paralelização deve ser feita nas expressões regulares:

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

Se uma linha corresponder a várias expressões regulares, a linha pode ser duplicada. O comando irá iniciar um
grep por CPU e lê bigfile uma vez por CPU, mas como isso é feito em paralelo, todas as leituras
exceto o primeiro será armazenado em cache na RAM. Dependendo do tamanho de regexp.txt, pode ser
mais rápido de usar --block 10m em vez de -L1000. Se regexp.txt for muito grande para caber na RAM,
remova --round-robin e ajuste -L1000. Isso fará com que o bigfile seja lido mais vezes.

Alguns sistemas de armazenamento têm melhor desempenho ao ler vários blocos em paralelo. Isso é verdade
para alguns sistemas RAID e para alguns sistemas de arquivos de rede. Para paralelizar a leitura de
arquivo grande:

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

Isso dividirá o bigfile em pedaços de 100 MB e executará o grep em cada um desses pedaços. Para
paralelize a leitura de bigfile e regexp.txt combine os dois usando --fifo:

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

Se uma linha corresponder a várias expressões regulares, a linha pode ser duplicada.

EXEMPLO: utilização remoto computadores

Para executar comandos em um computador remoto, o SSH precisa ser configurado e você deve ser capaz de fazer o login
sem inserir uma senha (Os comandos ssh-cópia-id e agente ssh pode ajudá-lo a fazer isso).

Se você precisa fazer login em um cluster inteiro, normalmente não quer aceitar a chave de host
para cada host. Você quer aceitá-los pela primeira vez e ser avisado se eles forem
mudado. Fazer isso:

# Adicione os servidores ao sshloginfile
(echo servera; echo serverb)> .parallel / my_cluster
# Certifique-se de que existe .ssh / config
toque em .ssh / config
cp .ssh / config .ssh / config.backup
# Desativar StrictHostKeyChecking temporariamente
(echo 'Host *'; echo StrictHostKeyChecking não) >> .ssh / config
paralelo --slf meu_cluster --nonall true
# Remova a desativação de StrictHostKeyChecking
mv .ssh / config.backup .ssh / config

Os servidores em .parallel / my_cluster agora estão adicionados em .ssh / known_hosts.

Para correr eco on servidor.exemplo.com:

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

Para executar comandos em mais de um computador remoto, execute:

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

Ou:

seq 10 | paralelo --sshlogin server.example.com \
--sshlogin server2.example.net echo

Se o nome de usuário de login for Foo on servidor2.exemplo.net usar:

seq 10 | paralelo --sshlogin server.example.com \
--sshlogin [email protegido] eco

Se a sua lista de hosts é servidor1-88.exemplo.net com login Foo:

seq 10 | paralelo -Sfoo @ server {1..88} .example.net echo

Para distribuir os comandos a uma lista de computadores, crie um arquivo meus computadores com todo o
computadores:

servidor.exemplo.com
[email protegido]
server3.example.com

Então corra:

seq 10 | paralelo --sshloginfile mycomputers echo

Para incluir o computador local, adicione o sshlogin especial ':' à lista:

servidor.exemplo.com
[email protegido]
server3.example.com
:

GNU paralelo tentará determinar o número de núcleos de CPU em cada um dos controles remotos
computadores e executar um trabalho por núcleo de CPU - mesmo se os computadores remotos não tiverem o
mesmo número de núcleos de CPU.

Se o número de núcleos de CPU nos computadores remotos não for identificado corretamente, o número
de núcleos de CPU podem ser adicionados na frente. Aqui, o computador possui 8 núcleos de CPU.

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

EXEMPLO: Transferir of arquivos

Para recomprimir arquivos compactados com bzip2 usando um computador remoto, execute:

localizar logs / -nome '* .gz' | \
paralelo --sshlogin server.example.com \
--transfer "zcat {} | bzip2 -9> {.}. bz2"

Isso irá listar os arquivos .gz no toras diretório e todos os diretórios abaixo. Então vai
transferir os arquivos para servidor.exemplo.com para o diretório correspondente em $ HOME / logs. Em
servidor.exemplo.com o arquivo será recompactado usando zcat e bzip2 resultando no
arquivo correspondente com .gz substituído por . Bz2.

Se você deseja que o arquivo bz2 resultante seja transferido de volta para o computador local, adicione
--Retorna {.}. bz2:

localizar logs / -nome '* .gz' | \
paralelo --sshlogin server.example.com \
--transfer --return {.}. bz2 "zcat {} | bzip2 -9> {.}. bz2"

Depois que a recompactação é feita, o . Bz2-o arquivo é transferido de volta para o computador local
e coloque ao lado do original .gz-Arquivo.

Se você deseja excluir os arquivos transferidos no computador remoto, adicione --limpar. Este
irá remover o arquivo transferido para o computador remoto e os arquivos transferidos
do computador remoto:

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

Se você deseja executar em vários computadores, adicione os computadores ao --sshlogin usando ',' ou
múltiplo --sshlogin:

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

Você pode adicionar o computador local usando --sshlogin :. Isso irá desativar a remoção e
transferindo apenas para o computador local:

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

Frequentemente --transferir, --Retorna e --limpar são usados ​​juntos. Eles podem ser encurtados para
--trc:

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

Com o arquivo meus computadores contendo a lista de computadores, torna-se:

localizar logs / -nome '* .gz' | paralelo --sshloginfile meuscomputadores \
--trc {.}. bz2 "zcat {} | bzip2 -9> {.}. bz2"

Se o arquivo ~ / .parallel / sshloginfile contém a lista de computadores a abreviação especial
-S .. pode ser usado:

localizar logs / -nome '* .gz' | paralelo -S .. \
--trc {.}. bz2 "zcat {} | bzip2 -9> {.}. bz2"

EXEMPLO: Distribuindo trabalho para local e remoto computadores

Converta * .mp3 para * .ogg executando um processo por núcleo de CPU no computador local e no servidor2:

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

EXEMPLO: Corrida da mesmo comando on remoto computadores

Para executar o comando uptime em computadores remotos, você pode fazer:

paralelo --marcação --nonall -S servidor1, servidor2 uptime

--nonall não lê argumentos. Se você tiver uma lista de trabalhos que deseja executar em cada computador,
pode fazer:

paralelo --marcação --em todos -S servidor1, servidor2 eco ::: 1 2 3

Eliminar --marcação se você não quiser que o sshlogin seja adicionado antes da saída.

Se você tiver muitos hosts, use '-j0' para acessar mais hosts em paralelo.

EXEMPLO: Paralelizando rsync

rsync é uma ótima ferramenta, mas às vezes não preenche a largura de banda disponível. Isto é
frequentemente um problema ao copiar vários arquivos grandes em conexões de alta velocidade.

O seguinte iniciará um rsync por grande arquivo em src-dir para destino-dir no servidor
servidor de fooserver:

cd src-dir; find . -Tipo f -Tamanho +100000 | paralelo -v ssh servidor de fooserver mkdir -p
/ dest-dir / {//} \; rsync -s -Havesh {} fooserver: / dest-dir / {}

Os diretórios criados podem acabar com permissões erradas e arquivos menores não estão sendo
transferido. Para consertar aqueles correm rsync uma última vez:

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

Se você não conseguir enviar dados, mas precisar extraí-los, os arquivos são chamados de digits.png
(por exemplo, 000000.png), você pode ser capaz de fazer:

seq -w 0 99 | paralelo rsync -Havesh fooserver: src-path / * {}. png destdir /

EXEMPLO: Use múltiplo inputs in um comando

Copie arquivos como foo.es.ext para foo.ext:

ls * .es. * | perl -educaçao Fisica 'imprimir; s / \. es // ' | paralelo -N2 cp 1 {} 2 {}

O comando perl cospe 2 linhas para cada entrada. GNU paralelo leva 2 entradas (usando -N2)
e substitui {1} e {2} pelas entradas.

Contagem em binário:

paralelo -k eco ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1

Imprima o número nos lados opostos de um dado de seis lados:

paralelo --xapply -a <(seq 6) -a <(seq 6 -1 1) eco

paralelo --xapply eco :::: <(seq 6) <(seq 6 -1 1)

Converta arquivos de todos os subdiretórios em arquivos PNG com números consecutivos (útil para fazer
inserir PNGs para ffmpeg):

paralelo --xapply -a <(encontrar . -Tipo f | organizar) -a <(seq $ (encontrar . -Tipo f | wc -eu)) converter
1 {} {2} .png

Versão alternativa:

find . -Tipo f | tipo | paralelo converter {} {#}. png

EXEMPLO: Use a mesa as entrada

Conteúdo de table_file.tsv:

foo bar
baz quux

Para correr:

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

você pode correr:

paralelo -a arquivo_tabela.tsv --colsep '\ t' cmd -o 2 {} -i 1 {}

Nota: O padrão para GNU paralelo é remover os espaços ao redor das colunas. Para manter o
espaços:

paralelo -a arquivo_tabela.tsv --aparar n --colsep '\ t' cmd -o 2 {} -i 1 {}

EXEMPLO: Execute da mesmo comando 10 vezes

Se você quiser executar o mesmo comando com os mesmos argumentos 10 vezes em paralelo, você pode
Faz:

seq 10 | paralelo -n0 meu_comando meus_args

EXEMPLO: Trabalho as gato | eh. Recursos barato empregos e avaliação

GNU paralelo pode funcionar semelhante a gato | sh.

Um trabalho de baixo custo de recursos é um trabalho que consome muito pouca CPU, E / S de disco e E / S de rede.
Ping é um exemplo de trabalho de baixo custo de recursos. wget também - se as páginas da web forem pequenas.

O conteúdo do arquivo jobs_to_run:

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

Para executar 100 processos simultaneamente, faça:

paralelo -j 100 < trabalhos_para_executar

Como não há um comando os trabalhos serão avaliados pelo shell.

EXEMPLO: Tratamento a big lima utilização mais núcleos

Para processar um arquivo grande ou alguma saída que você pode usar --tubo para dividir os dados em blocos
e canalizar os blocos para o programa de processamento.

Se o programa é gzip -9 você pode fazer:

gato arquivo grande | paralelo --tubo --receber '' -k gzip -9 >arquivogrande.gz

Isso vai se dividir arquivo grande em blocos de 1 MB e passe para gzip -9 em paralelo. Um gzip
será executado por núcleo de CPU. A saída de gzip -9 será mantido em ordem e salvo em
arquivogrande.gz

gzip funciona bem se a saída for anexada, mas algum processamento não funciona assim -
por exemplo, classificação. Para este GNU paralelo pode colocar a saída de cada comando em um arquivo.
Isso classificará um arquivo grande em paralelo:

gato arquivo grande | paralelo --tubo --arquivos tipo | paralelo -Xj1 tipo -m {} ';' rm {}
>arquivogrande.sort

Aqui você encontra arquivo grande é dividido em blocos de cerca de 1 MB, cada bloco terminando em '\ n' (que é o
padrão para --receber) Cada bloco é passado para tipo e a saída de tipo é salvo em
arquivos. Esses arquivos são passados ​​para o segundo paralelo que corre tipo -m nos arquivos antes
ele remove os arquivos. A saída é salva em arquivogrande.sort.

GNU paralelo's --tubo atinge no máximo cerca de 100 MB / s porque cada byte deve ser copiado
através do GNU paralelo. Mas se arquivo grande é um arquivo GNU real (procurável) paralelo pode contornar
a cópia e envio das peças diretamente para o programa:

paralelo --pipepart --bloquear 100m -a arquivo grande --arquivos tipo | paralelo -Xj1 tipo -m {} ';' rm
{} >arquivogrande.sort

EXEMPLO: Corrida mais do que 250 empregos solução alternativa

Se você precisar executar uma grande quantidade de trabalhos em paralelo, provavelmente atingirá o
limite de manuseio de arquivos, que geralmente é em torno de 250 empregos. Se você for superusuário, poderá aumentar o
limite em /etc/security/limits.conf mas você também pode usar esta solução alternativa. O filehandle
o limite é por processo. Isso significa que se você apenas gerar mais GNU paraleloentão cada um
eles podem executar 250 trabalhos. Isso gerará até 2500 empregos:

gato minha entrada | paralelo --tubo -N 50 --round-robin -j50 paralelo -j50 seu_prg

Isso gerará até 62500 trabalhos (use com cuidado - você precisa de 64 GB de RAM para fazer isso, e
você pode precisar aumentar / proc / sys / kernel / pid_max):

gato minha entrada | paralelo --tubo -N 250 --round-robin -j250 paralelo -j250 seu_prg

EXEMPLO: Trabalho as mutex e contando semáforo

O comando este é um apelido para paralelo --semáforo.

Um semáforo de contagem permitirá que um determinado número de trabalhos seja iniciado em segundo plano.
Quando o número de trabalhos está sendo executado em segundo plano, GNU este vai esperar por um destes
para concluir antes de iniciar outro comando. este --esperar vai esperar por todos os trabalhos para
completa.

Execute 10 tarefas simultaneamente em segundo plano:

para i em * .log; Faz
echo $ i
sem -j10 gzip $ i ";" eco feito
feito
sem --esperar

Um mutex é um semáforo de contagem que permite a execução de apenas um trabalho. Isso irá editar o arquivo
meu arquivo e precede o arquivo com linhas com os números de 1 a 3.

seq 3 | paralelo sem sed -i -e 'i {}' meuarquivo

As meu arquivo pode ser muito grande, é importante que apenas um processo edite o arquivo ao mesmo tempo
tempo.

Nomeie o semáforo para ter vários semáforos diferentes ativos ao mesmo tempo:

seq 3 | paralelo sem --id mymutex sed -i -e 'i {}' meuarquivo

EXEMPLO: Início editor com nomes de arquivos da stdin (padrão entrada)

Você pode usar GNU paralelo para iniciar programas interativos como emacs ou vi:

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

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

Se houver mais arquivos do que cabem em uma única linha de comando, o editor será iniciado
novamente com os arquivos restantes.

EXEMPLO: Corrida sudo

sudo requer uma senha para executar um comando como root. Ele armazena em cache o acesso, então você só precisa
para inserir a senha novamente se você não tiver usado sudo por um tempo.

O comando:

paralelo sudo echo ::: Esta é uma má ideia

não é bom, pois seria solicitada a senha sudo para cada um dos trabalhos. Você pode
ou faça:

sudo echo isso
paralelo sudo echo ::: é uma boa ideia

ou:

sudo parallel echo ::: Esta é uma boa ideia

Dessa forma, você só precisa inserir a senha do sudo uma vez.

EXEMPLO: GNU Paralelo as fila sistema / lote Gerente

GNU paralelo pode funcionar como um sistema de fila de trabalhos simples ou gerenciador de lote. A ideia é colocar
os trabalhos em um arquivo e têm GNU paralelo leia a partir disso continuamente. Como GNU paralelo
vai parar no final do arquivo que usamos cauda para continuar lendo:

verdadeiro >fila de trabalho; cauda -n + 0 -f fila de trabalho | paralelo

Para enviar seus trabalhos para a fila:

eco meu_comando meu_arg >> fila de trabalho

Você pode, é claro, usar -S para distribuir os trabalhos para computadores remotos:

verdadeiro >fila de trabalho; cauda -f fila de trabalho | paralelo -S ..

Há um pequeno problema ao usar GNU paralelo como sistema de fila / gerenciador de lote: Você tem
para enviar o número de jobs do JobSlot antes de começarem e, depois disso, você pode enviar um
por vez, e o trabalho começará imediatamente se houver slots livres disponíveis. Saída do
trabalhos em execução ou concluídos são retidos e só serão impressos quando JobSlot mais trabalhos
foi iniciado (a menos que você use --ungroup ou -u, caso em que a saída dos trabalhos
são impressos imediatamente). Por exemplo, se você tiver 10 slots de trabalho, a saída do primeiro
o trabalho concluído só será impresso quando o trabalho 11 for iniciado, e a saída do segundo
o trabalho concluído só será impresso quando o trabalho 12 for iniciado.

Para utilizar o --eof fazer GNU paralelo saída, cauda também precisa ser forçado a sair:

tail -n + 0 -f command-list.txt |
(paralelo --eof = SAÍDA {}; o eco paralelo agora está concluído;
(seq 1000 >> command-list.txt &);
echo Concluído anexando dados fictícios, forçando cauda a sair)

EXEMPLO: GNU Paralelo as dir processador

Se você tiver um diretório no qual os usuários soltam arquivos que precisam ser processados, você pode fazer isso em
GNU / Linux (se você sabe o que inotifyesperar é chamado em outras plataformas, registre um relatório de bug):

inotifyesperar -q -m -r -e MUDOU-SE PARA -e CLOSE_WRITE --formato % w% f meu_dir | paralelo -u eco

Isso irá executar o comando eco em cada arquivo colocado em meu_dir ou subdiretórios de meu_dir.

Você pode, é claro, usar -S para distribuir os trabalhos para computadores remotos:

inotifyesperar -q -m -r -e MUDOU-SE PARA -e CLOSE_WRITE --formato % w% f meu_dir | paralelo -S .. -u
eco

Se os arquivos a serem processados ​​estiverem em um arquivo tar, descompacte um arquivo e processe-o
imediatamente pode ser mais rápido do que descompactar todos os arquivos. Configure o processador dir como
acima e descompacte no diretório.

Usar GNU Parallel como processador dir tem as mesmas limitações que usar GNU Parallel como
sistema de filas / gerenciador de lote.

CITAÇÃO

GNU paralelo é muito liberal ao citar. Você só precisa citar caracteres que tenham
significado especial em shell:

() $ `'" <>; | \

e dependendo do contexto, eles também precisam ser citados:

~ & #! ? espaço * {

Portanto, a maioria das pessoas nunca precisará de mais citações do que colocar '\' na frente do
caracteres especiais.

Freqüentemente, você pode simplesmente colocar \ 'em torno de cada':

perl -ne '/ ^ \ S + \ s + \ S + $ / e imprimir $ ARGV, arquivo "\ n"'

pode ser citado:

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

No entanto, quando você deseja usar uma variável de shell, você precisa citar o sinal $. Aqui está um
exemplo usando $ PARALLEL_SEQ. Esta variável é definida pelo GNU paralelo em si, então o
a avaliação do $ deve ser feita pelo sub shell iniciado pelo GNU paralelo:

seq 10 | paralelo -N2 eco seq: \ $ PARALLEL_SEQ arg1: {1} arg2: {2}

Se a variável é definida antes do GNU paralelo começa você pode fazer isso:

VAR = this_is_set_before_starting

eco teste | paralelo eco {} $ VAR

Impressões: teste this_is_set_before_starting

É um pouco mais complicado se a variável contiver mais de um espaço em uma linha:

VAR = "dois espaços entre cada palavra"

eco teste | paralelo eco {} \ '"$ VAR" \'

Impressões: teste dois espaços entre cada palavra

Se a variável não deve ser avaliada pelo shell iniciando GNU paralelo mas seja
avaliado pelo sub shell iniciado por GNU paralelo, então você precisa citá-lo:

eco teste | paralelo VAR = this_is_set_after_starting \; eco {} \ $ VAR

Impressões: teste this_is_set_after_starting

É um pouco mais complicado se a variável contiver espaço:

eco teste | paralelo VAR = '"dois espaços entre cada palavra"' eco {} \ '"$ VAR" \'

Impressões: teste dois espaços entre cada palavra

$$ é a variável do shell que contém o id do processo do shell. Isso irá imprimir o
id do processo do shell rodando GNU paralelo:

seq 10 | paralelo eco $$

E isto irá imprimir os ids de processo dos sub shells iniciados pelo GNU paralelo.

seq 10 | paralelo eco \ $ \ $

Se os caracteres especiais não devem ser avaliados pelo sub shell, você precisa
protegê-lo contra avaliação de ambos o shell iniciando GNU paralelo e a subestrutura:

eco teste | paralelo eco {} \\\ $ VAR

Impressões: teste $ VAR

GNU paralelo pode proteger contra avaliação pelo subconcha usando -q:

eco teste | paralelo -q eco {} \ $ VAR

Impressões: teste $ VAR

Isso é particularmente útil se você fizer muitas citações. Se você deseja executar um script perl
como isso:

perl -um '/ ^ \ S + \ s + \ S + $ / e impressão $ ARGV, "\ n" ' lima

Precisa ser citado assim:

ls | paralelo perl -um '/ ^ \\ S + \\ s + \\ S + \ $ / \ e\ imprimir\ \ $ ARGV, \ "\\ n \" ' ls | paralelo perl
-um \ '' / ^ \ S + \ s + \ S + $ / e impressão $ ARGV, "\ n" '\'

Observe como os espaços, \ 's, "' s e $ 's precisam ser citados. GNU paralelo pode fazer as citações por
usando a opção -q:

ls | paralelo -q perl -um '/ ^ \ S + \ s + \ S + $ / e impressão $ ARGV, "\ n" '

No entanto, isso significa que você não pode fazer o sub shell interpretar caracteres especiais. Por
exemplo por causa de -q isso NÃO FUNCIONARÁ:

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

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

porque> e | precisa ser interpretado pelo sub shell.

Se você receber erros como:

sh: -c: linha 0: erro de sintaxe próximo ao token inesperado
sh: Erro de sintaxe: string entre aspas não terminada
sh: -c: linha 0: EOF inesperado enquanto procura a correspondência `''
sh: -c: linha 1: erro de sintaxe: final de arquivo inesperado

então você pode tentar usar -q.

Se você estiver usando bater substituição de processo como <(gato foo) então você pode tentar -q e
antecedendo comando com bater -c:

ls | paralelo -q bater -c 'banheiro -c <(eco {}) '

Ou para substituir a saída:

ls | paralelo -q bater -c 'alcatrão c {} | tee >(gzip >{} .tar.gz) | bzip2 >{} .tar.bz2 '

Conclusão: Para evitar lidar com os problemas de cotação, pode ser mais fácil apenas escrever um
pequeno script ou uma função (lembre-se de exportar -f a função) e ter GNU paralelo chamada
aquele.

LISTA CORRENDO EMPREGO

Se você quiser uma lista dos trabalhos em execução, pode executar:

Mate todos -USR1 paralelo

GNU paralelo irá então imprimir os trabalhos atualmente em execução em stderr (erro padrão).

COMPLETO CORRENDO EMPREGO MAS DO NÃO Abra NOVAS EMPREGO

Se você se arrepende de ter começado muitos trabalhos, você pode simplesmente quebrar o GNU paralelo, mas se você quiser
certifique-se de não ter tarefas concluídas pela metade, você deve enviar o sinal PRAZO META para GNU
paralelo:

Mate todos -PRAZO paralelo

Isso vai dizer ao GNU paralelo para não iniciar nenhum novo trabalho, mas espere até o momento
os trabalhos em execução são concluídos antes de sair.

MEIO AMBIENTE VARIÁVEIS

$ PARALLEL_PID
A variável de ambiente $ PARALLEL_PID é definida pelo GNU paralelo e é visível para
os trabalhos começaram a partir do GNU paralelo. Isso torna possível para os trabalhos
comunicar-se diretamente com GNU paralelo. Lembre-se de citar $, para que seja
avaliado pelo shell correto.

Exemplo: Se cada um dos trabalhos testa uma solução e um dos trabalhos encontra a solução
o trabalho pode dizer ao GNU paralelo não começar mais trabalhos por: matar -PRAZO
$ PARALLEL_PID. Isso só funciona no computador local.

$ PARALLEL_SHELL (teste alfa)
Use este shell para os comandos executados pelo GNU Parallel:

· $ PARALLEL_SHELL. Se indefinido, use:

· O shell que iniciou o GNU Parallel. Se isso não puder ser determinado:

· $ SHELL. Se indefinido, use:

· / Bin / sh

$ PARALLEL_SEQ
$ PARALLEL_SEQ será definido como o número de sequência do trabalho em execução. Lembrar de
cite o $, para que seja avaliado pelo shell correto.

Exemplo:

seq 10 | paralelo -N2 eco seq: '$' PARALLEL_SEQ arg1: {1} arg2: {2}

$ TMPDIR Diretório para arquivos temporários. Ver: --tmpdir.

$ PARALLEL
A variável de ambiente $ PARALLEL será usada como opções padrão para GNU
paralelo. Se a variável contém caracteres especiais de shell (por exemplo, $, * ou espaço)
então, estes precisam ser escapados com \.

Exemplo:

gato Lista | paralelo -j1 -k -v ls

pode ser escrito como:

gato Lista | PARALLEL = "- kvj1" paralelo ls

gato Lista | paralelo -j1 -k -v -S "myssh usuário @ servidor " ls

pode ser escrito como:

gato Lista | PARALLEL = '- kvj1 -S myssh \ usuário @ servidor ' paralelo eco

Observe que o \ no meio é necessário porque 'myssh' e 'user @ server' devem ser
um argumento.

PADRÃO PROFILE (CONFIGURAÇÃO ARQUIVO)

O arquivo de configuração global / etc / parallel / config, seguido pelo arquivo de configuração do usuário
~ / .parallel / config (anteriormente conhecido como .parallelrc) serão lidos alternadamente, se existirem.
As linhas que começam com '#' serão ignoradas. O formato pode seguir o do ambiente
variável $ PARALLEL, mas geralmente é mais fácil simplesmente colocar cada opção em sua própria linha.

As opções na linha de comando têm precedência, seguidas pela variável de ambiente
$ PARALLEL, arquivo de configuração do usuário ~ / .parallel / confige, finalmente, o global
arquivo de configuração / etc / parallel / config.

Observe que nenhum arquivo que é lido para opções, nem a variável de ambiente $ PARALLEL, pode
contêm opções retiradas, como --tollef.

PROFILE ARQUIVOS

If --perfil conjunto, GNU paralelo irá ler o perfil desse arquivo em vez do global
ou arquivos de configuração do usuário. Você pode ter vários --perfis.

Exemplo: Perfil para executar um comando em cada sshlogin em ~ / .ssh / sshlogins e prefixar
a saída com o sshlogin:

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

Exemplo: Perfil para executar cada comando com -j-1 e agradável

echo -j-1 bom> ~ / .parallel / nice_profile
paralelo -J nice_profile bzip2 -9 ::: *

Exemplo: Perfil para executar um script perl antes de cada comando:

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

Observe como $ e "precisam ser cotados usando \.

Exemplo: perfil para executar tarefas distribuídas com agradável nos computadores remotos:

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

SAIR STATUS

If --parada no erro 0 ou não especificado:

0 Todos os trabalhos foram executados sem erros.

1-253 Alguns dos trabalhos falharam. O status de saída fornece o número de trabalhos com falha

254 Mais de 253 trabalhos falharam.

255 Outro erro.

If --parada no erro 1 ou 2: Sair do status do trabalho com falha.

DIFERENÇAS ENTRE GNU Paralelo E ALTERNATIVAS

Existem muitos programas com algumas das funcionalidades do GNU paralelo. GNU paralelo
se esforça para incluir o melhor da funcionalidade sem sacrificar a facilidade de uso.

RESUMO TABELA
Os seguintes recursos estão em algumas das ferramentas comparáveis:

entradas
I1. Os argumentos podem ser lidos de stdin
I2. Os argumentos podem ser lidos de um arquivo
I3. Os argumentos podem ser lidos de vários arquivos
I4. Os argumentos podem ser lidos na linha de comando
I5. Os argumentos podem ser lidos de uma mesa
I6. Os argumentos podem ser lidos do mesmo arquivo usando #! (shebang)
I7. Entrada orientada por linha como padrão (citação de caracteres especiais não é necessária)

Manipulação de entrada
M1. Comando composto
M2. Vários argumentos podem preencher uma linha de execução
M3. Os argumentos podem ser colocados em qualquer lugar na linha de execução
M4. Vários argumentos podem ser colocados em qualquer lugar na linha de execução
M5. Os argumentos podem ser substituídos pelo contexto
M6. A entrada pode ser tratada como linha de execução completa

Saídas
O1. Agrupando a produção de forma que a produção de diferentes trabalhos não se misture
O2. Enviar stderr (erro padrão) para stderr (erro padrão)
O3. Enviar stdout (saída padrão) para stdout (saída padrão)
O4. A ordem de saída pode ser igual à ordem de entrada
O5. Stdout contém apenas stdout (saída padrão) do comando
O6. Stderr contém apenas stderr (erro padrão) do comando

Execução
E1. Execução de trabalhos em paralelo
E2. Lista de trabalhos em execução
E3. Conclua os trabalhos em execução, mas não inicie novos trabalhos
E4. O número de trabalhos em execução pode depender do número de cpus
E5. Conclua os trabalhos em execução, mas não inicie novos trabalhos após a primeira falha
E6. O número de trabalhos em execução pode ser ajustado durante a execução

Execução remota
R1. Os trabalhos podem ser executados em computadores remotos
R2. Os arquivos de base podem ser transferidos
R3. Arquivos de argumento podem ser transferidos
R4. Os arquivos de resultado podem ser transferidos
R5. Limpeza de arquivos transferidos
R6. Não são necessários arquivos de configuração
R7. Não execute mais do que MaxStartups do SSHD pode suportar
R8. Comando SSH configurável
R9. Tente novamente se a conexão for interrompida ocasionalmente

Semáforo
S1. Possibilidade de trabalhar como mutex
S2. Possibilidade de funcionar como semáforo de contagem

lenda
- = não
x = não aplicável
ID = sim

Como todas as novas versões dos programas não são testadas, a tabela pode estar desatualizada. Por favor arquive
um relatório de bug se você encontrar erros (veja REPORTING BUGS).

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

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

fazer -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 - Por favor, envie um relatório de bug se você souber quais recursos o xjobs suporta (Veja
RELATÓRIO DE ERROS).

prll: TODO - Envie um relatório de bug se você souber quais recursos prll suporta (consulte
RELATÓRIO DE ERROS).

dxargs: TODO - Por favor, envie um relatório de bug se você souber quais recursos o dxargs suporta (Veja
RELATÓRIO DE ERROS).

mdm / middelman: TODO - Envie um relatório de bug se você souber quais recursos mdm / middelman
suporta (Veja REPORTING BUGS).

xapply: TODO - Por favor, envie um relatório de bug se você souber quais recursos o xapply suporta (Veja
RELATÓRIO DE ERROS).

paexec: TODO - Por favor, envie um relatório de bug se você souber quais recursos o paexec suporta (Veja
RELATÓRIO DE ERROS).

ladon: TODO - Por favor, envie um relatório de bug se você souber quais recursos o ladon suporta (Veja
RELATÓRIO DE ERROS).

ClusterSSH: TODO - Envie um relatório de bug se você souber quais recursos o ClusterSSH suporta
(Veja REPORTING BUGS).

DIFERENÇAS ENTRE xargs E GNU Paralelo
xargs oferece algumas das mesmas possibilidades do GNU paralelo.

xargs lida mal com caracteres especiais (como espaço, 'e "). Para ver o problema, tente
esta:

toque em arquivo_importante
toque em 'not important_file'
ls não * | xargs rm
mkdir -p "Registros de 12 \" do meu irmão "
é | xargs rmdir

Você pode especificar -0 or -d "\ n", mas muitos geradores de entrada não são otimizados para usar NUL
como separador, mas são otimizados para nova linha como separador. Por exemplo cabeça, cauda, awk, ls, eco,
sede, alcatrão -v, perl (-0 e \ 0 em vez de \ n), localizar (requer o uso -0), find (requer
utilização -imprimir0), grep (requer que o usuário use -z or -Z), tipo (requer o uso -z).

Então GNU paraleloA separação de nova linha pode ser emulada com:

gato | xargs -d "\ n" -n1 comando

xargs pode executar um determinado número de trabalhos em paralelo, mas não tem suporte para execução de número-
trabalhos of-cpu-cores em paralelo.

xargs não tem suporte para agrupar a saída, portanto, a saída pode ser executada em conjunto, por exemplo, o
a primeira metade de uma linha é de um processo e a última metade da linha é de outro
processo. O exemplo Paralelo grep não pode ser feito de forma confiável com xargs devido a esta. Para
veja isso em ação, tente:

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

xargs não tem suporte para manter a ordem da saída, portanto, se estiver executando tarefas em
paralelo usando xargs a saída do segundo trabalho não pode ser adiada até o primeiro trabalho
é feito.

xargs não tem suporte para a execução de trabalhos em computadores remotos.

xargs não tem suporte para substituição de contexto, portanto, você terá que criar os argumentos.

Se você usar uma string de substituição em xargs (-I) você não pode forçar xargs usar mais de um
argumento.

Citando em xargs funciona como -q em GNU paralelo. Isso significa comandos compostos e
o redirecionamento requer o uso bater -c.

ls | paralelo "banheiro {} > {}.banheiro"

torna-se (supondo que você tenha 8 núcleos)

ls | xargs -d "\ n" -P8 -I {} bater -c "banheiro {} > {}.banheiro"

e

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

torna-se (supondo que você tenha 8 núcleos)

ls | xargs -d "\ n" -P8 -I {} bater -c "eco {}; ls {} | wc "

DIFERENÇAS ENTRE find -Exec E GNU Paralelo
find -Exec oferecem algumas das mesmas possibilidades do GNU paralelo.

find -Exec só funciona em arquivos. Portanto, o processamento de outras entradas (como hosts ou URLs) irá
requerem a criação dessas entradas como arquivos. find -Exec não tem suporte para executar comandos em
paralelo.

DIFERENÇAS ENTRE fazer -j E GNU Paralelo
fazer -j pode executar trabalhos em paralelo, mas requer um Makefile criado para fazer isso. Isso resulta
em citações extras para fazer com que o nome do arquivo contendo nova linha funcione corretamente.

fazer -j não tem suporte para agrupar a saída, portanto, a saída pode ser executada junto, por exemplo
a primeira metade de uma linha é de um processo e a última metade da linha é de outro
processo. O exemplo Paralelo grep não pode ser feito de forma confiável com fazer -j devido a esta.

(Versões muito antigas do GNU paralelo foram implementados coincidentemente usando fazer -j).

DIFERENÇAS ENTRE ppss E GNU Paralelo
ppss também é uma ferramenta para executar jobs em paralelo.

A saída de ppss são informações de status e, portanto, não são úteis para usar como entrada para
outro comando. A saída dos trabalhos é colocada em arquivos.

O argumento substituir string ($ ITEM) não pode ser alterado. Os argumentos devem ser citados - portanto
argumentos contendo caracteres especiais (espaço '"&! *) podem causar problemas. Mais de um
argumento não é suportado. Nomes de arquivos contendo novas linhas não são processados ​​corretamente.
Ao ler a entrada de um arquivo, o nulo não pode ser usado como um terminador. ppss precisa ler o
arquivo de entrada inteiro antes de iniciar qualquer trabalho.

As informações de saída e status são armazenadas em ppss_dir e, portanto, requerem limpeza quando
concluído. Se o dir não for removido antes de executar ppss novamente, pode não causar nada para
acontecer como ppss pensa que a tarefa já está concluída. GNU paralelo normalmente não vai precisar
limpar se estiver executando localmente e só precisará de limpeza se for interrompido de forma anormal e
executando remoto (--limpar pode não ser concluído se interrompido de forma anormal). O exemplo Paralelo
grep exigiria pós-processamento extra se escrito usando ppss.

Para sistemas remotos, o PPSS requer 3 etapas: configurar, implantar e iniciar. GNU paralelo só
requer uma etapa.

EXEMPLOS A PARTIR DE ppss MANUAL

Aqui estão os exemplos de ppssa página de manual com o equivalente usando GNU paralelo:

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

1 localizar / caminho / para / arquivos -tipo f | gzip paralelo

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

2 localizar / caminho / para / arquivos -tipo f | cp paralelo {} / destino / dir

3 ./ppss.sh autônomo -f list-of-urls.txt -c 'wget -q'

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

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

4 paralelo -a 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; ./ppss
implantar -C config.cfg; ./ppss start -C config

5 # paralelo não usa configurações. Se você quiser um nome de usuário diferente, coloque-o em nodes.txt:
usuário @ nome do host

5 localizar fonte / dir -tipo f | paralelo --sshloginfile nodes.txt --trc {.}. mp3 lame -a {} -o
{.}. mp3 - padrão predefinido --quiet

6 ./ppss parar -C config.cfg

6 killall -TERM paralelo

7 ./ppss pausa -C config.cfg

7 Pressione: CTRL-Z ou killall -SIGTSTP paralelo

8 ./ppss continue -C config.cfg

8 Digite: fg ou killall -SIGCONT parallel

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

9 killall -SIGUSR2 paralelo

DIFERENÇAS ENTRE pexe E GNU Paralelo
pexe também é uma ferramenta para executar jobs em paralelo.

EXEMPLOS A PARTIR DE pexe MANUAL

Aqui estão os exemplos de pexepágina de informações de com o equivalente usando GNU paralelo:

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

1 seq 10 | paralelo -j4 'echo "escala = 10000; sqrt ({})" | bc> sqrt - {}. dat '

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

2 ls myfiles * .ext | classificação paralela {} "> {}. classificação"

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

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

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

4 ls * .png | paralelo 'converter {} {.}. jpeg; echo {}: pronto '

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

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

6 para p em * .png; faça echo $ {p% .png}; feito | \
pexec -f - -i% s.png -o% s.jpg -c 'pngtopnm | pnmtojpeg '

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

7 LIST = $ (para p em * .png; faça echo $ {p% .png}; concluído)
pexec -r $ LIST -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 | pnmscale 0.5 | pnmtojpeg | \
pexec -j -m blockwrite -s th_ $ IMG '

8 Combinando GNU paralelo e GNU este.

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

8 Se a leitura e a gravação forem feitas no mesmo disco, isso pode ser mais rápido, pois apenas um processo
estará lendo ou escrevendo:

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

DIFERENÇAS ENTRE xjobs E GNU Paralelo
xjobs também é uma ferramenta para executar trabalhos em paralelo. Ele só suporta a execução de trabalhos em seu
computador local.

xjobs lida mal com caracteres especiais como xargs. Veja a seção DIFERENÇAS
ENTRE xargs E GNU Paralelo.

Aqui estão os exemplos de xjobspágina man do com o equivalente usando GNU paralelo:

1 ls -1 *.zip | xjobs descompactar

1 ls *.zip | descompactação paralela

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

2 ls *.zip | descompactação paralela >/dev/null

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

3 achar . -name '*.bak' | gzip paralelo

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

4 *.jar | jar paralela tf {} '>' {}.idx

5 script xjobs -s

5 roteiro de gato | paralelo

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

6 mkfifo /var/run/my_named_pipe; cat /var/run/my_named_pipe | paralelo e eco descompactar 1.zip
>> /var/run/my_named_pipe; echo tar cf /backup/myhome.tar /home/me >>
/var/run/my_named_pipe

DIFERENÇAS ENTRE prll E GNU Paralelo
prll também é uma ferramenta para executar trabalhos em paralelo. Não suporta a execução de trabalhos em
computadores remotos.

prll incentiva o uso de aliases BASH e funções BASH em vez de scripts. GNU paralelo
nunca suportará aliases em execução (veja porque
http://www.perlmonks.org/index.pl?node_id=484296). No entanto, scripts, comandos compostos ou
funções exportadas com exportar -f funcionam bem.

prll gera muitas informações de status no stderr (erro padrão), o que o torna
mais difícil usar a saída stderr (erro padrão) do trabalho diretamente como entrada para outro
.

Aqui está o exemplo de prllpágina man do com o equivalente usando GNU paralelo:

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

paralelo mogrify -flip ::: *.jpg

DIFERENÇAS ENTRE dxargs E GNU Paralelo
dxargs também é uma ferramenta para executar jobs em paralelo.

dxargs não lida bem com mais trabalhos simultâneos do que MaxStartups do SSHD. dxargs is
construído apenas para trabalhos de execução remota, mas não oferece suporte à transferência de arquivos.

DIFERENÇAS ENTRE mdm/intermediário E GNU Paralelo
intermediário(mdm) também é uma ferramenta para executar trabalhos em paralelo.

Aqui estão os shellscripts de http://mdm.berlios.de/usage.html portado para GNU paralelo:

seq 19 | paralelo buffon -o - | tipo -n > resultar

gato arquivos | paralelo cmd

find dir -execdir este cmd {} \;

DIFERENÇAS ENTRE xaplicar E GNU Paralelo
xaplicar pode executar trabalhos em paralelo no computador local.

Aqui estão os exemplos de xaplicarpágina man do com o equivalente usando GNU paralelo:

1 xapply '(cd %1 && fazer tudo)' */

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

2 xapply -f 'diff %1 ../version5/%1' manifesto | mais

2 diferença paralela {} ../version5/{} < manifest | mais

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

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

4 xapply 'recuo' *.c

4 recuo paralelo ::: *.c

5 encontre ~ksb/bin -type f ! -perm -111 -print | xapply -f -v 'chmod a+x' -

5 encontre ~ksb/bin -type f ! -perm -111 -print | paralelo -v chmod a+x

6 encontrar */ -... | fm 960 1024 | xapply -f -i /dev/tty 'vi' -

6 sh <(encontrar */ -... | paralelo -s 1024 eco vi)

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

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

7 sh <(encontrar ... |paralelo -n5 echo vi)

7 encontrar... |paralelo -n5 -uj1 vi

8 xapply -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 xapply '[ -d %1/RCS] || eco %1' */

10 paralelo '[ -d {}/RCS ] || echo {}' ::: */

11 xapply -f '[ -f %1 ] && echo %1' Lista | ...

11 paralelo '[ -f {} ] && echo {}' < List | ...

DIFERENÇAS ENTRE paexec E GNU Paralelo
paexec pode executar trabalhos em paralelo nos computadores local e remoto.

paexec requer comandos para imprimir uma linha em branco como a última saída. Isso significa que você vai
tem que escrever um wrapper para a maioria dos programas.

paexec tem um recurso de dependência de trabalho para que um trabalho possa depender de outro trabalho para ser executado
com sucesso. Uma espécie de pobre fazer.

Aqui estão os exemplos de paexeccatálogo de exemplo do com o equivalente usando GNU
paralelo:

1_div_X_run:
../../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 host1, host2 <
# Isso não é exatamente o mesmo, mas evita o wrapper
gcc paralelo -O2 -c -o {.}.o {} \
-S host1, host2 <

toupper_run:
../../paexec -lp -c "`pwd`/toupper_cmd" -n +10 <
eco paralelo {} '|' ./toupper_cmd <
# Sem o wrapper:
eco paralelo {} '| awk {print\ toupper\(\$0\)}' <

DIFERENÇAS ENTRE mapa, E GNU Paralelo
mapa, vê isso como um recurso para ter menos recursos e, ao fazê-lo, também lida com cantos
casos incorretamente. Muito GNU paraleloo código de é lidar com casos de canto corretamente em
todas as plataformas, para que você não tenha uma surpresa desagradável se um usuário, por exemplo, salvar um arquivo
chamado: My irmão de 12 " registros.txt

mapa,O exemplo de como lidar com caracteres especiais falha em caracteres especiais:

echo "The Cure" > Registros do meu\ irmão\ 12\"\

ls | map 'echo -n `gzip < "%" | wc -c`; echo -n '*100/'; wc -c < "%"' | bc

Funciona com GNU paralelo:

ls | paralelo 'echo -n `gzip < {} | wc -c`; echo -n '*100/'; wc -c < {}' | bc

E você pode até obter o nome do arquivo prefixado:

ls | paralelo --tag '(echo -n `gzip < {} | wc -c`'*100/'; wc -c < {}) | bc'

mapa, não tem suporte para agrupamento. Portanto, isso fornece os resultados errados sem nenhum aviso:

paralela perl -e '\ $ a = \ "1 {} \" x10000000 \; imprimir \ \ $ 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 out *
md5sum out *

A documentação mostra uma solução alternativa, mas não apenas mistura stdout (saída padrão)
com stderr (erro padrão) também falha completamente para certos trabalhos (e pode até ser
considerado menos legível):

eco paralelo -n {} ::: 1 2 3

map -p 4 'echo -n % 2>&1 | sed -e "s/^/$$:/"' 1 2 3 | classificar | corte -f2- -d:

mapa, não pode lidar com opções agrupadas: mapa, -vp 0 eco esse falha

mapa, não tem um separador de argumentos na linha de comando, mas usa o primeiro argumento
como comando. Isso torna a citação mais difícil, o que novamente pode afetar a legibilidade. Comparar:

map -p 2 perl\\\ -ne\\\ \\\'/^\\\\S+\\\\s+\\\\S+\\\$/\\\ e\\\ print\\\ \\\$ARGV,\\\"\\\\n\\\"\\\' *

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

mapa, pode fazer vários argumentos com substituição de contexto, mas não sem substituição de contexto:

paralelo --xargs echo 'BEGIN{'{}'}END' ::: 1 2 3

mapa, não define o valor de saída de acordo com a falha de um dos trabalhos:

paralelo falso ::: 1 || echo Job falhou

mapa falso 1 || echo Nunca corra

mapa, requer Perl v5.10.0 tornando-o mais difícil de usar em sistemas antigos.

mapa, não tem como usar % no comando (GNU Parallel tem -I para especificar outro
string de substituição que {}).

Por design mapa, é a opção incompatível com xargs, ele não possui execução remota de tarefas, um
forma estruturada de salvar resultados, múltiplas fontes de entrada, indicador de progresso, configurável
delimitador de registro (somente delimitador de campo), registro de jobs executados com possibilidade de retomar,
mantendo a saída na mesma ordem da entrada, --pipe processamento e dinamicamente
tempos limite.

DIFERENÇAS ENTRE Ladon E GNU Paralelo
Ladon pode executar vários trabalhos em arquivos em paralelo.

Ladon só funciona em arquivos e a única maneira de especificar arquivos é usando uma string glob entre aspas
(como \*.jpg). Não é possível listar os arquivos manualmente.

Como strings de substituição, ele usa FULLPATH DIRNAME BASENAME EXT RELDIR RELPATH

Estes podem ser simulados usando GNU paralelo colocando isso em ~ / .parallel / config:

--rpl 'FULLPATH $_=::shell_quote($_);chomp($_=qx{readlink -f $_});'
--rpl 'DIRNAME $_=::shell_quote(::dirname($_));chomp($_=qx{readlink -f $_});'
--rpl 'BASENAME s:.*/::;s:\.[^/.] + $ ::; '
--rpl 'EXT s:.*\.::'
--rpl 'RELDIR $_=::shell_quote($_);chomp(($_,$c)=qx{readlink -f $_;pwd});s:\Q$c/\E::; $_=::dirname($_);'
--rpl 'RELPATH $_=::shell_quote($_);chomp(($_,$c)=qx{readlink -f $_;pwd});s:\Q$c/\E::; '

Ladon lida mal com nomes de arquivos contendo " e nova linha, e falha para saída maior
de 200k:

lado '*' -- seq 36000 | banheiro

EXEMPLOS A PARTIR DE Ladon MANUAL

Supõe-se que os '--rpl's acima são colocados em ~ / .parallel / config e que é executado
sob um shell que suporta globbing '**' (como zsh):

1 ladon "**/*.txt" -- echo RELPATH

1 eco paralelo RELPATH ::: **/*.txt

2 lado "~ / Documentos /**/*.pdf" -- shasum FULLPATH > hashes.txt

2 paralelo shasum FULLPATH ::: ~ / Documentos /**/*.pdf >hashes.txt

3 ladon -m thumbs/RELDIR "**/*.jpg" loading="lazy" -- convert FULLPATH -thumbnail 100x100^ -gravity
centro - extensão 100x100 polegares/RELPATH

3 paralelo mkdir -p thumbs/RELDIR\; converter FULLPATH -miniatura 100x100^ -centro de gravidade
-extensão 100x100 polegares/RELPATH ::: **/*.jpg

4 lado "~/Música/*.wav" -- lame -V 2 FULLPATH DIRNAME/BASENAME.mp3

4 paralelo coxo -V 2 FULLPATH DIRNAME/BASENAME.mp3 ::: ~/Música/* .wav

DIFERENÇAS ENTRE ClusterSSH E GNU Paralelo
ClusterSSH resolve um problema diferente do GNU paralelo.

ClusterSSH abre uma janela de terminal para cada computador e usando uma janela mestra você pode executar
o mesmo comando em todos os computadores. Isso é normalmente usado para administrar vários
computadores que são quase idênticos.

GNU paralelo executa os mesmos (ou diferentes) comandos com argumentos diferentes em paralelo
possivelmente usando computadores remotos para ajudar a computação. Se mais de um computador estiver listado em
-S GNU paralelo só pode usar um deles (por exemplo, se houver 8 jobs a serem executados e um
computador tem 8 núcleos).

GNU paralelo pode ser usado como uma versão pobre do ClusterSSH:

paralelo --nonall -S servidor-a, servidor-b Fazer coisas Foo Barra

Use o online paralelo usando os serviços onworks.net