паралельно - онлайн в хмарі

ПРОГРАМА:

ІМ'Я

parallel - паралельно створювати та виконувати командні рядки оболонки зі стандартного введення

СИНТАКСИС

паралельно [параметри] [команда [аргументи]] < список_аргументів

паралельно [параметри] [команда [аргументи]] ( ::: аргументи | :::: argfile(s) ...

паралельно --семафор [параметри] команда

#!/usr/bin/parallel --shebang [параметри] [команда [аргументи]]

ОПИС

GNU паралельно є інструментом оболонки для паралельного виконання завдань за допомогою одного або кількох комп’ютерів. А
завдання може бути окремою командою або невеликим сценарієм, який потрібно запустити для кожного з рядків у
вхідний. Типовим введенням є список файлів, список хостів, список користувачів, список
URL-адрес або список таблиць. Завдання також може бути командою, яка зчитується з каналу. GNU
паралельно потім можна розділити вхідні дані на блоки та передати блок у кожну команду
паралельні.

Якщо ви сьогодні використовуєте xargs і tee, ви знайдете GNU паралельно дуже простий у використанні як GNU паралельно
написано, щоб мати ті самі параметри, що й xargs. Якщо ви пишете цикли в оболонку, ви знайдете
GNU паралельно можливо, зможе замінити більшість циклів і змусити їх працювати швидше, виконуючи виконання
кілька робіт паралельно.

GNU паралельно переконається, що вихід команд є таким же, як і ви
ви виконуєте команди послідовно. Це дає можливість використовувати вихідні дані GNU паралельно
як вхідні дані для інших програм.

Для кожного рядка введення GNU паралельно виконає команда з рядком як аргументи. Якщо ні
команда задано, рядок введення виконується. Кілька рядків будуть виконуватися паралельно.
GNU паралельно часто можна використовувати як заміну ксарг or як | бити.

Читацька керівництво
Почніть з перегляду вступних відео для швидкого вступу:
http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Тоді подивіться на прикладs після списку ВАРІАНТИ. Це дасть вам уявлення про те, що
GNU паралельно здатний.

Потім витратите годину на прогулянку підручником (людина parallel_tutorial). Ваш командний рядок
буде любити тебе за це.

Нарешті, ви можете переглянути решту цього посібника, якщо у вас немає особливих потреб
вже покритий.

ВАРІАНТИ

команда Команда для виконання. Якщо команда або наступні аргументи містять заміну
струни (наприклад {}) кожен екземпляр буде замінено введенням.

If команда дано, GNU паралельно вирішувати ті самі завдання, що ксарг. Якщо команда is
не надано GNU паралельно буде вести себе подібно до як | sh.

Команда команда має бути виконуваним файлом, сценарієм, складеною командою або функцією.

Якщо це функція Bash, вам потрібно експорт -f спочатку функція. Щоб використовувати псевдоніми
скопіюйте повне середовище, як описано нижче -Env І використовувати env_parallel замість
of паралельно.

Якщо це функція zsh, вам потрібно буде використовувати цю допоміжну функцію експорт f до
експортувати та встановити $PARALLEL_SHELL на bash:

функція exportf (){
export $(echo $1)="`whence -f $1 | sed -e "s/$1 //" `"
}

функція my_func(){
echo $1;
луна «привіт»;
}

exportf my_func
PARALLEL_SHELL=/ bin / bash паралельно "my_func {}" ::: 1 2

Команда не може містити символ \257 (макрон: X).

{} Вхідний рядок. Цей рядок заміни буде замінено повним рядком, прочитаним із
джерело введення. Джерелом введення зазвичай є stdin (стандартний вхід), але також може
надаватися з -a, :::або ::::.

Рядок заміни {} можна змінити за допомогою -I.

Якщо командний рядок не містить рядків для заміни, тоді {} буде додано до
командний рядок.

{.} Рядок введення без розширення. Цей рядок заміни буде замінено на
введення з вилученим розширенням. Якщо рядок введення містить . після останнього /
останній . до кінця рядка буде видалено і {.} буде замінено
з рештою. напр foo.jpg стає Foo, subdir/foo.jpg стає subdir/foo,
sub.dir/foo.jpg стає sub.dir/foo, sub.dir/bar залишається sub.dir/bar, Якщо
рядок введення не містить . воно залишиться незмінним.

Рядок заміни {.} можна змінити за допомогою --ер.

Щоб зрозуміти рядки заміни, див {}.

{/} Базове ім'я вхідного рядка. Цей рядок заміни буде замінено введенням
з вилученою частиною каталогу.

Рядок заміни {/} можна змінити за допомогою --basenameplace.

Щоб зрозуміти рядки заміни, див {}.

{//} Назва вхідного рядка. Цей рядок заміни буде замінено каталогом файлу
вхідний рядок. Подивитися прізвище(1).

Рядок заміни {//} можна змінити за допомогою --dirnamereplace.

Щоб зрозуміти рядки заміни, див {}.

{/.} Базове ім'я рядка введення без розширення. Цей рядок заміни буде
замінено на вхід із вилученою частиною каталогу та розширення. Це
поєднання {/} та {.}.

Рядок заміни {/.} можна змінити за допомогою --basenameextensionreplace.

Щоб зрозуміти рядки заміни, див {}.

{#} (альфа-тестування)
Порядковий номер завдання для виконання. Цей рядок заміни буде замінено на
порядковий номер завдання, яке виконується. Він містить те саме число, що й
$PARALLEL_SEQ.

Рядок заміни {#} можна змінити за допомогою --seqreplace.

Щоб зрозуміти рядки заміни, див {}.

{%} (альфа-тестування)
Номер робочого місця. Цей рядок заміни буде замінено слотом завдання
число від 1 до кількості завдань для паралельного виконання. 2 ніколи не буде
завдання, що виконуються одночасно з тим самим номером слота завдання.

Рядок заміни {%} можна змінити за допомогою --slotreplace.

Щоб зрозуміти рядки заміни, див {}.

{n} Аргумент із джерела введення n або n'-й аргумент. Це позиційна заміна
рядок буде замінено введенням із джерела введення n (при використанні з -a or
::::) або за допомогою n'-й аргумент (при використанні з -N). Якщо n є негативним, це посилається
до nОстанній аргумент.

Щоб зрозуміти рядки заміни, див {}.

{n.} Аргумент із джерела введення n або n'-й аргумент без розширення. Це
поєднання {n} та {.}.

Цей рядок позиційної заміни буде замінено введенням із входу
джерело n (при використанні з -a or ::::) або за допомогою n'-й аргумент (при використанні з
-N). Після введення розширення буде видалено.

Щоб зрозуміти рядки позиційної заміни див {n}.

{n/} Основна назва аргументу з джерела введення n або n'-й аргумент. Це
поєднання {n} та {/}.

Цей рядок позиційної заміни буде замінено введенням із входу
джерело n (при використанні з -a or ::::) або за допомогою n'-й аргумент (при використанні з
-N). У вхідних даних буде видалено каталог (якщо є).

Щоб зрозуміти рядки позиційної заміни див {n}.

{n//} Назва аргументу з джерела введення n або n'-й аргумент. Це
поєднання {n} та {//}.

Цей рядок позиційної заміни буде замінено каталогом введення з
джерело вхідного сигналу n (при використанні з -a or ::::) або за допомогою n'-й аргумент (при використанні
з -N). Подивитися прізвище(1).

Щоб зрозуміти рядки позиційної заміни див {n}.

{n/.} Основна назва аргументу з джерела введення n або n'-й аргумент без розширення.
Це поєднання з {n}, {/} та {.}.

Цей рядок позиційної заміни буде замінено введенням із входу
джерело n (при використанні з -a or ::::) або за допомогою n'-й аргумент (при використанні з
-N). У вхідних даних буде видалено каталог (якщо є) і розширення.

Щоб зрозуміти рядки позиційної заміни див {n}.

{=Perl вираз=}
Замінити розрахованим Perl вираз. $_ міститиме те саме, що {}. Після
оцінки Perl вираз $_ буде використано як значення. Рекомендується
змініть лише $_, але ви маєте повний доступ до всього GNU паралельновнутрішній
функції та структури даних.

Команда {=Perl вираз=} має бути подано як один рядок.

Див також: --rpl --батьки

{=n Perl вираз=}
Позиційний еквівалент до {= Perl вираз =}. Щоб зрозуміти позиційне
заміна рядків див {n}.

Див також: {= Perl вираз =} {n}.

::: аргументація
Використовуйте аргументи з командного рядка як джерело введення замість stdin (стандарт
введення). На відміну від інших варіантів для GNU паралельно ::: розміщується після команда та
перед аргументами.

Наступні є еквівалентними:

(файл ехо1; файл ехо2) | паралельний gzip
паралельний gzip ::: файл1 файл2
паралельний gzip {} ::: файл1 файл2
parallel --arg-sep ,, gzip {} ,, файл1 файл2
паралельно --arg-sep ,, gzip ,, файл1 файл2
паралельно ::: "файл gzip1" "файл gzip2"

Щоб уникнути лікування ::: як спеціального використання --арг-вер щоб встановити роздільник аргументів
щось ще. Дивіться також --арг-вер.

stdin (стандартний вхід) буде передано до першого запуску процесу.

Якщо кілька ::: дані, кожна група буде розглядатися як джерело введення, і всі
будуть створені комбінації вхідних джерел. Наприклад: ::: 1 2 ::: abc буде
призводять до комбінацій (1,a) (1,b) (1,c) (2,a) (2,b) (2,c). Це корисно
для заміни вкладених циклів for.

::: та :::: можна змішувати. Отже, вони еквівалентні:

паралельне відлуння {1} {2} {3} ::: 6 7 ::: 4 5 ::: 1 2 3
паралельне відлуння {1} {2} {3} :::: <(послідовність 6 7) <(послідовність 4 5) :::: <(послідовність 1 3)
parallel -a <(seq 6 7) echo {1} {2} {3} :::: <(seq 4 5) :::: <(seq 1 3)
паралельно -a <(seq 6 7) -a <(seq 4 5) echo {1} {2} {3} ::: 1 2 3
послідовність 6 7 | parallel -a - -a <(seq 4 5) echo {1} {2} {3} ::: 1 2 3
послідовність 4 5 | паралельне відлуння {1} {2} {3} :::: <(послідовність 6 7) - ::: 1 2 3

:::: файли arg
Інший спосіб написання -a argfile1 -a argfile2 ...

::: та :::: можна змішувати.

Читати -a, ::: та --xзастосувати.

--нуль
-0 Використовуйте NUL як роздільник. Зазвичай рядки введення закінчуються на \n (новий рядок). Якщо вони закінчуються
в \0 (NUL), то скористайтеся цим параметром. Це корисно для обробки аргументів, які можуть
містять \n (новий рядок).

--arg-файл вхідний файл
-a вхідний файл
Скористайтесь вхідний файл як джерело входу. Якщо ви використовуєте цю опцію, stdin (стандартний введення) є
надано до першого запуску процесу. В іншому випадку stdin (стандартний вхід) буде перенаправлено
з /dev/null.

Якщо кілька -a дано кожному вхідний файл буде розглядатися як джерело введення, і
будуть створені всі комбінації вхідних джерел. Наприклад, файл Foo містить 1
2, файл бар містить a b c. -a Foo -a бар призведе до комбінацій
(1,a) (1,b) (1,c) (2,a) (2,b) (2,c). Це корисно для заміни вкладених для-
петлі.

Дивіться також --xзастосувати та {n}.

--arg-file-sep вер-вул
Скористайтесь вер-вул замість :::: як рядок-роздільник між командою та аргументом
файли. Корисно, якщо :::: використовується командою для чогось іншого.

Див також: ::::.

--арг-вер вер-вул
Скористайтесь вер-вул замість ::: як роздільний рядок. Корисно, якщо ::: використовується для
щось інше за командою.

Також корисно, якщо ви використовуєте команду ::: але ви все одно хочете прочитати аргументи з
stdin (стандартний вхід): просто змінити --арг-вер до рядка, якого немає в
command line.

Див також: :::.

-- бар Показувати прогрес як індикатор виконання. На панелі показано: % виконаних робіт,
Залишилося приблизно секунди та кількість розпочатих завдань.

Він сумісний з зенітність:

послідовність 1000 | parallel -j30 --bar '(echo {};sleep 0.1)' 2> >(zenity --progress
--автоматичне вбивство) | туалет

--базовий файл файл
--bf файл
файл буде передано до кожного sshlogin перед запуском завдань. Це буде
видалено, якщо --прибирати є активним. Файл може бути скриптом для запуску або якимось загальним
базові дані, необхідні для роботи. Кілька --bf можна вказати, щоб передати більше
базові файли. The файл буде передано так само, як --перенесення.

--basenameplace замінити-вул
--бнр замінити-вул
Використовуйте рядок для заміни замінити-вул замість {/} для базового імені рядка введення.

--basenameextensionreplace замінити-вул
--бнер замінити-вул
Використовуйте рядок для заміни замінити-вул замість {/.} для базового імені рядка введення
без розширення.

--bg Виконайте команду у фоновому режимі, таким чином GNU паралельно не буде чекати завершення
команда перед виходом. Це значення за замовчуванням, якщо --семафор встановлено.

Див також: --fg, людина без.

Має на увазі --семафор.

--бібтекс Роздрукуйте запис BibTeX для GNU паралельно і вимкнути сповіщення про цитування.

--блок розмір
--розмір блоку розмір
Розмір блоку в байтах. Розмір можна постфіксувати за допомогою K, M, G, T, P, k, m, g, t,
або p, який помножить розмір на 1024, 1048576, 1073741824, 1099511627776,
1125899906842624, 1000, 1000000, 1000000000, 1000000000000 або 1000000000000000
відповідно.

GNU паралельно намагається відповідати розміру блоку, але може бути відхилений на довжину одного
запис. З міркувань продуктивності розмір має бути більшим за один запис.

розмір за замовчуванням 1М.

Читати --труба для використання цього.

-- кіт Створіть тимчасовий файл із вмістом. Зазвичай --труба надасть дані до
програма на stdin (стандартний введення). З -- кіт GNU паралельно створить
тимчасовий файл з назвою в {}, щоб ви могли: паралельно --труба -- кіт wc {}.

Дивіться також --fifo.

--прибирати
Видаліть передані файли. --прибирати видалить передані файли на
віддалений комп’ютер після завершення обробки.

знайти ім'я журналу '*gz' | паралельний \
--sshlogin server.example.com --transfer --return {.}.bz2 \
--cleanup "zcat {} | bzip -9 >{.}.bz2"

З --перенесення файл, переданий на віддалений комп’ютер, буде видалено
віддалений комп'ютер. Створені каталоги не будуть видалені, навіть якщо вони є
порожній.

З --повернення файл, переданий з віддаленого комп’ютера, буде видалено
віддалений комп'ютер. Створені каталоги не будуть видалені, навіть якщо вони є
порожній.

--прибирати ігнорується, якщо не використовується з --перенесення or --повернення.

--colsep RegExp
-C RegExp
Роздільник колонок. Вхід буде розглядатися як таблиця з RegExp відокремлення
колонки. Доступ до n-го стовпця можна отримати за допомогою {n} or {n.}. Напр 3 {} є 3-м
колонка.

--colsep мається на увазі -- обрізати rl.

RegExp є регулярним виразом Perl: http://perldoc.perl.org/perlre.html

-- стиснути
Стисніть тимчасові файли. Якщо вихід великий і дуже стисливий, це буде
займати менше місця на диску в $TMPDIR і, можливо, бути швидшим через менше дискового вводу-виводу.

GNU паралельно буде намагатися lzop, порося, gzip, pbzip2, plzip, bzip2, лзма, lzip, xz in
цього порядку та використовуйте перший доступний.

--compress-програма пр
--декомпрес-програма пр
Скористайтесь пр для (де)стиснення тимчасових файлів. Передбачається, що пр -dc волі
розпакуйте stdin (стандартний вхід) у stdout (стандартний вихід), якщо
--декомпрес-програма дається.

--ctrlc Відправляє SIGINT завданням, що виконуються на віддалених комп’ютерах, таким чином вбиваючи їх.

--розділювач розмежувати
-d розмежувати Елементи введення закінчуються вказаним символом. Лапки та зворотний слеш є
не особливий; кожен символ у вводі сприймається буквально. Вимикає кінець-
рядок файлу, який розглядається як будь-який інший аргумент. Це можна використовувати, коли
вхідні дані складаються з елементів, розділених новим рядком, хоча це майже так
завжди краще розробити свою програму для використання --null там, де це можливо. The
зазначений роздільник може бути одним символом, екрануванням символу в стилі C, наприклад
\n або вісімковий або шістнадцятковий escape-код. Вісімкові та шістнадцяткові escape-коди
розуміються як для команди printf. Багатобайтові символи не є
підтримується.

--dirnamereplace замінити-вул
--dnr замінити-вул
Використовуйте рядок для заміни замінити-вул замість {//} для імені рядка введення.

-E еоф-вул
Встановіть кінець рядка файлу на eof-str. Якщо кінець рядка файлу зустрічається як a
рядок введення, решта введених даних ігнорується. Якщо ні -E ні -e використовується,
не використовується кінець рядка файлу.

--затримка сухий
Затримка початку наступної роботи сухий секунд. GNU паралельно зупиниться сухий через секунди
розпочинаючи кожну роботу. сухий може бути менше 1 секунди.

--сушить
Роздрукуйте завдання для виконання на стандартному виводі (стандартний вихід), але не запускайте завдання. Використовуйте -v
-v щоб включити обтікання ssh/rsync, якщо завдання виконуватиметься на віддаленому пристрої
комп'ютер. Однак не розраховуйте на це буквально, оскільки робота може бути запланована
інший комп’ютер або локальний комп’ютер, якщо : є у списку.

--eof[=еоф-вул]
-e[еоф-вул]
Цей варіант є синонімом до -E варіант. Використовуйте -E натомість, тому що це POSIX
сумісний для ксарг а цього варіанту немає. Якщо еоф-вул пропущено, немає
кінець рядка файлу. Якщо ні -E ні -e використовується, кінець рядка файлу не використовується.

-Env було (альфа-тестування)
Копіювати змінну середовища було. Це буде копіювати було до середовища, яке
запущена команда. Це особливо корисно для віддаленого виконання.

В Bash було також може бути функцією Bash - просто не забувайте про це експорт -f
функція, див команда.

Змінна '_' є особливою. Він скопіює всі змінні середовища, за винятком
ті, які згадуються в ~/.parallel/ignored_vars.

Щоб скопіювати масиви Bash, вам потрібна функція імпорту, оскільки масиви Bash бути не можуть
експортовано:

import_array () {
local func=$1; зміна;
експорт $func='() {
'"$(для arr в $@; до
declare -p $arr|sed '1s/declare -./&g/'
зроблено)"'
}'
}

declare -A assoc='([one]="1" [two]="2")'
declare -a indexed='([0]="один" [1]="два")'

import_array my_importer assoc індексовано

parallel --env мій_імпортер \
'my_importer; echo "{}" "${indexed[{}]}" "${assoc[${indexed[{}]}]}" ::: "${!indexed[@]}"

Щоб скопіювати повне середовище, скористайтеся цією функцією (наприклад, помістивши її в .bashrc):

env_parallel() {
експорт parallel_bash_environment='() {
'"$(echo "shopt -s expand_aliases 2>/dev/null"; псевдонім;typeset -p | grep -vFf <(лише для читання; echo GROUPS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_;набір -f)"'
}'
# Запустити як: env_parallel [звичайні паралельні параметри]
`яка паралельна` "$@"
скасувати параметр parallel_bash_environment
}
# дзвонити як:
env_parallel [звичайні паралельні параметри]

Див також: --record-env.

--ета Покажіть приблизну кількість секунд до завершення. Це змушує GNU паралельно
щоб прочитати всі вакансії, перш ніж почати знаходити кількість вакансій. GNU паралельно
зазвичай читає лише наступне завдання для виконання. Має на увазі -- прогрес.

--fg Виконайте команду на передньому плані, таким чином GNU паралельно буде чекати завершення
команда перед виходом.

Дивіться також --bg, людина без.

Має на увазі --семафор.

--fifo Створіть тимчасовий fifo з вмістом. Зазвичай --труба надасть дані до
програма на stdin (стандартний введення). З --fifo GNU паралельно створить
тимчасовий fifo з назвою в {}, щоб ви могли робити: паралельно --труба --fifo wc {}.

Увага: якщо дані не зчитуються з fifo, завдання буде заблоковано назавжди.

Дивіться також -- кіт.

-- filter-hosts
Видаліть хости. Для кожного віддаленого хоста: перевірте, чи працює вхід через ssh. Якщо
ні: не використовуйте цей хост.

Наразі ви можете НЕ put -- filter-hosts у профілі, $PARALLEL,
/etc/parallel/config або подібне. Це тому, що GNU паралельно використовує GNU паралельно
щоб обчислити це, ви отримаєте нескінченний цикл. Ймовірно, це буде виправлено в a
пізніше випуск.

--gnu Поводьтеся як GNU паралельно. Цей варіант історично мав перевагу --tollef.
Команда --tollef наразі цей параметр вилучено, тому його не можна використовувати. --gnu зберігається
для сумісності.

--група Груповий вихід. Вихідні дані кожного завдання групуються разом і друкуються лише тоді, коли
команда закінчена. stderr (стандартна помилка), а потім stdout
(стандартний вихід). Це займає деякий час процесора. У рідкісних ситуаціях GNU паралельно
займає багато часу процесора, і якщо це допустимо, виходи з різних
команди змішуються разом, а потім вимикається групування за допомогою -u може прискорити GNU
паралельно в 10 рази.

--група є за замовчуванням. Можна перевернути за допомогою -u.

Див також: --рядковий буфер --розгрупувати

--допомога
-h Роздрукуйте підсумок параметрів для GNU паралельно і вийти.

--зупинка під час помилки Val
--зупинка Val
Як має GNU паралельно припинити роботу, якщо одна з кількох завдань не вдається?

0 Не зупиняйтеся, якщо завдання не вдається. Статус виходу – це кількість невиконаних завдань.
Це значення за замовчуванням.

1 Не починайте нові завдання, якщо завдання не вдається, а завершите поточні завдання
включаючи очищення. Статус виходу буде статусом виходу з останнього
невдала робота.

2 Негайно припиніть усі завдання та вийдіть без очищення. Статус виходу
буде статусом виходу з невдалого завдання.

1-99% Якщо Val% завдань невдало і мінімум 3: Не починайте нові роботи, але
завершити поточні роботи, включаючи очищення. Статус виходу буде
статус виходу з останнього невдалого завдання.

--заголовок RegExp
Використовуйте регулярний вираз як заголовок. Для нормального використання відповідний заголовок (зазвичай перший
лінія: --заголовок '.*\n') буде розділено за допомогою --colsep (який за замовчуванням буде '\t')
і назви стовпців можна використовувати як замінні змінні: {колонка ім'я}.

для --труба відповідний заголовок буде доданий до кожного виходу.

--заголовок : є псевдонімом для --заголовок '.*\n'.

If RegExp це число, воно відповідатиме такій кількості рядків.

-I замінити-вул
Використовуйте рядок для заміни замінити-вул замість {}.

--замінити[=замінити-вул]
-i[замінити-вул]
Цей варіант є синонімом для -Iзамінити-вул if замінити-вул вказано, а для
-I{} інакше. Ця опція не підтримується; використання -I замість цього.

--блог файл журналу
Журнал для виконаних завдань. Збережіть список виконаних завдань у файл журналу в
наступний формат, розділений TAB: порядковий номер, sshlogin, час початку в секундах
з епохи, час виконання в секундах, байти в переданих файлах, байти у файлах
повернуто, статус виходу, сигнал і виконання команди.

Щоб перевести час у суворий стандарт ISO-8601, виконайте:

Perl -a -F"\t" -не 'chomp($F[2]=`дата -d \@$F[2] +%FT%T`); друк join("\t",@F)'

Дивіться також --резюме.

-- робочі місця N
-j N
--max-proc N
-P N Кількість робочих місць. Виконуйте до N завдань паралельно. 0 означає якомога більше.
За замовчуванням встановлено значення 100%, що дозволяє виконувати одне завдання на ядро ​​ЦП.

If --семафор встановлено за замовчуванням 1, таким чином створюється мьютекс.

-- робочі місця +N
-j +N
--max-proc +N
-P +N Додайте N до кількості ядер ЦП. Виконуйте багато завдань паралельно. Дивіться також
--використання-cpus-замість ядер.

-- робочі місця -N
-j -N
--max-proc -N
-P -N Відніміть N від кількості ядер ЦП. Виконуйте багато завдань паралельно. Якщо
оцінене число менше 1, то буде використано 1. Дивіться також
--використання-cpus-замість ядер.

-- робочі місця N%
-j N%
--max-proc N%
-P N% Помножте N% на кількість ядер ЦП. Виконуйте багато завдань паралельно. Подивитися
Також --використання-cpus-замість ядер.

-- робочі місця профіль
-j профіль
--max-proc профіль
-P профіль
Прочитати параметр з файлу. Використовуйте вміст профіль як параметр для -j. Напр
профіль може містити рядок 100% або +2 або 10. Якщо профіль змінюється, коли a
робота завершена, профіль зчитується ще раз і обчислюється нова кількість робочих місць. Якщо
це число менше, ніж раніше, запущені завдання можна буде завершити, але нові
завдання не будуть розпочаті, доки не буде досягнуто бажаної кількості робочих місць. Це
дозволяє змінювати кількість одночасних виконуваних завдань під час GNU
паралельно біжить.

-- дотримуватись порядку
-k Зберігайте послідовність виводу так само, як і порядок введення. Зазвичай результат роботи
буде надруковано, щойно завдання завершиться. Спробуйте це, щоб побачити різницю:

паралельно -j4 сон {}\; echo {} ::: 2 1 4 3
паралельний -j4 -k сон {}\; echo {} ::: 2 1 4 3

Якщо використовується з --один усе or --не всі вихід буде згрупований за sshlogin у відсортованих
порядку.

-L макс-лінії
При використанні з --труба: Прочитати записи про макс-лінії.

При іншому використанні: використовувати щонайбільше макс-лінії непусті рядки введення в командному рядку.
Закінчення пробілів призводить до того, що рядок введення логічно продовжується на наступному введенні
лінія.

-L 0 означає прочитати один рядок, але вставити 0 аргументів у командний рядок.

Має на увазі -X якщо не -m, --xargsабо --труба встановлено.

--max-рядків[=макс-лінії]
-l[макс-лінії]
При використанні з --труба: Прочитати записи про макс-лінії.

Якщо використовується інакше: Синонім до -L варіант. На відміну від -L, макс-лінії
аргумент необов'язковий. Якщо макс-лінії не вказано, за замовчуванням має значення один. The -l
Опція не підтримується, оскільки стандарт POSIX визначає -L замість цього.

-l 0 є псевдонімом для -l 1.

Має на увазі -X якщо не -m, --xargsабо --труба встановлено.

--рядковий буфер
Буферний вихід на лінійній основі. --група збереже вихід разом для цілого
роботу. --розгрупувати дозволяє змішувати вихід з половиною рядка, що надходить від одного завдання і
половина рядка з іншої роботи. --рядковий буфер підходить між цими двома: GNU
паралельно надрукує повний рядок, але дозволить змішувати різні рядки
робочих місць.

--рядковий буфер займає більше потужності процесора, ніж обидва --група та --розгрупувати, але можна
бути швидше ніж --група якщо центральний процесор не є обмежуючим фактором.

Див також: --група --розгрупувати

-- навантаження максимальне навантаження
Не запускайте нові завдання на даному комп'ютері, якщо не кількість запущених процесів
на комп'ютері менше ніж максимальне навантаження. максимальне навантаження використовує той самий синтаксис, що й -- робочі місця,
so 100% для одного на ЦП є дійсним налаштуванням. Єдина різниця в 0, що є
інтерпретується як 0.01.

-- диспетчер
-M Використовуйте ControlMaster ssh, щоб зробити з’єднання ssh швидше. Корисно, якщо завдання виконуються віддалено
і дуже швидко бігають. Це вимкнено для sshlogins, які вказують свої власні
команда ssh.

--xargs Кілька аргументів. Вставте стільки аргументів, скільки дозволяє довжина командного рядка.

If {} не використовується, аргументи будуть додані до рядка. Якщо {} використовується
кілька разів кожен {} буде замінено всіма аргументами.

Підтримка --xargs з --sshlogin обмежений і може вийти з ладу.

Дивіться також -X для заміни контексту. Якщо сумніваєтеся, використовуйте -X як це, швидше за все, буде
що потрібно.

-m Кілька аргументів. Вставте стільки аргументів, скільки дозволяє довжина командного рядка.
Якщо паралельно виконується кілька завдань: рівномірно розподіліть аргументи між ними
робочі місця. Використовуйте -j1 щоб уникнути цього.

If {} не використовується, аргументи будуть додані до рядка. Якщо {} використовується
кілька разів кожен {} буде замінено всіма аргументами.

Підтримка -m з --sshlogin обмежений і може вийти з ладу.

Дивіться також -X для заміни контексту. Якщо сумніваєтеся, використовуйте -X як це, швидше за все, буде
що потрібно.

--мінверсія версія
Роздрукуйте версію GNU паралельно і вийти. Якщо поточна версія GNU паралельно
менше, ніж версія код виходу 255. В іншому випадку це 0.

Це корисно для сценаріїв, які залежать від функцій, доступних лише з певних
версія GNU паралельно.

--не всі (бета-тестування)
--один усе без аргументів. Виконайте команду на всіх комп’ютерах, заданих за допомогою --sshlogin
але без аргументів. GNU паралельно увійде в систему -- робочі місця кількість комп'ютерів в
паралельно і запустити завдання на комп’ютері. -j налаштовує кількість комп’ютерів для реєстрації
в паралельно.

Це корисно для виконання тієї ж команди (наприклад, безперервної роботи) у списку серверів.

--один усе (бета-тестування)
Виконайте всі завдання на всіх комп’ютерах, наданих з --sshlogin. GNU паралельно буде журнал
в -- робочі місця кількість комп’ютерів паралельно і виконувати одне завдання за раз на
комп'ютер. Порядок завдань не буде змінено, але деякі комп’ютери можуть
закінчити раніше інших. -j налаштовує кількість комп’ютерів для паралельного входу.

При використанні --група вихід буде згрупований кожним сервером, отже, весь вихід
з одного сервера будуть згруповані разом.

--виведення-як-файли
-- вихідні файли
--файли Замість друку результатів у стандартний вихід (стандартний висновок) результат кожного завдання
зберігається у файлі, а потім друкується ім’я файлу.

--труба
--spreadstdin
Розповсюджувати введення до завдань на stdin (стандартний вхід). Зчитування блоку даних із stdin
(стандартний вхід) і надати один блок даних як вхід для одного завдання.

Розмір блоку визначається --блок. Струни --перезапустіть та --останнє сказати
GNU паралельно як починається та/або закінчується запис. Читання блоку буде остаточним
частковий запис видалено до того, як блок буде передано до роботи. Часткове
запис буде додано до наступного блоку.

If --перезапустіть вказано, що це буде використано для поділу на початку запису.

If --останнє вказано, що це буде використано для поділу в кінці запису.

Якщо обоє --перезапустіть та --останнє дано, обидва повинні збігатися, щоб знайти поділ
положення.

Якщо ні --перезапустіть ні --останнє дані --останнє за замовчуванням '\n'. Мати
не використовується роздільник записів --останнє "".

--файли часто використовується з --труба.

Див також: --перезапустіть, --останнє, --fifo, -- кіт, -- трубопровідна частина.

-- трубопровідна частина (бета-тестування)
Конвейерні частини фізичного файлу. -- трубопровідна частина працює схоже на --труба, але багато
швидше. Він має кілька обмежень:

* Файл має бути фізичним (доступним для пошуку) і має бути наданий за допомогою -a or
::::.

* Підрахунок записів (-N) і підрахунок рядків (-L/-l) не працюють.

-- звичайний Ігноруйте будь-які --профіль, $PARALLEL і ~/.parallel/config щоб отримати повний контроль
командний рядок (використовується GNU паралельно внутрішньо при виклику з --sshlogin).

--плюс Активувати додаткові рядки заміни: {+/} {+.} {+..} {+...} {..} {...} {/ ..}
{/...}. Ідея полягає в тому, що '{+foo}' відповідає протилежності '{foo}' і {} =
{+/}/{/} = {.}.{+.} = {+/}/{/.}.{+.} = {..}.{+..} = {+/}/{/ ..}.{+..} =
{...}.{+...} = {+/}/{/...}.{+...}

-- прогрес
Показати хід обчислень. Перелічіть комп’ютери, які беруть участь у виконанні завдання
кількість виявлених ядер ЦП і максимальна кількість завдань для виконання. Після цього шоу
прогрес для кожного комп’ютера: кількість виконуваних завдань, кількість виконаних завдань і
відсоток усіх робіт, виконаних цим комп’ютером. Відсоток буде тільки
доступний після того, як усі завдання були заплановані як GNU паралельно читайте лише наступне
завдання, коли ви готові запланувати його - це означає, що ви не витрачаєте на це час і пам'ять
читати все під час запуску.

Надіславши GNU паралельно SIGUSR2 можна вмикати/виключати -- прогрес на
запуск GNU паралельно процесу.

Дивіться також --ета.

--max-args=max-args
-n max-args
Використовуйте щонайбільше max-args аргументів у командному рядку. Менше ніж max-args аргументація
буде використовуватися, якщо розмір (див -s варіант) перевищено, якщо не -x опція
дано, у цьому випадку GNU паралельно вийде.

-n 0 означає прочитати один аргумент, але вставити 0 аргументів у командний рядок.

Має на увазі -X якщо не -m встановлено.

--max-replace-args=max-args
-N max-args
Використовуйте щонайбільше max-args аргументів у командному рядку. Подібно до -n але й робить
змінні струни 1 {} .. {max-args} що представляє аргумент 1 .. max-args. Якщо
занадто мало аргументів {n} буде порожнім.

-N 0 означає прочитати один аргумент, але вставити 0 аргументів у командний рядок.

Це встановить власника домашнього каталогу для користувача:

tr ':' '\ n' < / etc / passwd | паралельно - 7 N Чаун 1 {} 6 {}

Має на увазі -X якщо не -m or --труба встановлено.

При використанні з --труба -N – кількість записів для читання. Це дещо
повільніше, ніж --блок.

--max-line-length-allowed
Надрукуйте максимальну кількість символів, дозволених у командному рядку, і вийдіть (використовується
від GNU паралельно для визначення довжини рядка на віддалених комп’ютерах).

--кількість процесора
Надрукувати кількість фізичних процесорів і вийти (використовується GNU паралельно себе до
визначити кількість фізичних процесорів на віддалених комп’ютерах).

--кількість ядер
Надрукувати кількість ядер ЦП і вийти (використовується GNU паралельно сама визначити
кількість ядер ЦП на віддалених комп’ютерах).

--не помічаємо
Не відображати повідомлення про цитування. Повідомлення про цитату друкується на stderr (стандартний
помилка), лише якщо stderr (стандартна помилка) є терміналом, який користувач не вказав
--не помічаємо, і користувач не запустився --бібтекс один раз

--приємно приємність
Виконайте команду на цьому місці. Для простих команд ви можете просто додати приємно in
перед командою. Але якщо команда складається з кількох підкоманд (наприклад:
ls|wc) потім додавання приємно не завжди буде працювати. --приємно переконається, що всі підп
команди гарні.

--інтерактивні
-p Підказувати користувачеві, чи запускати кожен командний рядок і читати рядок із файлу
термінал. Запустіть командний рядок, лише якщо відповідь починається з «y» або «Y».
Має на увазі -t.

--батьки Parensstring
Використовуйте для визначення початкових і кінцевих дужок для {= Perl вираз =}. Ліва і
права дужка може містити кілька символів і вважається однаковою
довжина. За замовчуванням є {==} дає {= як початкова дужка і =} як кінець
дужки.

Ще одна корисна настройка ,,,, що склало б обидві дужки ,,:

parallel --parens ,,,, echo foo це ,,s/I/O/g,, ::: FII

Див також: --rpl {= Perl вираз =}

--профіль Імя профілю
-J Імя профілю
Використовуйте профіль Імя профілю для варіантів. Це корисно, якщо ви хочете мати кілька
профілі. Ви можете мати один профіль для паралельного виконання завдань на локальному сервері
комп’ютер і інший профіль для виконання завдань на віддалених комп’ютерах. Див
розділ ПРОФІЛЬНІ ФАЙЛИ для прикладів.

Імя профілю відповідає файлу ~/.parallel/Імя профілю.

Ви можете надати кілька профілів, повторюючи --профіль. Якщо частини профілів
конфлікту, будуть використані пізніші.

За замовчуванням: конфігурація

--цитата
-q Quote команда. Командний рядок буде в лапках, тому спеціальні символи не будуть
інтерпретується оболонкою. Дивіться розділ ЦИТАННЯ. Більшості людей ніколи не знадобиться
це Цитування вимкнено за замовчуванням.

--не-виконати-якщо-пусто
-r Якщо stdin (стандартний введення) містить лише пробіли, не запускайте команду.

Якщо використовується з --труба це повільно.

--noswap Не починайте нові завдання на даному комп’ютері, якщо є і заміна, і заміна
діяльності.

Дія свопу відбирається лише кожні 10 секунд, оскільки вибірка займає 1 секунду
робити.

Активність обміну обчислюється як (swap-in)*(swap-out), що на практиці є хорошим
значення: заміна не є проблемою, заміна не є проблемою, але обидва
Заміна місцями зазвичай вказує на проблему.

--record-env
Запишіть поточні змінні середовища в ~/.parallel/ignored_vars. Це корисно
Перед використанням -Env _.

Дивіться також -Env.

--перезапустіть початковий рядок
--останнє кінцевий рядок
If --перезапустіть дається початковий рядок буде використовуватися для поділу на початку запису.

If --останнє дається кінцевий рядок буде використовуватися для поділу в кінці запису.

Якщо обоє --перезапустіть та --останнє дається комбінований рядок
кінцевий рядокпочатковий рядок доведеться збігтися, щоб знайти роздільну позицію. Це корисно
якщо будь-який початковий рядок or кінцевий рядок матч у середині запису.

Якщо ні --перезапустіть ні --останнє даються тоді --останнє за замовчуванням '\n'. До
не використовувати роздільник записів --останнє "".

--перезапустіть та --останнє використовуються з --труба.

Скористайтесь --регулярний вираз тлумачити --перезапустіть та --останнє як регулярні вирази. Це
повільно, однак.

--регулярний вираз Скористайтесь --регулярний вираз тлумачити --перезапустіть та --останнє як регулярні вирази. Це
повільно, однак.

--remove-rec-sep
--removerecsep
--rrs Видаліть текст, який відповідає --перезапустіть та --останнє перед тим як передати його до
команда

Використовується тільки з --труба.

--результати префікс
--рез префікс
Збережіть результат у файли. Файли будуть зберігатися в кореневому дереві каталогів
at префікс. У цьому дереві каталогів кожна команда призведе до двох файлів:
префікс/ /stdout і префікс/ /stderr, де є послідовністю
каталоги, що представляють заголовок джерела введення (якщо використовується --заголовок :) Або
номер вхідного джерела та відповідні значення.

Наприклад:

parallel --header : --results foo echo {a} {b} ::: a I II ::: b III IIII

згенерує файли:

foo/a/I/b/III/stderr
foo/a/I/b/III/stdout
foo/a/I/b/IIII/stderr
foo/a/I/b/IIII/stdout
foo/a/II/b/III/stderr
foo/a/II/b/III/stdout
foo/a/II/b/IIII/stderr
foo/a/II/b/IIII/stdout

та

parallel --results foo echo {1} {2} ::: I II ::: III IIII

згенерує файли:

foo/1/I/2/III/stderr
foo/1/I/2/III/stdout
foo/1/I/2/IIII/stderr
foo/1/I/2/IIII/stdout
foo/1/II/2/III/stderr
foo/1/II/2/III/stdout
foo/1/II/2/IIII/stderr
foo/1/II/2/IIII/stdout

Дивіться також --файли, --заголовок, --блог.

--резюме Резюме з останньої незавершеної роботи. Читаючи --блог або --результати реж
GNU паралельно з'ясує останню незавершену роботу і продовжить звідти. Як
GNU паралельно дивиться лише на порядкові номери в --блог потім вхід,
командування, і --блог все повинно залишитися незмінним; інакше GNU паралельно може
виконувати неправильні команди.

Дивіться також --блог, --результати, --відновити-не вдалося.

--відновити-не вдалося
Повторити всі спроби не вдалося, і відновіть роботу з останньої незавершеної роботи. Читаючи --блог GNU
паралельно з’ясує невдалі завдання та запустить їх знову. Після цього буде
відновити останню незавершену роботу і продовжити звідти. Як GNU паралельно тільки дивиться
порядкові номери в --блог потім вхід, команда і --блог всі
повинні залишатися незмінними; інакше GNU паралельно може виконувати неправильні команди.

Дивіться також --блог, --резюме.

--повторна спроба n
Якщо завдання не вдається, повторіть його на іншому комп’ютері, на якому воно не завершилося. Зробити це
n разів. Якщо їх менше ніж n комп'ютери в --sshlogin GNU паралельно буде повторно
використовувати всі комп’ютери. Це корисно, якщо деякі завдання зазнають невдачі без видимих ​​причин
(наприклад, збій мережі).

--повернення ім'я файлу
Передача файлів з віддалених комп’ютерів. --повернення використовується з --sshlogin коли
аргументи — це файли на віддалених комп’ютерах. Після завершення обробки файлу
ім'я файлу буде передано з віддаленого комп’ютера за допомогою rsync і буде поставлено
відносно каталога входу за замовчуванням. напр

echo foo/bar.txt | паралельний \
--sshlogin server.example.com --return {.}.out торкніться {.}.out

Це перенесе файл $HOME/foo/bar.out з комп'ютера
server.example.com до файлу foo/bar.out після бігу торкатися foo/bar.out on
server.example.com.

echo /tmp/foo/bar.txt | паралельний \
--sshlogin server.example.com --return {.}.out торкніться {.}.out

Це перенесе файл /tmp/foo/bar.out з комп'ютера server.example.com
до файлу /tmp/foo/bar.out після бігу торкатися /tmp/foo/bar.out on
server.example.com.

Кілька файлів можна передати, повторюючи параметри кілька разів:

echo /tmp/foo/bar.txt | \
parallel --sshlogin server.example.com \
--return {.}.out --return {.}.out2 дотик {.}.out {.}.out2

--повернення часто використовується з --перенесення та --прибирати.

--повернення ігнорується при використанні з --sshlogin : або коли не використовується з --sshlogin.

--кругової
-- круглий Зазвичай --труба дасть один блок кожному екземпляру команди. З
--кругової всі блоки будуть випадковим чином записані до вже запущених команд.
Це корисно, якщо команді потрібно багато часу для ініціалізації.

-- дотримуватись порядку не працюватиме з --кругової оскільки неможливо відстежити який
блок входу відповідає якому виходу.

--rpl 'тег Perl вираз'
Скористайтесь тег як рядок для заміни Perl вираз. Це дає можливість
визначити власні рядки заміни. GNU паралельно7 замінних рядків
реалізовано як:

--rpl '{}'
--rpl '{#} 1 $_=$job->seq()'
--rpl '{%} 1 $_=$job->slot()'
--rpl '{/} s:.*/::'
--rpl '{//} $Global::use{"File::Basename"} ||= eval "використовувати File::Basename; 1;"; $_ = ім'я користувача ($_);'
--rpl '{/.} s:.*/::; s:\.[^/.]+$::;'
--rpl '{.} s:\.[^/.]+$::'

Якщо визначений користувачем рядок заміни починається з '{', його також можна використовувати як a
рядок заміни позицій (наприклад {2.}).

Рекомендується змінити лише $_, але ви маєте повний доступ до всього GNU
паралельновнутрішні функції та структури даних.

Ось кілька прикладів.

Видаліть 2 розширення (наприклад, .tar.gz)
--rpl '{..} s:\.[^/.]+$::;s:\.[^/.]+$::;'
Залиште лише розширення
--rpl '{ext} s:.*\.::'
Послідовність роботи парна чи непарна?
--rpl '{odd} $_=$job->seq()%2?"odd":"even"'

Див також: {= Perl вираз =} --батьки

--max-символів=макс. символів
-s макс. символів
Використовуйте щонайбільше макс. символів символів у командному рядку, включаючи команду і
початкові аргументи та кінцеві нулі на кінцях рядків аргументів.
Найбільше дозволене значення залежить від системи і обчислюється як аргумент
обмеження довжини для exec, за вирахуванням розміру вашого середовища. Значення за замовчуванням таке
максимум.

Має на увазі -X якщо не -m встановлено.

--показувати межі
Відобразити обмеження на довжину командного рядка, які накладаються операцією
системи та -s варіант. Передайте вхідні дані з /dev/null (і, можливо, вкажіть
--no-run-if-empty), якщо ви не хочете GNU паралельно робити що-небудь.

--семафор
Робота як лічильний семафор. --семафор спричинить GNU паралельно , Щоб почати
команда у фоновому режимі. Коли буде досягнуто кількість одночасних завдань, GNU
паралельно чекатиме завершення однієї з них, перш ніж запускати іншу команду.

--семафор мається на увазі --bg якщо не --fg вказано.

--семафор мається на увазі --семафорна назва `tty` якщо не --семафорна назва вказано.

Використовується з --fg, -- зачекайте та --семафорна назва.

Команда без є псевдонімом для паралельно --семафор.

Дивіться також людина без.

--семафорна назва ім'я
--id ім'я
Скористайтесь ім'я як назва семафора. За замовчуванням – це ім’я контрольного tty
(вихід з tty).

За замовчуванням зазвичай працює належним чином, якщо використовується в інтерактивному режимі, але коли використовується в
скрипт ім'я слід встановити. $$ or ім'я мого_завдання часто є гарною ціною.

Семафор зберігається в ~/.parallel/semaphore/

Має на увазі --семафор.

Дивіться також людина без.

--тайм-аут семафору сухий
Якщо семафор не звільняється протягом кількох секунд, все одно скористайтеся ним.

Має на увазі --семафор.

Дивіться також людина без.

--seqreplace замінити-вул
Використовуйте рядок для заміни замінити-вул замість {#} для порядкового номера роботи.

--шебанг
-- хешбанг
GNU паралельно можна викликати як команду shebang (#!) як перший рядок a
сценарій. Вміст файлу буде розглядатися як джерело введення.

Подобається це:

#!/usr/bin/parallel --shebang -r traceroute

foss.org.my
debian.org
freenetproject.org

--шебанг необхідно встановити як перший варіант.

На FreeBSD env потрібен:

#!/usr/bin/env -S паралельно --shebang -r трасування

foss.org.my
debian.org
freenetproject.org

-- shebang-wrap
GNU паралельно може паралелізувати сценарії, обгортаючи лінію shebang. Якщо програма
можна запустити так:

котячі аргументи | паралельно_програмі

тоді сценарій можна змінити на:

#!/usr/bin/parallel --shebang-wrap /the/original/parser --with-options

Напр

#!/usr/bin/parallel --shebang-wrap /usr/bin/python

Якщо програму можна запустити так:

дані про кішку | parallel --pipe the_program

тоді сценарій можна змінити на:

#!/usr/bin/parallel --shebang-wrap --pipe /the/original/parser --with-options

Напр

#!/usr/bin/parallel --shebang-wrap --pipe /usr/bin/perl -w

-- shebang-wrap необхідно встановити як перший варіант.

--цитата оболонки
Не запускає команду, а цитує її. Корисно для створення цитованих композицій
команди для GNU паралельно.

--пропустити перший рядок
Не використовуйте перший рядок введення (використовується GNU паралельно себе при виклику з
--шебанг).

--sshзатримка сухий
Затримка початку наступного ssh на сухий секунд. GNU паралельно зупиниться сухий seconds
після запуску кожного ssh. сухий може бути менше 1 секунди.

-S [ncpu/]sshlogin[,[ncpu/]sshlogin[,...]]
--sshlogin [ncpu/]sshlogin[,[ncpu/]sshlogin[,...]]
Розподіл завдань на віддалені комп’ютери. Завдання виконуватимуться у списку віддаленого доступу
комп'ютери. GNU паралельно визначить кількість ядер ЦП на пульті
комп’ютерів і запустіть кількість завдань відповідно до -j. Якщо число ncpu is
дано GNU паралельно використовуватиме це число для кількості ядер ЦП на хості.
Зазвичай ncpu не знадобиться.

An sshlogin має вигляд:

[sshcommand [параметри]] [ім'я користувача@]ім'я хоста

sshlogin не повинен вимагати пароль.

sshlogin ':' є особливим, він означає 'no ssh' і, отже, буде працювати на
локальний комп'ютер.

sshlogin '..' є особливим, він читає sshlogins ~/.parallel/sshloginfile

Sshlogin '-' також є особливим, він читає sshlogins з stdin (стандартний введення).

Щоб указати більше sshlogins, розділіть sshlogins комою або повторіть параметри
кілька разів.

Для прикладів: див --sshloginfile.

Віддалений хост повинен мати GNU паралельно встановлений.

--sshlogin відомо, що викликає проблеми з -m та -X.

--sshlogin часто використовується з --перенесення, --повернення, --прибирати та --trc.

--sshloginfile ім'я файлу (бета-тестування)
--slf ім'я файлу (бета-тестування)
Файл з sshlogins. Файл складається з sshlogins в окремих рядках. Порожній
рядки та рядки, що починаються з '#', ігноруються. приклад:

server.example.com
[захищено електронною поштою]
8/my-8-core-server.example.com
2/[захищено електронною поштою]
# На цьому сервері працює протокол SSH на порту 2222
ssh -p 2222 server.example.net
4/ssh -p 2222 quadserver.example.net
# Використовуйте іншу програму ssh
myssh -p 2222 -l myusername hexacpu.example.net
# Використовуйте іншу програму ssh з кількістю ядер за замовчуванням
//usr/local/bin/myssh -p 2222 -l myusername hexacpu.example.net
# Використовуйте іншу програму ssh з 6 ядрами
6//usr/local/bin/myssh -p 2222 -l myusername hexacpu.example.net
# Припустимо, що на локальному комп'ютері 16 ядер
16/:

При використанні іншої програми ssh останнім аргументом має бути ім’я хоста.

множинний --sshloginfile дозволені.

GNU паралельно спочатку шукатиме файл у поточному каталогу; якщо це не вдасться, подивіться
для файлу в ~/.паралельно.

Файл sshlogin '..' є особливим, він читає sshlogins ~/.parallel/sshloginfile

Файл sshlogin '.' є особливим, він читає sshlogins з
/etc/parallel/sshloginfile

Файл sshlogin '-' також є особливим, він читає sshlogins з stdin (стандартний
введення).

Якщо файл sshlogin змінено, він буде повторно прочитаний, коли завдання завершиться, хоча на
найчастіше раз на секунду. Це дає можливість додавати та видаляти хости
працює.

Це можна використовувати, щоб мати демон, який оновлює sshloginfile лише так, щоб він містив
сервери, які працюють:

cp original.slf tmp2.slf
в той час як [ 1 ] ; робити
nice parallel --nonall -j0 -k --slf original.slf --tag echo | perl 's/\t$//' > tmp.slf
якщо diff tmp.slf tmp2.slf; тоді
mv tmp.slf tmp2.slf
fi
sleep 10
зроблено і
паралельно --slf tmp2.slf ...

--slotreplace замінити-вул
Використовуйте рядок для заміни замінити-вул замість {%} для номера робочого місця.

-- мовчазний Безмовний. Завдання, яке потрібно виконати, не буде надруковано. Це значення за замовчуванням. Може бути
перевернуто с -v.

--tty Відкрийте термінал tty. Якщо GNU паралельно використовується для запуску інтерактивної програми
тоді ця опція може знадобитися. Він запускатиме лише одну роботу за раз (тобто -j1),
не буферизувати вихід (тобто -u), і це відкриє tty для роботи. Коли робота
завершено, наступна робота отримає tty.

--тег Рядки тегів з аргументами. Перед кожним вихідним рядком буде додано аргументи
та TAB (\t). При поєднанні з --один усе or --не всі рядки будуть на початку
замість sshlogin.

--тег ігнорується під час використання -u.

--рядок тегів вул
Рядки тегів із рядком. Перед кожним вихідним рядком буде стояти вул і TAB
(\t). вул може містити рядки заміни, наприклад {}.

--рядок тегів ігнорується під час використання -u, --один усе та --не всі.

--tmpdir прізвище
Каталог для тимчасових файлів. GNU паралельно зазвичай буферує вихід у
тимчасові файли в /tmp. За допомогою налаштування --tmpdir ви можете використовувати інший каталог для
файли. Налаштування --tmpdir еквівалентно налаштуванню $TMPDIR.

--tmux Скористайтесь tmux для виходу. Почніть а tmux сеансу та запускайте кожне завдання у вікні в цьому
сесії. Іншої продукції не буде.

--час вийшов Val
Тайм-аут для команди. Якщо команда виконується довше ніж Val секунд це буде
вбитий за допомогою SIGTERM, потім SIGTERM через 200 мс, а потім SIGKILL через 200 мс
пізніше.

If Val за яким слідує %, тоді час очікування буде динамічно обчислено як a
відсоток середньої тривалості виконання. Тільки значення > 100% будуть мати сенс.

-багатослівний
-t Надрукуйте завдання, яке буде запущено на stderr (стандартна помилка).

Дивіться також -v, -p.

--перенесення
Передача файлів на віддалені комп’ютери. --перенесення використовується з --sshlogin коли
аргументи є файлами і повинні бути передані на віддалені комп’ютери. Файли
буде передано за допомогою rsync і буде розміщено відносно робочого каталогу за замовчуванням.
Якщо шлях містить /./ шлях, що залишився, буде відносно робочого dir.
Напр

echo foo/bar.txt | паралельний \
--sshlogin server.example.com --transfer wc

Це перенесе файл foo/bar.txt до комп'ютера server.example.com до
файл $HOME/foo/bar.txt перед бігом wc foo/bar.txt on server.example.com.

echo /tmp/foo/bar.txt | паралельний \
--sshlogin server.example.com --transfer wc

Це перенесе файл foo/bar.txt до комп'ютера server.example.com до
файл /tmp/foo/bar.txt перед бігом wc /tmp/foo/bar.txt on server.example.com.

--перенесення часто використовується з --повернення та --прибирати.

--перенесення ігнорується при використанні з --sshlogin : або коли не використовується з
--sshlogin.

--trc ім'я файлу
Трансфер, повернення, прибирання. Коротка рука для:

--перенесення --повернення ім'я файлу --прибирати

-- обрізати
Обрізати пробіл у вводі.

n Без обрізки. Введення не змінено. Це значення за замовчуванням.

l Ліва обшивка. Видалити пробіл з початку введення. Наприклад, " a bc " -> "a bc ".

r Права обрізка. Видалити пробіл з кінця введення. Наприклад, " a bc " -> " a bc ".

lr
rl Обидві обробки. Видаліть пробіл з початку та кінця введення. Наприклад, "a bc"
-> "a bc". Це значення за замовчуванням, якщо --colsep використовується.

--розгрупувати
-u Розгрупувати вихід. Вихідні дані друкуються якнайшвидше та обходяться GNU паралельно
внутрішня обробка. Це може призвести до змішування результатів різних команд
таким чином, його слід використовувати лише в тому випадку, якщо ви не дбаєте про вихід. Порівняйте ці:

паралельно -j0 'спати {}; відлуння -n почати{};сну {}; відлуння {}end' ::: 1 2 3 4

паралельно -u -j0 'спати {}; відлуння -n почати{};сну {}; відлуння {}end' ::: 1 2 3 4

Це також відключає --тег. GNU паралельно виводить швидше за допомогою -u. Порівняйте швидкість
ці:

parallel seq ::: 300000000 >/dev/null
parallel -u seq ::: 300000000 >/dev/null
parallel --line-buffer seq ::: 300000000 >/dev/null

Можна перевернути за допомогою --група.

Див також: --рядковий буфер --група

--розширення замінити замінити-вул
--ер замінити-вул
Використовуйте рядок для заміни замінити-вул замість {.} для рядка введення без
розширення.

--використання-cpus-замість ядер
Підрахуйте кількість фізичних процесорів замість ядер ЦП. При обчисленні скільки
завдання для одночасного виконання відносно кількості ядер ЦП, які ви можете запитати у GNU
паралельно щоб замість цього подивитися на кількість фізичних процесорів. Це матиме сенс для
комп’ютери, які мають гіперпотоку як два завдання, що виконуються на одному ЦП
Hyperthreading буде виконуватися повільніше, ніж два завдання, що виконуються на двох фізичних ЦП. Дещо
багатоядерні ЦП можуть працювати швидше, якщо на фізичному ЦП працює лише один потік.
Більшості користувачів ця опція не знадобиться.

-v Багатослівний. Роздрукуйте завдання, яке потрібно виконати на стандартному виводі (стандартний вихід). Можна перевернути
з -- мовчазний, Див. Також -t.

Скористайтесь -v -v для друку команди wrapping ssh під час віддаленого запуску.

-- версія
-V Роздрукуйте версію GNU паралельно і вийти.

--workdir mydir
--wd mydir
Файли передані за допомогою --перенесення та --повернення буде відносно mydir on
віддалені комп’ютери, і команда буде виконана в дир mydir.

Спеціальний mydir значення ... створить робочі каталоги під ~/.parallel/tmp/ on
віддалені комп'ютери. Якщо --прибирати вказано, що ці каталоги будуть видалені.

Спеціальний mydir значення . використовує поточний робочий дир. Якщо поточний робочий
dir знаходиться під вашим домашнім каталогом, значення . розглядається як відносний шлях до вашого
домашній реж. Це означає, що якщо ваш домашній каталог відрізняється на віддалених комп’ютерах (наприклад
якщо ваш логін інший), відносний шлях все одно буде відносно вашого дому
д.

Щоб побачити різницю, спробуйте:

паралельно -S сервер pwd ::: ""

паралельно --wd . -S сервер pwd ::: ""

паралельно --wd ... -S сервер pwd ::: ""

-- зачекайте Дочекайтеся завершення всіх команд.

Має на увазі --семафор.

Дивіться також людина без.

-X Кілька аргументів із заміною контексту. Вставте стільки аргументів, скільки в команді
дозволи на довжину лінії. Якщо паралельно виконується кілька завдань: розповсюджуйте файл
аргументи порівну між вакансіями. Використовуйте -j1 щоб уникнути цього.

If {} не використовується, аргументи будуть додані до рядка. Якщо {} використовується як
частина слова (як pic{}.jpg), то все слово буде повторено. Якщо {} is
використовувався кілька разів кожен {} буде замінено аргументами.

Зазвичай -X зробить правильно, тоді як -m може дати несподівані результати, якщо {}
вживається як частина слова.

Підтримка -X з --sshlogin обмежений і може вийти з ладу.

Дивіться також -m.

--вихід
-x Вийдіть, якщо розмір (див -s варіант) перевищено.

--xзастосувати Читайте кілька джерел введення, наприклад xapply. Якщо вказано кілька джерел входу, одне
аргумент буде зчитуватися з кожного з вхідних джерел. Аргументи можуть бути
доступ до команди як 1 {} .. {n}, так 1 {} буде рядком з першого введення
джерело, і 6 {} буде посилатися на рядок з таким же номером рядка з 6-го
джерело введення.

Порівняйте ці два:

паралельне відлуння {1} {2} ::: 1 2 3 ::: abc
parallel --xapply echo {1} {2} ::: 1 2 3 ::: abc

Аргументи будуть перероблені, якщо одне джерело введення має більше аргументів, ніж аргумент
інші:

parallel --xapply echo {1} {2} {3} ::: 1 2 ::: I II III ::: abcdefg

Дивіться також --заголовок.

ПРИКЛАД: Робочий as ксарг -n1. аргументація додавання

GNU паралельно може працювати аналогічно ксарг -n1.

Щоб стиснути всі файли html за допомогою gzip бігти:

знаходити . -ім'я '*.html' | паралельно gzip --найкраще

Якщо імена файлів можуть містити новий рядок, використовуйте -0. Замініть FOO BAR на FUBAR у всіх файлах
у цьому каталозі та підкаталогах:

знаходити . -типу f -друк0 | паралельно -q0 Perl -i -пе 's/FOO BAR/FUBAR/g'

Примітка: -q потрібен через місце в 'FOO BAR'.

ПРИКЛАД: читання аргументація від команда лінія

GNU паралельно може приймати аргументи з командного рядка замість stdin (стандартний введення).
Щоб стиснути всі html-файли в поточному каталозі за допомогою gzip бігти:

паралельно gzip --найкраще ::: *.html

Щоб перетворити *.wav у *.mp3 за допомогою LAME, який запускає один процес на ядро ​​ЦП:

паралельно Крихітний {} -o {.}.mp3 ::: * .wav

ПРИКЛАД: Вставлення множинний аргументація

При переміщенні багатьох файлів, як це: mv *.log destdir іноді ви отримаєте помилку:

баш: /bin/mv: аргументація список занадто довго

тому що файлів забагато. Замість цього ви можете зробити:

ls | GREP -E '\.log$' | паралельно mv {} destdir

Це буде працювати mv для кожного файлу. Це можна зробити швидше, якщо mv отримує стільки аргументів, що
поміститься на лінії:

ls | GREP -E '\.log$' | паралельно -m mv {} destdir

ПРИКЛАД: Контекст замінювати

Щоб видалити файли pic0000.jpg .. pic9999.jpg Ви можете зробити:

далі -w 0 9999 | паралельно rm pic{}.jpg

Ви також можете зробити:

далі -w 0 9999 | Perl -пе 's/(.*)/pict$1.jpg/' | паралельно -m rm

Побіжить перший rm 10000 разів, тоді як останній буде виконуватися лише rm стільки разів, скільки потрібно
Тримайте довжину командного рядка достатньо короткою, щоб уникнути аргументація список занадто довго (це зазвичай
виконується 1-2 рази).

Ви також можете запустити:

далі -w 0 9999 | паралельно -X rm pic{}.jpg

Це також буде працювати rm стільки разів, скільки потрібно, щоб довжина командного рядка була короткою
достатньо.

ПРИКЛАД: обчислення інтенсивний роботи та заміна

Якщо ImageMagick встановлено, це створить мініатюру файлу jpg:

конвертувати -геометрія 120 foo.jpg thumb_foo.jpg

Це буде виконуватися із завданнями з кількістю ядер процесора паралельно для всіх файлів jpg в каталозі:

ls * .jpg | паралельно конвертувати -геометрія 120 {} великий палець_{}

Щоб зробити це рекурсивно, скористайтеся знаходити:

знаходити . -ім'я '*.jpg' | паралельно конвертувати -геометрія 120 {} {}_thumb.jpg

Зверніть увагу, з чого має початися суперечка {} as {} буде включати шлях (наприклад, запуск конвертувати
-геометрія 120 ./foo/bar.jpg thumb_./foo/bar.jpg було б явно невірним). Команда буде
створювати такі файли, як ./foo/bar.jpg_thumb.jpg.

Скористайтесь {.} щоб уникнути зайвого .jpg в назві файлу. Ця команда зробить файли схожими на
./foo/bar_thumb.jpg:

знаходити . -ім'я '*.jpg' | паралельно конвертувати -геометрія 120 {} {.}_thumb.jpg

ПРИКЛАД: Заміна та перенаправлення

Це створить нестиснену версію файлів .gz поруч із файлом .gz:

паралельно zcat {} ">"{.} ::: *.gz

Цитата > необхідна, щоб відкласти переспрямування. Іншим рішенням є цитування
вся команда:

паралельно "zcat {} >{.}" ::: *.gz

Інші спеціальні символи оболонки (наприклад, * ; $ > < | >> <<) також потрібно помістити в лапки,
оскільки в іншому випадку вони можуть бути інтерпретовані оболонкою і не передані GNU паралельно.

ПРИКЛАД: Складається Команди

Робота може складатися з кількох команд. Це надрукує кількість файлів у кожному
каталог:

ls | паралельно 'луна -n {}" "; ls {}|туалет -я

Щоб помістити вихід у файл з викликом .dir:

ls | паралельно '(луна -n {}" "; ls {}|туалет -л) > {}.dir'

GNU може запускати навіть невеликі сценарії оболонки паралельно:

знаходити . | паралельно 'a={}; ім'я=${a##*/}; upper=$(ехо "$name" | tr "[:нижчий:]"
"[:верхній:]"); нудьгувати "$name - $upper"'

ls | паралельно 'mv {} "$(луна {} | tr "[:верхній:]" "[:нижній:]")"'

Отримавши список URL-адрес, перелічіть усі URL-адреси, які не вдалося завантажити. Надрукуйте номер рядка та
URL-адреса.

як url-файл | паралельно "wget {} 2>/ dev / null || GREP -n {} url-файл"

Створіть дзеркальний каталог з тими самими іменами файлів, за винятком того, що всі файли та символічні посилання порожні
файли.

cp -rs /the/source/dir дзеркальний каталог; знаходити дзеркальний каталог -типу l | паралельно -m rm {} '&&' торкатися
{}

Знайдіть у списку неіснуючі файли

як список_файлів | паралельно 'якщо [ ! -e {} ] ; потім нудьгувати {}; fi'

ПРИКЛАД: покликання Удар Функції

Якщо складена команда довша за рядок, її важко читати. У Bash можна
використовувати функції. Просто пам'ятайте експорт -f функція.

Зроби це() {
echo Робимо це за 1 долар
sleep 2
echo Готово з $1
}
експорт -f зробити
паралельно робити ::: 1 2 3

doubleit() {
echo Зробити це за $1 $2
sleep 2
echo Виконано з $1 $2
}
експорт -f подвійний
паралельний подвійний ::: 1 2 3 ::: аб

Для цього на віддалені сервери потрібно перенести функцію за допомогою -Env:

parallel --env doit -S сервер doit ::: 1 2 3
parallel --env doubleit -S сервер doubleit ::: 1 2 3 ::: ab

Якщо ваше середовище (псевдоніми, змінні та функції) невелике, ви можете скопіювати повне
оточення без необхідності експорт -f будь-що. Просто спочатку запустіть це:

env_parallel() {
експорт parallel_bash_environment='() {
'"$(echo "shopt -s expand_aliases 2>/dev/null"; псевдонім;typeset -p | grep -vFf <(лише для читання; echo GROUPS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_;набір -f)"'
}'
# Виконати як: env_parallel parallel_bash_environment "2>/dev/null;" ...
`яка паралельна` "$@"
скасувати параметр parallel_bash_environment
}

А потім зателефонуйте як:

env_parallel doit ::: 1 2 3
env_parallel doubleit ::: 1 2 3 ::: ab
env_parallel -S сервер doit ::: 1 2 3
env_parallel -S server doubleit ::: 1 2 3 ::: ab

ПРИКЛАД: функція тестер

Щоб перевірити програму з різними параметрами:

tester() {
if (eval "$@") >&/dev/null; тоді
perl -e 'printf "\033[30;102m[ OK ]\033[0m @ARGV\n"' "$@"
ще
perl -e 'printf "\033[30;101m[FAIL]\033[0m @ARGV\n"' "$@"
fi
}
тестер експорту -f
паралельний тестер my_program ::: arg1 arg2
вихід паралельного тестера ::: 1 0 2 0

If моя_програма невдало буде надруковано червоний FAIL, за яким слідуватиме команда про помилку; інакше
буде надруковано зелений ОК, а потім команда.

ПРИКЛАД: Видалення файл розширення коли обробка файли

При обробці файлів видалення розширення файлу за допомогою {.} часто корисний.

Створіть каталог для кожного zip-файлу та розпакуйте його в цьому каталогу:

паралельно 'mkdir {.}; cd {.}; розстебнути блискавку ../{}' ::: * .zip

Повторне стиснення всіх файлів .gz у поточному каталозі за допомогою bzip2 виконання 1 завдання на ядро ​​ЦП
паралельно:

паралельно "zcat {} | bzip2 >{.}.bz2 && rm {}" ::: *.gz

Конвертуйте всі файли WAV в MP3 за допомогою LAME:

знаходити звуковий каталог -типу f -ім'я '*.wav' | паралельно Крихітний {} -o {.}.mp3

Помістіть усі конвертовані в той самий каталог:

знаходити звуковий каталог -типу f -ім'я '*.wav' | паралельно Крихітний {} -o mydir/{/.}.mp3

ПРИКЛАД: Видалення два файл Розширення коли обробка файли

Якщо у вас є каталог із файлами tar.gz і ви хочете, щоб вони були розпаковані у відповідний каталог
(наприклад, foo.tar.gz буде витягнуто в каталог foo), ви можете зробити:

паралельно --плюс 'mkdir {..}; дьоготь -C {..} -xf {}' ::: *.tar.gz

ПРИКЛАД: Завантажити 10 зображень та цінності кожен of Минуле 30 днів

Припустимо, що веб-сайт зберігає такі зображення:

http://www.example.com/path/to/YYYYMMDD_##. jpg

де РРРРММДД — дата, а ## — число 01-10. Це завантажить зображення для
останні 30 днів:

паралельно Wget http://www.example.com/path/to/'$(дата -d "сьогодні -{1} днів "
+%Y%m%d)_{2}.jpg' ::: $(п.п 30) ::: $(п.п -w 10)

$(дата -d "сьогодні -{1} днів " +%Y%m%d) надасть дати в РРРРММДД із {1} дн
віднімається.

ПРИКЛАД: Скопіювати файли as останній модифікований дата (ISO8601) з доданий випадковий цифр

знаходити . | паралельно 'cp {} ../destdir/{= $a = int(10000*ранд); $_ = `дата -r "$_"
+%FT%T"$a"`; жувати; =}'

ПРИКЛАД: Digtal годинник з "блимає" :

Мигає : на цифровому годиннику. Щоб кожен другий рядок мав ':', а решта ' ' a
Вираз perl використовується для перегляду 3-го джерела введення. Якщо значення modudo 2 дорівнює 1: Використовуйте
":" інакше використовуйте " ":

паралельно -k нудьгувати {1}'{=3 $_=$_%2?":":" "=}'{2}{3} ::: {0..12} ::: {0..5} ::: {0..9}

ПРИКЛАД: Агрегуючий зміст of файли

Це:

parallel --header : echo x{X}y{Y}z{Z} \> x{X}y{Y}z{Z} \
::: X {1..5} ::: Y {01..10} ::: Z {1..5}

згенерує файли x1y01z1 .. x5y10z5. Якщо ви хочете згрупувати вихідні дані
на x і z ви можете зробити це:

parallel eval 'cat {=s/y01/y*/=} > {=s/y01//=}' ::: *y01*

Для всіх значень x і z він виконує такі команди:

кіт x1y*z1 > x1z1

Отже, ви отримаєте x1z1 .. x1z5, кожен із яких містить вміст усіх значень y.

ПРИКЛАД: Ширина перший паралельно Web сканер/дзеркало

Цей сценарій, наведений нижче, буде сканувати та відображати URL-адресу паралельно. Він завантажує перші сторінки, які
1 клацання вниз, потім 2 клацання вниз, потім 3; замість звичайної глибини спочатку, де
перше посилання на кожну сторінку отримується першим.

Виконайте так:

ПАРАЛЕЛЬ=-j100 ./parallel-crawl http://gatt.org.yeslab.org/

Видалити Wget частина, якщо вам потрібен лише веб-сканер.

Він працює шляхом отримання сторінки зі списку URL-адрес і пошуку посилань на цій сторінці
знаходяться в межах однієї початкової URL-адреси, які ще не були помічені. Ці посилання є
додано до нової черги. Коли всі сторінки зі списку завершені, нова черга переміщується
список URL-адрес і процес починається заново, доки не буде знайдено невидимих ​​посилань.

#!/ bin / bash

#Напр http://gatt.org.yeslab.org/
URL=$1
# Залишайтеся всередині початкового каталогу
BASEURL=$(echo $URL | perl -pe 's:#.*::; s:(//.*/)[^/]*:$1:')
URLLIST=$(mktemp urllist.XXXX)
URLLIST2=$(mktemp urllist.XXXX)
SEEN=$(mktemp seen.XXXX)

# Павук, щоб отримати URL-адреси
echo $URL >$URLLIST
cp $URLLIST $SEEN

while [ -s $URLLIST ] ; робити
кіт $URLLIST |
parallel lynx -listonly -image_links -dump {} \; wget -qm -l1 -Q1 {} \; echo Spidered: {} \>\&2 |
perl -ne 's/#.*//; s/\s+\d+.\s(\S+)$/$1/ і виконайте { $seen{$1}++ або надрукуйте }' |
grep -F $BASEURL |
grep -v -x -F -f $SEEN | tee -a $SEEN > $URLLIST2
mv $URLLIST2 $URLLIST
зроблений

rm -f $URLLIST $URLLIST2 $SEEN

ПРИКЛАД: Процес файли від a дьоготь файл в той час як розпакування

Якщо файли, які підлягають обробці, знаходяться у файлі tar, розпакуйте один файл і обробіть його
негайно може бути швидше, ніж перше розпакування всіх файлів.

дьоготь f foo.tgz | Perl -не 'друк $l;$l=$_;END{друк $l}' | паралельно нудьгувати

Однорядковість Perl необхідна, щоб уникнути гонки.

ПРИКЛАД: Переписування a for-цикл та a цикл читання

цикли for:

(для x у `списку котів` ; do
зробити_щось $x
зроблено) | process_output

і цикли while-read:

список котів | (під час читання x ; робити
зробити_щось $x
зроблено) | process_output

можна записати так:

як список | паралельно робити щось | процес_виведення

Наприклад: Знайдіть, яке ім’я хоста в списку має IP-адресу 1.2.3 4:

як hosts.txt | паралельно -P 100 господар | GREP 1.2.3.4

Якщо для обробки потрібно більше кроків, цикл for:

(для x у `списку котів` ; do
no_extension=${x%.*};
do_something $x масштаб $no_extension.jpg
do_step2 <$x $no_extension
зроблено) | process_output

і цикли while:

список котів | (під час читання x ; робити
no_extension=${x%.*};
do_something $x масштаб $no_extension.jpg
do_step2 <$x $no_extension
зроблено) | process_output

можна записати так:

як список | паралельно "робити щось {} масштаб {.}.jpg ; do_step2 <{} {.}" | процес_виведення

ПРИКЛАД: Переписування вкладений for-петлі

Вкладені цикли for:

(для x у `cat xlist` ; do
для y в `cat ylist`; робити
зробити_щось $x $y
зроблений
зроблено) | process_output

можна записати так:

паралельно робити щось 1 {} 2 {} :::: xlist ylist | процес_виведення

Вкладені цикли for:

(для статі в МФ ; до
для розміру в SML XL XXL ; робити
echo $gender $size
зроблений
зроблено) | сортувати

можна записати так:

паралельно нудьгувати 1 {} 2 {} ::: M F ::: S M L XL XXL | сортувати

ПРИКЛАД: Виявлення найнижчий різниця між файли

різниця добре підходить для пошуку відмінностей у текстових файлах. різниця | wc -l дає вказівку на
розмір різниці. Щоб знайти відмінності між усіма файлами в поточному dir
робити:

паралельно --тег 'різниця 1 {} 2 {} | wc -я ::: * ::: * | сортувати -nk3

Таким чином можна побачити, чи є деякі файли ближчими до інших.

ПРИКЛАД: for-петлі з колонка Імена

Під час виконання кількох вкладених циклів for-циклів може бути легше відстежувати змінну циклу
if є названо замість того, щоб просто мати номер. Використовуйте --заголовок : дозволити перший аргумент
бути іменованим псевдонімом для рядка позиційної заміни:

parallel --header : echo {gender} {size} ::: стать MF ::: розмір SML XL XXL

Це також працює, якщо вхідний файл є файлом зі стовпцями:

cat addressbook.tsv | parallel --colsep '\t' --header : echo {ім'я} {адреса електронної пошти}

ПРИКЛАД: Рахувати Відмінності між всі файли in a реж

використання --результати результати зберігаються в /tmp/diffcount*.

parallel --results /tmp/diffcount "diff -U 0 {1} {2} |tail -n +3 |grep -v '^@'|wc -l" ::: * ::: *

Щоб побачити різницю між файлом A та файлом B, перегляньте файл '/tmp/diffcount/1/A/2/B'.

ПРИКЛАД: Перевищення швидкості up швидко роботи

Початок завдання на локальній машині займає близько 10 мс. Це може бути великими накладними витратами, якщо
завдання займає дуже кілька мс для виконання. Часто ви можете згрупувати невеликі завдання разом за допомогою -X який буде
зробити накладні витрати менш значними. Порівняйте їх швидкість:

seq -w 0 9999 | паралельний дотик pict{}.jpg

seq -w 0 9999 | паралельний -X сенсорний малюнок{}.jpg

Якщо ваша програма не може приймати кілька аргументів, ви можете використовувати GNU паралельно нереститися
кілька GNU паралельноs:

seq -w 0 999999 | parallel -j10 --pipe parallel -j0 touch pict{}.jpg

If -j0 зазвичай створює 252 вакансії, тоді вищезгадане намагатиметься створити 2520 вакансії. На нормальному
У системі GNU/Linux ви можете створити 32000 робочих місць, використовуючи цю техніку без проблем. Підняти
підвищення ліміту в 32000 робочих місць /proc/sys/kernel/pid_max в 4194303.

ПРИКЛАД: використання оболонка змінні

Використовуючи змінні оболонки, ви повинні правильно вводити їх у лапки, оскільки в іншому випадку вони можуть бути розділені
на просторах.

Зверніть увагу на різницю між:

V=("Записи "12\" мого брата коштують <\$\$\$>"'!' Foo Bar)
parallel echo ::: ${V[@]} # Можливо, це не те, що ви хочете

і:

V=("Записи "12\" мого брата коштують <\$\$\$>"'!' Foo Bar)
паралельне відлуння ::: "${V[@]}"

При використанні змінних у фактичній команді, яка містить спеціальні символи (наприклад, пробіл)
ви можете процитувати їх за допомогою "$VAR" або за допомогою "'s і -q:

V="Ось два"
parallel echo "'$V'" ::: пробіли
parallel -q echo "$V" ::: пробіли

ПРИКЛАД: Group вихід lines

Під час виконання завдань, які виводять дані, часто не потрібно виводити кілька завдань
бігати разом. GNU паралельно за замовчуванням групує вихідні дані кожного завдання, тому вихід є
надруковано після завершення завдання. Якщо ви хочете, щоб під час виконання завдання друкувались повні рядки
біг ви можете використовувати --рядковий буфер. Якщо ви хочете, щоб результат був надрукований якомога швидше
ви можете використовувати -u.

Порівняйте результат:

паралельно traceroute ::: foss.org.my debian.org freenetproject.org

на вихід:

паралельно --рядковий буфер traceroute ::: foss.org.my debian.org freenetproject.org

і:

паралельно -u traceroute ::: foss.org.my debian.org freenetproject.org

ПРИКЛАД: Тег вихід lines

GNU паралельно групує вихідні рядки, але може бути важко побачити, де знаходяться різні завдання
почати --тег передує аргумент, щоб зробити його більш видимим:

паралельно --тег traceroute ::: foss.org.my debian.org freenetproject.org

--тег працює з --рядковий буфер але не з -u:

паралельно --тег --рядковий буфер traceroute ::: foss.org.my debian.org freenetproject.org

Перевірте час роботи серверів у ~/.parallel/sshloginfile:

паралельно --тег -S .. --не всі час безвідмовної роботи

ПРИКЛАД: тримати порядок of вихід то ж as порядок of вхід

Зазвичай результат роботи буде надруковано, щойно воно буде завершено. Іноді хочеться
порядок виводу залишається таким же, як і порядок введення. Це часто буває
важливо, якщо вихід використовується як вхід для іншої системи. -k забезпечить замовлення
вихід буде в тому ж порядку, що і вхідний, навіть якщо пізні завдання закінчуються перед попередніми.

Додайте рядок до кожного рядка текстового файлу:

як текстовий файл | паралельно -k нудьгувати {} додаток_рядок

Якщо видалити -k деякі рядки можуть вийти в неправильному порядку.

Іншим прикладом може служити traceroute:

паралельно traceroute ::: foss.org.my debian.org freenetproject.org

дасть traceroute для foss.org.my, debian.org і freenetproject.org, але це буде
відсортовано відповідно до того, яке завдання було виконано першим.

Щоб порядок залишився таким же, як і введення, запустіть:

паралельно -k traceroute ::: foss.org.my debian.org freenetproject.org

Це гарантує, що трасування до foss.org.my буде надруковано першим.

Трохи складнішим прикладом є паралельне завантаження величезного файлу частинами: трохи Інтернету
підключення доставлять більше даних, якщо ви завантажуєте файли паралельно. Для завантаження
файли паралельно див.: "ПРИКЛАД: Завантажте 10 зображень за кожний з останніх 30 днів". Але якщо
ви завантажуєте великий файл, ви можете завантажувати його частинами паралельно.

Для завантаження байт 10000000-19999999 можна використовувати витися:

витися -r 10000000-19999999 http://example.com/the/big/file > файл.частина

Щоб завантажити файл розміром 1 Гб, нам потрібно завантажити та об’єднати 100 фрагментів по 10 МБ.
порядку.

далі 0 99 | паралельно -k витися -r \
{}0000000-{}9999999 http://example.com/the/big/file > файл

ПРИКЛАД: Паралельні GREP

GREP -r greps рекурсивно через каталоги. На багатоядерних ЦП GNU паралельно часто може
прискорити це.

знаходити . -типу f | паралельно -k -j150% -n 1000 -m GREP -H -n STRING {}

Це запустить 1.5 завдання на ядро ​​і дасть 1000 аргументів GREP.

ПРИКЛАД: Греппінг n lines та цінності m регулярний вирази.

Найпростішим рішенням для отримання великого файлу для великої кількості регулярних виразів є:

grep -f regexps.txt великий файл

Або якщо регулярні вирази є фіксованими рядками:

grep -F -f regexps.txt великий файл

Є 2 обмежувальні фактори: процесор і дисковий ввод-вивод. ЦП легко виміряти: якщо grep приймає
>90% ЦП (наприклад, при запуску зверху), тоді ЦП є обмежуючим фактором, і паралелізація
пришвидшить це. Якщо ні, то дисковий ввод-вивод є обмежуючим фактором, залежно від
дискової системи, її розпаралелювання може відбуватися швидше або повільніше. Єдиний спосіб дізнатися напевно
для вимірювання.

Якщо центральний процесор є обмежуючим фактором, розпаралелювання слід виконати для регулярних виразів:

cat regexp.txt | parallel --pipe -L1000 --round-robin grep -f - великий файл

Якщо рядок відповідає кільком регулярним виразам, рядок може дублюватися. Команда запустить одну
grep на ЦП і читати великий файл один раз на ЦП, але оскільки це робиться паралельно, усі читання
за винятком того, що перший буде кешуватися в RAM. Залежно від розміру regexp.txt це може бути
швидше використовувати --block 10m замість -L1000. Якщо regexp.txt занадто великий, щоб поміститися в RAM,
видалити --round-robin і налаштувати -L1000. Це призведе до того, що великий файл буде читатися більше разів.

Деякі системи зберігання працюють краще при паралельному читанні кількох фрагментів. Це правда
для деяких систем RAID і для деяких мережевих файлових систем. Щоб паралелізувати читання
великий файл:

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

Це розділить великий файл на частини по 100 МБ і запустить grep на кожному з цих фрагментів. До
паралелізуйте як читання bigfile, так і regexp.txt, об’єднайте обидва за допомогою --fifo:

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

Якщо рядок відповідає кільком регулярним виразам, рядок може дублюватися.

ПРИКЛАД: використання віддалений комп'ютери

Щоб виконувати команди на віддаленому комп’ютері, необхідно налаштувати SSH і мати можливість увійти
без введення пароля (Команди ssh-copy-id та ssh-agent може допомогти вам це зробити).

Якщо вам потрібно ввійти в цілий кластер, ви, як правило, не хочете приймати ключ хоста
для кожного господаря. Ви хочете прийняти їх у перший раз і отримати попередження, якщо вони коли-небудь будуть
змінився. Щоб зробити це:

# Додайте сервери до sshloginfile
(echo servera; echo serverb) > .parallel/my_cluster
# Переконайтеся, що .ssh/config існує
торкніться .ssh/config
cp .ssh/config .ssh/config.backup
# Тимчасово вимкніть StrictHostKeyChecking
(echo 'Host *'; echo StrictHostKeyChecking ні) >> .ssh/config
parallel --slf my_cluster --nonall true
# Видаліть відключення StrictHostKeyChecking
mv .ssh/config.backup .ssh/config

Сервери в .parallel/my_cluster тепер додані .ssh/відомі_хости.

Бігти нудьгувати on server.example.com:

послідовність 10 | parallel --sshlogin server.example.com echo

Щоб запустити команди на кількох віддалених комп’ютерах, виконайте:

послідовність 10 | parallel --sshlogin server.example.com,server2.example.net echo

Або:

послідовність 10 | parallel --sshlogin server.example.com \
--sshlogin server2.example.net echo

Якщо ім’я користувача для входу є Foo on server2.example.net використання:

послідовність 10 | parallel --sshlogin server.example.com \
--sshlogin [захищено електронною поштою] нудьгувати

Якщо ваш список хостів є server1-88.example.net з логіном Foo:

послідовність 10 | parallel -Sfoo@server{1..88}.example.net echo

Щоб розповсюдити команди на список комп’ютерів, створіть файл мої комп'ютери з усіма
комп’ютери:

server.example.com
[захищено електронною поштою]
server3.example.com

Потім запустіть:

послідовність 10 | parallel --sshloginfile mycomputers echo

Щоб включити локальний комп’ютер, додайте спеціальний sshlogin ':' до списку:

server.example.com
[захищено електронною поштою]
server3.example.com
:

GNU паралельно спробує визначити кількість ядер ЦП на кожному пульті
комп’ютери, і виконувати одне завдання на ядро ​​ЦП, навіть якщо на віддалених комп’ютерах його немає
однакова кількість ядер ЦП.

Якщо кількість ядер ЦП на віддалених комп’ютерах не визначена правильно, число
ядер ЦП можна додати спереду. Тут комп’ютер має 8 ядер ЦП.

послідовність 10 | parallel --sshlogin 8/server.example.com echo

ПРИКЛАД: Передача of файли

Щоб повторно стиснути файли gzip за допомогою bzip2 за допомогою віддаленого комп’ютера запустіть:

знайти журнали/ -name '*.gz' | \
parallel --sshlogin server.example.com \
--transfer "zcat {} | bzip2 -9 >{.}.bz2"

Це покаже список файлів .gz у файлі logs каталог і всі каталоги нижче. Тоді це буде
передати файли до server.example.com у відповідний каталог в $HOME/журнали, на
server.example.com файл буде повторно стиснутий за допомогою zcat та bzip2 в результаті чого
відповідний файл з .gz замінено на . Bz2.

Якщо ви хочете, щоб отриманий bz2-файл був перенесений назад на локальний комп’ютер, додайте
--повернення {.}.bz2:

знайти журнали/ -name '*.gz' | \
parallel --sshlogin server.example.com \
--transfer --return {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

Після виконання повторного стиснення . Bz2-файл передається назад на локальний комп'ютер
і поставити поруч з оригіналом .gz-файл.

Якщо ви хочете видалити передані файли на віддаленому комп’ютері, додайте --прибирати, це
видалить як файл, переданий на віддалений комп’ютер, так і передані файли
з віддаленого комп'ютера:

знайти журнали/ -name '*.gz' | \
parallel --sshlogin server.example.com \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"

Якщо ви хочете запустити на кількох комп’ютерах, додайте комп’ютери до --sshlogin або за допомогою ',' або
множинний --sshlogin:

знайти журнали/ -name '*.gz' | \
parallel --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"

Ви можете додати локальний комп’ютер за допомогою --sshlogin :. Це призведе до вимкнення видалення і
перенесення лише для локального комп’ютера:

знайти журнали/ -name '*.gz' | \
parallel --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--sshlogin : \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"

Часто --перенесення, --повернення та --прибирати використовуються разом. Їх можна скоротити до
--trc:

знайти журнали/ -name '*.gz' | \
parallel --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--sshlogin : \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

З файлом мої комп'ютери містить список комп'ютерів, він стає:

знайти журнали/ -name '*.gz' | parallel --sshloginfile мої комп'ютери \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

Якщо файл ~/.parallel/sshloginfile містить список комп'ютерів спеціальної короткої руки
-S .. може бути використаний:

знайти журнали/ -name '*.gz' | паралельно -S .. \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"

ПРИКЛАД: Поширюючи робота до місцевий та віддалений комп'ютери

Перетворіть *.mp3 в *.ogg, що запускає один процес на ядро ​​ЦП на локальному комп’ютері та сервері2:

паралельний --trc {.}.ogg -S server2,: \
'mpg321 -w - {} | oggenc -q0 - -o {.}.ogg' ::: *.mp3

ПРИКЛАД: Робота то ж команда on віддалений комп'ютери

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

паралельно --тег --не всі -S сервер 1, сервер 2 час безвідмовної роботи

--не всі не читає аргументів. Якщо у вас є список завдань, які ви хочете виконувати на кожному комп’ютері
можна зробити:

паралельно --тег --один усе -S сервер 1, сервер 2 нудьгувати ::: 1 2 3

Видалення --тег якщо ви не хочете, щоб sshlogin додавалося перед виводом.

Якщо у вас багато хостів, використовуйте '-j0' для паралельного доступу до більшої кількості хостів.

ПРИКЛАД: Паралелювання rsync

rsync є чудовим інструментом, але іноді він не заповнює доступну пропускну здатність. Це
часто виникає проблема під час копіювання кількох великих файлів через високошвидкісні з'єднання.

Нижче розпочнеться один rsync за великий файл у src-каталог до напрямок призначення на сервері
Fooserver:

cd src-каталог; знаходити . -типу f -розмір +100000 | паралельно -v SSH Fooserver mkdir -p
/dest-dir/{//}\;rsync -s -Хавеш {} Fooserver:/dest-dir/{}

Створені каталоги можуть отримати неправильні дозволи, а менші файли не будуть
передано. Щоб виправити ці пробіги rsync останній раз:

rsync -Хавеш src-dir/ Fooserver:/dest-dir/

Якщо ви не можете надіслати дані, але вам потрібно їх витягнути, файли називаються digits.png
(наприклад, 000000.png) ви можете зробити:

далі -w 0 99 | паралельно rsync -Хавеш fooserver:src-path/*{}.png destdir/

ПРИКЛАД: Скористайтесь множинний витрати in один команда

Скопіюйте такі файли, як foo.es.ext в foo.ext:

ls *.es.* | Perl -пе 'друк; s/\.es//' | паралельно - 2 N cp 1 {} 2 {}

Команда perl видає 2 рядки для кожного введення. GNU паралельно приймає 2 входи (використовуючи - 2 N)
і замінює {1} і {2} на входи.

Підрахунок у двійковій системі:

паралельно -k нудьгувати ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1

Надрукуйте число на протилежних сторонах шестигранного кубика:

паралельно --xзастосувати -a <(п.п 6) -a <(п.п 6 -1 1) нудьгувати

паралельно --xзастосувати нудьгувати :::: <(п.п 6) <(п.п 6 -1 1)

Перетворюйте файли з усіх підкаталогів у PNG-файли з послідовними номерами (корисно для створення
введіть PNG для ffmpeg):

паралельно --xзастосувати -a <(знайти . -типу f | сортувати) -a <(п.п $(знайти . -типу f|wc -л)) конвертувати
1 {} {2}.png

Альтернативна версія:

знаходити . -типу f | сортувати | паралельно конвертувати {} {#}.png

ПРИКЛАД: Скористайтесь a таблиця as вхід

Вміст table_file.tsv:

foo бар
баз quux

Бігти:

cmd -o bar -i foo
cmd -o quux -i baz

ви можете запустити:

паралельно -a файл_таблиці.tsv --colsep '\ t' CMD -o 2 {} -i 1 {}

Примітка: за замовчуванням для GNU паралельно полягає в тому, щоб видалити пробіли навколо стовпців. Щоб зберегти
пробіли:

паралельно -a файл_таблиці.tsv -- обрізати n --colsep '\ t' CMD -o 2 {} -i 1 {}

ПРИКЛАД: прогін то ж команда 10 times

Якщо ви хочете запустити ту саму команду з однаковими аргументами 10 разів паралельно, ви можете
робити:

далі 10 | паралельно -n0 моя_команда мої_аргументи

ПРИКЛАД: Робочий as як | ш. Ресурс недорогий роботи та оцінка

GNU паралельно може працювати аналогічно як | sh.

Недорога робота — це робота, яка займає дуже мало ЦП, дискового вводу-виводу та мережевого вводу-виводу.
Ping є прикладом недорогої роботи. wget також - якщо веб-сторінки невеликі.

Вміст файлу jobs_to_run:

ping -c 1 10.0.0.1
Wget http://example.com/status.cgi?ip=10.0.0.1
ping -c 1 10.0.0.2
Wget http://example.com/status.cgi?ip=10.0.0.2
...
ping -c 1 10.0.0.255
Wget http://example.com/status.cgi?ip=10.0.0.255

Щоб запустити 100 процесів одночасно:

паралельно -j 100 < jobs_to_run

Оскільки немає а команда роботи будуть оцінені оболонкою.

ПРИКЛАД: Обробка a великий файл використання більше сердечники

Ви можете використовувати для обробки великого файлу або якогось результату --труба розбити дані на блоки
і передайте блоки в програму обробки.

Якщо програма є gzip -9 Ви можете зробити:

як великий файл | паралельно --труба --останнє '' -k gzip -9 >bigfile.gz

Це розділить великий файл на блоки по 1 МБ і передайте це до gzip -9 паралельно. один gzip
буде запускатися на ядро ​​ЦП. Вихід з gzip -9 буде зберігатися в порядку та збережено
bigfile.gz

gzip працює нормально, якщо вивід додається, але деяка обробка не працює так -
наприклад сортування. Для цього GNU паралельно може помістити результат кожної команди у файл.
Це відсортує великий файл паралельно:

як великий файл | паралельно --труба --файли сортувати | паралельно -Xj1 сортувати -m {} ';' rm {}
>bigfile.sort

тут великий файл розбивається на блоки розміром приблизно 1 МБ, кожен блок закінчується на "\n" (що є
за замовчуванням для --останнє). До кожного блоку передається сортувати і вихід з сортувати зберігається в
файли. Ці файли передаються другому паралельно що працює сортувати -m у файлах раніше
він видаляє файли. Вихідні дані зберігаються в bigfile.sort.

GNU паралельно's --труба досягає максимуму близько 100 МБ/с, тому що кожен байт потрібно скопіювати
через GNU паралельно. Але якщо великий файл є справжнім (доступним для пошуку) файлом GNU паралельно можна обійти
копіювання та надсилання частин безпосередньо до програми:

паралельно -- трубопровідна частина --блок 100m -a великий файл --файли сортувати | паралельно -Xj1 сортувати -m {} ';' rm
{} >bigfile.sort

ПРИКЛАД: Робота більше ніж 250 роботи обхідний шлях

Якщо вам потрібно паралельно виконувати величезну кількість завдань, то, швидше за все, ви потрапите
обмеження на обробку файлів, яке часто становить близько 250 завдань. Якщо ви суперкористувач, ви можете підняти
обмежити в /etc/security/limits.conf але ви також можете скористатися цим обхідним шляхом. Обробник файлу
обмеження на процес. Це означає, що якщо ви просто створите більше GNU паралельноs потім кожен з
вони можуть виконувати 250 робочих місць. Це створить до 2500 робочих місць:

як мій вхід | паралельно --труба -N 50 --кругової -j50 паралельно -j50 your_prg

Це створить до 62500 64 робочих місць (використовуйте з обережністю - для цього вам потрібно XNUMX ГБ ОЗП, і
вам може знадобитися збільшити /proc/sys/kernel/pid_max):

як мій вхід | паралельно --труба -N 250 --кругової -j250 паралельно -j250 your_prg

ПРИКЛАД: Робочий as мутекс та підрахунок семафор

Команда без є псевдонімом для паралельно --семафор.

Підрахунковий семафор дозволить запускати певну кількість завдань у фоновому режимі.
Коли кількість завдань виконується у фоновому режимі, GNU без буде чекати одного з них
завершити перед початком іншої команди. без -- зачекайте буде чекати на всі завдання
завершено.

Виконуйте 10 завдань одночасно у фоновому режимі:

for i в *.log ; робити
echo $ i
sem -j10 gzip $i ";" відлуння зроблено
зроблений
sem -- зачекайте

Мьютекс — це лічильний семафор, який дозволяє виконувати лише одне завдання. Це відредагує файл
мій файл і додає до файлу рядки з числами від 1 до 3.

послідовність 3 | паралельно sem sed -i -e 'i{}' myfile

As мій файл може бути дуже великим, важливо лише один процес редагує файл одночасно
часу.

Назвіть семафор, щоб одночасно було активним кілька різних семафорів:

послідовність 3 | parallel sem --id mymutex sed -i -e 'i{}' myfile

ПРИКЛАД: Start редактор з імена файлів від stdin (стандарт вхід)

Ви можете використовувати GNU паралельно щоб запустити інтерактивні програми, такі як emacs або vi:

як список файлів | паралельно --tty -X emacs

як список файлів | паралельно --tty -X vi

Якщо файлів більше, ніж в одному командному рядку, буде запущено редактор
знову з файлами, що залишилися.

ПРИКЛАД: Робота Суду

Суду потрібен пароль для запуску команди від імені root. Він кешує доступ, тому вам лише потрібно
щоб знову ввести пароль, якщо ви не використовували його Суду на деякий час

Команда:

parallel sudo echo ::: Це погана ідея

не годиться, оскільки вам буде запропоновано ввести пароль sudo для кожного з завдань. Ти можеш
або зробити:

sudo echo Це
parallel sudo echo ::: є гарною ідеєю

або:

sudo parallel echo ::: Це гарна ідея

Таким чином, вам потрібно буде ввести пароль sudo лише один раз.

ПРИКЛАД: GNU Паралельні as чергу система/партія менеджер

GNU паралельно може працювати як проста система черги завдань або пакетний менеджер. Ідея в тому, щоб поставити
завдання у файл і мати GNU паралельно читати з цього постійно. Як GNU паралельно
зупиниться в кінці файлу, який ми використовуємо хвіст продовжити читання:

правда >черга робочих місць; хвіст -n+0 -f черга робочих місць | паралельно

Щоб поставити свої завдання в чергу:

нудьгувати моя_команда мій_арг >> черга робочих місць

Ви, звичайно, можете використовувати -S розподілити завдання на віддалені комп’ютери:

правда >черга робочих місць; хвіст -f черга робочих місць | паралельно -S ..

Під час використання GNU є невелика проблема паралельно як система черги/менеджер пакетів: у вас є
щоб надіслати кількість вакансій JobSlot до їх запуску, а після цього ви можете надіслати одне
за один раз, і робота почнеться негайно, якщо є вільні місця. Вихід з
запущені або завершені завдання затримуються і будуть надруковані лише тоді, коли JobSlots більше завдань
було запущено (якщо ви не використовуєте --ungroup або -u, у цьому випадку вихід із завдань
друкуються негайно). Наприклад, якщо у вас є 10 робочих місць, то вихід з першого
завершене завдання буде надруковано лише тоді, коли розпочнеться завдання 11, а результат другого
завершене завдання буде надруковано лише тоді, коли розпочато завдання 12.

використовувати --eof зробити GNU паралельно вихід, хвіст також потрібно змусити вийти:

tail -n+0 -f список команд.txt |
(parallel --eof=EXIT {}; echo Паралель зараз виконано;
(послідовність 1000 >> command-list.txt &);
echo Завершено додавання фіктивних даних, що змушує хвіст вийти)

ПРИКЛАД: GNU Паралельні as реж процесор

Якщо у вас є каталог, до якого користувачі скидають файли, які потрібно обробити, ви можете зробити це на
GNU/Linux (Якщо ви знаєте що inotifywait викликається на інших платформах, подайте звіт про помилку):

inotifywait -q -m -r -e ПЕРЕЇХАВ ДО -e CLOSE_WRITE --формат %w%f мій_каталог | паралельно -u нудьгувати

Це запустить команду нудьгувати на кожному файлі, вставленому в мій_каталог або підкаталоги мій_каталог.

Ви, звичайно, можете використовувати -S розподілити завдання на віддалені комп’ютери:

inotifywait -q -m -r -e ПЕРЕЇХАВ ДО -e CLOSE_WRITE --формат %w%f мій_каталог | паралельно -S .. -u
нудьгувати

Якщо файли, які підлягають обробці, знаходяться у файлі tar, розпакуйте один файл і обробіть його
негайно може бути швидше, ніж перше розпакування всіх файлів. Налаштуйте процесор каталогів як
вище та розпакуйте в дир.

Використання GNU Parallel як процесора dir має ті самі обмеження, що й використання GNU Parallel as
система черг/менеджер пакетів.

ЦИТАТИ

GNU паралельно дуже ліберальний у цитуванні. Вам потрібно лише цитувати символи, які мають
особливе значення в оболонці:

( ) $ ` ' " ; | \

і залежно від контексту їх також потрібно процитувати:

~ & # ! ? пробіл * {

Тому більшість людей ніколи не потребуватиме більше цитат, ніж поставити «\» перед
спеціальні символи.

Часто ви можете просто поставити \' навколо кожного ':

perl -ne '/^\S+\s+\S+$/ і надрукувати файл $ARGV,"\n"'

можна процитувати:

parallel perl -ne \''/^\S+\s+\S+$/ і надрукувати $ARGV,"\n"'\' ::: файл

Однак, якщо ви хочете використовувати змінну оболонки, вам потрібно ввести в лапки знак $. Ось
приклад використання $PARALLEL_SEQ. Ця змінна встановлюється GNU паралельно себе, тому
оцінка $ має виконуватися підоболонкою, запущеною GNU паралельно:

далі 10 | паралельно - 2 N нудьгувати послідовність:\$PARALLEL_SEQ аргумент1:{1} аргумент2:{2}

Якщо змінна встановлена ​​перед GNU паралельно для початку ви можете зробити це:

VAR=this_is_set_before_starting

нудьгувати тест | паралельно нудьгувати {} $VAR

Друк: тест this_is_set_before_starting

Це трохи складніше, якщо змінна містить більше одного пробілу в рядку:

VAR="два пробіли між кожен слово"

нудьгувати тест | паралельно нудьгувати {} \'"$VAR"\'

Друк: тест два пробіли між кожен слово

Якщо змінна не повинна бути оцінена оболонкою, яка запускає GNU паралельно але будь
оцінюється підоболонкою, запущеною GNU паралельно, то вам потрібно його процитувати:

нудьгувати тест | паралельно VAR=це_встановлено_після_запуску \; нудьгувати {} \$VAR

Друк: тест this_is_set_after_starting

Трохи складніше, якщо змінна містить пробіл:

нудьгувати тест | паралельно VAR='"два пробіли між кожен слово"' нудьгувати {} \'"$VAR"\'

Друк: тест два пробіли між кожен слово

$$ – це змінна оболонки, що містить ідентифікатор процесу оболонки. Це надрукує
ідентифікатор процесу оболонки, на якій працює GNU паралельно:

далі 10 | паралельно нудьгувати $$

І це надрукує ідентифікатори процесів підоболонок, запущених GNU паралельно.

далі 10 | паралельно нудьгувати \$\$

Якщо спеціальні символи не повинні бути оцінені підоболонкою, вам це потрібно
захистити його від оцінки з обох оболонок, які запускають GNU паралельно і підоболонка:

нудьгувати тест | паралельно нудьгувати {} \\\$VAR

Друк: тест $VAR

GNU паралельно може захистити від оцінки підоболонкою за допомогою -q:

нудьгувати тест | паралельно -q нудьгувати {} \$VAR

Друк: тест $VAR

Це особливо корисно, якщо у вас багато цитат. Якщо ви хочете запустити сценарій perl
подобається це:

Perl -не '/^\S+\s+\S+$/ та друк $ARGV,"\n"' файл

Його потрібно процитувати так:

ls | паралельно Perl -не '/^\\S+\\s+\\S+\$/\ і\ друкувати\ \$ARGV,\"\\n\"' ls | паралельно Perl
-не \''/^\S+\s+\S+$/ та друк $ARGV,"\n"'\'

Зверніть увагу, як пробіли, \'s, "' і $' повинні бути в лапках. GNU паралельно може зробити цитування за
використовуючи параметр -q:

ls | паралельно -q Perl -не '/^\S+\s+\S+$/ та друк $ARGV,"\n"'

Однак це означає, що ви не можете змусити підоболонку інтерпретувати спеціальні символи. Для
приклад через -q це НЕ ПРАЦЮЄ:

ls *.gz | паралельно -q "zcat {} >{.}"

ls *.gz | паралельно -q "zcat {} | bzip2 >{.}.bz2"

тому що > і | необхідно інтерпретувати підоболонкою.

Якщо ви отримуєте такі помилки, як:

sh: -c: рядок 0: синтаксична помилка біля неочікуваного маркера
sh: Синтаксична помилка: рядок у лапках без закінчення
sh: -c: рядок 0: неочікуваний EOF під час пошуку відповідності `''
sh: -c: рядок 1: синтаксична помилка: неочікуваний кінець файлу

тоді ви можете спробувати використати -q.

Якщо ви використовуєте бити процес заміни як <(кіт фу) тоді можна спробувати -q та
передплата команда з бити -c:

ls | паралельно -q бити -c 'туалет -c <(луна {})'

Або для заміни вихідних даних:

ls | паралельно -q бити -c 'дьоготь c {} | трійник >(gzip >{}.tar.gz) | bzip2 >{}.tar.bz2'

Висновок: Щоб уникнути проблем із цитуванням, може бути простіше просто написати a
невеликий скрипт або функція (запам’ятайте експорт -f функція) і мають GNU паралельно call
це.

СПИСОК РУНІНГ РОБОТА

Якщо ви хочете отримати список поточних завдань, ви можете запустити:

killall -ЄДР1 паралельно

GNU паралельно потім надрукує поточні завдання на stderr (стандартна помилка).

ЗАВЕРШЕНО РУНІНГ РОБОТА АЛЕ DO $NOT Почати гру Нове РОБОТА

Якщо ви пошкодуєте, що почали багато робіт, ви можете просто зламати GNU паралельно, але якщо ви хочете
переконайтеся, що у вас немає напіввиконаних завдань, вам слід надіслати сигнал СИГТЕРМ до GNU
паралельно:

killall -ТЕРМІН паралельно

Про це розповість GNU паралельно щоб не починати жодних нових робіт, а дочекатися поточної
запущені завдання закінчуються перед виходом.

НАВКОЛИШНЄ СЕРЕДОВИЩЕ ЗМІННІ

$PARALLEL_PID
Змінна середовища $PARALLEL_PID встановлюється GNU паралельно і видно
робота почалася з GNU паралельно. Це дає можливість для робочих місць
спілкуватися безпосередньо з GNU паралельно. Не забудьте вказати $, щоб це сталося
оцінюється за правильною оболонкою.

приклад: Якщо кожне з завдань перевіряє рішення, а одне з завдань знаходить рішення
завдання може сказати GNU паралельно не починати більше роботи: вбивати -ТЕРМІН
$PARALLEL_PID. Це працює лише на локальному комп’ютері.

$PARALLEL_SHELL (альфа-тестування)
Використовуйте цю оболонку для команд, запущених GNU Parallel:

· $PARALLEL_SHELL. Якщо невизначено використовувати:

· Оболонка, яка запустила GNU Parallel. Якщо це неможливо визначити:

· $SHELL. Якщо невизначено використовувати:

· / Бен / ш

$PARALLEL_SEQ
$PARALLEL_SEQ буде встановлено на порядковий номер виконуваного завдання. Не забувайте
заведіть $, щоб він оцінювався правильною оболонкою.

приклад:

далі 10 | паралельно - 2 N нудьгувати seq:'$'PARALLEL_SEQ аргумент1:{1} аргумент2:{2}

Каталог $TMPDIR для тимчасових файлів. Подивитися: --tmpdir.

$ПАРАЛЕЛЬ
Змінна середовища $PARALLEL буде використовуватися як параметри за замовчуванням для GNU
паралельно. Якщо змінна містить спеціальні символи оболонки (наприклад, $, * або пробіл)
тоді їх потрібно екранувати за допомогою \.

приклад:

як список | паралельно -j1 -k -v ls

можна записати так:

як список | ПАРАЛЕЛЬ="-kvj1" паралельно ls

як список | паралельно -j1 -k -v -Мисш користувач@сервер" ls

можна записати так:

як список | ПАРАЛЕЛЬ='-kvj1 -S myssh\ user@server' паралельно нудьгувати

Зверніть увагу, що \ в середині потрібен, оскільки 'myssh' і 'user@server' повинні бути
один аргумент.

ПОВЕРНЕНО ПРОФІЛЬ (КОНФІГ ФАЙЛ)

Глобальний файл конфігурації /etc/parallel/config, а потім файл конфігурації користувача
~/.parallel/config (раніше відомий як .parallelrc) буде читатися по черзі, якщо вони існують.
Рядки, які починаються з '#', ігноруватимуться. Формат може відповідати формату середовища
змінної $PARALLEL, але часто простіше просто помістити кожен параметр у окремий рядок.

Параметри командного рядка мають пріоритет, а потім змінна середовища
$PARALLEL, файл конфігурації користувача ~/.parallel/config, і, нарешті, глобальна
файл конфігурації /etc/parallel/config.

Зауважте, що жоден файл, який читається для параметрів, ні змінна середовища $PARALLEL не можуть
містять виключені параметри, такі як --tollef.

ПРОФІЛЬ ФАЙЛИ

If --профіль набір, GNU паралельно буде читати профіль з цього файлу, а не з глобального
або файли конфігурації користувача. Ви можете мати кілька --профілі.

Приклад: профіль для запуску команди для кожного sshlogin ~/.ssh/sshlogins і заздалегідь
вихід з sshlogin:

echo --тег -S .. --nonall > ~/.паралельно/н
час роботи паралельного -Jn

Приклад: профіль для виконання кожної команди -j-1 та приємно

echo -j-1 гарно > ~/.parallel/nice_profile
parallel -J nice_profile bzip2 -9 ::: *

Приклад: профіль для запуску сценарію perl перед кожною командою:

echo "perl -e '\$a=\$\$; надрукувати \$a,\" \",'\$PARALLEL_SEQ',\" \";';" > ~/.parallel/pre_perl
parallel -J pre_perl echo ::: *

Зверніть увагу на те, як $ і " потрібно вводити в лапки за допомогою \.

Приклад: профіль для виконання розподілених завдань з приємно на віддалених комп'ютерах:

луна -S .. приємно > ~/.parallel/dist
parallel -J dist --trc {.}.bz2 bzip2 -9 ::: *

EXIT СТАТУС

If --зупинка під час помилки 0 або не вказано:

0 Усі завдання виконано без помилок.

1-253 Деякі завдання були невдалими. Статус виходу показує кількість невдалих завдань

254 Понад 253 роботи не вдалося.

255 Інша помилка.

If --зупинка під час помилки 1 або 2: статус виходу з невдалого завдання.

РІЗНАННЯ МІЖ GNU Паралельні І АЛЬТЕРНАТИВИ

Існує багато програм з деякими функціями GNU паралельно. GNU паралельно
прагне включити найкращі функції без шкоди для простоти використання.

РЕЗЮМЕ ТАБЛИЦЯ
У деяких порівнянних інструментах є такі функції:

Витрати
I1. Аргументи можна прочитати з stdin
I2. Аргументи можна прочитати з файлу
I3. Аргументи можна прочитати з кількох файлів
I4. Аргументи можна прочитати з командного рядка
I5. Аргументи можна прочитати з таблиці
I6. Аргументи можна прочитати з одного файлу за допомогою #! (shebang)
I7. Орієнтований на рядок введення за замовчуванням (введення спеціальних символів не потрібно)

Маніпулювання введенням
M1. Складена команда
М2. Кілька аргументів можуть заповнити рядок виконання
M3. Аргументи можна вводити будь-де в рядку виконання
M4. Декілька аргументів можна ввести в будь-яке місце в рядку виконання
M5. Аргументи можна замінити контекстом
M6. Введення можна розглядати як повну лінію виконання

Виходи
O1. Групування виводу, щоб вихідні дані з різних завдань не змішувалися
O2. Надіслати stderr (стандартна помилка) до stderr (стандартна помилка)
O3. Надіслати стандартний вихід (стандартний вихід) у стандартний вихід (стандартний вихід)
O4. Порядок виведення може бути таким же, як і порядок введення
O5. Stdout містить лише стандартний вихід (стандартний вихід) команди
O6. Stderr містить лише stderr (стандартна помилка) з команди

Виконання
E1. Паралельне виконання робіт
E2. Перелік запущених завдань
E3. Завершуйте поточні завдання, але не починайте нові
E4. Кількість виконуваних завдань може залежати від кількості процесора
E5. Завершіть виконання завдань, але не починайте нові завдання після першої невдачі
E6. Кількість виконуваних завдань можна регулювати під час роботи

Дистанційне виконання
R1. Роботи можна виконувати на віддалених комп’ютерах
R2. Базові файли можна передавати
R3. Файли аргументів можна передавати
R4. Файли результатів можна передавати
R5. Очищення переданих файлів
R6. Конфігураційні файли не потрібні
R7. Не запускайте більше, ніж може впоратися MaxStartups SSHD
R8. Конфігурована команда SSH
R9. Повторіть спробу, якщо з’єднання час від часу обривається

Семафор
S1. Можливість працювати як мьютекс
S2. Можливість працювати як лічильний семафор

легенда
- = ні
x = не застосовується
ID = так

Оскільки кожна нова версія програм не тестується, таблиця може бути застарілою. Будь ласка, подайте файл
звіт про помилки, якщо ви знайдете помилки (див. ЗВІТ ПРО ПОМИЛКИ).

паралельно: I1 I2 I3 I4 I5 I6 I7 M1 M2 M3 M4 M5 M6 O1 O2 O3 O4 O5 O6 E1 E2 E3 E4 E5 E6 R1 R2
R3 R4 R5 R6 R7 R8 R9 S1 S2

xargs: I1 I2 - - - - - - M2 M3 - - - - O2 O3 - O5 O6 E1 - - - - - - - - -
- х - - - - -

знайти -exec: - - - x - x - - M2 M3 - - - - - O2 O3 O4 O5 O6 - - - - - - -
- - - - - - - - - xx

зробити -j: - - - - - - - - - - - - - O1 O2 O3 - x O6 E1 - - - E5 - - - -
- - - - - - - -

ppss: I1 I2 - - - - I7 M1 - M3 - - M6 O1 - - x - - E1 E2 ?E3 E4 - - R1 R2 R3 R4
- - ?R7 ? ? - -

pexec: I1 I2 - I4 I5 - - M1 - M3 - - M6 O1 O2 O3 - O5 O6 E1 - - E4 - E6 R1 - -
- - R6 - - - S1 -

xjobs: TODO - Будь ласка, надішліть звіт про помилку, якщо ви знаєте, які функції підтримує xjobs (Див.
ПОВІДОМЛЕННЯ ПРО ПОМИЛКИ).

prll: TODO - Будь ласка, надішліть звіт про помилку, якщо ви знаєте, які функції підтримує prll (Див
ПОВІДОМЛЕННЯ ПРО ПОМИЛКИ).

dxargs: TODO - Будь ласка, надішліть звіт про помилку, якщо ви знаєте, які функції підтримує dxargs (Див.
ПОВІДОМЛЕННЯ ПРО ПОМИЛКИ).

mdm/middelman: TODO - Будь ласка, надішліть звіт про помилку, якщо ви знаєте, які функції mdm/middelman
підтримує (Див. ПОВІДОМЛЕННЯ ПРО ПОМИЛКИ).

xapply: TODO - Будь ласка, надішліть звіт про помилку, якщо ви знаєте, які функції підтримує xapply (див.
ПОВІДОМЛЕННЯ ПРО ПОМИЛКИ).

paexec: TODO - Будь ласка, надішліть звіт про помилку, якщо ви знаєте, які функції підтримує paexec (див.
ПОВІДОМЛЕННЯ ПРО ПОМИЛКИ).

ladon: TODO - Будь ласка, надішліть звіт про помилку, якщо ви знаєте, які функції підтримує ladon (Див.
ПОВІДОМЛЕННЯ ПРО ПОМИЛКИ).

ClusterSSH: TODO - Будь ласка, надішліть звіт про помилку, якщо ви знаєте, які функції підтримує ClusterSSH
(Див. ПОВІДОМЛЕННЯ ПРО ПОМИЛКИ).

РІЗНАННЯ МІЖ ксарг І GNU Паралельні
ксарг пропонує деякі з тих самих можливостей, що й GNU паралельно.

ксарг погано справляється зі спеціальними символами (такими як пробіл, ' і "). Щоб побачити проблему, спробуйте
це:

торкніться важливого_файлу
торкніться «неважливий_файл»
Не* | xargs rm
mkdir -p "Записи 12 мого брата"
ls | xargs rmdir

Ви можете вказати -0 or -d "\n", але багато генераторів вхідних даних не оптимізовані для використання NUL
як роздільник, але оптимізовані для новий рядок як роздільник. напр голова, хвіст, awk, ls, нудьгувати,
sed, дьоготь -v, Perl (-0 і \0 замість \n), розмістити (потребує використання -0), знаходити (Потрібно
використання -друк0), GREP (потребує користувача для використання -z or -Z), сортувати (потребує використання -z).

Отже, GNU паралельноРозділення нового рядка можна емулювати за допомогою:

як | ксарг -d "\n" -n1 команда

ксарг може виконувати задану кількість завдань паралельно, але не підтримує виконання ряду-
паралельні завдання з процесорними ядрами.

ксарг не підтримує групування виводу, тому вихід може виконуватися разом, наприклад
перша половина рядка з одного процесу, а остання половина рядка з іншого
процес. Приклад Паралельні GREP неможливо зробити надійно з ксарг через це. До
подивіться це в дії, спробуйте:

parallel perl -e '\$a=\"1{}\"x10000000\;print\ \$a,\"\\n\"' '>' {} ::: abcdef
ls -labcdef
parallel -kP4 -n1 grep 1 > out.par ::: abcdef
echo abcdef | xargs -P4 -n1 grep 1 > out.xargs-unbuf
echo abcdef | xargs -P4 -n1 grep --line-buffered 1 > out.xargs-linebuf
echo abcdef | xargs -n1 grep 1 > out.xargs-serial
ls -l out*
md5sum out*

ксарг не підтримує збереження порядку виводу, тому якщо запущені завдання
паралельне використання ксарг вихід другого завдання не можна відкласти до першого завдання
робиться.

ксарг не підтримує виконання завдань на віддалених комп’ютерах.

ксарг не має підтримки заміни контексту, тому вам доведеться створити аргументи.

Якщо ви використовуєте рядок заміни в ксарг (-I) не можна змусити ксарг використовувати більше одного
аргумент.

Цитування в ксарг працює як -q в GNU паралельно. Це означає складені команди і
перенаправлення вимагає використання бити -c.

ls | паралельно "туалет {} > {}.туалет"

стає (якщо у вас є 8 ядер)

ls | ксарг -d "\n" -Р8 -I {} бити -c "туалет {} > {}.туалет"

та

ls | паралельно "відлуння {}; ls {}|туалет"

стає (якщо у вас є 8 ядер)

ls | ксарг -d "\n" -Р8 -I {} бити -c "відлуння {}; ls {}|туалет"

РІЗНАННЯ МІЖ знаходити Exec- І GNU Паралельні
знаходити Exec- пропонують деякі з тих самих можливостей, що й GNU паралельно.

знаходити Exec- працює лише з файлами. Тому обробка інших введених даних (наприклад, хости або URL-адреси) буде відбуватися
вимагають створення цих входів як файлів. знаходити Exec- не підтримує виконання команд у
паралельні.

РІЗНАННЯ МІЖ зробити -j І GNU Паралельні
зробити -j може виконувати завдання паралельно, але для цього потрібен створений Makefile. Це призводить
у додаткових лапках, щоб назва файлу, що містить новий рядок, працювала правильно.

зробити -j не підтримує групування виводу, тому вихід може виконуватися разом, напр
перша половина рядка — від одного процесу, а остання половина — від іншого
процес. Приклад Паралельні GREP неможливо зробити надійно з зробити -j Тому що.

(Дуже ранні версії GNU паралельно були реалізовані за збігом обставин зробити -j).

РІЗНАННЯ МІЖ ppss І GNU Паралельні
ppss також є інструментом для паралельного виконання завдань.

Вихідні дані ppss є інформацією про стан і, таким чином, не є корисним для використання як вхідні дані для
інша команда. Результати завдань поміщаються у файли.

Аргумент заміни рядка ($ITEM) не можна змінити. Аргументи треба цитувати - таким чином
Аргументи, що містять спеціальні символи (пробіл «&!*), можуть спричинити проблеми. Більше одного
аргумент не підтримується. Імена файлів, які містять нові рядки, обробляються неправильно.
Під час читання введених даних з файлу null не може використовуватися як термінатор. ppss необхідно прочитати
весь вхідний файл перед початком будь-яких завдань.

Вихідна інформація та інформація про стан зберігається в ppss_dir і, таким чином, потребує очищення
завершено. Якщо перед запуском каталог не видалено ppss знову ж таки це може ні до чого
відбуватися як ppss вважає, що завдання вже виконане. GNU паралельно зазвичай не знадобиться
очищення, якщо воно працює локально, і очищення знадобиться лише в разі ненормальної зупинки та
запуск дистанційного керування (--прибирати може не завершитися, якщо зупинити ненормально). Приклад Паралельні
GREP вимагатиме додаткової постобробки, якщо написано з використанням ppss.

Для віддалених систем PPSS вимагає 3 кроків: конфігурація, розгортання та запуск. GNU паралельно тільки
вимагає одного кроку.

ПРИКЛАДИ З ppss КЕРІВНИЦТВО

Ось приклади з ppssсторінка посібника з еквівалентом за допомогою GNU паралельно:

1 ./ppss.sh автономний -d /шлях/до/файлів -c 'gzip'

1 знайти /шлях/до/файлів -тип f | паралельний gzip

2 ./ppss.sh standalone -d /path/to/files -c 'cp "$ITEM" /destination/dir '

2 знайти /шлях/до/файлів -тип f | паралельний cp {} /destination/dir

3 ./ppss.sh автономний -f list-of-urls.txt -c 'wget -q '

3 parallel -a list-of-urls.txt wget -q

4 ./ppss.sh standalone -f list-of-urls.txt -c 'wget -q "$ITEM"'

4 parallel -a list-of-urls.txt wget -q {}

5 ./ppss config -C config.cfg -c 'encode.sh ' -d /source/dir -m 192.168.1.100 -u ppss -k
ppss-key.key -S ./encode.sh -n nodes.txt -o /some/output/dir --upload --download ; ./ppss
розгорнути -C config.cfg ; ./ppss start -C config

5 # parallel не використовує конфігурації. Якщо вам потрібно інше ім’я користувача, введіть його в nodes.txt:
користувач@ім'я хоста

5 знайти джерело/каталог -тип f | parallel --sshloginfile nodes.txt --trc {.}.mp3 lame -a {} -o
{.}.mp3 --попередньо встановлений стандарт --тихий

6 ./ppss stop -C config.cfg

6 killall -TERM паралельно

7 ./ppss pause -C config.cfg

7 Натисніть: CTRL-Z або killall -SIGTSTP паралельно

8 ./ppss продовжити -C config.cfg

8 Введіть: fg або killall -SIGCONT паралельно

9 ./ppss.sh статус -C config.cfg

9 killall -SIGUSR2 паралельно

РІЗНАННЯ МІЖ pexec І GNU Паралельні
pexec також є інструментом для паралельного виконання завдань.

ПРИКЛАДИ З pexec КЕРІВНИЦТВО

Ось приклади з pexecінформаційна сторінка з еквівалентом за допомогою GNU паралельно:

1 pexec -o sqrt-%s.dat -p "$(seq 10)" -e NUM -n 4 -c -- \
'echo "scale=10000;sqrt($NUM)" | до нашої ери

1 послідовність 10 | parallel -j4 'echo "scale=10000;sqrt({})" | bc > sqrt-{}.dat'

2 pexec -p "$(ls myfiles*.ext)" -i %s -o %s.sort -- сортування

2 ls myfiles*.ext | паралельне сортування {} ">{}.sort"

3 pexec -f image.list -n auto -e B -u star.log -c -- \
'fistar $B.fits -f 100 -F id,x,y,flux -o $B.star'

3 parallel -a image.list \
'fistar {}.fits -f 100 -F id,x,y,flux -o {}.star' 2>star.log

4 pexec -r *.png -e IMG -c -o - -- \
'перетворити $IMG ${IMG%.png}.jpeg ; "echo $IMG: готово"'

4 ls *.png | parallel 'перетворити {} {.}.jpeg; echo {}: готово'

5 pexec -r *.png -i %s -o %s.jpg -c 'pngtopnm | pnmtojpeg'

5 ls *.png | parallel 'pngtopnm < {} | pnmtojpeg > {}.jpg'

6 для p у *.png ; do echo ${p%.png} ; зроблено | \
pexec -f - -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'

6 ls *.png | parallel 'pngtopnm < {} | pnmtojpeg > {.}.jpg'

7 LIST=$(для p у *.png ; зробити echo ${p%.png} ; зроблено)
pexec -r $LIST -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'

7 ls *.png | parallel 'pngtopnm < {} | pnmtojpeg > {.}.jpg'

8 pexec -n 8 -r *.jpg -y unix -e IMG -c \
'pexec -j -m blockread -d $IMG | \
jpegtopnm | pnmscale 0.5 | pnmtojpeg | \
pexec -j -m blockwrite -s th_$IMG'

8 Поєднання GNU паралельно та GNU без.

8 ls *jpg | parallel -j8 'sem --id blockread cat {} | jpegtopnm |' \
'pnmscale 0.5 | pnmtojpeg | sem --id blockwrite cat > th_{}'

8 Якщо читання та запис виконуються на одному диску, це може бути швидше, оскільки лише один процес
буде читати або писати:

8 ls *jpg | parallel -j8 'sem --id diskio cat {} | jpegtopnm |' \
'pnmscale 0.5 | pnmtojpeg | sem --id diskio cat > th_{}'

РІЗНАННЯ МІЖ xjobs І GNU Паралельні
xjobs також є інструментом для паралельного виконання завдань. Він підтримує лише виконання завдань на вашому пристрої
локальний комп'ютер.

xjobs погано справляється зі спеціальними символами ксарг. Дивіться розділ РІЗНАННЯ
МІЖ ксарг І GNU Паралельні.

Ось приклади з xjobsДовідкова сторінка з еквівалентом за допомогою GNU паралельно:

1 ls -1 *.zip | xjobs розпакувати

1 ls *.zip | паралельно розстебнути

2 ls -1 *.zip | xjobs -n розпакувати

2 ls *.zip | паралельно розпакувати >/dev/null

3 знайти . -ім'я '*.bak' | xjobs gzip

3 знайти . -ім'я '*.bak' | паралельний gzip

4 ls -1 *.jar | sed 's/\(.*\)/\1 > \1.idx/' | xjobs jar tf

4 ls *.jar | паралельний jar tf {} '>' {}.idx

5 xjobs -s сценарій

5 котячий сценарій | паралельні

6 mkfifo /var/run/my_named_pipe; xjobs -s /var/run/my_named_pipe & echo unzip 1.zip >>
/var/run/my_named_pipe; echo tar cf /backup/myhome.tar /home/me >> /var/run/my_named_pipe

6 mkfifo /var/run/my_named_pipe; cat /var/run/my_named_pipe | parallel & echo розпакуйте 1.zip
>> /var/run/my_named_pipe; echo tar cf /backup/myhome.tar /home/me >>
/var/run/my_named_pipe

РІЗНАННЯ МІЖ prll І GNU Паралельні
prll також є інструментом для паралельного виконання завдань. Він не підтримує виконання завдань на
віддалені комп'ютери.

prll заохочує використовувати псевдоніми BASH і функції BASH замість сценаріїв. GNU паралельно
ніколи не підтримуватиме запущені псевдоніми (дивіться чому
http://www.perlmonks.org/index.pl?node_id=484296). Однак сценарії, складені команди або
функції, експортовані за допомогою експорт -f працювати просто чудово.

prll генерує багато інформації про стан stderr (стандартна помилка), що робить його
важче використовувати вихідні дані завдання stderr (стандартна помилка) безпосередньо як вхідні дані для іншого
програми.

Ось приклад з prllДовідкова сторінка з еквівалентом за допомогою GNU паралельно:

prll -s 'mogrify -flip $1' *.jpg

паралельно mogrify -flip ::: *.jpg

РІЗНАННЯ МІЖ dxargs І GNU Паралельні
dxargs також є інструментом для паралельного виконання завдань.

dxargs погано справляється з більшою кількістю одночасних завдань, ніж MaxStartups SSHD. dxargs is
створений лише для завдань віддаленого запуску, але не підтримує передачу файлів.

РІЗНАННЯ МІЖ mdm/середник І GNU Паралельні
посередник(mdm) також є інструментом для паралельного виконання завдань.

Ось сценарії оболонки http://mdm.berlios.de/usage.html портовано на GNU паралельно:

далі 19 | паралельно скоморох -o - | сортувати -n > результат

як файли | паралельно CMD

знаходити реж -execdir без CMD {} \;

РІЗНАННЯ МІЖ xapply І GNU Паралельні
xapply може виконувати завдання паралельно на локальному комп’ютері.

Ось приклади з xapplyДовідкова сторінка з еквівалентом за допомогою GNU паралельно:

1 xapply '(cd %1 && зробити все)' */

1 parallel 'cd {} && make all' ::: */

2 xapply -f 'diff %1 ../version5/%1' маніфест | більше

2 parallel diff {} ../version5/{} < маніфест | більше

3 xapply -p/dev/null -f 'diff %1 %2' маніфест1 контрольний список1

3 parallel --xapply diff {1} {2} :::: маніфест1 контрольний список1

4 xapply 'відступ' *.c

4 паралельний відступ ::: *.c

5 знайти ~ksb/bin -type f! -завивка -111 -друк | xapply -f -v 'chmod a+x' -

5 знайти ~ksb/bin -type f! -завивка -111 -друк | паралельно -v chmod a+x

6 знайти */ -... | fmt 960 1024 | xapply -f -i /dev/tty 'vi' -

6 sh <(знайти */ -... | parallel -s 1024 echo vi)

6 знайти */ -... | паралельний -s 1024 -Xuj1 vi

7 знайти ... | xapply -f -5 -i /dev/tty 'vi' - - - - -

7 sh <(знайти ... |parallel -n5 echo vi)

7 знайти ... |паралель -n5 -uj1 vi

8 xapply -fn "" / etc / passwd

8 паралельно -к відлуння / etc / passwd

9 tr ':' '\012' / etc / passwd | xapply -7 -nf 'chown %1 %6' - - - - - - -

9 tr ':' '\012' / etc / passwd | паралельний -N7 chown {1} {6}

10 xapply '[ -d %1/RCS ] || луна %1' */

10 паралельний '[ -d {}/RCS] || echo {}' ::: */

11 xapply -f '[ -f %1 ] && echo %1' Список | ...

11 parallel '[ -f {} ] && echo {}' < Список | ...

РІЗНАННЯ МІЖ paexec І GNU Паралельні
paexec може виконувати завдання паралельно як на локальному, так і на віддаленому комп’ютері.

paexec вимагає команд для друку порожнього рядка як останнього результату. Це означає, що ви будете
для більшості програм потрібно написати обгортку.

paexec має функцію залежності від роботи, тому завдання може залежати від іншого завдання, яке буде виконано
успішно. Начебто бідняк зробити.

Ось приклади з paexec's приклад каталогу з еквівалентом за допомогою GNU
паралельно:

1_div_X_run:
../../paexec -s -l -c "`pwd`/1_div_X_cmd" -n +1 <
паралельне відлуння {} '|' `pwd`/1_div_X_cmd <

all_substr_run:
../../paexec -lp -c "`pwd`/all_substr_cmd" -n +3 <
паралельне відлуння {} '|' `pwd`/all_substr_cmd <

cc_wrapper_run:
../../paexec -c "env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd" \
-n 'хост1 хост2' \
-т '/usr/bin/ssh -x' <
паралельне відлуння {} '|' "env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd" \
-S хост1, хост2 <
# Це не зовсім те саме, але уникає обгортки
паралельно gcc -O2 -c -o {.}.o {} \
-S хост1, хост2 <

toupper_run:
../../paexec -lp -c "`pwd`/toupper_cmd" -n +10 <
паралельне відлуння {} '|' ./toupper_cmd <
# Без обгортки:
паралельне відлуння {} '| awk {print\ toupper\(\$0\)}' <

РІЗНАННЯ МІЖ карта І GNU Паралельні
карта розглядає це як можливість мати менше функцій, і при цьому він також обробляє кути
випадків неправильно. Багато GNU паралельноКод 's призначений для правильної обробки кутових випадків
на кожній платформі, тому ви не отримаєте неприємного сюрпризу, якщо користувач, наприклад, збереже файл
називається: My братів 12" records.txt

карта's приклад, який показує, як працювати зі спеціальними символами, не працює для спеціальних символів:

echo "The Cure" > Записи мого\ брата\ 12\"\

ls | map 'echo -n `gzip < "%" | туалет -c`; echo -n '*100/'; wc -c < "%"' | до нашої ери

Він працює з GNU паралельно:

ls | parallel 'echo -n `gzip < {} | туалет -c`; echo -n '*100/'; wc -c < {}' | до нашої ери

І ви навіть можете додати ім’я файлу до початку:

ls | parallel --tag '(echo -n `gzip < {} | wc -c`'*100/'; wc -c < {}) | до нашої ери

карта не підтримує групування. Отже, це дає неправильні результати без будь-яких попереджень:

parallel perl -e '\$a=\"1{}\"x10000000\;print\ \$a,\"\\n\"' '>' {} ::: abcdef
ls -labcdef
parallel -kP4 -n1 grep 1 > out.par ::: abcdef
map -p 4 'grep 1' abcdef > out.map-unbuf
map -p 4 'grep --line-buffered 1' abcdef > out.map-linebuf
map -p 1 'grep --line-buffered 1' abcdef > out.map-serial
ls -l out*
md5sum out*

Документація показує обхідний шлях, але не тільки змішує стандартний вихід (стандартний вихід)
зі stderr (стандартна помилка) він також повністю виходить з ладу для певних завдань (і може навіть бути
вважається менш читабельним):

паралельне відлуння -n {} ::: 1 2 3

map -p 4 'echo -n % 2>&1 | sed -e "s/^/$$:/"' 1 2 3 | сортувати | вирізати -f2- -d:

карта не може обробляти пакетні параметри: карта -вп 0 нудьгувати це зазнає невдачі

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

map -p 2 perl\\\ -ne\\\ \\\'/^\\\\S+\\\\s+\\\\S+\\\$/\\\ та\\\ print\\\ \\\$ARGV,\\\"\\\\n\\\"\\\' *

parallel -q perl -ne '/^\S+\s+\S+$/ і надрукувати $ARGV,"\n"' ::: *

карта може виконувати кілька аргументів із заміною контексту, але не без заміни контексту:

parallel --xargs echo 'BEGIN{'{}'}END' ::: 1 2 3

карта не встановлює значення виходу відповідно до того, чи не вдалося виконати одне із завдань:

паралельно false ::: 1 || echo Не вдалося виконати роботу

карта false 1 || echo Ніколи не бігайте

карта вимагає Perl версії 5.10.0, що ускладнює використання на старих системах.

карта не має можливості використовувати % у команді (GNU Parallel має -I, щоб вказати інше
рядок заміни, ніж {}).

By design карта є варіантом, несумісним з ксарг, він не має віддаленого виконання завдання, a
структурований спосіб збереження результатів, кілька джерел введення, індикатор прогресу, настроюється
роздільник записів (тільки роздільник полів), журнал виконання завдань з можливістю відновити,
зберігаючи вихідні дані в тому ж порядку, що й вхідні, обробку --pipe та динамічно
тайм-аути.

РІЗНАННЯ МІЖ Ladon І GNU Паралельні
Ladon може паралельно виконувати кілька завдань над файлами.

Ladon працює лише з файлами, і єдиний спосіб вказати файли - це використовувати рядок у лапках
(наприклад, \*.jpg). Неможливо перерахувати файли вручну.

Як рядки заміни він використовує FULLPATH DIRNAME BASENAME EXT RELDIR RELPATH

Їх можна моделювати за допомогою GNU паралельно вставивши це ~/.parallel/config:

--rpl 'FULLPATH $_=::shell_quote($_);chomp($_=qx{readlink -f $_});'
--rpl 'DIRNAME $_=::shell_quote(::dirname($_));chomp($_=qx{readlink -f $_});'
--rpl 'BASENAME s:.*/::;s:\.[^/.]+$::;'
--rpl 'EXT s:.*\.::'
--rpl 'RELDIR $_=::shell_quote($_);chomp(($_,$c)=qx{readlink -f $_;pwd});s:\Q$c/\E::; $_=::dirname($_);'
--rpl 'RELPATH $_=::shell_quote($_);chomp(($_,$c)=qx{readlink -f $_;pwd});s:\Q$c/\E::; '

Ladon погано справляється з іменами файлів, що містять " і новий рядок, і не вдається для виведення більшого розміру
ніж 200 тис.:

ladon '*' -- seq 36000 | туалет

ПРИКЛАДИ З Ladon КЕРІВНИЦТВО

Передбачається, що '--rpl вище вставлено ~/.parallel/config і що він запущений
під оболонкою, яка підтримує глобінг '**' (наприклад zsh):

1 ladon "**/*.txt" -- echo RELPATH

1 паралельне відлуння RELPATH ::: **/*.txt

2 ладон "~/Документи/**/*.pdf" -- shasum FULLPATH >hashes.txt

2 паралельний shasum FULLPATH ::: ~/Документи/**/*.pdf >hashes.txt

3 ladon -m thumbs/RELDIR "**/*.jpg" loading="lazy" -- конвертувати FULLPATH -thumbnail 100x100^ -gravity
центр - розмір 100x100 великих пальців/RELPATH

3 паралельний mkdir -p thumbs/RELDIR\; convert FULLPATH -ескіз 100x100^ -центр тяжіння
-розмір 100x100 thumbs/RELPATH ::: **/*.jpg

4 ладон "~/Музика/*.wav" -- lame -V 2 FULLPATH DIRNAME/BASENAME.mp3

4 parallel lame -V 2 FULLPATH DIRNAME/BASENAME.mp3 ::: ~/Музика/* .wav

РІЗНАННЯ МІЖ ClusterSSH І GNU Паралельні
ClusterSSH вирішує іншу проблему, ніж GNU паралельно.

ClusterSSH відкриває вікно терміналу для кожного комп’ютера, і за допомогою головного вікна можна запускати
та сама команда на всіх комп’ютерах. Зазвичай це використовується для керування кількома
майже ідентичні комп’ютери.

GNU паралельно паралельно виконує ті самі (або різні) команди з різними аргументами
можливо, використання віддалених комп’ютерів, щоб допомогти обчисленню. Якщо в списку вказано більше одного комп’ютера
-S GNU паралельно може використовувати лише одне з них (наприклад, якщо потрібно виконати 8 завдань і одне
комп’ютер має 8 ядер).

GNU паралельно можна використовувати як версію ClusterSSH для бідняків:

паралельно --не всі -S сервер-а, сервер-б do_stuff Foo бар

Використовуйте паралельний режим онлайн за допомогою служб onworks.net