grep: memoria esaurita

Stavo facendo una ricerca molto semplice:

grep -R Milledgeville ~/Documents

E dopo qualche tempo è apparso questo errore:

grep: memory exhausted

Come posso evitarlo?

Ho 10 GB di RAM sul mio sistema e poche applicazioni sono in esecuzione, quindi sono davvero sorpreso che un semplice grep abbia esaurito la memoria. ~/Documentsè di circa 100 GB e contiene tutti i tipi di file.

grep -RI potrebbe non avere questo problema, ma voglio cercare anche nei file binari.

Due potenziali problemi:

• grep -R(ad eccezione della GNU modificata greptrovata su OS / X 10.8 e versioni successive) segue i collegamenti simbolici, quindi anche se ci sono solo 100 GB di file ~/Documents, potrebbe esserci ancora un collegamento simbolico ad /esempio e finirai per scansionare l'intero file system inclusi i file come /dev/zero. Utilizzare grep -rcon GNU più recenti grepo utilizzare la sintassi standard:

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

  (tuttavia si noti che lo stato di uscita non rifletterà il fatto che il modello sia abbinato o meno).

• greptrova le linee che corrispondono al modello. Per questo, deve caricare una riga alla volta in memoria. GNU, grepa differenza di molte altre grepimplementazioni, non ha un limite alla dimensione delle righe che legge e supporta la ricerca in file binari. Quindi, se hai un file con una linea molto grande (cioè con due caratteri newline molto lontani), più grande della memoria disponibile, fallirà.

  Ciò accade in genere con un file sparse. Puoi riprodurlo con:

  truncate -s200G some-file
  grep foo some-file
  

  Quello è difficile da aggirare. Potresti farlo come (sempre 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 {} +
  

  Ciò converte le sequenze di caratteri NUL in un carattere di nuova riga prima di alimentare l'input grep. Ciò coprirebbe i casi in cui il problema è dovuto a file sparsi.

  Potresti ottimizzarlo facendolo solo per file di grandi dimensioni:

  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 i file sono non sparse e si dispone di una versione di GNU grepprima 2.6, è possibile utilizzare l' --mmapopzione. Le linee verranno mmappate in memoria anziché copiate lì, il che significa che il sistema può sempre recuperare la memoria pagando le pagine nel file. Questa opzione è stata rimossa in GNU grep2.6

Di solito lo faccio

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

Ho provato un sacco di metodi e ho scoperto che questo è il più veloce. Si noti che questo non gestisce molto bene i file con spazi il nome del file. Se sai che questo è il caso e hai una versione GNU di grep, puoi usare:

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

Altrimenti puoi usare:

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

Quale sarà execun grep per ogni file.

Posso pensare ad alcuni modi per aggirare questo:

• Invece di eseguire il grepping di tutti i file contemporaneamente, esegui un file alla volta. Esempio:

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

• Se hai solo bisogno di sapere quali file contengono le parole, fallo grep -linvece. Poiché grep smetterà di cercare dopo il primo hit, non dovrà continuare a leggere file di grandi dimensioni

• Se vuoi anche il testo reale, puoi mettere insieme due greps separati:

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

Sto cercando un disco da 6 TB per cercare dati persi e ho esaurito la memoria -error. Questo dovrebbe funzionare anche per altri file.

La soluzione che ci è venuta in mente è stata quella di leggere il disco in blocchi usando dd e eseguendo il grepping dei blocchi. Questo è il codice (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