Por que existe tanta diferença no tempo de execução de eco e gato?

Responder a essa pergunta me fez fazer outra pergunta:
Eu pensei que os seguintes scripts fazem a mesma coisa e o segundo deve ser muito mais rápido, porque o primeiro usa o catque precisa abrir o arquivo repetidamente, mas o segundo abre apenas o arquivo uma vez e depois apenas ecoa uma variável:

(Consulte a seção de atualização para obter o código correto.)

Primeiro:

#!/bin/sh
for j in seq 10; do
  cat input
done >> output

Segundo:

#!/bin/sh
i=`cat input`
for j in seq 10; do
  echo $i
done >> output

enquanto a entrada é de cerca de 50 megabytes.

Mas quando tentei o segundo, era muito, muito lento, porque repetir a variável iera um processo massivo. Também tive alguns problemas com o segundo script, por exemplo, o tamanho do arquivo de saída foi menor que o esperado.

Também verifiquei a página de manual echoe catcomparei-as:

eco - exibe uma linha de texto

cat - concatena arquivos e imprime na saída padrão

Mas eu não entendi a diferença.

Então:

• Por que o gato é tão rápido e o eco é tão lento no segundo script?
• Ou é o problema com variável i? (porque, na página de manual echo, diz que ele exibe "uma linha de texto" e, portanto, acho que é otimizado apenas para variáveis ​​curtas, não para variáveis ​​muito muito longas como i. No entanto, isso é apenas uma suposição.)
• E por que tenho problemas quando uso echo?

ATUALIZAR

Eu usei em seq 10vez de `seq 10`incorretamente. Este é o código editado:

Primeiro:

#!/bin/sh
for j in `seq 10`; do
  cat input
done >> output

Segundo:

#!/bin/sh
i=`cat input`
for j in `seq 10`; do
  echo $i
done >> output

(Agradecimentos especiais a roaima .)

No entanto, este não é o objetivo do problema. Mesmo que o loop ocorra apenas uma vez, recebo o mesmo problema: catfunciona muito mais rápido que echo.

Há várias coisas a considerar aqui.

i=`cat input`

pode ser caro e há muitas variações entre as conchas.

Esse é um recurso chamado substituição de comando. A idéia é armazenar toda a saída do comando menos os caracteres de nova linha à direita na ivariável na memória.

Para fazer isso, os shells dividem o comando em um subshell e leem sua saída através de um cano ou soquete. Você vê muita variação aqui. Em um arquivo de 50MiB aqui, posso ver, por exemplo, o bash sendo 6 vezes mais lento que o ksh93, mas um pouco mais rápido que o zsh e duas vezes mais rápido que yash.

O principal motivo para bashser lento é que ele lê a partir do canal 128 bytes por vez (enquanto outros shells lêem 4KiB ou 8KiB por vez) e é penalizado pela sobrecarga de chamada do sistema.

zshprecisa executar algum pós-processamento para escapar de bytes NUL (outros shells quebram em bytes NUL) e yashfaz um processamento ainda mais pesado analisando caracteres de vários bytes.

Todos os shells precisam retirar os caracteres de nova linha à direita, que eles podem estar executando de maneira mais ou menos eficiente.

Alguns podem querer lidar com bytes NUL mais graciosamente que outros e verificar sua presença.

Então, uma vez que você tenha essa grande variável na memória, qualquer manipulação nela geralmente envolve alocar mais memória e lidar com dados.

Aqui, você está passando (pretendia passar) o conteúdo da variável para echo.

Felizmente, echoestá embutido no seu shell, caso contrário, a execução provavelmente falharia com um erro muito longo da lista arg . Mesmo assim, construir a matriz da lista de argumentos possivelmente envolverá a cópia do conteúdo da variável.

O outro problema principal em sua abordagem de substituição de comando é que você está chamando o operador split + glob (esquecendo de citar a variável).

Para isso, os shells precisam tratar a sequência como uma sequência de caracteres (embora alguns shells não o façam e são problemáticos a esse respeito), portanto, nos locais UTF-8, isso significa analisar as sequências UTF-8 (se ainda não o fez yash) , procure $IFScaracteres na sequência. Se $IFScontiver espaço, tabulação ou nova linha (que é o caso por padrão), o algoritmo é ainda mais complexo e caro. Em seguida, as palavras resultantes dessa divisão precisam ser alocadas e copiadas.

