Як запустити sed на понад 10 мільйонів файлів у каталозі?

У мене є каталог, у якому є 10144911 файлів. Поки я спробував таке:

• for f in ls; do sed -i -e 's/blah/blee/g' $f; done

Розбив мою оболонку, lsзнаходиться в тильді, але я не можу зрозуміти, як зробити її.

• ls | xargs -0 sed -i -e 's/blah/blee/g'

Занадто багато аргументів для sed

• find . -name "*.txt" -exec sed -i -e 's/blah/blee/g' {} \;

Не вдалося розщедрити більше не більше пам’яті

Будь-які інші ідеї, як створити таку команду? Файлам не потрібно спілкуватися один з одним. ls | wc -lздається, працює (дуже повільно), тому це повинно бути можливим.

Спробуйте:

find -name '*.txt' -print0 | xargs -0 -I {} -P 0 sed -i -e 's/blah/blee/g' {}

Він буде подавати лише одне ім’я файлу для кожного виклику sed. Це вирішить проблему "занадто багато аргументів для sed". -PВаріант повинен дозволити кільком процесам бути роздвоєною одночасно. Якщо 0 не працює (він повинен працювати якомога більше), спробуйте інші числа (10? 100 - кількість ядер у вас?), Щоб обмежити кількість.

Я перевірив цей метод (і всі інші) на 10 мільйонах (порожніх) файлів, названих "привіт 00000001" на "привіт 10000000" (14 байт на ім'я).

ОНОВЛЕННЯ: Зараз я включив чотириядерний запуск 'find |xargs'методу (все ще без 'sed'; просто відлуння> / dev / null) ..

# Step 1. Build an array for 10 million files
#   * RAM usage approx:  1.5 GiB 
#   * Elapsed Time:  2 min 29 sec 
  names=( hello\ * )

# Step 2. Process the array.
#   * Elapsed Time:  7 min 43 sec
  for (( ix=0, cnt=${#names[@]} ; ix<$cnt; ix++ )) ; do echo "${names[ix]}" >/dev/null ; done  

Ось короткий підсумок того, як надані відповіді виправдались, коли протистояли згаданим вище тестовим даним. Ці результати включають лише основні накладні витрати; тобто "sed" не називався. Процес засідання майже напевно буде найбільш трудомістким, але я подумав, що буде цікаво подивитися, як порівнюють голі методи.

'find |xargs'Метод Денніса , використовуючи одне ядро, зайняв * 4 годин 21 хв ** довше, ніж bash arrayметод на no sedходу ... Однак перевага багатоядерного, запропонована функцією 'find', повинна перевищувати часові різниці, показані при виклику sed обробка файлів ...

           | Time    | RAM GiB | Per loop action(s). / The command line. / Notes
-----------+---------+---------+----------------------------------------------------- 
Dennis     | 271 min | 1.7 GiB | * echo FILENAME >/dev/null
Williamson   cores: 1x2.66 MHz | $ time find -name 'hello *' -print0 | xargs -0 -I {} echo >/dev/null {}
                               | Note: I'm very surprised at how long this took to run the 10 million file gauntlet
                               |       It started processing almost immediately (because of xargs I suppose),  
                               |       but it runs **significantly slower** than the only other working answer  
                               |       (again, probably because of xargs) , but if the multi-core feature works  
                               |       and I would think that it does, then it could make up the defecit in a 'sed' run.   
           |  76 min | 1.7 GiB | * echo FILENAME >/dev/null
             cores: 4x2.66 MHz | $ time find -name 'hello *' -print0 | xargs -0 -I {} -P 0 echo >/dev/null {}
                               |  
-----------+---------+---------+----------------------------------------------------- 
fred.bear  | 10m 12s | 1.5 GiB | * echo FILENAME >/dev/null
                               | $ time names=( hello\ * ) ; time for (( ix=0, cnt=${#names[@]} ; ix<$cnt; ix++ )) ; do echo "${names[ix]}" >/dev/null ; done
-----------+---------+---------+----------------------------------------------------- 
l0b0       | ?@#!!#  | 1.7 GiB | * echo FILENAME >/dev/null 
                               | $ time  while IFS= read -rd $'\0' path ; do echo "$path" >/dev/null ; done < <( find "$HOME/junkd" -type f -print0 )
                               | Note: It started processing filenames after 7 minutes.. at this point it  
                               |       started lots of disk thrashing.  'find' was using a lot of memory, 
                               |       but in its basic form, there was no obvious advantage... 
                               |       I pulled the plug after 20 minutes.. (my poor disk drive :(
-----------+---------+---------+----------------------------------------------------- 
intuited   | ?@#!!#  |         | * print line (to see when it actually starts processing, but it never got there!)
                               | $ ls -f hello * | xargs python -c '
                               |   import fileinput
                               |   for line in fileinput.input(inplace=True):
                               |       print line ' 
                               | Note: It failed at 11 min and approx 0.9 Gib
                               |       ERROR message: bash: /bin/ls: Argument list too long  
-----------+---------+---------+----------------------------------------------------- 
Reuben L.  | ?@#!!#  |         | * One var assignment per file
                               | $ ls | while read file; do x="$file" ; done 
                               | Note: It bombed out after 6min 44sec and approx 0.8 GiB
                               |       ERROR message: ls: memory exhausted
-----------+---------+---------+----------------------------------------------------- 

Ще одна можливість для абсолютно безпечної знахідки :

while IFS= read -rd $'\0' path
do
    file_path="$(readlink -fn -- "$path"; echo x)"
    file_path="${file_path%x}"
    sed -i -e 's/blah/blee/g' -- "$file_path"
done < <( find "$absolute_dir_path" -type f -print0 )

Це в основному поза темою, але ви можете скористатися

find -maxdepth 1 -type f -name '*.txt' | xargs python -c '
import fileinput
for line in fileinput.input(inplace=True):
    print line.replace("blah", "blee"),
'

Основна перевага тут (над ... xargs ... -I {} ... sed ...) - швидкість: ви уникаєте звернення в sed10 мільйонів разів. Але все-таки було б швидше, якщо ви не зможете використовувати Python (оскільки python начебто повільний, відносно), тому perl може бути кращим вибором для цього завдання. Я не впевнений, як зробити еквівалент зручно за допомогою perl.

Як це працює, це xargsпризведе до того, що Python викликає стільки аргументів, скільки він може вміститися в одному командному рядку, і продовжуватиме це робити, поки у нього не вичерпаються аргументи (які надаються ls -f *.txt). Кількість аргументів до кожного виклику буде залежати від довжини імен файлів і, гм, деяких інших матеріалів. fileinput.inputФункція дає послідовні рядки з файлів , названих в якості аргументів для кожного виклику, в і inplaceопція вказує , що чарівним чином «зловити» вихід і використовувати його для заміни кожного рядка.

Зауважте, що струнний replaceметод Python не використовує регулярні вирази; якщо вони вам потрібні, ви повинні import reі користуватися print re.sub(line, "blah", "blee"). Вони є Perl-сумісними RegExps, які є на зразок сильно укріплених версій тих, з якими ви отримуєте sed -r.

редагувати

Як згадує akira в коментарях, оригінальна версія, що використовує glob ( ls -f *.txt) замість findкоманди, не працюватиме, оскільки глобуси обробляються самою shell ( bash). Це означає, що перед тим, як команда навіть буде запущена, 10 мільйонів імен файлів буде замінено в командний рядок. Це майже гарантовано перевищує максимальний розмір списку аргументів команди. Ви можете використовувати xargs --show-limitsдля цього інформацію про систему.

Максимальний розмір списку аргументів також враховується тим xargs, що обмежує кількість аргументів, які він передає, до кожного виклику python відповідно до цієї межі. Оскільки xargsдоведеться ще кілька разів викликати python, пропозиція Akira використовувати os.path.walkдля отримання списку файлів, ймовірно, заощадить ваш час.

Спробуйте:

ls | while read file; do (something to $file); done