grep: mémoire épuisée

Je faisais une recherche très simple:

grep -R Milledgeville ~/Documents

Et après un certain temps, cette erreur est apparue:

grep: memory exhausted

Comment puis-je éviter ça?

J'ai 10 Go de RAM sur mon système et peu d'applications en cours d'exécution, donc je suis vraiment surpris qu'un simple grep manque de mémoire. ~/Documentsest d'environ 100 Go et contient toutes sortes de fichiers.

grep -RI peut-être pas ce problème, mais je veux aussi chercher dans des fichiers binaires.

Deux problèmes potentiels:

• grep -R(à l'exception de la version modifiée de GNU grepdisponible sur OS / X 10.8 et versions ultérieures) suit les liens symboliques. Ainsi, même s'il ne contient que 100 Go de fichiers ~/Documents, il peut toujours y avoir un lien symbolique vers /par exemple et vous finirez par analyser l'ensemble du système de fichiers, fichiers compris. comme /dev/zero. Utilisez cette version grep -ravec GNU grepou utilisez la syntaxe standard suivante:

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

  (notez cependant que l'état de sortie ne reflétera pas le fait que le modèle correspond ou non).

• greptrouve les lignes qui correspondent au motif. Pour cela, il doit charger une ligne à la fois en mémoire. GNU grep, contrairement à de nombreuses autres grepimplémentations, ne limite pas la taille des lignes lues et prend en charge la recherche dans les fichiers binaires. Donc, si vous avez un fichier avec une très grosse ligne (c'est-à-dire avec deux caractères de nouvelle ligne très éloignés), plus grand que la mémoire disponible, cela échouera.

  Cela se produirait généralement avec un fichier fragmenté. Vous pouvez le reproduire avec:

  truncate -s200G some-file
  grep foo some-file
  

  Celui-là est difficile à contourner. Vous pouvez le faire comme (toujours avec GNU grep):

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

  Cela convertit les séquences de caractères NUL en un caractère de nouvelle ligne avant d’alimenter l’entrée grep. Cela couvrirait les cas où le problème est dû à la rareté des fichiers.

  Vous pouvez l'optimiser en ne le faisant que pour les gros fichiers:

  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 les fichiers ne sont pas clairsemés et que vous avez une version grepantérieure de GNU 2.6, vous pouvez utiliser cette --mmapoption. Les lignes seront mappées en mémoire et non copiées, ce qui signifie que le système peut toujours récupérer la mémoire en paginant les pages du fichier. Cette option a été supprimée dans GNU grep2.6.

Je fais habituellement

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

J'ai essayé un tas de méthodes et j'ai trouvé que c'était le plus rapide. Notez que cela ne gère pas très bien les fichiers avec des espaces, le nom de fichier. Si vous savez que c'est le cas et que vous avez une version GNU de grep, vous pouvez utiliser:

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

Sinon, vous pouvez utiliser:

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

Quel sera execun grep pour chaque fichier.

Je peux penser à quelques façons de contourner cela:

• Au lieu de mettre tous les fichiers à la fois, créez un fichier à la fois. Exemple:

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

• Si vous avez seulement besoin de savoir quels fichiers contiennent les mots, faites-le grep -lplutôt. Puisque grep arrêtera de chercher après le premier coup, il ne sera pas obligé de lire de gros fichiers.

• Si vous souhaitez également obtenir le texte réel, vous pouvez également y insérer deux groupes distincts:

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

Je cherche un disque de 6 To pour rechercher les données perdues et la mémoire est épuisée - erreur. Cela devrait fonctionner pour d'autres fichiers aussi.

La solution que nous avons proposée consistait à lire le disque en morceaux en utilisant dd et en les attrapant. C'est le code (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