filtrando um arquivo grande com um filtro grande

Ele é abordado em man parallel https://www.gnu.org/software/parallel/man.html#EXAMPLE:-Grepping-n-lines-for-m-regular-expressions

EXEMPLO: Grepping n linhas para m expressões regulares.

A solução mais simples para grep um arquivo grande para muitos regexps é:

grep -f regexps.txt bigfile

Ou se os regexps forem strings fixas:

grep -F -f regexps.txt bigfile

Existem 3 fatores limitantes: CPU, RAM e E/S de disco.

A RAM é fácil de medir: Se o processo grep ocupar a maior parte de sua memória livre (por exemplo, ao executar top), então a RAM é um fator limitante.

A CPU também é fácil de medir: se o grep levar > 90% da CPU no topo, a CPU é um fator limitante e a paralelização acelerará isso.

É mais difícil ver se a E/S do disco é o fator limitante e, dependendo do sistema de disco, pode ser mais rápido ou mais lento para paralelizar. A única maneira de saber com certeza é testar e medir.

Fator limitante: RAM

O arquivo grande grep -f regexs.txt normal funciona independentemente do tamanho do arquivo grande, mas se o arquivo regexps.txt for tão grande que não cabe na memória, você precisará dividi-lo.

grep -F leva cerca de 100 bytes de RAM e grep leva cerca de 500 bytes de RAM por 1 byte de regexp. Portanto, se regexps.txt for 1% da sua RAM, pode ser muito grande.

Se você puder converter seus regexps em strings fixas, faça isso. Por exemplo, se as linhas que você está procurando no bigfile se parecem com:

ID1 foo bar baz Identifier1 quux
fubar ID2 foo bar baz Identifier2

então seu regexps.txt pode ser convertido de:

ID1.*Identifier1   
ID2.*Identifier2

em:

ID1 foo bar baz Identifier1
ID2 foo bar baz Identifier2

Dessa forma, você pode usar grep -F, que consome cerca de 80% menos memória e é muito mais rápido.

Se ainda não couber na memória, você pode fazer isso:

parallel --pipepart -a regexps.txt --block 1M grep -Ff - -n bigfile |
  sort -un | perl -pe 's/^\d+://'

O 1M deve ser sua memória livre dividido pelo número de threads da CPU e dividido por 200 para grep -F e por 1000 para grep normal. No GNU/Linux você pode fazer:

free=$(awk '/^((Swap)?Cached|MemFree|Buffers):/ { sum += $2 }
          END { print sum }' /proc/meminfo)
percpu=$((free / 200 / $(parallel --number-of-threads)))k

parallel --pipepart -a regexps.txt --block $percpu --compress \
  grep -F -f - -n bigfile |
  sort -un | perl -pe 's/^\d+://'

Se você pode conviver com linhas duplicadas e ordem errada, é mais rápido fazer:

parallel --pipepart -a regexps.txt --block $percpu --compress \
  grep -F -f - bigfile

Fator limitante: CPU

Se a CPU é o fator limitante a paralelização deve ser feita nas regexps:

cat regexp.txt | parallel --pipe -L1000 --round-robin --compress \
  grep -f - -n bigfile |
  sort -un | perl -pe 's/^\d+://'

O comando iniciará um grep por CPU e lerá bigfile uma vez por CPU, mas como isso é feito em paralelo, todas as leituras, exceto a primeira, serão armazenadas em cache na RAM. Dependendo do tamanho do regexp.txt, pode ser mais rápido usar --block 10m em vez de -L1000.

Alguns sistemas de armazenamento têm melhor desempenho ao ler vários fragmentos em paralelo. Isso é verdade para alguns sistemas RAID e para alguns sistemas de arquivos de rede. Para paralelizar a leitura do bigfile:

parallel --pipepart --block 100M -a bigfile -k --compress \
  grep -f regexp.txt

Isso dividirá o bigfile em pedaços de 100 MB e executará o grep em cada um desses pedaços. Para paralelizar a leitura de bigfile e regexp.txt, combine os dois usando --fifo:

parallel --pipepart --block 100M -a bigfile --fifo cat regexp.txt \
  \| parallel --pipe -L1000 --round-robin grep -f - {}

Se uma linha corresponder a vários regexps, a linha poderá ser duplicada.

Problema maior

Se o problema for grande demais para ser resolvido com isso, você provavelmente está pronto para o Lucene.