grep: memoria agotada

Estaba haciendo una búsqueda muy simple:

grep -R Milledgeville ~/Documents

Y después de algún tiempo apareció este error:

grep: memory exhausted

¿Cómo puedo evitar esto?

Tengo 10 GB de RAM en mi sistema y pocas aplicaciones ejecutándose, así que estoy realmente sorprendido de que un simple grep se quede sin memoria. ~/Documentstiene aproximadamente 100 GB y contiene todo tipo de archivos.

grep -RI Es posible que no tenga este problema, pero también quiero buscar en archivos binarios.

Dos posibles problemas:

• grep -R(a excepción del GNU modificado que se grepencuentra en OS / X 10.8 y superior) sigue los enlaces simbólicos, por lo que incluso si solo hay 100 GB de archivos ~/Documents, podría haber un enlace simbólico, /por ejemplo, y terminará escaneando todo el sistema de archivos, incluidos los archivos como /dev/zero. Use grep -rcon GNU más nuevo grep, o use la sintaxis estándar:

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

  (sin embargo, tenga en cuenta que el estado de salida no reflejará el hecho de que el patrón coincide o no).

• grepencuentra las líneas que coinciden con el patrón. Para eso, tiene que cargar una línea a la vez en la memoria. GNU grep, a diferencia de muchas otras grepimplementaciones, no tiene un límite en el tamaño de las líneas que lee y admite la búsqueda en archivos binarios. Entonces, si tiene un archivo con una línea muy grande (es decir, con dos caracteres de nueva línea muy separados), más grande que la memoria disponible, fallará.

  Eso normalmente sucedería con un archivo disperso. Puedes reproducirlo con:

  truncate -s200G some-file
  grep foo some-file
  

  Ese es difícil de evitar. Podrías hacerlo como (todavía con GNU grep):

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

  Eso convierte secuencias de caracteres NUL en un carácter de nueva línea antes de alimentar la entrada grep. Eso cubriría los casos en que el problema se deba a la escasez de archivos.

  Puede optimizarlo haciéndolo solo para archivos 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 {} + \)
  

  Si los archivos no son escasos y tiene una versión de GNU grepanterior 2.6, puede usar la --mmapopción. Las líneas se mapearán en la memoria en lugar de copiarse allí, lo que significa que el sistema siempre puede recuperar la memoria paginando las páginas al archivo. Esa opción fue eliminada en GNU grep2.6

Yo suelo hacer

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

Probé varios métodos y descubrí que este es el más rápido. Tenga en cuenta que esto no maneja muy bien los archivos con espacios del nombre del archivo. Si sabe que este es el caso y tiene una versión GNU de grep, puede usar:

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

Si no, puedes usar:

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

Lo cual será execun grep para cada archivo.

Se me ocurren algunas maneras de evitar esto:

• En lugar de agrupar todos los archivos a la vez, haga un archivo a la vez. Ejemplo:

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

• Si solo necesita saber qué archivos contienen las palabras, hágalo grep -l. Dado que grep dejará de buscar después del primer golpe, no tendrá que seguir leyendo ningún archivo enorme

• Si también desea el texto real, puede encadenar dos greps separados:

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

Estoy usando un disco de 6TB para buscar datos perdidos, y la memoria se agotó. Esto también debería funcionar para otros archivos.

La solución que se nos ocurrió fue leer el disco en fragmentos utilizando dd y haciendo un grep de los fragmentos. Este es el 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