grep: memória esgotada

Eu estava fazendo uma pesquisa muito simples:

grep -R Milledgeville ~/Documents

E depois de algum tempo esse erro apareceu:

grep: memory exhausted

Como posso evitar isso?

Eu tenho 10 GB de RAM no meu sistema e alguns aplicativos estão sendo executados, então estou realmente surpreso que um simples grep fique sem memória. ~/Documentstem cerca de 100 GB e contém todos os tipos de arquivos.

grep -RI pode não ter esse problema, mas também quero pesquisar em arquivos binários.

Dois problemas em potencial:

• grep -R(exceto o GNU modificado grepencontrado no OS / X 10.8 e posterior) segue links simbólicos, portanto, mesmo que haja apenas 100 GB de arquivos ~/Documents, ainda pode haver um link simbólico, /por exemplo, e você acabará verificando todo o sistema de arquivos, incluindo arquivos gosto /dev/zero. Use grep -rcom o GNU mais recente grepou use a sintaxe padrão:

  find ~/Documents -type f -exec grep Milledgeville /dev/null {} +
  

  (no entanto, observe que o status de saída não refletirá o fato de o padrão corresponder ou não).

• greplocaliza as linhas que correspondem ao padrão. Para isso, ele precisa carregar uma linha de cada vez na memória. O GNU grep, ao contrário de muitas outras grepimplementações, não tem limite no tamanho das linhas que lê e suporta a pesquisa em arquivos binários. Portanto, se você tiver um arquivo com uma linha muito grande (ou seja, com dois caracteres de nova linha muito distantes), maior que a memória disponível, ele falhará.

  Isso normalmente aconteceria com um arquivo esparso. Você pode reproduzi-lo com:

  truncate -s200G some-file
  grep foo some-file
  

  Essa é difícil de contornar. Você poderia fazê-lo como (ainda com o GNU grep):

  find ~/Documents -type f -exec sh -c 'for i do
    tr -s "\0" "\n" < "$i" | grep --label="$i" -He "$0"
    done' Milledgeville {} +
  

  Isso converte seqüências de caracteres NUL em um caractere de nova linha antes de alimentar a entrada grep. Isso cobriria os casos em que o problema ocorre devido a arquivos esparsos.

  Você pode otimizá-lo fazendo isso apenas para arquivos grandes:

  find ~/Documents -type f \( -size -100M -exec \
    grep -He Milledgeville {} + -o -exec sh -c 'for i do
    tr -s "\0" "\n" < "$i" | grep --label="$i" -He "$0"
    done' Milledgeville {} + \)
  

  Se os arquivos não forem escassos e você tiver uma versão do GNU grepanterior 2.6, poderá usar a --mmapopção As linhas serão mapeadas na memória, em vez de copiadas, o que significa que o sistema sempre pode recuperar a memória paginando as páginas para o arquivo. Essa opção foi removida no GNU grep2.6

Eu costumo fazer

find ~/Documents | xargs grep -ne 'expression'

Tentei vários métodos e achei que era o mais rápido. Observe que isso não trata arquivos com espaços com o nome do arquivo muito bem. Se você sabe que esse é o caso e tem uma versão GNU do grep, você pode usar:

find ~/Documents -print0 | xargs -0 grep -ne 'expression'

Caso contrário, você pode usar:

 find ~/Documents -exec grep -ne 'expression' "{}" \;

Qual será execum grep para cada arquivo.

Eu posso pensar em algumas maneiras de contornar isso:

• Em vez de grepping todos os arquivos de uma vez, faça um arquivo de cada vez. Exemplo:

  find /Documents -type f -exec grep -H Milledgeville "{}" \;
  

• Se você precisar apenas saber quais arquivos contêm as palavras, faça-o grep -l. Como o grep interromperá a pesquisa após o primeiro hit, não será necessário continuar lendo nenhum arquivo enorme

• Se você quiser o texto real também, poderá inserir dois greps separados:

  for file in $( grep -Rl Milledgeville /Documents ); do grep -H Milledgeville "$file"; done
  

Estou esperando um disco de 6 TB para procurar dados perdidos e a memória está esgotada - erro. Isso deve funcionar para outros arquivos também.

A solução que encontramos foi ler o disco em pedaços usando dd e grepping os pedaços. Este é o código (big-grep.sh):

#problem: grep gives "memory exhausted" error on 6TB disks
#solution: read it on parts
if [ -z $2 ] || ! [ -e $1 ]; then echo "$0 file string|less -S # greps in chunks"; exit; fi

FILE="$1"
MATCH="$2"

SIZE=`ls -l $1|cut -d\  -f5`
CHUNKSIZE=$(( 1024 * 1024 * 1 )) 
CHUNKS=100 # greps in (100 + 1) x 1MB = 101MB chunks
COUNT=$(( $SIZE / $CHUNKSIZE * CHUNKS ))

for I in `seq 0 $COUNT`; do
  dd bs=$CHUNKSIZE skip=$(($I*$CHUNKS)) count=$(( $CHUNKS+1)) if=$FILE status=none|grep -UF -a --context 6 "$MATCH"
done