Início / unix / Perguntas / 443539
Accepted
Luc
Asked: 2018-05-14 03:17:14 +0800 CST

O GNU pode gerar saída paralela stdout antes que o programa seja encerrado?

  • 772
echo 'echo "hello, world!";sleep 3;' | parallel

Este comando não gera nada até que seja concluído. Reivindicações da página de manual do Parallel:

O paralelo GNU garante que a saída dos comandos seja a mesma que você obteria se executasse os comandos sequencialmente.

Acho que o diabo está na frase: você obtém a mesma saída como se fosse executá-lo normalmente, mas não a mesma saída como se fosse executá-lo normalmente. Procurei uma opção que fizesse isso, por exemplo --results /dev/stdout, mas não funcionou.

Meu caso de uso está vendo a saída de progresso em tempo real do comando que estou executando. Não é sobre quantas tarefas foram concluídas, qual paralelo pode ser exibido para mim, mas sobre a saída de progresso de cada comando individualmente que desejo ver.

Eu usaria um loop bash ( for i in $x; do cmd & done;), mas quero poder interromper todas as tarefas com um único Ctrl+C, que o paralelo me permite fazer.

É possível fazer isso em paralelo? Se não, existe outra ferramenta?

gnu-parallel

3 respostas

  1. Best Answer

    Acho que você está procurando --ungroup. A página de manual diz:

    --group  Group output. Output from each jobs is grouped 
         together and is only printed when the command is finished. 

         --group is the default. Can be reversed with -u.

    -uclaro que é sinônimo de --ungroup.

    • 22

  2. Para observar o progresso de alguns trabalhos paralelos, tente --tmuxpane --fg:

    parallel --tmuxpane --fg seq {} 10000000 ::: {1..100}

    Você também pode estar procurando por -uou (mais provavelmente) --lb. De man parallel:

       --line-buffer
   --lb
       Buffer output on line basis. --group will keep the output together
       for a whole job. --ungroup allows output to mixup with half a line
       coming from one job and half a line coming from another job.
       --line-buffer fits between these two: GNU parallel will print a full
       line, but will allow for mixing lines of different jobs.

       --line-buffer takes more CPU power than both --group and --ungroup,
       but can be much faster than --group if the CPU is not the limiting
       factor.

       Normally --line-buffer does not buffer on disk, and can thus process
       an infinite amount of data, but it will buffer on disk when combined
       with: --keep-order, --results, --compress, and --files. This will
       make it as slow as --group and will limit output to the available
       disk space.

       With --keep-order --line-buffer will output lines from the first job
       while it is running, then lines from the second job while that is
       running. It will buffer full lines, but jobs will not mix. Compare:

         parallel -j0 'echo {};sleep {};echo {}' ::: 1 3 2 4
         parallel -j0 --lb 'echo {};sleep {};echo {}' ::: 1 3 2 4
         parallel -j0 -k --lb 'echo {};sleep {};echo {}' ::: 1 3 2 4

       See also: --group --ungroup

    [...]

       --ungroup
   -u  Ungroup output.  Output is printed as soon as possible and by passes
       GNU parallel internal processing. This may cause output from
       different commands to be mixed thus should only be used if you do not
       care about the output. Compare these:

         seq 4 | parallel -j0 \
           'sleep {};echo -n start{};sleep {};echo {}end'
         seq 4 | parallel -u -j0 \
           'sleep {};echo -n start{};sleep {};echo {}end'

       It also disables --tag. GNU parallel outputs faster with -u. Compare
       the speeds of these:

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

       Can be reversed with --group.

       See also: --line-buffer --group

    Um exemplo onde -ushines é onde stdout e stderr são misturados na mesma linha:

    echo -n 'This is stdout (';echo -n stderr >&2 ; echo ')'

    Isso será formatado incorretamente com --lb e --group.

    Mas even -unão garante que será formatado corretamente devido à mistura de meia linha entre os processos: http://mywiki.wooledge.org/BashPitfalls#Non-atomic_writes_with_xargs_-P

    • 12

  3. Minha solução foi registrar a saída em arquivos e observá-la mudar em tempo real com o tail -f <file>comando e, em seguida, excluí-los automaticamente quando o trabalho for concluído. Também achei --progressflag útil.

    parallel --progress ./program {} '>' {}.log';' rm {}.log ::: A B C

    Aqui, os trabalhos consistirão em executar programcom diferentes entradas A, Be Cenviar a saída do programa para os arquivos de log correspondentes.

    • 5

relate perguntas