A parte glob será ainda mais cara. Se qualquer uma dessas palavras conter caracteres glob ( *, ?, [), então o shell terá que ler o conteúdo de alguns diretórios e fazer alguma correspondência de padrão caro ( bashde implementação, por exemplo, é notoriamente muito ruim em que).

Se a entrada contiver algo como /*/*/*/../../../*/*/*/../../../*/*/*, isso será extremamente caro, pois significa listar milhares de diretórios e pode expandir para várias centenas de MiB.

Em seguida echo, normalmente fará algum processamento extra. Algumas implementações expandem \xsequências no argumento recebido, o que significa analisar o conteúdo e provavelmente outra alocação e cópia dos dados.

Por outro lado, OK, na maioria dos shells catnão é incorporado, o que significa bifurcar um processo e executá-lo (carregar o código e as bibliotecas), mas após a primeira chamada, esse código e o conteúdo do arquivo de entrada será armazenado em cache na memória. Por outro lado, não haverá intermediário. catlerá grandes quantidades de cada vez e gravará imediatamente, sem processamento, e não precisará alocar uma quantidade enorme de memória, apenas aquele buffer que ele reutiliza.

Isso também significa que é muito mais confiável, pois não engasga com bytes NUL e não corta caracteres de nova linha à direita (e não divide + glob, embora você possa evitar isso citando a variável e não expanda a sequência de escape, embora você possa evitá-la usando em printfvez de echo).

Se você deseja otimizá-lo ainda mais, em vez de chamar catvárias vezes, basta passar inputvárias vezes para cat.

yes input | head -n 100 | xargs cat

Irá executar 3 comandos em vez de 100.

Para tornar a versão variável mais confiável, você precisará usar zsh(outros shells não podem lidar com bytes NUL) e fazer isso:

zmodload zsh/mapfile
var=$mapfile[input]
repeat 10 print -rn -- "$var"

Se você souber que a entrada não contém bytes NUL, poderá fazê-lo de maneira confiável POSIXly (embora possa não funcionar onde printfnão está embutido) com:

i=$(cat input && echo .) || exit # add an extra .\n to avoid trimming newlines
i=${i%.} # remove that trailing dot (the \n was removed by cmdsubst)
n=10
while [ "$n" -gt 10 ]; do
  printf %s "$i"
  n=$((n - 1))
done

Mas isso nunca será mais eficiente do que usar catno loop (a menos que a entrada seja muito pequena).

O problema não é cate echoé sobre a variável de cotação esquecida $i.

No shell script do tipo Bourne (exceto zsh), deixar variáveis ​​sem aspas causa glob+splitoperadores nas variáveis.

$var

é na verdade:

glob(split($var))

Portanto, com cada iteração de loop, todo o conteúdo de input(excluir novas linhas à direita) será expandido, dividido e globbing. Todo o processo requer que o shell aloque memória, analisando a sequência repetidamente. Essa é a razão pela qual você teve um desempenho ruim.

Você pode citar a variável para evitar, glob+splitmas isso não ajudará muito, pois quando o shell ainda precisar criar o argumento de cadeia grande e verificar seu conteúdo echo(Substituir builtin echopor external /bin/echofornecerá a lista de argumentos muito longa ou sem memória depende do $itamanho). A maior parte da echoimplementação não é compatível com POSIX, ela expandirá as \xseqüências de barra invertida nos argumentos recebidos.

Com cat, o shell precisa gerar um processo a cada iteração de loop e catfará a cópia de E / S. O sistema também pode armazenar em cache o conteúdo do arquivo para acelerar o processo do gato.

Se você ligar

i=`cat input`

isso permite que o processo do shell cresça de 50 MB a 200 MB (dependendo da implementação interna de caracteres amplos). Isso pode tornar seu shell lento, mas esse não é o principal problema.

O principal problema é que o comando acima precisa ler o arquivo inteiro na memória shell e echo $iprecisa dividir o campo no conteúdo desse arquivo $i. Para fazer a divisão de campos, todo o texto do arquivo precisa ser convertido em caracteres largos e é aqui que passa a maior parte do tempo.

Fiz alguns testes com o caso lento e obtive estes resultados:

• O mais rápido é ksh93
• Em seguida é o meu Bourne Shell (2x mais lento que ksh93)
• A seguir, o bash (3x mais lento que o ksh93)
• O último é ksh88 (7x mais lento que ksh93)

A razão pela qual o ksh93 é o mais rápido parece ser que o ksh93 não usa mbtowc()da libc, mas sim uma implementação própria.

BTW: Stephane está enganado que o tamanho da leitura tenha alguma influência. Compilei o Bourne Shell para ler em pedaços de 4096 bytes em vez de 128 bytes e obtive o mesmo desempenho nos dois casos.

Nos dois casos, o loop será executado apenas duas vezes (uma vez para a palavra seqe outra para a palavra 10).

Além disso, ambos mesclarão o espaço em branco adjacente e eliminarão o espaço em branco inicial / final, de modo que a saída não seja necessariamente duas cópias da entrada.

Primeiro

#!/bin/sh
for j in $(seq 10); do
    cat input
done >> output

Segundo

#!/bin/sh
i="$(cat input)"
for j in $(seq 10); do
    echo "$i"
done >> output

Uma razão pela qual a echovelocidade é mais lenta pode ser que sua variável não citada esteja sendo dividida no espaço em branco em palavras separadas. Para 50 MB, será muito trabalho. Cite as variáveis!

Sugiro que você corrija esses erros e reavalie seus horários.

Eu testei isso localmente. Criei um arquivo de 50 MB usando a saída de tar cf - | dd bs=1M count=50. Também estendi os loops para serem executados por um fator de x100, para que os tempos fossem redimensionados para um valor razoável (adicionei um loop adicional ao redor de todo o seu código: for k in $(seq 100); do... done). Aqui estão os horários:

time ./1.sh

real    0m5.948s
user    0m0.012s
sys     0m0.064s

time ./2.sh

real    0m5.639s
user    0m4.060s
sys     0m0.224s

Como você pode ver, não há diferença real, mas, se houver algo que a versão contenha echo, execute marginalmente mais rápido. Se eu remover as aspas e executar sua versão quebrada 2, o tempo dobrará, mostrando que o shell está tendo que fazer muito mais trabalho esperado.

time ./2original.sh

real    0m12.498s
user    0m8.645s
sys     0m2.732s

read é muito mais rápido que cat

Eu acho que todos podem testar isso:

$ cd /sys/devices/system/cpu/cpu0/cpufreq
───────────────────────────────────────────────────────────────────────────────────────────
$ time for ((i=0; i<10000; i++ )); do read p < scaling_cur_freq ; done

real    0m0.232s
user    0m0.139s
sys     0m0.088s
───────────────────────────────────────────────────────────────────────────────────────────
$ time for ((i=0; i<10000; i++ )); do cat scaling_cur_freq > /dev/null ; done

real    0m9.372s
user    0m7.518s
sys     0m2.435s
───────────────────────────────────────────────────────────────────────────────────────────
$ type -a read
read is a shell builtin
───────────────────────────────────────────────────────────────────────────────────────────
$ type -a cat
cat is /bin/cat

catleva 9,372 segundos. echoleva .232segundos.

readé 40 vezes mais rápido .

Meu primeiro teste quando $pecoou na tela revelada readfoi 48 vezes mais rápido que cat.

O echoobjetivo é colocar uma linha na tela. O que você faz no segundo exemplo é que você coloca o conteúdo do arquivo em uma variável e depois imprime essa variável. No primeiro, você coloca imediatamente o conteúdo na tela.

caté otimizado para esse uso. echonão é. Também colocar 50Mb em uma variável de ambiente não é uma boa ideia.

Não se trata de eco ser mais rápido, é sobre o que você está fazendo:

Em um caso, você está lendo da entrada e escrevendo na saída diretamente. Em outras palavras, o que quer que seja lido da entrada através do gato, vai para a saída através do stdout.

input -> output

No outro caso, você está lendo da entrada para uma variável na memória e depois escrevendo o conteúdo da variável na saída.

input -> variable
variable -> output

O último será muito mais lento, especialmente se a entrada for de 50 MB.