نام (NAME)

parallel - ساخت و اجرای خطوط دستور شل از ورودی استاندارد به‌صورت موازی

خلاصه دستور (SYNOPSIS)

parallel [گزینه‌ها] [command [arguments]] < list_of_arguments

parallel [گزینه‌ها] [command [arguments]] ( ::: arguments | :::+ arguments | :::: argfile(s) | ::::+ argfile(s) ) ...

parallel --semaphore [گزینه‌ها] command

#!/usr/bin/parallel --shebang [گزینه‌ها] [command [arguments]]

#!/usr/bin/parallel --shebang-wrap [گزینه‌ها] [command [arguments]]

توضیحات (DESCRIPTION)

توقف!

اگر به تازگی کار با GNU parallel را آغاز کرده‌اید، بخش راهنمای خواننده در ادامه را مطالعه کنید.

ابزار GNU parallel یک ابزار شل برای اجرای موازی کارها (jobs) با استفاده از یک یا چند رایانه است. یک کار می‌تواند یک دستور منفرد یا یک اسکریپت کوچک باشد که باید برای هر یک از خطوط ورودی اجرا شود. ورودی معمولاً فهرستی از فایل‌ها، میزبان‌ها (hosts)، کاربران، نشانی‌های وب (URLs) یا جدولی از داده‌ها است. یک کار همچنین می‌تواند دستوری باشد که از یک پایپ (pipe) ورودی می‌خواند؛ در این حالت GNU parallel می‌تواند ورودی را به بلوک‌هایی تقسیم کرده و هر بلوک را به‌طور موازی به دستور پایپ کند.

اگر امروزه از xargs و tee استفاده می‌کنید، کار با GNU parallel را بسیار آسان خواهید یافت چرا که به گونه‌ای نوشته شده است که گزینه‌های مشابه xargs داشته باشد. اگر در شل حلقه می‌نویسید، GNU parallel می‌تواند جایگزین بیشتر حلقه‌ها شود و با اجرای هم‌زمان چندین کار به‌صورت موازی، سرعت اجرای آن‌ها را افزایش دهد.

ابزار GNU parallel تضمین می‌کند که خروجی حاصل از دستورات دقیقاً همان خروجی باشد که در صورت اجرای ترتیبی به دست می‌آوردید. این ویژگی استفاده از خروجی GNU parallel را به‌عنوان ورودی سایر برنامه‌ها ممکن می‌سازد.

به ازای هر خط از ورودی، GNU parallel دستور command را با آن خط به‌عنوان آرگومان اجرا می‌کند. اگر هیچ command مشخص نشده باشد، خود خط ورودی اجرا می‌شود. چندین خط به‌طور همزمان اجرا خواهند شد. GNU parallel اغلب می‌تواند به‌عنوان جایگزینی برای xargs یا cat | bash استفاده شود.

گزینه‌ها (OPTIONS)

command

دستور برای اجرا.

اگر command یا آرگومان‌های بعدی شامل رشته‌های جایگزینی (مانند {}) باشند، هر مورد با ورودی جایگزین خواهد شد.

اگر command مشخص شده باشد، GNU parallel همان وظایف xargs را انجام می‌دهد. اگر command داده نشود، GNU parallel رفتاری مشابه cat | sh خواهد داشت.

مقدار command باید یک فایل اجرایی، یک اسکریپت، یک دستور ترکیبی، یک نام مستعار (alias) یا یک تابع باشد.

توابع Bash: ابتدا تابع را با export -f اکسپورت کنید یا از env_parallel استفاده نمایید.

نام‌های مستعار Bash، Csh یا Tcsh: از env_parallel استفاده کنید.

توابع و نام‌های مستعار Zsh، Fish، Ksh و Pdksh: از env_parallel استفاده کنید.

{}

خط ورودی.

این رشته جایگزینی با یک خط کامل خوانده‌شده از منبع ورودی جایگزین می‌شود. منبع ورودی معمولاً stdin (ورودی استاندارد) است، اما با --arg-file، ::: یا :::: نیز می‌تواند مشخص شود.

رشته جایگزینی {} را می‌توان با -I تغییر داد.

اگر خط فرمان هیچ رشته جایگزینی نداشته باشد، {} به انتهای خط فرمان اضافه خواهد شد.

رشته‌های جایگزینی معمولاً نقل‌قول (کوتیشن) می‌شوند تا کاراکترهای ویژه توسط شل پردازش نشوند. استثنا زمانی است که دستور با یک رشته جایگزینی شروع شود؛ در این صورت رشته کوتیشن نمی‌شود.

همچنین ببینید: --plus {.} {/} {//} {/.} {#} {%} {n} {=perl expression=}

{.}

خط ورودی بدون پسوند.

این رشته جایگزینی با ورودی پس از حذف پسوند آن جایگزین می‌شود. اگر خط ورودی بعد از آخرین / حاوی . باشد، آخرین . تا انتهای رشته حذف شده و {.} با باقیمانده متن جایگزین می‌شود. برای مثال foo.jpg تبدیل به foo می‌شود، subdir/foo.jpg به subdir/foo، sub.dir/foo.jpg به sub.dir/foo، و sub.dir/bar بدون تغییر به‌صورت sub.dir/bar باقی می‌ماند. اگر خط ورودی شامل . نباشد، دست‌نخورده باقی می‌ماند.

رشته جایگزینی {.} را می‌توان با --extensionreplace تغییر داد.

همچنین ببینید: {} --extensionreplace

{/}

نام پایه (basename) خط ورودی.

این رشته جایگزینی با ورودی پس از حذف بخش دایرکتوری جایگزین می‌شود.

همچنین ببینید: {} --basenamereplace

{//}

نام دایرکتوری (dirname) خط ورودی.

این رشته جایگزینی با مسیر دایرکتوری خط ورودی جایگزین می‌شود. به dirname(1) مراجعه کنید.

همچنین ببینید: {} --dirnamereplace

{/.}

نام پایه (basename) خط ورودی بدون پسوند.

این رشته جایگزینی با ورودی پس از حذف هر دو بخش دایرکتوری و پسوند جایگزین می‌شود. {/.} ترکیبی از {/} و {.} است.

همچنین ببینید: {} --basenameextensionreplace

{#}

شماره ترتیبی کاری که باید اجرا شود.

این رشته جایگزینی با شماره ترتیبی کار در حال اجرا جایگزین می‌شود. این مقدار معادل متغیر $PARALLEL_SEQ است.

همچنین ببینید: {} --seqreplace

{%} (آزمایشی / alpha testing)

شماره اسلات (slot) کار.

این رشته جایگزینی با شماره اسلات کار بین ۱ و تعداد کارهای قابل اجرا به‌صورت موازی جایگزین می‌شود. هیچ‌گاه ۲ کار به‌طور همزمان با یک شماره اسلات یکسان اجرا نخواهند شد.

اگر نیاز به تلاش مجدد برای یک کار باشد (مثلاً با استفاده از --retries یا --retry-failed)، شماره اسلات کار به‌طور خودکار به‌روزرسانی نمی‌شود. در این حالت باید در عوض از $PARALLEL_JOBSLOT استفاده کنید:

$ do_test() {
    id="$3 {%}=$1 PARALLEL_JOBSLOT=$2"
    echo run "$id";
    sleep 1
    # fail if {%} is odd
    return `echo $1%2 | bc`
  }
$ export -f do_test
$ parallel -j3 --jl mylog do_test {%} \$PARALLEL_JOBSLOT {} ::: A B C D
run A {%}=1 PARALLEL_JOBSLOT=1
run B {%}=2 PARALLEL_JOBSLOT=2
run C {%}=3 PARALLEL_JOBSLOT=3
run D {%}=1 PARALLEL_JOBSLOT=1
$ parallel --retry-failed -j3 --jl mylog do_test {%} \$PARALLEL_JOBSLOT {} ::: A B C D
run A {%}=1 PARALLEL_JOBSLOT=1
run C {%}=3 PARALLEL_JOBSLOT=2
run D {%}=1 PARALLEL_JOBSLOT=3

توجه کنید که چگونه {%} و $PARALLEL_JOBSLOT در اجرای مجدد C و D تفاوت دارند.

همچنین ببینید: {} --jobs --slotreplace

{n}

آرگومان برگرفته از منبع ورودی n یا n'مین آرگومان.

این رشته جایگزینی موقعیتی با مقدار ورودی از منبع ورودی n (هنگام استفاده با --arg-file یا ::::) یا با n'مین آرگومان (هنگام استفاده با -N یا --colsep) جایگزین می‌شود.

اگر n منفی باشد، به n'مین آرگومان از انتها اشاره دارد.

همچنین ببینید: {} {n.} {n/} {n//} {n/.} --colsep

{n.}

آرگومان برگرفته از منبع ورودی n یا n'مین آرگومان بدون پسوند.

{n.} ترکیبی از {n} و {.} است.

این رشته جایگزینی موقعیتی با مقدار ورودی از منبع ورودی n (هنگام استفاده با --arg-file یا ::::) یا با n'مین آرگومان (هنگام استفاده با -N) پس از حذف پسوند آن جایگزین می‌شود.

همچنین ببینید: {n} {.}

{n/}

نام پایه (basename) آرگومان برگرفته از منبع ورودی n یا n'مین آرگومان.

{n/} ترکیبی از {n} و {/} است.

این رشته جایگزینی موقعیتی با مقدار ورودی از منبع ورودی n (هنگام استفاده با --arg-file یا ::::) یا با n'مین آرگومان (هنگام استفاده با -N) پس از حذف بخش دایرکتوری (در صورت وجود) جایگزین می‌شود.

همچنین ببینید: {n} {/}

{n//}

نام دایرکتوری (dirname) آرگومان برگرفته از منبع ورودی n یا n'مین آرگومان.

{n//} ترکیبی از {n} و {//} است.

این رشته جایگزینی موقعیتی با مسیر دایرکتوری ورودی از منبع ورودی n (هنگام استفاده با --arg-file یا ::::) یا با n'مین آرگومان (هنگام استفاده با -N) جایگزین می‌شود. به dirname(1) مراجعه کنید.

همچنین ببینید: {n} {//}

{n/.}

نام پایه (basename) آرگومان برگرفته از منبع ورودی n یا n'مین آرگومان بدون پسوند.

{n/.} ترکیبی از {n}، {/} و {.} است.

این رشته جایگزینی موقعیتی با مقدار ورودی از منبع ورودی n (هنگام استفاده با --arg-file یا ::::) یا با n'مین آرگومان (هنگام استفاده با -N) پس از حذف هر دو بخش دایرکتوری (در صورت وجود) و پسوند جایگزین می‌شود.

همچنین ببینید: {n} {/.}

{=perl expression=}

جایگزینی با مقدار محاسبه‌شده perl expression.

متغیر $_ حاوی همان مقدار {} خواهد بود. پس از ارزیابی perl expression، مقدار $_ به‌عنوان مقدار جایگزین استفاده خواهد شد. توصیه می‌شود فقط $_ را تغییر دهید، هرچند به تمامی توابع و ساختارهای داده داخلی GNU parallel دسترسی کامل دارید.

عبارت باید در صورت دو بار ارزیابی شدن نتیجه یکسانی ارائه دهد - در غیر این صورت رفتار نامشخص خواهد بود. به عنوان مثال در برخی از نسخه‌های GNU parallel این دستور طبق انتظار کار نخواهد کرد:

parallel echo '{= $_= ++$wrong_counter =}' ::: a b c

چندین تابع و ساختار داده کمکی جهت سهولت استفاده در نظر گرفته شده است:

parallel echo {} is quoted as '{= $_=Q($_) =}' ::: \$PWD

seq 10 | parallel echo {} + 1 is {= '$_++' =}
parallel csh -c {= '$_="mkdir ".Q($_)' =} ::: '12" dir'
seq 50 | parallel echo job {#} of {= '$_=total_jobs()' =}

{=n perl expression=}

معادل مکانی برای {=perl expression=}.

برای درک رشته‌های جایگزین مکانی، {n} را ببینید.

همچنین ببینید: {=perl expression=} {n}

{rpl:format}

قالب‌بندی رشته جایگزین.

از format برای قالب‌بندی rpl استفاده کنید. format یک رشته قالب استفاده‌شده در printf است. rpl یک رشته جایگزین است.

مثال‌ها:

{#:%04d} - Job number ({#}) with 4 digits prepended with 0
{%:%02d} - Job slot ({%}) with 2 digits prepended with 0
{:%6s} - Input line ({}) right aligned 6 chars wide
{/:%12s} - Basename ({/}) right aligned 12 chars wide
{2:%8.2f} - Second input source ({2}) 8 chars wide, 2 decimals

رشته‌های قالب همچنین روی رشته‌های جایگزین تعریف‌شده از طریق --rpl که با '{' شروع می‌شوند کار می‌کنند.

همچنین ببینید: {} {n} --rpl

::: arguments

استفاده از آرگومان‌ها در خط فرمان به عنوان منبع ورودی.

برخلاف سایر گزینه‌های GNU parallel، ::: پس از command و قبل از آرگومان‌ها قرار می‌گیرد.

موارد زیر معادل هستند:

(echo file1; echo file2) | parallel gzip
parallel gzip ::: file1 file2
parallel gzip {} ::: file1 file2
parallel --arg-sep ,, gzip {} ,, file1 file2
parallel --arg-sep ,, gzip ,, file1 file2
parallel ::: "gzip file1" "gzip file2"

برای جلوگیری از برخورد ویژه با :::، از --arg-sep برای تنظیم جداکننده آرگومان به چیزی دیگر استفاده کنید.

اگر چند ::: داده شوند، با هر گروه مانند یک منبع ورودی رفتار خواهد شد و تمام ترکیب‌های منابع ورودی تولید می‌شوند. به عنوان مثال، ::: 1 2 ::: a b c به ترکیب‌های (1,a) (1,b) (1,c) (2,a) (2,b) (2,c) منجر خواهد شد. این قابلیت برای جایگزینی حلقه‌های تو در توی for مفید است.

می‌توان :::، :::: و --arg-file را با هم ترکیب کرد. بنابراین موارد زیر معادلند:

parallel echo {1} {2} {3} ::: 6 7 ::: 4 5 ::: 1 2 3
parallel echo {1} {2} {3} :::: <(seq 6 7) <(seq 4 5) \
  :::: <(seq 1 3)
parallel -a <(seq 6 7) echo {1} {2} {3} :::: <(seq 4 5) \
  :::: <(seq 1 3)
parallel -a <(seq 6 7) -a <(seq 4 5) echo {1} {2} {3} \
  ::: 1 2 3
seq 6 7 | parallel -a - -a <(seq 4 5) echo {1} {2} {3} \
  ::: 1 2 3
seq 4 5 | parallel echo {1} {2} {3} :::: <(seq 6 7) - \
  ::: 1 2 3

همچنین ببینید: --arg-sep --arg-file :::: :::+ ::::+ --link

:::+ arguments

مانند ::: اما مثل --link به منبع ورودی قبلی پیوند داده شده است.

بر خلاف --link، مقادیر چرخش (wrap) ندارند: کوتاه‌ترین منبع ورودی طول را تعیین می‌کند.

مثال:

parallel echo ::: a b c :::+ 1 2 3 ::: X Y :::+ 11 22

همچنین ببینید: ::::+ --link

:::: argfiles

روش دیگری برای نوشتن --arg-file argfile1 --arg-file argfile2 ...

می‌توان ::: و :::: را با هم ترکیب کرد.

همچنین ببینید: --arg-file ::: ::::+ --link

::::+ argfiles

مانند :::: اما مثل --link به منبع ورودی قبلی پیوند داده شده است.

بر خلاف --link، مقادیر چرخش ندارند: کوتاه‌ترین منبع ورودی طول را تعیین می‌کند.

همچنین ببینید: --arg-file :::+ --link

--null

-0

استفاده از NUL به عنوان جداکننده.

در حالت عادی خطوط ورودی به \n (خط جدید) ختم می‌شوند. اگر به \0 (NUL) ختم می‌شوند، از این گزینه استفاده کنید. این گزینه برای پردازش آرگومان‌هایی که ممکن است شامل \n (خط جدید) باشند مفید است.

کوتاه‌شده برای --delimiter '\0'.

همچنین ببینید: --delimiter

--arg-file input-file

-a input-file

استفاده از input-file به عنوان منبع ورودی.

اگر چند --arg-file مشخص شود، با هر input-file مانند یک منبع ورودی رفتار خواهد شد و تمام ترکیب‌های منابع ورودی تولید می‌شوند. به عنوان مثال، اگر فایل foo شامل 1 2 و فایل bar شامل a b c باشد، دستور -a foo -a bar به ترکیب‌های (1,a) (1,b) (1,c) (2,a) (2,b) (2,c) منجر خواهد شد. این قابلیت برای جایگزینی حلقه‌های تو در توی for مفید است.

اگر input-file با + آغاز شود، فایل به --arg-file قبلی پیوند داده خواهد شد. به عنوان مثال، اگر فایل foo شامل 1 2 و فایل bar شامل a b باشد، دستور -a foo -a +bar مانند --link به ترکیب‌های (1,a) (2,b) منجر می‌شود به جای اینکه تمام ترکیب‌ها تولید شوند.

همچنین ببینید: --link {n} :::: ::::+ :::

--arg-file-sep sep-str

استفاده از sep-str به جای :::: به عنوان رشته جداکننده میان دستور و فایل‌های آرگومان.

مفید در صورتی که :::: برای کار دیگری توسط دستور استفاده شود.

همچنین ببینید: ::::

--arg-sep sep-str

استفاده از sep-str به جای ::: به عنوان رشته جداکننده.

مفید در صورتی که ::: برای کار دیگری توسط دستور استفاده شود.

همچنین زمانی کاربرد دارد که دستور شما از ::: استفاده می‌کند اما همچنان می‌خواهید آرگومان‌ها را از ورودی استاندارد (stdin) بخوانید: کافی است --arg-sep را به رشته‌ای تغییر دهید که در خط فرمان وجود ندارد.

همچنین ببینید: :::

--bar

نمایش پیشرفت به صورت یک نوار پیشرفت.

در نوار موارد زیر نمایش داده می‌شوند: درصد کارهای تکمیل‌شده، تخمین ثانیه‌های باقی‌مانده و تعداد کارهای شروع‌شده.

با zenity سازگار است:

seq 1000 | parallel -j30 --bar '(echo {};sleep 0.1)' \
  2> >(perl -pe 'BEGIN{$/="\r";$|=1};s/\r/\n/g' |
       zenity --progress --auto-kill) | wc

همچنین ببینید: --eta --progress --total-jobs

--basefile file (beta testing)

--bf file (beta testing)

پرونده file قبل از شروع اولین کار به هر sshlogin منتقل خواهد شد.

در صورت فعال بودن --cleanup، پرونده حذف خواهد شد. این فایل می‌تواند اسکریپتی برای اجرا یا داده‌های پایه مشترک مورد نیاز برای کار باشد. می‌توان چندین --bf را برای انتقال پرونده‌های پایه بیشتر تعیین کرد. پرونده file به همان شیوه --transferfile منتقل خواهد شد.

همچنین ببینید: --sshlogin --transfer --return --cleanup --workdir

--basenamereplace replace-str

--bnr replace-str

استفاده از رشته جایگزین replace-str به جای {/} برای نام پایه (basename) خط ورودی.

همچنین ببینید: {/}

--basenameextensionreplace replace-str

--bner replace-str

استفاده از رشته جایگزین replace-str به جای {/.} برای نام پایه خط ورودی بدون پسوند.

همچنین ببینید: {/.}

--bin binexpr

استفاده از binexpr به عنوان کلید دسته‌بندی و دسته‌بندی ورودی میان کارها.

عبارت binexpr به صورت [شماره ستون|نام ستون] [عبارت پرل] است، مثلاً:

3
Address
3 $_%=100
Address s/\D//g

هر خط ورودی با استفاده از --colsep تفکیک می‌شود. مقدار ستون در $_ قرار می‌گیرد، عبارت پرل اجرا می‌شود و مقدار حاصل، اسلات کاری خواهد بود که خط به آن داده می‌شود. اگر مقدار از تعداد اسلات‌های کار بزرگ‌تر باشد، مقدار بر تعداد اسلات‌های کار محاسبه پیمانه (modulo) خواهد شد.

این عملکرد شبیه به --shard است اما الگوریتم درهم‌سازی (هش) یک پیمانه ساده است که پیش‌بینی این که کدام اسلات کار کدام مقدار را دریافت خواهد کرد را ممکن می‌سازد.

کارایی در حدود ۱۰۰ هزار ردیف در ثانیه است. اگر bincol کوچک باشد (<10) سریع‌تر و اگر بزرگ باشد (>100) کندتر خواهد بود.

گزینه --bin به --pipe و یک مقدار عددی ثابت برای --jobs نیاز دارد.

همچنین ببینید: SPREADING BLOCKS OF DATA --group-by --round-robin --shard

--bg

اجرای دستور در پس‌زمینه.

دستور GNU parallel معمولاً منتظر اتمام یک کار می‌ماند. با --bg دستور GNU parallel قبل از خروج، منتظر تکمیل دستور نخواهد ماند.

اگر --semaphore تنظیم شده باشد، این حالت پیش‌فرض است.

مستلزم --semaphore است.

همچنین ببینید: --fg man sem

--bibtex

--citation

چاپ اعلان ارجاع و ورودی BibTeX برای GNU parallel، بی‌صدا کردن اعلان ارجاع برای تمام اجراهای آینده، و خروج. هیچ دستوری اجرا نخواهد شد.

اگر اجرای --citation برای شما مقدور نیست، می‌توانید به‌جای آن از --will-cite استفاده کنید که دستورات را اجرا می‌کند، اما اعلان ارجاع را فقط برای همین یک‌بار اجرا بی‌صدا می‌سازد.

اگر از --will-cite در اسکریپت‌هایی استفاده کنید که قرار است توسط دیگران اجرا شوند، دیدن اعلان ارجاع را برای دیگران دشوارتر می‌کنید. توسعهٔ GNU parallel به‌طور غیرمستقیم از طریق ارجاعات تأمین مالی می‌شود، بنابراین اگر کاربران شما ندانند که باید ارجاع دهند، تأمین مالی توسعه را دشوارتر می‌کنید. با این حال، اگر ۱۰,۰۰۰ یورو پرداخت کنید، سهم خود را در تأمین مالی توسعه‌های آینده ادا کرده‌اید و می‌توانید با خیال راحت از --will-cite در اسکریپت‌ها استفاده کنید.

اگر نمی‌خواهید با اجازه دادن به سایر کاربران برای دیدن اعلان ارجاع یا با پرداخت هزینه به تأمین مالی توسعهٔ آینده کمک کنید، لطفاً استفاده از ابزار دیگری به‌جای GNU parallel را در نظر بگیرید. می‌توانید برخی از گزینه‌های جایگزین را در man parallel_alternatives بیابید.

--block size (آزمایشی)

--block-size size (آزمایشی)

اندازهٔ بلوک برحسب بایت برای خواندن در هر نوبت.

مقدار size می‌تواند پسوند K، M، G، T، P، k، m، g، t، یا p داشته باشد.

دستور GNU parallel تلاش می‌کند به اندازهٔ بلوک برسد اما ممکن است به اندازهٔ طول یک رکورد خطا داشته باشد. به دلایل کارایی و عملکرد، size باید بزرگ‌تر از دو رکورد باشد. اگر انتخابی داشته باشید که size آن بیش از حد کوچک باشد، GNU parallel به شما هشدار داده و اندازه را به‌طور خودکار افزایش می‌دهد.

مقدار پیش‌فرض size برابر 1M است.

اندازهٔ بلوک منفی به‌عنوان اندازهٔ بلوک تفسیر نمی‌شود، بلکه بیانگر تعداد بلوک‌هایی است که هر اسلات کاری (jobslot) باید داشته باشد. بنابراین --block -3 به ازای هر اسلات کاری ۳ کار ایجاد می‌کند. به عبارت دیگر: این دستور در مجموع ۳*۵ = ۱۵ کار را اجرا خواهد کرد:

parallel --pipe-part -a myfile --block -3 -j5 wc
cat myfile | parallel --pipe --block -3 -j5 wc

گزینهٔ --pipe-part --block جایگزینی کارآمد برای --round-robin است زیرا داده‌ها هرگز توسط GNU parallel خوانده نمی‌شوند، اما با این حال می‌توانید با تعداد بسیار کمی اسلات کاری مقادیر عظیمی از داده را پردازش کنید.

از سوی دیگر، --pipe --block کاملاً ناکارآمد است: تمام فایل را پیش از تقسیم‌بندی در حافظه می‌خواند. در نتیجه ورودی باید قادر باشد در حافظه جای گیرد.

اگر از --block -size استفاده می‌کنید، ورودی باید بزرگ‌تر از size+1 رکورد باشد.

همچنین ببینید: UNIT PREFIX -N --pipe --pipe-part --round-robin --block-timeout

--block-timeout duration

--bt duration

مهلت زمانی (تایم‌اوت) برای خواندن بلوک هنگام استفاده از --pipe.

اگر خواندن یک بلوک کامل بیشتر از duration طول بکشد، از همان بلوک ناقصی که تاکنون خوانده شده استفاده می‌شود.

مقدار duration برحسب ثانیه است، اما می‌تواند پسوند s، m، h، یا d داشته باشد.

همچنین ببینید: TIME POSTFIXES --pipe --block

--cat (آزمایشی)

ایجاد فایل موقت حاوی محتوا.

به‌طور معمول --pipe/--pipe-part داده‌ها را روی ورودی استاندارد (stdin) به برنامه می‌دهند. با --cat دستور GNU parallel یک فایل موقت با نام موجود در {} ایجاد می‌کند، بنابراین می‌توانید انجام دهید: parallel --pipe --cat wc {}.

مستلزم --pipe است مگر اینکه --pipe-part استفاده شود.

همچنین ببینید: --pipe --pipe-part --fifo

--cleanup (آزمایشی)

حذف فایل‌های منتقل‌شده.

گزینهٔ --cleanup فایل‌های منتقل‌شده روی رایانهٔ دوردست را پس از اتمام پردازش حذف می‌کند.

find log -name '*gz' | parallel \
  --sshlogin server.example.com --transferfile {} \
  --return {.}.bz2 --cleanup "zcat {} | bzip -9 >{.}.bz2"

با --transferfile {} فایلی که به رایانهٔ دوردست منتقل شده است روی همان رایانهٔ دوردست حذف خواهد شد. دایرکتوری‌های حاوی فایل روی رایانهٔ دوردست در صورتی که خالی باشند حذف خواهند شد.

با --return فایلی که از رایانهٔ دوردست منتقل شده است روی رایانهٔ دوردست حذف خواهد شد. دایرکتوری‌های حاوی فایل روی رایانهٔ دوردست در صورتی که خالی باشند حذف خواهند شد.

اگر --cleanup همراه با --basefile، --transfer، --transferfile یا --return استفاده نشود نادیده گرفته می‌شود.

همچنین ببینید: --basefile --transfer --transferfile --sshlogin --return

--color

رنگی کردن خروجی.

رنگی کردن خروجی. هر کار ترکیب رنگی خود را دریافت می‌کند (پس‌زمینه+پیش‌زمینه).

گزینهٔ --color هنگام استفاده از -u نادیده گرفته می‌شود.

همچنین ببینید: --color-failed

--color-failed

--cf

رنگی کردن خروجی کارهای ناموفق به‌صورت سفید روی قرمز.

زمانی مفید است که تعداد کارهای زیادی دارید و می‌خواهید روی کارهای ناموفق تمرکز کنید.

گزینهٔ --color-failed هنگام استفاده از -u و --line-buffer نادیده گرفته می‌شود و هنگام استفاده از --latest-line غیرقابل اتکا است.

همچنین ببینید: --color

--colsep regexp

-C regexp

جداکنندهٔ ستون‌ها.

ورودی به‌عنوان یک جدول در نظر گرفته می‌شود که در آن regexp ستون‌ها را جدا می‌کند. به ستون nام می‌توان با استفاده از {n} یا {n.} دسترسی پیدا کرد؛ مانند {3} که ستون سوم است.

اگر منابع ورودی بیشتری وجود داشته باشد، هر منبع ورودی تفکیک می‌شود، اما ستون‌های هر منبع ورودی به یکدیگر متصل خواهند شد. در اینجا {4} به ستون ۲ در منبع ورودی ۲ اشاره دارد:

parallel --colsep '-' echo {4} {3} {2} {1} \
  ::: A-B C-D ::: e-f g-h

گزینهٔ --colsep مستلزم --trim rl است، که می‌توان آن را با --trim n بازنویسی (override) کرد.

مقدار regexp یک عبارت باقاعده پرل است: https://perldoc.perl.org/perlre.html

همچنین ببینید: --csv {n} --trim --link --match

--combineexec name

--combine-executable name

ترکیب GNU parallel با برنامه‌ای دیگر در یک فایل اجرایی واحد.

فرض کنید برنامه‌ای به نام myprg توسعه داده‌اید که یک آرگومان واحد می‌گیرد. نمی‌خواهید خودتان آن را موازی‌سازی کنید.

می‌توانید یک پوشش‌دهنده (wrapper) با استفاده از GNU parallel بنویسید به نام myparprg:

#!/bin/sh
parallel myprg ::: "$@"

اما برای اینکه دیگران بتوانند از آن استفاده کنند، باید این موارد را نصب کنند: GNU parallel، myprg، و myparprg.

اگر همه در یک فایل اجرایی واحد بسته‌بندی می‌شدند، نصب آن آسان‌تر بود.

اگر myprg در شل نوشته شده باشد، می‌توانید از --embed استفاده کنید.

اگر myprg یک فایل باینری باشد، می‌توانید از --combineexec استفاده کنید.

در اینجا از gzip به‌عنوان مثال استفاده می‌کنیم:

parallel --combineexec pargzip gzip -9 :::

اکنون می‌توانید انجام دهید:

./pargzip foo bar baz

اگر می‌خواهید گزینه‌هایی را به gzip ارسال کنید، می‌توانید انجام دهید:

parallel --combineexec pargzip gzip

و در ادامه:

./pargzip -1 ::: foo bar baz

همچنین ببینید: --embed --shebang --shebang-wrap

--compress

فشرده‌سازی فایل‌های موقت.

اگر خروجی بزرگ و بسیار فشرده‌پذیر باشد، این گزینه فضای کمتری از دیسک را در $TMPDIR اشغال کرده و احتمالاً به‌دلیل کاهش ورودی/خروجی دیسک سریع‌تر خواهد بود.

دستور GNU parallel به ترتیب ابزارهای pzstd، lbzip2، pbzip2، zstd، pigz، lz4، lzop، plzip، lzip، lrz، gzip، pxz، lzma، bzip2، xz، clzip را امتحان کرده و از اولین گزینهٔ در دسترس استفاده می‌کند.

دستور GNU parallel به ازای هر کاری که در انتظار چاپ شدن است، تا ۸ فرایند را به کار می‌گیرد. برای جزئیات بیشتر به man parallel_design مراجعه کنید.

همچنین ببینید: --compress-program

--compress-program prg

--decompress-program prg

استفاده از prg برای فشرده‌سازی/استخراج فایل‌های موقت.

فرض بر این است که prg -dc داده‌های ورودی استاندارد (stdin) را استخراج کرده و به خروجی استاندارد (stdout) می‌فرستد مگر اینکه --decompress-program داده شده باشد.

همچنین ببینید: --compress

--csv

برخورد با ورودی به‌صورت قالب CSV.

گزینهٔ --colsep جداکننده فیلدها را تعیین می‌کند. --csv بسیار شبیه به --colsep کار می‌کند با این تفاوت که با نقل‌قول‌ها (quotes) به‌درستی رفتار می‌کند. مقایسه کنید:

echo '"1 big, 2 small","2""x4"" plank",12.34' |
  parallel --csv echo {1} of {2} at {3}
echo '"1 big, 2 small","2""x4"" plank",12.34' |
  parallel --colsep ',' echo {1} of {2} at {3}

حتی خطوط جدید نقل‌قول‌شده نیز به‌درستی تجزیه می‌شوند:

(echo '"Start of field 1 with newline'
 echo 'Line 2 in field 1";value 2') |
  parallel --csv --colsep ';' echo Field 1: {1} Field 2: {2}

هنگام استفاده با --pipe فقط رکوردهای کامل CSV را منتقل می‌کند.

همچنین ببینید: --pipe --link {n} --colsep --header --match

--ctag (منسوخ: از --color --tag استفاده کنید)

برچسب رنگی.

اگر مقادیر در بررسی خروجی بسیار شبیه به نظر برسند، ممکن است تشخیص زمان استفاده از یک مقدار جدید دشوار باشد. گزینهٔ --ctag به هر مقدار یک رنگ تصادفی اختصاص می‌دهد.

همچنین ببینید: --color --tag

--ctagstring str (منسوخ: از --color --tagstring استفاده کنید)

رشته‌برچسب رنگی.

همچنین ببینید: --color --ctag --tagstring

--delay duration

تأخیر در شروع کار بعدی به میزان duration.

دستور GNU parallel به مدت duration کار دیگری را شروع نخواهد کرد.

مقدار duration برحسب ثانیه است، اما می‌تواند پسوند s، m، h، یا d داشته باشد.

اگر عبارت 'auto' را به duration اضافه کنید (مانند 13m3sauto)، دستور GNU parallel به‌طور خودکار سعی می‌کند مقدار بهینه را بیابد: اگر کاری با شکست مواجه شود، duration به میزان ۳۰٪ افزایش می‌یابد. اگر کاری با موفقیت انجام شود، duration به میزان ۱۰٪ کاهش می‌یابد.

همچنین ببینید: TIME POSTFIXES --retries --ssh-delay

--delimiter delim

-d delim

رکوردهای ورودی با delim خاتمه می‌یابند.

جداکنندهٔ مشخص‌شده می‌تواند نویسه‌ها، کدهای اسکیپ به سبک C مانند \n، یا کدهای اسکیپ هشت‌هشتی (\012) یا شانزده‌شانزدهی (\x0A) باشد. کدهای اسکیپ هشت‌هشتی و شانزده‌شانزدهی همانند دستور printf درک می‌شوند.

همچنین ببینید: --colsep

--dirnamereplace replace-str

--dnr replace-str

استفاده از رشتهٔ جایگزین replace-str به‌جای {//} برای نام دایرکتوری (dirname) خط ورودی.

همچنین ببینید: {//}

--dry-run (آزمایشی)

چاپ کاری که باید در خروجی استاندارد (stdout) اجرا شود، بدون اجرای واقعی کار.

از -v -v استفاده کنید تا کدهای پوشش‌دهنده‌ای که GNU parallel تولید می‌کند نیز گنجانده شوند (برای کارهای دوردست، --tmux، --nice، --pipe، --pipe-part، --fifo و --cat). البته به‌طور تحت‌اللفظی روی این حساب نکنید، زیرا اگر : در فهرست باشد ممکن است کار روی رایانهٔ دیگر یا رایانهٔ محلی زمان‌بندی شود.

همچنین ببینید: -v

-E eof-str

تنظیم رشته پایان فایل به eof-str.

اگر رشته پایان فایل به عنوان یک خط از ورودی رخ دهد، بقیه ورودی خوانده نمی‌شود. اگر نه از -E و نه از -e استفاده شود، هیچ رشته پایان فایلی استفاده نخواهد شد.

--eof[=eof-str]

-e[eof-str]

این گزینه مترادفی برای گزینه -E است.

به‌جای آن از -E استفاده کنید، زیرا برای xargs با استاندارد POSIX سازگار است در حالی که این گزینه چنین نیست. اگر eof-str حذف شود، هیچ رشته پایان فایلی وجود ندارد. اگر نه از -E و نه از -e استفاده شود، هیچ رشته پایان فایلی استفاده نخواهد شد.

--embed

جاسازی GNU parallel درون یک اسکریپت شل.

اگر نیاز دارید اسکریپت خود را برای شخصی ارسال کنید که مایل به نصب GNU parallel نیست، می‌توانید GNU parallel را درون اسکریپت شل خود جاسازی کنید:

parallel --embed > new_script

پس از آن کد خود را به انتهای new_script اضافه می‌کنید. این قابلیت روی ash، bash، dash، ksh، sh و zsh آزمایش شده است.

--env var (alpha testing)

کپی متغیر محیطی export شده var.

این گزینه var را به محیطی که دستور در آن اجرا می‌شود کپی می‌کند. این کار به‌ویژه برای اجرای از راه دور مفید است.

در Bash، متغیر var می‌تواند یک تابع Bash نیز باشد - فقط به یاد داشته باشید که تابع را با export -f خروجی (export) دهید.

متغیر '_' خاص است. این متغیر تمام متغیرهای محیطی export شده را به‌جز متغیرهای ذکر شده در ~/.parallel/ignored_vars کپی می‌کند.

برای کپی کردن محیط کامل (شامل متغیرهای export شده و نشده، آرایه‌ها و توابع) از env_parallel استفاده کنید.

همچنین ببینید: --record-env --session --sshlogin command env_parallel

--eta

نمایش تعداد ثانیه‌های تخمینی باقی‌مانده تا پایان.

این گزینه GNU parallel را مجبور می‌کند قبل از شروع، تمام کارها را بخواند تا تعداد کل آن‌ها را پیدا کند (مگر اینکه از --total-jobs استفاده کنید). GNU parallel معمولاً فقط کار بعدی را برای اجرا می‌خواند.

تخمین بر اساس زمان اجرای کارهای پایان‌یافته محاسبه می‌شود، بنابراین اولین تخمین فقط پس از پایان اولین کار نمایش داده خواهد شد.

به معنی فعال‌سازی خودکار --progress است.

همچنین ببینید: --bar --progress --total-jobs

--extensionreplace replace-str

--er replace-str

استفاده از رشته جایگزین replace-str به‌جای {.} برای خط ورودی بدون پسوند.

همچنین ببینید: {.}

--fast (alpha testing)

اجرای سریع کارها.

این گزینه بسیاری از قابلیت‌های GNU parallel را غیرفعال می‌کند تا کارها با بیشترین سرعت ممکن اجرا شوند: آن را مانند یک ماشین مسابقه‌ای با نیترو در مقایسه با ولوو در نظر بگیرید.

برای بنچمارک و زمانی که هزاران کار بسیار کوچک دارید کاربردی است.

مقایسه کنید:

# ~10 seconds/1000 jobs
seq 1000 | time parallel echo | wc -l
# ~1 seconds/1000 jobs
seq 1000 | time parallel --fast echo | wc -l
# ~10 seconds/1000000 jobs
seq 1000000 | time parallel --fast echo | wc -l

کاملاً پشتیبانی‌شده:

{}، --compress/--compress-program، --dry-run، --jobs، --keep-order، --nice، --tag، --tagstring (رشته‌های ثابت و {})، --ungroup.

پشتیبانی‌شده اما کندتر (بازگشت به مسیر صف کارها، حدود ۰.۵ میلی‌ثانیه به ازای هر کار):

--fg

اجرای دستور در پیش‌زمینه.

همراه با --tmux و --tmuxpane، ابزار GNU parallel برنامه tmux را در پیش‌زمینه اجرا خواهد کرد.

همراه با --semaphore، ابزار GNU parallel دستور را در پیش‌زمینه اجرا می‌کند (برعکس --bg) و قبل از خروج، منتظر اتمام دستور می‌ماند. کد خروج برابر با کد خروج دستور خواهد بود.

همچنین ببینید: --bg man sem

--fifo (alpha testing)

ایجاد یک fifo موقت حاوی محتوا.

معمولاً --pipe و --pipe-part داده‌ها را روی stdin (ورودی استاندارد) به برنامه می‌دهند. با --fifo ابزار GNU parallel یک fifo موقت با نام قرار گرفته در {} ایجاد می‌کند، بنابراین می‌توانید انجام دهید:

parallel --pipe --fifo wc {}

توجه: اگر fifo هرگز برای خواندن باز نشود، کار تا ابد متوقف (block) خواهد شد:

seq 1000000 | parallel --fifo echo This will block forever
seq 1000000 | parallel --fifo 'echo This will not block < {}'

با استفاده از --fifo به‌جای --cat می‌توانید در I/O صرفه‌جویی کنید زیرا --cat در یک فایل موقت می‌نویسد، در حالی که --fifo چنین نمی‌کند.

به معنی فعال‌سازی خودکار --pipe است مگر اینکه از --pipe-part استفاده شود.

همچنین ببینید: --cat --pipe --pipe-part

--filter filter (alpha testing)

فقط کارهایی را اجرا می‌کند که در آن‌ها filter درست (true) باشد.

عبارت filter می‌تواند شامل رشته‌های جایگزین و کد Perl باشد. مثال:

parallel --filter '{1}+{2}+{3} < 10' echo {1},{2},{3} \
  ::: {1..10} ::: {3..8} ::: {3..10}

خروجی‌ها: 1,3,3 1,3,4 1,3,5 1,4,3 1,4,4 1,5,3 2,3,3 2,3,4 2,4,3 3,3,3

parallel --filter '{1} < {2}*{2}' echo {1},{2} \
  ::: {1..10} ::: {1..3}

خروجی‌ها: 1,2 1,3 2,2 2,3 3,2 3,3 4,3 5,3 6,3 7,3 8,3

parallel --filter '{choose_k}' --plus echo {1},{2},{3} \
  ::: {1..5} ::: {1..5} ::: {1..5}

خروجی‌ها: 1,2,3 1,2,4 1,2,5 1,3,4 1,3,5 1,4,5 2,3,4 2,3,5 2,4,5 3,4,5

همچنین ببینید: skip() --no-run-if-empty {choose_k}

--filter-hosts (beta testing)

حذف میزبان‌های از کار افتاده (down).

برای هر میزبان دوردست: بررسی می‌کند که آیا ورود از طریق ssh کار می‌کند یا خیر. اگر کار نکند: از این میزبان استفاده نمی‌شود.

به دلایل کارایی، این بررسی فقط در ابتدا و هر بار که --sshloginfile تغییر کند انجام می‌شود. اگر میزبانی پس از اولین بررسی از کار بیفتد، تا زمان تغییر --sshloginfile شناسایی نخواهد شد؛ برای کاهش اثر این مشکل می‌توان از --retries استفاده کرد.

در حال حاضر نمی‌توانید --filter-hosts را در یک پروفایل، $PARALLEL، /etc/parallel/config یا موارد مشابه قرار دهید. این به این دلیل است که GNU parallel از GNU parallel برای محاسبه این مورد استفاده می‌کند، بنابراین وارد یک حلقه بی‌نهایت خواهید شد. این مورد احتمالاً در انتشار بعدی برطرف خواهد شد.

همچنین ببینید: --sshloginfile --sshlogin --retries

--gnu

رفتار مشابه با GNU parallel.

این گزینه از نظر تاریخی بر --tollef اولویت داشت. گزینه --tollef اکنون بازنشسته شده است و بنابراین نباید استفاده شود. گزینه --gnu برای سازگاری حفظ شده است، اما کاری انجام نمی‌دهد.

--group

گروه‌بندی خروجی.

خروجی هر کار با هم گروه‌بندی شده و تنها پس از اتمام دستور چاپ می‌شود. ابتدا stdout (خروجی استاندارد) و سپس stderr (خطای استاندارد).

این عمل در حدود ۰.۵ میلی‌ثانیه زمان CPU به ازای هر کار می‌برد و برای خروجی‌های بزرگ‌تر به سرعت دیسک شما بستگی دارد.

گزینه --group پیش‌فرض است.

همراه با --fast: خروجی به ازای هر قطعه گروه‌بندی می‌شود (یک قطعه شامل چندین کار است). درون یک قطعه، خروجی‌های stdout و stderr هر کار به ترتیب طبیعی ظاهر می‌شوند (کارها به صورت متوالی اجرا می‌شوند)، اما parallel درونی تمام stdout یک قطعه را قبل از تمام stderr آن بافر می‌کند. برای برچسب‌گذاری صحیح به ازای هر کار از --tag استفاده کنید.

همچنین ببینید: --line-buffer --ungroup --tag

--group-by val (alpha testing)

گروه‌بندی ورودی بر اساس مقدار.

در ترکیب با --pipe/--pipe-part، گزینه --group-by خطوط با مقدار یکسان را در یک رکورد گروه‌بندی می‌کند.

مقدار را می‌توان از کل خط یا از یک ستون منفرد محاسبه کرد.

مقدار val می‌تواند موارد زیر باشد:

UserID, Consumption
123,    1
123,    2
12-3,   1
221,    3
221,    1
2/21,   5

tail -n +2 table.csv | \
  parallel --pipe --colsep , --group-by 1 -kN1 wc

cat table.csv | \
  parallel --pipe --colsep , --header : --group-by 1 -kN1 wc

cat table.csv | \
  parallel --pipe --colsep , --header : --group-by UserID -kN1 wc

cat table.csv | parallel --pipe --colsep , --header : \
  --group-by 'UserID s/\D//g' -kN1 wc

--help

-h

چاپ خلاصه‌ای از گزینه‌های GNU parallel و خروج.

--halt-on-error val

--halt val

GNU parallel چه زمانی باید پایان یابد؟

در برخی شرایط اجرای تمام کارها بی‌معنی است. GNU parallel باید به محض برآورده شدن یک شرط متوقف شود.

مقدار پیش‌فرض val برابر never است، که تمام کارها را تحت هر شرایطی اجرا می‌کند.

همچنین val می‌تواند به شکل when,why باشد.

مقدار when می‌تواند 'now' باشد که به معنی متوقف کردن (kill) تمام کارهای در حال اجرا و پایان فوری است، یا می‌تواند 'soon' باشد که یعنی منتظر اتمام کارهای در حال اجرا بماند اما کار جدیدی شروع نکند.

مقدار why می‌تواند 'fail=X'، 'fail=Y%'، 'success=X'، 'success=Y%'، 'done=X'، یا 'done=Y%' باشد که در آن X تعداد کارهایی است که باید پیش از توقف ناموفق شوند، موفق شوند یا کامل گردند، و Y درصد کارهایی است که باید پیش از توقف ناموفق شوند، موفق شوند یا کامل گردند.

مثال:

--header regexp

استفاده از عبارت باقاعده (regexp) به‌عنوان سرآیند (header).

برای استفاده عادی، سرآیند تطبیق‌یافته (معمولاً خط اول: --header '.*\n') با استفاده از --colsep (که مقدار پیش‌فرض آن '\t' است) تقسیم می‌شود و نام ستون‌ها می‌توانند به‌عنوان متغیرهای جایگزین استفاده شوند: {column name}، {column name/}، {column name//}، {column name/.}، {column name.}، {=column name perl expression =}، ..

برای --pipe، سرآیند تطبیق‌یافته به ابتدای هر خروجی افزوده خواهد شد.

گزینه --header : نام مستعاری برای --header '.*\n' است.

اگر regexp یک عدد باشد، تعداد ثابتی از خطوط در نظر گرفته می‌شود.

گزینه --header 0 حالت ویژه‌ای است: رشته‌های جایگزین را برای فایل‌های داده‌شده با --arg-file یا :::: ایجاد می‌کند. این گزینه {foo/bar} را برای فایل foo/bar تولید خواهد کرد.

همچنین ببینید: --colsep --pipe --pipe-part --arg-file

--hostgroups

--hgrp

فعال‌سازی گروه‌های میزبان (hostgroups) روی آرگومان‌ها.

اگر یک آرگومان حاوی '@' باشد، رشته پس از '@' حذف شده و به‌عنوان فهرستی از گروه‌های میزبان که این کار مجاز به اجرا روی آن‌هاست در نظر گرفته می‌شود. اگر هیچ --sshlogin با گروه متناظر وجود نداشته باشد، کار روی هر گروه میزبانی اجرا خواهد شد.

مثال:

parallel --hostgroups \
  --sshlogin @grp1/myserver1 -S @grp1+grp2/myserver2 \
  --sshlogin @grp3/myserver3 \
  echo ::: my_grp1_arg@grp1 arg_for_grp2@grp2 third@grp1+grp3

my_grp1_arg ممکن است روی myserver1 یا myserver2 اجرا شود، third ممکن است روی myserver1 یا myserver3 اجرا شود، اما arg_for_grp2 فقط روی myserver2 اجرا خواهد شد.

همچنین ببینید: --sshlogin $PARALLEL_HOSTGROUPS $PARALLEL_ARGHOSTGROUPS

-I replace-str

استفاده از رشته جایگزین replace-str به‌جای {}.

همچنین ببینید: {}

--replace [replace-str]

-i [replace-str]

این گزینه منسوخ شده است؛ به‌جای آن از -I استفاده کنید.

اگر replace-str مشخص شده باشد، این گزینه مترادفی برای -Ireplace-str است، و در غیر این صورت مترادفی برای -I {} خواهد بود.

همچنین ببینید: {}

--joblog logfile

--jl logfile

فایل گزارش (logfile) برای کارهای اجراشده.

ذخیره فهرستی از کارهای اجراشده در logfile در قالب جداشده با TAB به ترتیب زیر: شماره ترتیب، sshlogin، زمان شروع بر حسب ثانیه از مبدأ زمان (epoch)، مدت زمان اجرا بر حسب ثانیه، بایت‌های انتقال‌یافته در فایل‌ها، بایت‌های برگشتی در فایل‌ها، وضعیت خروج، سیگنال و دستور اجراشده.

برای --pipe، بایت‌های انتقال‌یافته و بایت‌های برگشتی به معنی تعداد بایت‌های ورودی و خروجی هستند.

اگر پیش از logfile علامت '+' قرار گیرد، خطوط گزارش به انتهای فایل لاگ افزوده خواهند شد.

برای تبدیل زمان‌ها به قالب دقیق ISO-8601 دستور زیر را اجرا کنید:

cat logfile | perl -a -F"\t" -ne \
  'chomp($F[2]=`date -d \@$F[2] +%FT%T`); print join("\t",@F)'

اگر نام میزبان طولانی است، می‌توانید از column -t برای چاپ مرتب و مناسب‌تر آن استفاده کنید:

cat joblog | column -t

همچنین ببینید: --resume --resume-failed --progress

--jobs num

-j num

--max-procs num

-P num

تعداد شیارهای کار (jobslots) روی هر ماشین.

اجرای حداکثر num کار به‌صورت موازی. مقدار پیش‌فرض 100% است.

--keep-order (alpha testing)

-k (alpha testing)

حفظ ترتیب خروجی دقیقاً مشابه با ترتیب ورودی.

به‌طور معمول خروجی هر کار به محض اتمام آن کار چاپ می‌شود. برای مشاهده تفاوت دستورهای زیر را امتحان کنید:

parallel -j4 sleep {}\; echo {} ::: 2 1 4 3
parallel -j4 -k sleep {}\; echo {} ::: 2 1 4 3

در صورت استفاده همراه با --onall یا --nonall، خروجی‌ها بر اساس sshlogin به صورت مرتب‌شده دسته‌بندی می‌شوند.

گزینه --keep-order هنگام استفاده با --pipe --round-robin نمی‌تواند ترتیب خروجی را حفظ کند. در اینجا در عوض به این معنی است که در صورت ثابت ماندن ورودی، شیارهای کار (jobslots) در هر اجرا همان بلوک‌ها را به‌عنوان ورودی و با همان ترتیب دریافت خواهند کرد. هر یک از این موارد را دو بار اجرا و مقایسه کنید:

seq 10000000 | parallel --pipe --round-robin 'sleep 0.$RANDOM; wc'
seq 10000000 | parallel --pipe -k --round-robin 'sleep 0.$RANDOM; wc'

گزینه -k فقط بر ترتیبی که خروجی چاپ می‌شود تأثیر می‌گذارد - نه بر ترتیب اجرای کارها.

همچنین ببینید: --group --line-buffer

-L recsize

در صورت استفاده همراه با --pipe: خواندن رکوردهایی به اندازه recsize.

در غیر این صورت: استفاده از حداکثر recsize خط ورودی غیرخالی در هر خط فرمان. فاصله‌های خالی انتهایی باعث می‌شوند که یک خط ورودی به شکل منطقی در خط ورودی بعدی ادامه یابد.

گزینه -L 0 به معنی خواندن یک خط است، اما ۰ آرگومان را در خط فرمان درج می‌کند.

مقدار recsize می‌تواند پسوندهای K، M، G، T، P، k، m، g، t، یا p داشته باشد.

گزینه -X را فعال می‌کند مگر اینکه -m، --xargs یا --pipe تنظیم شده باشد.

همچنین ببینید: UNIT PREFIX -N --max-lines --block -X -m --xargs --pipe

--max-lines [recsize]

-l[recsize]

در صورت استفاده همراه با --pipe: خواندن رکوردهایی با اندازه recsize خط.

در غیر این صورت: مترادفی برای گزینه -L. برخلاف -L، آرگومان recsize اختیاری است. اگر recsize مشخص نشود، مقدار پیش‌فرض آن یک خواهد بود. گزینه -l منسوخ شده است چرا که استاندارد POSIX گزینه -L را به‌جای آن تعیین کرده است.

گزینه -l 0 نام مستعاری برای -l 1 است.

گزینه -X را فعال می‌کند مگر اینکه -m، --xargs یا --pipe تنظیم شده باشد.

همچنین ببینید: UNIT PREFIX -N --block -X -m --xargs --pipe

--limit "command args"

محدودیت پویای کار.

پیش از شروع یک کار جدید، دستور command را با آرگومان‌های args اجرا می‌کند. مقدار وضعیت خروج command تعیین می‌کند که GNU parallel چه کاری انجام دهد:

--latest-line

--ll

چاپ آخرین سطر. هر کار یک سطر مجزا روی صفحه دریافت می‌کند که با آخرین سطر کامل کارهای در حال اجرا به‌روزرسانی می‌شود.

صفحه نمایش قدیمی‌ترین کار در حال اجرا را در دید نگه می‌دارد، بنابراین ممکن است کارهای جدیدتر دیده نشوند. با این حال، با پایان یافتن قدیمی‌ترین کار، این کارها نمایش داده خواهند شد.

اجرای این مثال درک آن را آسان‌تر می‌کند. دقت کنید که با پایان یافتن کار بالای صفحه، چگونه صفحه اسکرول می‌شود:

slow_seq() {
  # Run seq with 33 characters per second
  seq "$@" |
    perl -ne '$|=1; for(split//){ print; select($a,$a,$a,0.03);}'
}
export -f slow_seq
parallel --shuf -j99 --ll --tag --bar --color slow_seq {} ::: {1..300}

همچنین ببینید: --line-buffer

--line-buffer

--lb

بافر کردن خروجی بر مبنای سطر.

گزینه --group خروجی را برای کل یک کار یکپارچه نگه می‌دارد. گزینه --ungroup اجازه می‌دهد خروجی کارها با هم مخلوط شوند؛ به‌طوری‌که نیمی از یک سطر از یک کار و نیمی از کار دیگری بیاید. گزینه --line-buffer بین این دو قرار می‌گیرد: برنامه GNU parallel یک سطر کامل را چاپ می‌کند، اما اجازه می‌دهد سطرهای کارهای مختلف با یکدیگر ترکیب شوند.

گزینه --line-buffer توان پردازشی بیشتری از CPU نسبت به هر دو گزینه --group و --ungroup مصرف می‌کند، اما اگر CPU عامل محدودکننده نباشد، می‌تواند بسیار سریع‌تر از --group عمل کند.

به‌طور معمول --line-buffer روی دیسک بافر نمی‌کند، بنابراین می‌تواند حجم نامحدودی از داده‌ها را پردازش کند، اما هنگام ترکیب با گزینه‌های --keep-order، --results، --compress و --files روی دیسک بافر خواهد کرد. این کار باعث می‌شود به کندی --group شده و خروجی را به فضای دیسک در دسترس محدود کند.

با گزینه --keep-order، گزینه --line-buffer در حین اجرای اولین کار، سطرهای آن را به‌طور پیوسته خروجی می‌دهد، سپس سطرهای کار دوم را هنگام اجرای آن چاپ می‌کند. این گزینه سطرهای کامل را بافر می‌کند اما خروجی کارها با هم مخلوط نمی‌شوند. مقایسه کنید:

parallel -j0 'echo [{};sleep {};echo {}]' ::: 1 3 2 4
parallel -j0 --lb 'echo [{};sleep {};echo {}]' ::: 1 3 2 4
parallel -j0 -k --lb 'echo [{};sleep {};echo {}]' ::: 1 3 2 4

همچنین ببینید: --group --ungroup --keep-order --tag

--link

--xapply

پیوند دادن منابع ورودی.

خواندن چندین منبع ورودی همانند دستور xapply. اگر چندین منبع ورودی مشخص شده باشد، از هر یک از منابع ورودی یک آرگومان خوانده خواهد شد. در دستور می‌توان به آرگومان‌ها به‌صورت {1} الی {n} دسترسی داشت؛ بنابراین {1} سطری از منبع ورودی اول خواهد بود و {6} به سطری با همان شماره سطر از ششمین منبع ورودی اشاره خواهد کرد.

این دو را مقایسه کنید:

parallel echo {1} {2} ::: 1 2 3 ::: a b c
parallel --link echo {1} {2} ::: 1 2 3 ::: a b c

اگر تعداد آرگومان‌های یک منبع ورودی بیشتر از بقیه باشد، آرگومان‌ها بازیافت (تکرار چرخشی) می‌شوند:

parallel --link echo {1} {2} {3} \
  ::: 1 2 ::: I II III ::: a b c d e f g

همچنین ببینید: --header :::+ ::::+

--load max-load

تنها در صورتی کارها را شروع کن که بار سیستم (load) کمتر از max-load باشد.

روی یک رایانه مشخص هیچ کار جدیدی را آغاز نکن مگر اینکه تعداد فرآیندهای در حال اجرا روی آن رایانه کمتر از max-load باشد. مقدار max-load از همان نحو نگارشی --jobs استفاده می‌کند، بنابراین مقدار 100% برای یک کار به ازای هر CPU تنظیمی معتبر است. تنها تفاوت مقدار 0 است که به عنوان 0.01 تفسیر می‌شود.

همچنین ببینید: --limit --jobs

--controlmaster

-M

استفاده از ControlMaster در ssh برای بالا بردن سرعت اتصالات ssh.

زمانی مفید است که کارها از راه دور (remote) اجرا می‌شوند و اجرای آن‌ها بسیار سریع است. این قابلیت برای sshloginهایی که دستور ssh سفارشی خود را مشخص کرده‌اند غیرفعال است.

همچنین ببینید: --ssh --sshlogin

-m

چندین آرگومان.

درج بیشترین تعداد آرگومان ممکن تا جایی که طول خط فرمان اجازه می‌دهد. اگر چندین کار به‌صورت موازی در حال اجرا باشند: آرگومان‌ها را به‌طور یکنواخت میان کارها توزیع کن. برای جلوگیری از این رفتار از -j1 یا --xargs استفاده کنید.

اگر از {} استفاده نشود، آرگومان‌ها به انتهای خط اضافه خواهند شد. اگر {} چندین بار استفاده شود، هر بار با تمام آرگومان‌ها جایگزین خواهد شد.

پشتیبانی از -m همراه با --sshlogin محدود بوده و ممکن است با شکست مواجه شود.

اگر تردید دارید از -X استفاده کنید، زیرا به احتمال زیاد همان رفتار مورد نظر شما را فراهم می‌کند.

همچنین ببینید: -X --xargs

--match regexp

تطبیق منبع ورودی با regexp برای تنظیم فیلدهای جایگزینی.

با گزینه --match اغلب می‌توانید از پیش‌پردازش ورودی با awk یا ابزارهای مشابه برای استخراج فیلدهای مربوطه بی‌نیاز شوید.

می‌توانید به هر گروه تطبیق (capture group)، یعنی پرانتزها در عبارت باقاعده '(...)'، با یک فیلد جایگزینی دسترسی پیدا کنید. فیلدهای جایگزینی به‌صورت {m.n} نام‌گذاری می‌شوند که در آن m شماره منبع ورودی و n شماره گروه تطبیق است:

parallel --match '(.*),(.*)_(.*)' echo {1.2} {1.3} {1.1} \
  ::: Gold,Heart_of
parallel --match '(.*),' --match '([a-z]+)' echo {1.1}{2.1} \
  ::: Milli,bar ::: 10ways

برای استفاده مجدد از یک --match کافی است از +n استفاده کنید که n منبع ورودی است. برای مثال +2 برای دومی:

parallel --match +2 --match '([A-Za-z]+)' echo {1.1} {2.1} \
  ::: /Improbability/ ::: 10drive

برای تنظیم --match فقط برای منبع ورودی ۲، یک --match صوری برای منبع ورودی ۱ بسازید:

parallel --match '' --match '([a-z]+)' echo {1} {2.1} \
  ::: Telephone ::: 10sanitizer

همچنین ببینید: {n} --colsep

--memfree size

حداقل حافظه آزاد هنگام شروع یک کار دیگر.

مقدار size می‌تواند با پسوندهای K، M، G، T، P، k، m، g، t یا p همراه باشد.

اگر کارها مقادیر بسیار متفاوتی از RAM را مصرف کنند، GNU parallel فقط به تعدادی کار شروع می‌کند که حافظه برای آن‌ها موجود باشد. اگر کمتر از size بایت آزاد باشد، هیچ کار جدیدی شروع نخواهد شد. اگر کمتر از 50% مقدار size بایت آزاد باشد، جدیدترین کار (مطابق --term-seq) متوقف خواهد شد (killed) و دوباره به صف بازگردانده می‌شود تا بعداً اجرا شود.

همچنین ببینید: UNIT PREFIX --term-seq --memsuspend

--memsuspend size

معلق کردن کارها در صورت کاهش حافظه در دسترس.

اگر حافظه در دسترس به کمتر از 2 * size برسد، GNU parallel برخی از کارهای در حال اجرا را معلق (suspend) می‌کند. اگر حافظه در دسترس به کمتر از size برسد، تنها یک کار در حال اجرا باقی خواهد ماند.

اگر یک کار منفرد در اندازه مشخص‌شده جای گیرد، همه کارها بدون مواجه شدن با کمبود حافظه تکمیل خواهند شد. اگر فضای swap دارید، معمولاً می‌توانید size را تا حدود نصف اندازه یک کار تکی کاهش دهید - با ریسک اندکِ کمی استفاده از swap.

با در دسترس قرار گرفتن RAM بیشتر - معمولاً پس از اتمام قدیمی‌ترین کار - کارها ادامه خواهند یافت (resume).

گزینه --memsuspend تنها برای کارهای محلی (local) کار می‌کند زیرا روش مشخصی برای معلق کردن کارهای راه دور (remote) وجود ندارد.

مقدار size می‌تواند با پسوندهای K، M، G، T، P، k، m، g، t یا p همراه باشد.

همچنین ببینید: UNIT PREFIX --memfree

--milestone str

تعیین نقاط عطف (milestones) که در آن‌ها تمام کارهای قبلی باید به پایان رسیده باشند.

مثال:

doit() {
    start=$(date +%H:%M:%S)
    # Sleep up to 5 sec
    sleep $((RANDOM % 5000))e-3
    end=$(date +%H:%M:%S)
    echo Start: $start End: $end
}
export -f doit
parallel --tag --milestone // doit ::: a b c // 1 2 // A B // I II II

این دستور دسته‌های (a, b, c)، (1, 2)، (A, B) و (I, II, III) را اجرا می‌کند. کارهای درون یک دسته به‌صورت موازی اجرا می‌شوند، اما دسته‌ها به‌صورت ترتیبی (سریال) اجرا خواهند شد.

دقت کنید که چگونه زمان شروع هر دسته دیرتر از زمان پایان دسته قبلی است.

مثال حاصل‌ضرب دکارتی:

parallel --tag --milestone // doit ::: Frist_run // Second_run ::: file{1..10}

این دستور ابتدا First_run را با تمام فایل‌ها تکمیل می‌کند و سپس Second_run را روی تمام فایل‌ها آغاز می‌نماید.

مثال دکارتی پیشرفته (دارای باگ):

parallel --tag --milestone // doit ::: a b // 1 2 3 ::: A B C // I II

این دستور موارد زیر را اجرا می‌کند: [a] x [A B C], [a] x [I II], [b] x [A B C], [b] x [I II], [1] x [A B C], [1] x [I II], [2] x [A B C], [2] x [I II], [3] x [A B C], [3] x [I II] = (a A, a B, a C), (a I, a II), (b A, b B, b C), (b I, b II), (1 A, 1 B, 1 C), (1 I, 1 II), (2 A, 2 B, 2 C), (2 I, 2 II), (3 A, 3 B, 3 C), (3 I, 3 II).

کارهای درون یک دسته به‌صورت موازی اجرا می‌شوند، اما دسته‌ها به‌صورت ترتیبی اجرا خواهند شد.

زمانی که این باگ برطرف شود، به‌صورت زیر اجرا خواهد شد: [a b] x [A B C], [a b] x [I II], [1 2 3] x [A B C], [1 2 3] x [I II] = (a A, a B, a C, b A, b B, b C), (a I, a II, b I, b II), (1 A, 1 B, 1 C, 2 A, 2 B, 2 C, 3 A, 3 B, 3 C), (1 I, 1 II, 2 I, 2 II, 3 I, 3 II).

--minversion version

چاپ نسخه GNU parallel و خروج.

اگر نسخه فعلی GNU parallel کمتر از version باشد، کد خروج 255 است. در غیر این صورت 0 خواهد بود.

این گزینه برای اسکریپت‌هایی مفید است که به ویژگی‌هایی وابسته هستند که فقط از نسخه خاصی از GNU parallel به بعد در دسترس است:

parallel --minversion 20170422 &&
  echo halt done=50% supported from version 20170422 &&
  parallel --halt now,done=50% echo ::: {1..100}

همچنین ببینید: --version

--max-args max-args

-n max-args

استفاده از حداکثر max-args آرگومان در هر خط فرمان.

اگر از حد اندازه (گزینه -s را ببینید) فراتر رود، آرگومان‌های کمتری از max-args استفاده خواهد شد، مگر اینکه گزینه -x داده شده باشد که در آن صورت GNU parallel خارج خواهد شد.

مقدار -n 0 به معنای خواندن یک آرگومان اما درج 0 آرگومان در خط فرمان است.

مقدار max-args می‌تواند با پسوندهای K، M، G، T، P، k، m، g، t یا p همراه باشد (به UNIT PREFIX مراجعه کنید).

به معنی فعال‌سازی خودکار -X است، مگر اینکه -m تنظیم شده باشد.

همچنین ببینید: -X -m --xargs --max-replace-args

--max-replace-args max-args

-N max-args

استفاده از حداکثر max-args آرگومان در هر خط فرمان.

مشابه -n اما همچنین رشته‌های جایگزینی {1} الی {max-args} را می‌سازد که بیانگر آرگومان‌های 1 الی max-args هستند. اگر تعداد آرگومان‌ها کمتر باشد، {n} خالی خواهد بود.

مقدار -N 0 به معنای خواندن یک آرگومان اما درج 0 آرگومان در خط فرمان است.

این دستور مالک دایرکتوری خانگی (homedir) را روی کاربر تنظیم می‌کند:

tr ':' '\n' < /etc/passwd | parallel -N7 chown {1} {6}

به معنی فعال‌سازی خودکار -X است، مگر اینکه -m یا --pipe تنظیم شده باشد.

مقدار max-args می‌تواند با پسوندهای K، M، G، T، P، k، m، g، t یا p همراه باشد.

هنگام استفاده با --pipe، مقدار -N نشان‌دهنده تعداد رکوردهایی است که باید خوانده شوند. این حالت تا حدی کندتر از --block است.

همچنین ببینید: UNIT PREFIX --pipe --block -m -X --max-args

--nonall (آزمایشی آلفا)

همان --onall بدون آرگومان.

دستور را روی تمام رایانه‌های مشخص‌شده با --sshlogin اجرا می‌کند اما هیچ آرگومانی دریافت نمی‌کند. ابزار GNU parallel به تعداد مشخص‌شده در --jobs رایانه به صورت موازی وارد می‌شود و کار را روی رایانه اجرا می‌کند. گزینه -j تعداد رایانه‌هایی را که همزمان به آن‌ها وارد می‌شود تنظیم می‌کند.

این گزینه برای اجرای یک دستور یکسان (مانند uptime) روی فهرستی از سرورها مفید است.

همچنین ببینید: --onall --sshlogin

--onall (آزمایشی آلفا)

اجرای تمام کارها روی تمام رایانه‌های مشخص‌شده با --sshlogin.

ابزار GNU parallel به تعداد مشخص‌شده در --jobs رایانه به صورت موازی وارد می‌شود و در هر رایانه یک کار را در هر لحظه اجرا می‌کند. ترتیب کارها تغییر نخواهد کرد، اما ممکن است برخی رایانه‌ها زودتر از بقیه کار را به پایان برسانند.

هنگام استفاده از --group، خروجی بر اساس هر سرور گروه‌بندی می‌شود، بنابراین تمام خروجی‌های حاصل از یک سرور در کنار هم قرار می‌گیرند.

گزینه --joblog شامل یک ورودی برای هر کار روی هر سرور خواهد بود، بنابراین چندین شماره توالی ۱ (job sequence 1) وجود خواهد داشت.

همچنین ببینید: --nonall --sshlogin

--open-tty

-o

باز کردن tty ترمینال.

مشابه --tty است اما --jobs یا --ungroup را تنظیم نمی‌کند.

همچنین ببینید: --tty

--output-as-files

--outputasfiles

--files

--files0

ذخیره خروجی در فایل‌ها.

به جای چاپ خروجی در stdout (خروجی استاندارد)، خروجی هر کار در یک فایل ذخیره شده و سپس نام فایل چاپ می‌شود.

گزینه --files0 از NUL (\0) به جای خط جدید (\n) به عنوان جداکننده استفاده می‌کند.

همچنین ببینید: --results

--pipe (آزمایشی بتا)

--spreadstdin (آزمایشی بتا)

توزیع ورودی بین کارها از طریق stdin (ورودی استاندارد).

یک بلوک از داده‌ها را از stdin (ورودی استاندارد) می‌خواند و آن را به عنوان ورودی به یک کار تحویل می‌دهد.

اندازه بلوک توسط --block تعیین می‌شود (پیش‌فرض: 1M).

به جز اولین و آخرین رکورد، GNU parallel فقط رکوردهای کامل را به کار ارسال می‌کند. رشته‌های --recstart و --recend محل شروع و پایان یک رکورد را مشخص می‌کنند: مرز میان دو رکورد به صورت --recend که بلافاصله پس از آن --recstart آمده تعریف می‌شود. ابزار GNU parallel دقیقاً پس از --recend و قبل از --recstart عمل برش را انجام می‌دهد. آخرین رکورد ناقص قبل از تحویل بلوک به کار از آن حذف خواهد شد. این رکورد ناقص به ابتدای بلوک بعدی اضافه می‌شود.

می‌توانید تعداد رکوردهای ارسالی را با -N محدود کرده و اندازه رکورد را با -L تعیین کنید.

گزینه --pipe حداکثر تا حدود ۱ گیگابایت بر ثانیه ورودی و ۱۰۰ مگابایت بر ثانیه خروجی را پوشش می‌دهد. اگر کارایی و سرعت بالا مهم است از --pipe-part استفاده کنید.

گزینه‌های --fifo و --cat ورودی stdin (ورودی استاندارد) را روی یک fifo یا یک فایل موقت ارائه می‌دهند.

اگر داده‌ها به آرامی می‌رسند، می‌توانید از --block-timeout برای پایان زودهنگام خواندن یک بلوک استفاده کنید.

داده‌ها را می‌توان با استفاده از --round-robin، --bin، --shard و --group-by به روش‌های خاصی بین کارها توزیع کرد. به بخش توزیع بلوک‌های داده (SPREADING BLOCKS OF DATA) مراجعه کنید.

همچنین ببینید: --block --block-timeout --recstart --recend --fifo --cat --pipe-part -N -L --round-robin

--pipe-part (آزمایشی آلفا)

ارسال بخش‌هایی از یک فایل فیزیکی از طریق پایپ.

گزینه --pipe-part عملکردی مشابه --pipe دارد، اما بسیار سریع‌تر است. نرخ ۵ گیگابایت بر ثانیه را می‌توان به راحتی فراهم کرد.

گزینه --pipe-part دارای چند محدودیت است:

--plain

نادیده گرفتن --profile، $PARALLEL و ~/.parallel/config.

نادیده گرفتن هرگونه --profile، $PARALLEL و ~/.parallel/config برای به دست آوردن کنترل کامل روی خط فرمان (توسط GNU parallel در هنگام فراخوانی داخلی با --sshlogin استفاده می‌شود).

نکته امنیتی: متغیر محیطی $PARALLEL به عنوان گزینه‌های اضافی خط فرمان تجزیه می‌شود، از جمله گزینه‌هایی که مقادیر آن‌ها به عنوان عبارات ارزیابی می‌شوند (مانند --blocksize، --timeout، --delay). در بسترهای دارای دسترسی ویژه — اسکریپت‌های پوششی setuid، اسکریپت‌های sudo یا هر وضعیتی که $PARALLEL ممکن است توسط یک طرف با سطح اعتماد کمتر تنظیم شود — گزینه --plain را پاس دهید تا از تأثیرگذاری $PARALLEL (و پروفایل‌های کاربری) بر فراخوانی جلوگیری شود.

نمونه اسکریپت پوششی که به عنوان root اجرا می‌شود:

#!/bin/sh
exec parallel --plain "$@"

همچنین ببینید: --profile

--plus

افزودن رشته‌های جایگزینی بیشتر.

فعال‌سازی رشته‌های جایگزینی اضافی: {+/} {+.} {+..} {+...} {..} {...} {/..} {/...} {##}. ایده این است که '{+foo}' با نقطه مقابل '{foo}' مطابقت دارد، به طوری که:

{} = {+/}/{/} = {.}.{+.} = {+/}/{/.}.{+.} = {..}.{+..} = {+/}/{/..}.{+..} = {...}.{+...} = {+/}/{/...}.{+...}

{##} تعداد کل کارهایی است که باید اجرا شوند. این گزینه با -X/-m/--xargs ناسازگار است.

{0%} جایگاه کار (jobslot) با صفرهای ابتدایی (zero-padded).

{0#} شماره توالی با صفرهای ابتدایی (zero-padded).

{slot-1} جایگاه کار - ۱ (شمارش از ۰).

{seq-1} شماره توالی - ۱ (شمارش از ۰).

{choose_k} از مفهوم «انتخاب k از n» (n choose k) الهام گرفته شده است: با داشتن فهرستی از n عنصر، k عنصر انتخاب می‌شوند. k تعداد منابع ورودی و n تعداد آرگومان‌ها در یک منبع ورودی است. محتوای منابع ورودی باید یکسان باشد و آرگومان‌ها باید یکتا باشند.

{uniq} کارهایی را که مقادیر دو منبع ورودی در آن‌ها یکسان است رد می‌کند.

نام‌های کوتاه برای متغیرها:

{slot}         $PARALLEL_JOBSLOT (see {%})
{sshlogin}     $PARALLEL_SSHLOGIN
{host}         $PARALLEL_SSHHOST
{agrp}         $PARALLEL_ARGHOSTGROUPS
{hgrp}         $PARALLEL_HOSTGROUPS

رشته‌های جایگزینی پویای زیر نیز فعال می‌شوند. این رشته‌ها از بسط پارامتر bash (parameter expansion) الهام گرفته شده‌اند:

{:-str}        str if the value is empty
{:num}         remove the first num characters
{:pos:len}     substring from position pos length len
{#regexp}      remove prefix regexp (non-greedy)
{##regexp}     remove prefix regexp (greedy)
{%regexp}      remove postfix regexp (non-greedy)
{%%regexp}     remove postfix regexp (greedy)
{/regexp/str}  replace one regexp with str
{//regexp/str} replace every regexp with str
{^str}         uppercase str if found at the start
{^^str}        uppercase str
{,str}         lowercase str if found at the start
{,,str}        lowercase str

همچنین ببینید: --rpl {}

--process-slot-var varname

تنظیم متغیر محیطی varname برابر با شماره جایگاه کار منهای یک (jobslot number-1).

seq 10 | parallel --process-slot-var=name echo '$name' {}

--progress

نمایش پیشرفت محاسبات.

رایانه‌های درگیر در وظیفه را همراه با تعداد پردازنده‌های شناسایی‌شده و حداکثر تعداد کارهای قابل اجرا فهرست می‌کند. پس از آن پیشرفت را برای هر رایانه نشان می‌دهد: تعداد کارهای در حال اجرا، تعداد کارهای تکمیل‌شده، و درصد تمام کارهای انجام‌شده توسط آن رایانه. درصد فقط پس از زمان‌بندی تمام کارها در دسترس خواهد بود، زیرا GNU parallel تنها زمانی کار بعدی را می‌خواند که آماده زمان‌بندی آن باشد — این کار برای جلوگیری از هدر رفتن زمان و حافظه با خواندن همه‌چیز در ابتدای اجرا است.

با ارسال سیگنال SIGUSR2 به GNU parallel می‌توانید فعال/غیرفعال بودن --progress را در یک فرآیند در حال اجرای GNU parallel تغییر وضعیت دهید.

همچنین ببینید: --eta --bar --joblog

--max-line-length-allowed

چاپ حداکثر طول خط فرمان.

حداکثر تعداد نویسه‌های مجاز در خط فرمان را چاپ کرده و خارج می‌شود (توسط خود GNU parallel برای تعیین طول خط در رایانه‌های راه دور استفاده می‌شود).

همچنین ببینید: --show-limits

--number-of-cpus (منسوخ‌شده)

چاپ تعداد هسته‌های فیزیکی CPU و خروج.

--number-of-cores

چاپ تعداد هسته‌های فیزیکی CPU و خروج (توسط خود GNU parallel برای تعیین تعداد هسته‌های فیزیکی CPU در رایانه‌های راه دور استفاده می‌شود).

همچنین ببینید: --number-of-sockets --number-of-threads --use-cores-instead-of-threads --jobs

--number-of-sockets

چاپ تعداد سوکت‌های پرشده CPU و خروج (توسط خود GNU parallel برای تعیین تعداد سوکت‌های پرشده CPU در رایانه‌های راه دور استفاده می‌شود).

همچنین ببینید: --number-of-cores --number-of-threads --use-sockets-instead-of-threads --jobs

--number-of-threads

چاپ تعداد هسته‌های هایپرتریدینگ (hyperthreaded) CPU و خروج (توسط خود GNU parallel برای تعیین تعداد هسته‌های هایپرترید CPU در رایانه‌های راه دور استفاده می‌شود).

همچنین ببینید: --number-of-cores --number-of-sockets --jobs

--no-keep-order

بازنویسی و نادیده گرفتن گزینه قبلی --keep-order (مثلاً اگر در ~/.parallel/config تنظیم شده باشد).

--nice niceness

اجرای دستور با این اولویت (niceness).

به صورت پیش‌فرض، GNU parallel کارها را با همان سطح nice که در هنگام شروع GNU parallel وجود داشته اجرا می‌کند — چه در رایانه محلی و چه در سرورهای راه دور، بنابراین بعید است که هرگز به این گزینه نیاز پیدا کنید.

تنظیم --nice این سطح nice را بازنویسی می‌کند. اگر سطح nice کمتر از سطح فعلی باشد، تنها بر کارهای راه دور تأثیر می‌گذارد (به عنوان مثال اگر سطح فعلی ۱۰ باشد، --nice 5 باعث می‌شود کارهای محلی در سطح ۱۰ اجرا شوند اما کارهای راه دور در سطح ۵ اجرا شوند).

--interactive

-p

پرسش از کاربر قبل از اجرای هر کار.

در مورد اینکه آیا هر خط فرمان اجرا شود یا خیر از کاربر می‌پرسد و یک خط از ترمینال می‌خواند. خط فرمان تنها در صورتی اجرا می‌شود که پاسخ با 'y' یا 'Y' شروع شود. مستلزم گزینه -t است.

--_parset type,varname

به صورت داخلی توسط parset استفاده می‌شود.

تولید کد شل برای اجرا با eval که متغیر(های) varname را مقداردهی می‌کند. مقدار type می‌تواند 'assoc' برای آرایه انجمنی یا 'var' برای متغیرهای عادی باشد.

تنها کاربرد پشتیبانی‌شده به عنوان بخشی از ابزار parset است.

--parens parensstring

استفاده از parensstring به جای {==}.

تعریف پرانتزهای شروع و پایان برای {=perl expression=}. پرانتزهای چپ و راست می‌توانند چندکاراکتری باشند و فرض بر این است که طول یکسانی دارند. مقدار پیش‌فرض {==} است که {= را به عنوان پرانتز شروع و =} را به عنوان پرانتز پایان تعیین می‌کند.

یک مقدار مفید دیگر ,,,, است که هر دو پرانتز را ,, قرار می‌دهد:

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

همچنین ببینید: --rpl {=perl expression=}

--profile profilename

-J profilename

استفاده از پروفایل profilename برای گزینه‌ها.

این گزینه زمانی مفید است که بخواهید چندین پروفایل داشته باشید. می‌توانید یک پروفایل برای اجرای کارها به صورت موازی در رایانه محلی و یک پروفایل دیگر برای اجرای کارها در رایانه‌های راه دور داشته باشید.

شناسه profilename متناظر با فایل ~/.parallel/profilename است.

می‌توانید با تکرار --profile چندین پروفایل را مشخص کنید. اگر بخش‌هایی از پروفایل‌ها با یکدیگر تداخل داشته باشند، اولویت با موارد بعدی خواهد بود.

پیش‌فرض: ~/.parallel/config

همچنین ببینید: فایل‌های پروفایل (PROFILE FILES)

--quote

-q

نقل‌قول کردن و اسکیپ command.

اگر دستور شما شامل نویسه‌های خاصی است که نباید توسط پوسته تفسیر شوند (مانند ; \ | *)، از --quote برای اسکیپ کردن آن‌ها استفاده کنید. دستور باید یک دستور ساده باشد (به man bash مراجعه کنید) بدون تغییرمسیرها (redirections) و بدون انتساب متغیرها.

اکثر افراد به این گزینه نیازی نخواهند داشت. نقل‌قول کردن به صورت پیش‌فرض غیرفعال است.

همچنین ببینید: نقل‌قول (QUOTING) command --shell-quote uq() Q().IP --no-run-if-empty 4

-r

عدم اجرای ورودی خالی.

اگر ورودی استاندارد (stdin) فقط شامل نویسه‌های فاصله خالی (whitespace) باشد، دستور را اجرا نمی‌کند.

در صورت استفاده همراه با --pipe این فرایند کند خواهد بود.

همچنین ببینید: command --pipe --interactive

--noswap

اگر رایانه در حال تعویض حافظه (swap) باشد کار جدیدی را آغاز نمی‌کند.

اگر روی یک رایانه مشخص هم‌زمان فعالیت ورود به حافظه مجازی (swap-in) و خروج از آن (swap-out) وجود داشته باشد، کارهای جدید را روی آن آغاز نمی‌کند.

فعالیت swap فقط هر ۱۰ ثانیه یک‌بار نمونه‌برداری می‌شود زیرا انجام نمونه‌برداری ۱ ثانیه زمان می‌برد.

فعالیت swap به‌صورت (swap-in)*(swap-out) محاسبه می‌شود که در عمل مقدار مناسبی است: swap-out مشکلی ندارد، swap-in مشکلی ندارد، اما وجود هم‌زمان هر دو حالت swap-in و swap-out معمولاً نشان‌دهندهٔ یک مشکل است.

گزینه‌های --memfree و --memsuspend ممکن است نتایج بهتری ارائه دهند، بنابراین ابتدا استفاده از آن‌ها را امتحان کنید.

همچنین ببینید: --memfree --memsuspend

--record-env

ثبت متغیرهای محیطی صادرشده.

متغیرهای محیطی صادرشدهٔ (exported) فعلی را در ~/.parallel/ignored_vars ثبت می‌کند. این کار باعث نادیده گرفتن متغیرهای تنظیم‌شدهٔ فعلی هنگام استفاده از --env _ می‌شود. بنابراین باید متغیرها/توابعی را که می‌خواهید استفاده کنید پس از اجرای --record-env تنظیم نمایید.

همچنین ببینید: --env --session env_parallel

--recstart startstring

--recend endstring

تفکیک رکورد بین endstring و startstring.

اگر --recstart مشخص شود، از startstring برای تفکیک در ابتدای رکورد استفاده می‌شود.

اگر --recend مشخص شود، از endstring برای تفکیک در انتهای رکورد استفاده می‌شود.

اگر هر دو گزینهٔ --recstart و --recend مشخص شوند، رشتهٔ ترکیبی endstringstartstring باید مطابقت داشته باشد تا موقعیت تفکیک پیدا شود. این ویژگی زمانی مفید است که startstring یا endstring در میانهٔ یک رکورد مطابقت پیدا کنند.

اگر هیچ‌کدام از --recstart یا --recend مشخص نشوند، مقدار پیش‌فرض --recend برابر '\n' خواهد بود. برای نداشتن جداکنندهٔ رکورد (مثلاً برای فایل‌های باینری) از --recend "" استفاده کنید.

گزینه‌های --recstart و --recend همراه با --pipe استفاده می‌شوند.

از --regexp برای تفسیر --recstart و --recend به‌عنوان عبارات باقاعده (regular expressions) استفاده کنید. با این حال، این کار کند است.

برای حذف --recstart و --recend پیش از ارسال بلوک به کار، از --remove-rec-sep استفاده کنید.

همچنین ببینید: --pipe --regexp --remove-rec-sep

--regexp

از --regexp برای تفسیر --recstart و --recend به‌عنوان عبارات باقاعده (regular expressions) استفاده کنید. با این حال، این کار کند است.

همچنین ببینید: --pipe --regexp --remove-rec-sep --recstart --recend

--remove-rec-sep

--removerecsep

--rrs

حذف جداکننده رکورد.

متن منطبق‌شده با --recstart و --recend را پیش از پایپ کردن به دستور حذف می‌کند.

فقط همراه با --pipe/--pipe-part استفاده می‌شود.

همچنین ببینید: --pipe --regexp --pipe-part --recstart --recend

--results name

--res name

ذخیره خروجی در فایل‌ها.

دایرکتوری خروجی با رشته ساده

اگر name فاقد رشته‌های جایگزینی باشد و به .csv/.tsv ختم نشود، خروجی در یک ساختار درختی دایرکتوری با ریشهٔ name ذخیره خواهد شد. درون این ساختار درختی، هر دستور منجر به سه فایل می‌شود: name/<ARGS>/stdout و name/<ARGS>/stderr و name/<ARGS>/seq، که در آن <ARGS> دنباله‌ای از دایرکتوری‌ها است که سربرگ منبع ورودی (در صورت استفاده از --header :) یا شمارهٔ منبع ورودی و مقادیر متناظر آن را نشان می‌دهد.

برای مثال:

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

فایل‌های زیر را تولید خواهد کرد:

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

و

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

فایل‌های زیر را تولید خواهد کرد:

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

خروجی فایل CSV

اگر name به .csv/.tsv ختم شود، خروجی یک فایل CSV به نام name خواهد بود.

پسوند .csv یک فایل با مقادیر جداشده با کاما و .tsv یک فایل با مقادیر جداشده با TAB ارائه می‌دهد.

مقادیر -.csv/-.tsv حالت خاص هستند: فایل را روی خروجی استاندارد (stdout) ارائه می‌دهند.

خروجی فایل JSON

اگر name به .json ختم شود، خروجی یک فایل JSON به نام name خواهد بود.

مقدار -.json حالت خاص است: فایل را روی خروجی استاندارد (stdout) ارائه می‌دهد.

فایل خروجی با رشته جایگزینی

اگر name حاوی یک رشتهٔ جایگزینی باشد و نتیجهٔ جایگزین‌شده به / ختم نشود، خروجی استاندارد در فایلی با نام این نتیجه ذخیره می‌شود. خطای استاندارد در همان نام فایل همراه با '.err' اضافه شده و شمارهٔ توالی در همان نام فایل با '.seq' اضافه شده ذخیره خواهد شد.

برای مثال:

parallel --results my_{} echo ::: foo bar baz

فایل‌های زیر را تولید خواهد کرد:

my_bar
my_bar.err
my_bar.seq
my_baz
my_baz.err
my_baz.seq
my_foo
my_foo.err
my_foo.seq

دایرکتوری خروجی با رشته جایگزینی

اگر name حاوی یک رشتهٔ جایگزینی باشد و نتیجهٔ جایگزین‌شده به / ختم شود، فایل‌های خروجی در دایرکتوری حاصل ذخیره خواهند شد.

برای مثال:

parallel --results my_{}/ echo ::: foo bar baz

فایل‌های زیر را تولید خواهد کرد:

my_bar/seq
my_bar/stderr
my_bar/stdout
my_baz/seq
my_baz/stderr
my_baz/stdout
my_foo/seq
my_foo/stderr
my_foo/stdout

همچنین ببینید: --output-as-files --tag --header --joblog

--resume

از سرگیری از آخرین کار ناتمام.

با خواندن --joblog یا دایرکتوری --results، گنو parallel آخرین کار ناتمام را تشخیص داده و از همان‌جا ادامه می‌دهد. از آنجا که گنو parallel فقط به شماره‌های توالی در --joblog نگاه می‌کند، ورودی، دستور و --joblog همگی باید بدون تغییر باقی بمانند؛ در غیر این صورت ممکن است گنو parallel دستورات نادرستی را اجرا کند.

همچنین ببینید: --joblog --results --resume-failed --retries

--resume-failed

تلاش مجدد برای تمام موارد ناموفق و از سرگیری از آخرین کار ناتمام.

با خواندن --joblog، گنو parallel کارهای ناموفق را تشخیص داده و آن‌ها را مجدداً اجرا می‌کند. پس از آن، از آخرین کار ناتمام از سر گرفته و ادامه می‌دهد. از آنجا که گنو parallel فقط به شماره‌های توالی در --joblog نگاه می‌کند، ورودی، دستور و --joblog همگی باید بدون تغییر باقی بمانند؛ در غیر این صورت ممکن است گنو parallel دستورات نادرستی را اجرا کند.

همچنین ببینید: --joblog --resume --retry-failed --retries

--retry-failed

تلاش مجدد برای تمام کارهای ناموفق در joblog.

با خواندن --joblog، گنو parallel کارهای ناموفق را تشخیص داده و آن‌ها را مجدداً اجرا می‌کند.

گزینهٔ --retry-failed دستور و آرگومان‌های روی خط فرمان را نادیده می‌گیرد: این گزینه فقط به joblog نگاه می‌کند.

تفاوت‌های میان --resume و --resume-failed و --retry-failed

در این مثال، عبارت exit {= $_%=2 =} باعث شکست یکی‌درمیان کارها می‌شود.

timeout -k 1 4 parallel --joblog log -j10 \
  'sleep {}; exit {= $_%=2 =}' ::: {10..1}

۴ کار کامل شد، ۲ کار با شکست مواجه شد:

Seq   [...]   Exitval Signal  Command
10    [...]   1       0       sleep 1; exit 1
9     [...]   0       0       sleep 2; exit 0
8     [...]   1       0       sleep 3; exit 1
7     [...]   0       0       sleep 4; exit 0

گزینهٔ --resume به Exitval اهمیتی نمی‌دهد و فقط به Seq نگاه می‌کند. اگر یک Seq اجرا شده باشد، دوباره اجرا نخواهد شد. بنابراین در صورت نیاز می‌توانید دستور را برای دنباله‌هایی که هنوز اجرا نشده‌اند تغییر دهید:

parallel --resume --joblog log -j10 \
  'sleep .{}; exit {= $_%=2 =}' ::: {10..1}
Seq   [...]   Exitval Signal  Command
[... as above ...]
1     [...]   0       0       sleep .10; exit 0
6     [...]   1       0       sleep .5; exit 1
5     [...]   0       0       sleep .6; exit 0
4     [...]   1       0       sleep .7; exit 1
3     [...]   0       0       sleep .8; exit 0
2     [...]   1       0       sleep .9; exit 1

گزینهٔ --resume-failed به Exitval توجه دارد، اما برای تشخیص دستوراتی که باید اجرا شوند باز هم فقط به Seq نگاه می‌کند. این یعنی مجدداً می‌توانید خود دستور را تغییر دهید، اما آرگومان‌ها را خیر. این گزینه دنباله‌های ناموفق و دنباله‌هایی را که هنوز اجرا نشده‌اند اجرا خواهد کرد:

parallel --resume-failed --joblog log -j10 \
  'echo {};sleep .{}; exit {= $_%=3 =}' ::: {10..1}
Seq   [...]   Exitval Signal  Command
[... as above ...]
10    [...]   1       0       echo 1;sleep .1; exit 1
8     [...]   0       0       echo 3;sleep .3; exit 0
6     [...]   2       0       echo 5;sleep .5; exit 2
4     [...]   1       0       echo 7;sleep .7; exit 1
2     [...]   0       0       echo 9;sleep .9; exit 0

گزینهٔ --retry-failed به Exitval توجه دارد، اما دستور را از joblog برمی‌دارد. این گزینه هرگونه آرگومان یا دستور داده‌شده روی خط فرمان را نادیده می‌گیرد:

parallel --retry-failed --joblog log -j10 this part is ignored
Seq   [...]   Exitval Signal  Command
[... as above ...]
10    [...]   1       0       echo 1;sleep .1; exit 1
6     [...]   2       0       echo 5;sleep .5; exit 2
4     [...]   1       0       echo 7;sleep .7; exit 1

همچنین ببینید: --joblog --resume --resume-failed --retries

--retries n (beta testing)

تلاش مجدد برای کارهای ناموفق تا n بار.

اگر کاری با شکست مواجه شود، تلاش مجدد را روی رایانهٔ دیگری که در آن شکست نخورده انجام می‌دهد. این کار را n بار تکرار می‌کند. اگر تعداد رایانه‌های موجود در --sshlogin کمتر از n باشد، گنو parallel دوباره از همهٔ رایانه‌ها استفاده خواهد کرد. این ویژگی زمانی مفید است که برخی کارها بدون دلیل مشخصی (مانند نقص شبکه) شکست می‌خورند.

مقدار n=0 به معنای نامحدود است.

همچنین ببینید: --term-seq --sshlogin

--return filename (beta testing)

انتقال فایل‌ها از رایانه‌های دوردست.

گزینه --return همراه با --sshlogin زمانی استفاده می‌شود که آرگومان‌ها فایل‌هایی روی رایانه‌های دوردست باشند. پس از اتمام پردازش، فایل filename با استفاده از rsync از رایانه دوردست منتقل شده و به صورت نسبی در دایرکتوری ورود پیش‌فرض قرار می‌گیرد. به عنوان مثال:

echo foo/bar.txt | parallel --return {.}.out \
  --sshlogin server.example.com touch {.}.out

این دستور فایل $HOME/foo/bar.out را از رایانه server.example.com پس از اجرای touch foo/bar.out روی server.example.com به فایل foo/bar.out منتقل خواهد کرد.

parallel -S server --trc out/./{}.out touch {}.out ::: in/file

این دستور فایل in/file.out را از رایانه server.example.com پس از اجرای touch in/file.out روی server به فایل‌های out/in/file.out منتقل خواهد کرد.

echo /tmp/foo/bar.txt | parallel --return {.}.out \
  --sshlogin server.example.com touch {.}.out

این دستور فایل /tmp/foo/bar.out را از رایانه server.example.com پس از اجرای touch /tmp/foo/bar.out روی server.example.com به فایل /tmp/foo/bar.out منتقل خواهد کرد.

با تکرار چندباره این گزینه می‌توان چندین فایل را منتقل کرد:

echo /tmp/foo/bar.txt | parallel \
  --sshlogin server.example.com \
  --return {.}.out --return {.}.out2 touch {.}.out {.}.out2

در صورت استفاده با --sshlogin : یا هنگام عدم استفاده همراه با --sshlogin، گزینه --return نادیده گرفته می‌شود.

برای جزئیات بیشتر در مورد انتقال، --transferfile را ببینید.

همچنین ببینید: --transfer --transferfile --sshlogin --cleanup --workdir

--round-robin (alpha testing)

--round (alpha testing)

توزیع تکه‌های ورودی استاندارد به شیوه نوبت‌گردشی (round robin).

به طور معمول --pipe به هر نمونه از دستور یک بلوک می‌دهد. با --round-robin تمام بلوک‌ها به صورت تصادفی به دستوراتی که از قبل در حال اجرا هستند نوشته می‌شوند. این قابلیت زمانی مفید است که مقداردهی اولیه دستور زمان زیادی ببرد.

در صورت استفاده از --keep-order و --round-robin، اگر ورودی یکسان نگه داشته شود، اسلات‌های کار در هر بار اجرا همان بلوک‌ها را با همان ترتیب به عنوان ورودی دریافت خواهند کرد. جزئیات بیشتر را ذیل --keep-order ببینید.

گزینه --round-robin مستلزم --pipe است، مگر اینکه --pipe-part داده شده باشد.

بخش SPREADING BLOCKS OF DATA را ببینید.

همچنین ببینید: --bin --group-by --shard

--rpl 'tag perl expression'

تعریف رشته جایگزین.

استفاده از tag به عنوان رشته جایگزین برای perl expression. این امکان را فراهم می‌سازد که رشته‌های جایگزین سفارشی خود را تعریف کنید. ۷ رشته جایگزین در GNU parallel به این صورت پیاده‌سازی شده‌اند:

--rpl '{} '
--rpl '{#} 1 $_=$job->seq()'
--rpl '{%} 1 $_=$job->slot()'
--rpl '{/} s:.*/::'
--rpl '{//} $Global::use{"File::Basename"} ||=
            eval "use File::Basename; 1;"; $_ = dirname($_);'
--rpl '{/.} s:.*/::; s:\.[^/.]+$::;'
--rpl '{.} s:\.[^/.]+$::'

رشته‌های جایگزین --plus به این صورت پیاده‌سازی شده‌اند:

--rpl '{+/} s:/[^/]*$:: || s:.*$::'
--rpl '{+.} s:.*\.:: || s:.*$::'
--rpl '{+..} s:.*\.([^/.]+\.[^/.]+)$:$1: || s:.*$::'
--rpl '{+...} s:.*\.([^/.]+\.[^/.]+\.[^/.]+)$:$1: || s:.*$::'
--rpl '{..} s:\.[^/.]+\.[^/.]+$::'
--rpl '{...} s:\.[^/.]+\.[^/.]+\.[^/.]+$::'
--rpl '{/..} s:.*/::; s:\.[^/.]+\.[^/.]+$::'
--rpl '{/...} s:.*/::; s:\.[^/.]+\.[^/.]+\.[^/.]+$::'
--rpl '{choose_k}
       for $t (2..$#arg){ if($arg[$t-1] ge $arg[$t]) { skip() } }'
--rpl '{##} 1 $_=total_jobs()'
--rpl '{0%} 1 $f=1+int((log($Global::max_jobs_running||1)/
                        log(10))); $_=sprintf("%0${f}d",slot())'
--rpl '{0#} 1 $f=1+int((log(total_jobs())/log(10)));
            $_=sprintf("%0${f}d",seq())'
--rpl '{seq(.*?)} $_=eval q{$job->seq()}.qq{$$1}'
--rpl '{slot(.*?)} $_=eval q{$job->slot()}.qq{$$1}'
--rpl '{:-([^}]+?)} $_ ||= $$1'
--rpl '{:(\d+?)} substr($_,0,$$1) = ""'
--rpl '{:(\d+?):(\d+?)} $_ = substr($_,$$1,$$2);'
--rpl '{#([^#}][^}]*?)} $nongreedy=::make_regexp_ungreedy($$1);
                        s/^$nongreedy(.*)/$1/;'
--rpl '{##([^#}][^}]*?)} s/^$$1//;'
--rpl '{%([^}]+?)} $nongreedy=::make_regexp_ungreedy($$1);
                   s/(.*)$nongreedy$/$1/;'
--rpl '{%%([^}]+?)} s/$$1$//;'
--rpl '{/([^}]+?)/([^}]*?)} s/$$1/$$2/;'
--rpl '{^([^}]+?)} s/^($$1)/uc($1)/e;'
--rpl '{^^([^}]+?)} s/($$1)/uc($1)/eg;'
--rpl '{,([^}]+?)} s/^($$1)/lc($1)/e;'
--rpl '{,,([^}]+?)} s/($$1)/lc($1)/eg;'
--rpl '{slot} 1 $_="\${PARALLEL_JOBSLOT}";uq()'
--rpl '{host} 1 $_="\${PARALLEL_SSHHOST}";uq()'
--rpl '{sshlogin} 1 $_="\${PARALLEL_SSHLOGIN}";uq()'
--rpl '{hgrp} 1 $_="\${PARALLEL_HOSTGROUPS}";uq()'
--rpl '{agrp} 1 $_="\${PARALLEL_ARGHOSTGROUPS}";uq()'

اگر رشته جایگزین تعریف‌شده توسط کاربر با '{' آغاز شود، می‌تواند به عنوان یک رشته جایگزین موضعی (مانند {2.}) نیز استفاده شود.

توصیه می‌شود تنها $_ را تغییر دهید، اما به تمام توابع و ساختارهای داده داخلی GNU parallel دسترسی کامل دارید.

چند مثال در اینجا آورده شده است:

Is the job sequence even or odd?
--rpl '{odd} $_ = seq() % 2 ? "odd" : "even"'
Pad job sequence with leading zeros to get equal width
--rpl '{0#} $f=1+int("".(log(total_jobs())/log(10)));
  $_=sprintf("%0${f}d",seq())'
Job sequence counting from 0
--rpl '{#0} $_ = seq() - 1'
Job slot counting from 2
--rpl '{%1} $_ = slot() + 1'
Remove all extensions
--rpl '{:} s:(\.[^/]+)*$::'

می‌توانید با قرار دادن پرانتز در رشته جایگزین و افزودن یک عبارت منظم درون پرانتز، رشته‌های جایگزین پویا داشته باشید. رشته منطبق به صورت $$1 درج خواهد شد:

parallel --rpl '{%(.*?)} s/$$1//' echo {%.tar.gz} ::: my.tar.gz
parallel --rpl '{:+(.+?)} s:$$1(\.[^/]+)*$::' \
  echo {:+_file} ::: my_file.tar.gz
parallel -n3 --rpl '{/:+(.*?)} s:.*/(.*)$$1(\.[^/]+)*$:$1:' \
  echo job {#}: {2} {2.} {3/:+_1} ::: a/b.c c/d.e f/g_1.h.i

حتی می‌توانید از چندین تطابق استفاده کنید:

parallel --rpl '{/(.+?)/(.*?)} s/$$1/$$2/;'
  echo {/replacethis/withthis} {/b/C} ::: a_replacethis_b
parallel --rpl '{(.*?)/(.*?)} $_="$$2$_$$1"' \
  echo {swap/these} ::: -middle-

همچنین ببینید: {=perl expression=} --parens

--rsync-opts options

گزینه‌ها برای ارسال به rsync.

تنظیم --rsync-opts بر مقدار متغیر محیطی $PARALLEL_RSYNC_OPTS اولویت دارد.

--max-chars max-chars

-s max-chars

محدود کردن طول دستور.

حداکثر از max-chars نویسه در هر خط دستور استفاده شود، شامل دستور و آرگومان‌های اولیه (initial-arguments) و نویسه‌های null پایانی در انتهای رشته‌های آرگومان. بزرگ‌ترین مقدار مجاز وابسته به سیستم است و به صورت حد طول آرگومان برای exec منهای اندازه محیط شما محاسبه می‌شود. مقدار پیش‌فرض حداکثر ممکن است.

می‌توان پسوندهای K، M، G، T، P، k، m، g، t یا p را به max-chars اضافه کرد (بخش UNIT PREFIX را ببینید).

مستلزم -X است مگر اینکه -m یا --xargs تنظیم شده باشد.

همچنین ببینید: -X -m --xargs --max-line-length-allowed --show-limits

--show-limits

نمایش محدودیت‌های تعیین‌شده توسط سیستم‌عامل.

نمایش محدودیت‌های طول خط فرمان که توسط سیستم‌عامل و گزینه -s اعمال می‌شوند. اگر نمی‌خواهید GNU parallel کاری انجام دهد، ورودی را از dev/null/ پایپ کنید (و در صورت نیاز --no-run-if-empty را مشخص نمایید).

همچنین ببینید: --max-chars --max-line-length-allowed --version

--semaphore

کارکرد به عنوان یک سمافور شمارشی (counting semaphore).

گزینه --semaphore باعث می‌شود GNU parallel دستور command را در پس‌زمینه اجرا کند. هنگامی که تعداد کارهای مشخص‌شده توسط --jobs پر شد، GNU parallel پیش از شروع دستوری دیگر، منتظر اتمام یکی از این کارها می‌ماند.

گزینه --semaphore مستلزم --bg است مگر اینکه --fg مشخص شده باشد.

دستور sem نام مستعاری (alias) برای parallel --semaphore است.

همچنین ببینید: man sem --bg --fg --semaphore-name --semaphore-timeout --wait

--semaphore-name name

--id name

استفاده از name به عنوان نام سمافور.

مقدار پیش‌فرض، نام tty کنترل‌کننده است (خروجی دستور tty).

مقدار پیش‌فرض معمولاً در استفاده تعاملی طبق انتظار کار می‌کند، اما هنگام استفاده در یک اسکریپت باید name تنظیم شود. مقادیر $$ یا my_task_name معمولاً گزینه‌های مناسبی هستند.

سمافور در مسیر ‎~/.parallel/semaphores/‎ ذخیره می‌شود.

مستلزم --semaphore است.

همچنین ببینید: man sem --semaphore

--semaphore-timeout secs

--st secs

اگر 0 < secs: چنانچه سمافور ظرف secs ثانیه آزاد نشود، در هر صورت آن را در اختیار بگیر.

اگر 0 > secs: چنانچه سمافور ظرف secs ثانیه آزاد نشود، خارج شو.

مقدار secs به ثانیه است، اما می‌تواند با پسوندهای s، m، h یا d همراه شود (بخش TIME POSTFIXES را ببینید).

مستلزم --semaphore است.

همچنین ببینید: man sem

--seqreplace replace-str

استفاده از رشته جایگزین replace-str به جای {#} برای شماره توالی کار.

همچنین ببینید: {#}

--session

ثبت نام‌های موجود در محیط فعلی در $PARALLEL_IGNORED_NAMES و خروج.

فقط همراه با env_parallel استفاده می‌شود. نام مستعارها، توابع و متغیرهایی با نام‌های موجود در $PARALLEL_IGNORED_NAMES کپی نخواهند شد. بنابراین باید متغیرها/توابعی را که می‌خواهید کپی شوند، بعد از اجرای --session تنظیم کنید.

این گزینه مشابه --record-env است، اما فقط برای این نشست اعمال می‌شود.

فقط در Ash, Bash, Dash, Ksh, Sh, and Zsh پشتیبانی می‌شود.

همچنین ببینید: --env --record-env env_parallel

--shard shardexpr

استفاده از shardexpr به عنوان کلید شارد و قطعه‌بندی (shard) ورودی برای کارها.

عبارت shardexpr به صورت [column number|column name] [perlexpression] است، به عنوان مثال:

3
Address
3 $_%=100
Address s/\d//g

هر خط ورودی با استفاده از --colsep تفکیک می‌شود. رشته مربوط به ستون در $_ قرار می‌گیرد، عبارت پرل اجرا می‌شود و رشته حاصل هش می‌گردد تا تمام خطوط با یک مقدار مشخص به همان اسلات کار اختصاص یابند.

این عملکرد مشابه شاردینگ در پایگاه‌های داده است.

کارایی در حدود ۱۰۰ هزار سطر در ثانیه است؛ اگر shardcol کوچک باشد (کمتر از 10) سریع‌تر و اگر بزرگ باشد (بیشتر از 100) کندتر خواهد بود.

گزینه --shard مستلزم --pipe و یک مقدار عددی ثابت برای --jobs است.

بخش SPREADING BLOCKS OF DATA را ببینید.

همچنین ببینید: --bin --group-by --round-robin

--shebang

--hashbang

ابزار GNU parallel می‌تواند به عنوان یک دستور شِبَنگ (#!) در خط اول یک اسکریپت فراخوانی شود. محتوای فایل به عنوان منبع ورودی (inputsource) در نظر گرفته خواهد شد.

مانند این:

#!/usr/bin/parallel --shebang -r wget
https://ftpmirror.gnu.org/parallel/parallel-20120822.tar.bz2
https://ftpmirror.gnu.org/parallel/parallel-20130822.tar.bz2
https://ftpmirror.gnu.org/parallel/parallel-20140822.tar.bz2

گزینه --shebang باید به عنوان اولین گزینه تنظیم شود.

در FreeBSD دستور env مورد نیاز است:

#!/usr/bin/env -S parallel --shebang -r wget
https://ftpmirror.gnu.org/parallel/parallel-20120822.tar.bz2
https://ftpmirror.gnu.org/parallel/parallel-20130822.tar.bz2
https://ftpmirror.gnu.org/parallel/parallel-20140822.tar.bz2

محدودیت‌های زیادی برای شِبَنگ (#!) بسته به سیستم‌عامل شما وجود دارد. جزئیات را در https://www.in-ulm.de/~mascheck/various/shebang ببینید.

همچنین ببینید: --shebang-wrap

--shebang-wrap

برنامه GNU parallel می‌تواند اسکریپت‌ها را با پوشش‌دادن خط shebang موازی‌سازی کند. اگر برنامه به این صورت قابل اجرا باشد:

cat arguments | parallel the_program

آنگاه اسکریپت را می‌توان به این شکل تغییر داد:

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

برای مثال:

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

اگر برنامه به این صورت قابل اجرا باشد:

cat data | parallel --pipe the_program

آنگاه اسکریپت را می‌توان به این صورت تغییر داد:

#!/usr/bin/parallel --shebang-wrap --pipe /orig/parser --opts

برای مثال:

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

گزینه --shebang-wrap باید به عنوان اولین گزینه تنظیم شود.

همچنین ببینید: --shebang

--shell-completion shell

تولید کد تکمیل شل (shell completion) برای شل‌های تعاملی.

شل‌های پشتیبانی‌شده: bash zsh.

از auto به عنوان shell برای تشخیص خودکار شل در حال اجرا استفاده کنید.

فعال‌سازی کد تکمیل با:

zsh% eval "$(parallel --shell-completion auto)"
bash$ eval "$(parallel --shell-completion auto)"

یا این متن را در `/usr/share/zsh/site-functions/_parallel` قرار داده، سپس `compinit` را برای تولید `~/.zcompdump` اجرا کنید:

#compdef parallel
(( $+functions[_comp_parallel] )) ||
  eval "$(parallel --shell-completion auto)" &&
  _comp_parallel

--shell-quote

دستور را اجرا نمی‌کند بلکه آن را کوت (نقل‌قول) می‌کند. برای ساخت دستورات ترکیبی کوت‌شده برای GNU parallel کاربرد دارد.

استفاده چندباره از --shell-quote رشته را چندین بار کوت می‌کند، بنابراین parallel --shell-quote | parallel --shell-quote را می‌توان به صورت parallel --shell-quote --shell-quote نوشت.

همچنین ببینید: --quote

--shuf

برزدن (shuffle) کارها.

هنگام استفاده از چندین منبع ورودی، تصادفی‌سازی کارها دشوار است. گزینه --shuf تمام کارها را تولید کرده و پیش از اجرا آن‌ها را برمی‌زند. این ویژگی برای دریافت یک پیش‌نمایش سریع از نتایج پیش از اجرای کامل دسته کاربردی است.

در ترکیب با --halt soon,done=1% می‌توانید یک نمونه تصادفی ۱ درصدی از تمام کارها را اجرا کنید:

parallel --shuf --halt soon,done=1% echo ::: {1..100} ::: {1..100}

همچنین ببینید: --halt

--skip-first-line

خط اول ورودی را نادیده می‌گیرد (توسط خود GNU parallel هنگام فراخوانی با --shebang استفاده می‌شود).

--sql DBURL (منسوخ)

به جای آن از --sql-master استفاده کنید.

--sql-master DBURL

ارسال کارها از طریق سرور SQL. مقدار DBURL باید به یک جدول اشاره کند که شامل همان اطلاعات --joblog، مقادیر حاصل از منابع ورودی (ذخیره‌شده در ستون‌های V1 .. Vn)، و خروجی (ذخیره‌شده در ستون‌های Stdout و Stderr) خواهد بود.

اگر DBURL با '+' شروع شود، GNU parallel فرض می‌کند جدول قبلاً با ستون‌های صحیح ایجاد شده است و کارها را به آن ضمیمه می‌کند.

اگر DBURL با '+' شروع نشود، جدول حذف شده (drop) و با تعداد مناسب ستون‌های V ایجاد می‌شود مگر آنکه

گزینه --sqlmaster هیچ کاری را اجرا نمی‌کند، بلکه مقادیر مربوط به کارهایی که باید اجرا شوند را ایجاد می‌نماید. برای اجرای واقعی کارها باید یک یا چند --sqlworker اجرا شوند.

اگر --wait تنظیم شده باشد، GNU parallel تا اتمام کارها منتظر خواهد ماند.

قالب DBURL به این صورت است:

[sql:]vendor://[[user][:pwd]@][host][:port]/[db]/[table]

برای مثال:

sql:mysql://hr:hr@localhost:3306/hrdb/jobs
mysql://scott:tiger@my.example.com/pardb/paralleljobs
sql:oracle://scott:tiger@ora.example.com/xe/parjob
postgresql://scott:tiger@pg.example.com/pgdb/parjob
pg:///parjob
sqlite3:///%2Ftmp%2Fpardb.sqlite/parjob
sqlite:///file_in_current_dir.sqlite/my_table
csv:///%2Ftmp%2Fpardb/parjob
csv:///./file_in_current_dir
pg:////

توجه کنید که چگونه / در مسیر sqlite و CSV باید به صورت %2F کدگذاری شود، به جز آخرین / در CSV که باید یک / باشد.

مقادیر پیش‌فرض db و table برابر با $USER: pg://// = pg:///$USER/$USER

همچنین می‌تواند یک نام مستعار (alias) از ~/.sql/aliases باشد:

:myalias mysql:///mydb/paralleljobs

همچنین ببینید: --sql-and-worker --sql-worker --joblog

--sql-and-worker DBURL

کوتاه‌نوشت برای: --sql-master DBURL --sql-worker DBURL.

همچنین ببینید: --sql-master --sql-worker

--sql-worker DBURL

اجرای کارها از طریق سرور SQL. متغیرهای منابع ورودی را از جدول مشخص‌شده توسط DBURL می‌خواند. دستور command در خط فرمان باید همان دستوری باشد که به --sqlmaster داده شده است.

اگر بیش از یک --sqlworker داشته باشید، ممکن است کارها بیش از یک بار اجرا شوند.

اگر --sqlworker روی رایانه محلی اجرا شود، نام میزبان در جدول SQL به جای ':' نام میزبان همان رایانه خواهد بود.

همچنین ببینید: --sql-master --sql-and-worker

--ssh sshcommand (آزمایشی آلفا)

برنامه GNU parallel به طور پیش‌فرض از ssh برای دسترسی از راه دور استفاده می‌کند. این مورد را می‌توان با --ssh بازنویسی کرد. همچنین می‌توان آن را برای هر سرور به طور جداگانه با --sshlogin تنظیم نمود.

همچنین ببینید: --sshlogin

--ssh-delay duration

تأخیر در شروع ssh بعدی به میزان duration.

برنامه GNU parallel برای مدت زمان duration اتصال ssh دیگری را آغاز نخواهد کرد.

مقدار duration به ثانیه است، اما می‌تواند پسوند s، m، h، یا d داشته باشد.

همچنین ببینید: TIME POSTFIXES --sshlogin --delay

--sshlogin [@hostgroups/][ncpus/][[user][:[password]]@]host[:port][,...] (آزمایشی آلفا)

--sshlogin @hostgroup/

-S [@hostgroups/][ncpus/][ssh command][[user][:[password]]@]host[:port][,...] (آزمایشی آلفا)

-S @hostgroup/

توزیع کارها روی رایانه‌های راه دور.

کارها روی فهرستی از رایانه‌های راه دور اجرا خواهند شد.

--sshloginfile filename (آزمایشی بتا)

--slf filename (آزمایشی بتا)

فایل حاوی sshloginها. این فایل شامل sshloginها در خطوط جداگانه است. خطوط خالی و خطوطی که با '#' شروع می‌شوند نادیده گرفته خواهند شد. مثال:

server.example.com
username@server2.example.com
8/my-8-cpu-server.example.com
2/my_other_username@my-dualcore.example.net
# These servers have SSH running on port 2222
ssh -p 2222 server.example.net
server01.example.net:2222
4/ssh -p 2222 quadserver.example.net
# Use a different ssh program
myssh -p 2222 -l myusername hexacpu.example.net
# Use a different ssh program with default number of CPUs
//usr/local/bin/myssh -p 2222 -l myusername hexacpu
# Use a different ssh program with 6 CPUs
6//usr/local/bin/myssh -p 2222 -l myusername hexacpu
# Assume 16 CPUs on the local computer
16/:
# Use password for authentication
user:password@host
# Use $SSHPASS for authentication
user:@host
# Use $SSHPASS for authentication and current username
:@host
# Use password for authentication and current username
:password@host
# Login in as bob with :p@ss:w0rd@ as password
bob::p@ss:w0rd@@host
# Put server1 in hostgroup1
@hostgroup1/server1
# Put myusername@server2 in hostgroup1+hostgroup2
@hostgroup1+hostgroup2/myusername@server2
# Force 4 CPUs and put 'ssh -p 2222 server3' in hostgroup1
@hostgroup1/4/ssh -p 2222 server3
# TODO example with ,,

هنگام استفاده از یک برنامه ssh متفاوت، آخرین آرگومان باید نام میزبان باشد.

استفاده از چندین --sshloginfile مجاز است.

برنامه GNU parallel ابتدا به دنبال فایل در دایرکتوری فعلی می‌گردد؛ اگر یافت نشد در ~/.parallel جستجو می‌کند.

۳ نام با معنی خاص وجود دارد:

cp original.slf tmp2.slf
while [ 1 ] ; do
  nice parallel --nonall -j0 -k --slf original.slf \
    --tag echo | perl 's/\t$//' > tmp.slf
  if diff tmp.slf tmp2.slf; then
    mv tmp.slf tmp2.slf
  fi
  sleep 10
done &
parallel --slf tmp2.slf ...

--slotreplace replace-str

استفاده از رشته جایگزین replace-str به جای {%} برای شماره اسلات کار.

همچنین ببینید: {%}

--silent

حالت بی‌صدا.

کاری که باید اجرا شود در خروجی چاپ نخواهد شد. این حالت پیش‌فرض است. با -v می‌توان آن را معکوس کرد.

همچنین ببینید: -v

--template file=repl

--tmpl file=repl

جایگزینی رشته‌های جایگزین در file و ذخیره آن در repl.

تمامی رشته‌های جایگزین در محتوای file جایگزین خواهند شد. تمامی رشته‌های جایگزین در نام repl نیز جایگزین خواهند شد.

با استفاده از --cleanup پس از پایان کار، فایل جدید حذف خواهد شد.

اگر my.tmpl حاوی این متن باشد:

Xval: {x}
Yval: {y}
FixedValue: 9
# x with 2 decimals
DecimalX: {=x $_=sprintf("%.2f",$_) =}
TenX: {=x $_=$_*10 =}
RandomVal: {=1 $_=rand() =}

می‌توان از آن به این شکل استفاده کرد:

myprog() { echo Using "$@"; cat "$@"; }
export -f myprog
parallel --cleanup --header : --tmpl my.tmpl={#}.t myprog {#}.t \
  ::: x 1.234 2.345 3.45678 ::: y 1 2 3

همچنین ببینید: {} --cleanup

--tty

باز کردن ترمینال tty.

اگر از GNU parallel برای اجرای برنامه‌ای استفاده شود که به tty دسترسی دارد (مانند یک برنامه تعاملی)، ممکن است این گزینه مورد نیاز باشد. به طور پیش‌فرض فقط یک کار را در هر لحظه اجرا می‌کند (یعنی -j1)، خروجی را بافر نمی‌کند (یعنی -u)، و یک tty برای کار باز می‌کند.

البته می‌توانید مقادیر -j1 و -u را بازنویسی و لغو کنید.

متأسفانه استفاده از --tty به این معنی است که GNU parallel نمی‌تواند کارها را متوقف سازد (با --timeout، --memfree یا --halt). این به این دلیل است که GNU parallel به هر پردازه فرزند یک گروه پردازه مجزا اختصاص می‌دهد که سپس متوقف می‌شوند. گروه‌های پردازه به tty وابسته هستند.

همچنین ببینید: --ungroup --open-tty

--tag

برچسب‌گذاری خطوط با آرگومان‌ها.

در ابتدای هر خط خروجی، آرگومان‌ها و یک تب (\t) درج خواهد شد. هنگام ترکیب با --onall یا --nonall، به جای آن، sshlogin در ابتدای خطوط قرار می‌گیرد.

هنگام استفاده از -u، گزینه --tag نادیده گرفته می‌شود.

همچنین ببینید: --tagstring --ctag

--tagstring str

برچسب‌گذاری خطوط با یک رشته.

در ابتدای هر خط خروجی، str و یک تب (\t) درج خواهد شد. str می‌تواند شامل رشته‌های جایگزین مانند {} باشد.

هنگام استفاده از -u، --onall و --nonall، گزینه --tagstring نادیده گرفته می‌شود.

همچنین ببینید: --tag --ctagstring

--tee (alpha testing)

هدایت (pipe) تمام داده‌ها به تمامی کارها.

همراه با --pipe/--pipe-part و ::: استفاده می‌شود.

seq 1000 | parallel --pipe --tee -v wc {} ::: -w -l -c

چه تعداد از اعداد ۱ تا ۱۰۰۰ شامل ارقام ۰ تا ۹ هستند، و چه مقدار بایت را اشغال می‌کنند:

seq 1000 | parallel --pipe --tee --tag \
  'grep {1} | wc {2}' ::: {0..9} ::: -l -c

چه تعداد از کلمات شامل حروف a تا z هستند و چند بایت را اشغال می‌کنند؟

parallel -a /usr/share/dict/words --pipe-part --tee --tag \
  'grep {1} | wc {2}' ::: {a..z} ::: -l -c

همچنین ببینید: ::: --pipe --pipe-part

--term-seq sequence

توالی خاتمه (termination sequence).

هنگامی که یک کار به دلیل --timeout، --memfree، --halt یا خاتمه غیرعادی GNU parallel متوقف می‌شود، sequence نحوه پایان دادن به کار را مشخص می‌کند. حالت پیش‌فرض عبارت است از:

TERM,200,TERM,100,TERM,50,KILL,25

که یک سیگنال TERM ارسال می‌کند، ۲۰۰ میلی‌ثانیه صبر می‌کند، یک سیگنال TERM دیگر می‌فرستد، ۱۰۰ میلی‌ثانیه صبر می‌کند، سیگنال TERM دیگری می‌فرستد، ۵۰ میلی‌ثانیه صبر می‌کند، یک سیگنال KILL ارسال می‌کند، ۲۵ میلی‌ثانیه صبر می‌کند و خارج می‌شود. GNU parallel تشخیص می‌دهد که آیا یک پردازه قبل از اتمام زمان انتظار پایان یافته است یا خیر.

همچنین ببینید: --halt --timeout --memfree

--total-jobs jobs

--total jobs

ارائه تعداد کل کارها برای محاسبه زمان تقریبی اتمام (ETA) که برای --bar نیز استفاده می‌شود.

بدون --total-jobs، ابزار GNU Parallel قبل از شروع یک کار، تمامی کارها را خواهد خواند. در صورتی که ورودی به صورت آهسته تولید شود، --total-jobs مفید خواهد بود.

همچنین ببینید: --bar --eta

--tmpdir dirname

دایرکتوری برای فایل‌های موقت.

به‌طور معمول GNU parallel خروجی را در فایل‌های موقت در /tmp بافر می‌کند. با تنظیم --tmpdir می‌توانید از دایرکتوری دیگری برای فایل‌ها استفاده کنید. تنظیم --tmpdir معادل مقداردهی $TMPDIR است.

همچنین ببینید: --compress $TMPDIR $PARALLEL_REMOTE_TMPDIR

--tmux (alpha testing)

استفاده از tmux برای خروجی. یک نشست (session) tmux را آغاز کرده و هر کار را در یک پنجره درون آن نشست اجرا می‌کند. هیچ خروجی دیگری تولید نخواهد شد.

همچنین ببینید: --tmuxpane

--tmuxpane (alpha testing)

استفاده از tmux برای خروجی اما قرار دادن خروجی درون قاب‌ها (panes) در پنجره اول. مناسب برای زمان‌هایی که می‌خواهید پیشرفت کمتر از ۱۰۰ کار همزمان را نظارت کنید.

همچنین ببینید: --tmux

--timeout duration

مهلت زمانی (timeout) برای دستور. اگر اجرای دستور بیش از duration ثانیه طول بکشد، طبق --term-seq متوقف خواهد شد.

اگر بعد از duration علامت % بیاید، مهلت زمانی به صورت پویا به عنوان درصدی از میانه میانگین زمان اجرای کارهای موفق محاسبه می‌شود. تنها مقادیر > 100% منطقی خواهند بود.

مقدار duration بر حسب ثانیه است، اما می‌تواند پسوندهای s، m، h یا d داشته باشد.

همچنین ببینید: TIME POSTFIXES --term-seq --retries

--verbose

-t

چاپ کاری که باید اجرا شود در خطای استاندارد (stderr).

همچنین ببینید: -v --interactive

--transfer (beta testing)

انتقال فایل‌ها به رایانه‌های راه دور.

مخفف برای: --transferfile {}.

همچنین ببینید: --transferfile.

--transferfile filename (beta testing)

--tf filename

انتقال filename به رایانه‌های راه دور.

گزینه --transferfile همراه با --sshlogin برای انتقال فایل‌ها به رایانه‌های راه دور استفاده می‌شود. فایل‌ها با استفاده از rsync منتقل شده و به صورت نسبی نسبت به دایرکتوری کاری (work dir) قرار داده می‌شوند.

به‌طور معمول filename حاوی یک رشته جایگزین خواهد بود.

اگر مسیر شامل /./ باشد، ادامه مسیر نسبت به دایرکتوری کاری نسبی خواهد بود (برای جزئیات: rsync را ببینید). اگر دایرکتوری کاری /home/user باشد، انتقال به صورت زیر خواهد بود:

/tmp/foo/bar   => /tmp/foo/bar
tmp/foo/bar    => /home/user/tmp/foo/bar
/tmp/./foo/bar => /home/user/foo/bar
tmp/./foo/bar  => /home/user/foo/bar

مثال‌ها

این دستور فایل foo/bar.txt را قبل از اجرای wc foo/bar.txt در server.example.com، به رایانه server.example.com در فایل $HOME/foo/bar.txt منتقل می‌کند:

echo foo/bar.txt | parallel --transferfile {} \
  --sshlogin server.example.com wc

این دستور فایل /tmp/foo/bar.txt را قبل از اجرای wc /tmp/foo/bar.txt در server.example.com، به رایانه server.example.com در فایل /tmp/foo/bar.txt منتقل می‌کند:

echo /tmp/foo/bar.txt | parallel --transferfile {} \
  --sshlogin server.example.com wc

این دستور فایل /tmp/foo/bar.txt را قبل از اجرای wc ./foo/bar.txt در server.example.com، به رایانه server.example.com در فایل foo/bar.txt منتقل می‌کند:

echo /tmp/./foo/bar.txt | parallel --transferfile {} \
  --sshlogin server.example.com wc {= s:.*/\./:./: =}

گزینه --transferfile اغلب همراه با --return و --cleanup استفاده می‌شود. معادل کوتاه‌تر برای --transferfile {} گزینه --transfer است.

گزینه --transferfile هنگام استفاده با --sshlogin : یا زمانی که بدون --sshlogin استفاده شود نادیده گرفته می‌شود.

همچنین ببینید: --workdir --sshlogin --basefile --return --cleanup

--trc filename

انتقال، بازگرداندن، پاکسازی (Transfer, Return, Cleanup). مخفف برای: --transfer --return filename --cleanup

همچنین ببینید: --transfer --return --cleanup

--trim <n|l|r|lr|rl>

حذف فاصله‌های خالی (white space) در ورودی.

--ungroup

-u

تفکیک نکردن (گروه‌بندی نکردن) خروجی.

خروجی در سریع‌ترین زمان ممکن چاپ شده و پردازش داخلی GNU parallel را دور می‌زند. این امر ممکن است باعث درهم‌آمیختن خروجی دستورات مختلف شود، بنابراین فقط در صورتی باید استفاده شود که به تفکیک خروجی نیازی ندارید. این موارد را مقایسه کنید:

seq 4 | parallel -j0 \
  'sleep {};echo -n start{};sleep {};echo {}end'
seq 4 | parallel -u -j0 \
  'sleep {};echo -n start{};sleep {};echo {}end'

همچنین --tag را غیرفعال می‌کند. خروجی GNU parallel با -u سریع‌تر است. سرعت این موارد را مقایسه کنید:

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

با --group می‌توان آن را معکوس کرد.

همچنین ببینید: --line-buffer --group

--unsafe

ابزار GNU parallel تلاش می‌کند محتاطانه عمل کند تا از نتایج غیرمنتظره جلوگیری شود. گزینه --unsafe به GNU parallel اجازه می‌دهد در محیط‌ها و روی ورودی‌هایی اجرا شود که آزمایش نشده‌اند و ممکن است منجر به نتایج غیرمنتظره و حتی مشکلات امنیتی شوند، به‌طوری که یک مهاجم بتواند بر نتایج تأثیر بگذارد. حملاتی مشابه Shellshock را در نظر بگیرید: https://en.wikipedia.org/wiki/Shellshock_(software_bug)

اگر برای کاری که ایمن است همیشه مجبور به استفاده از --unsafe هستید، زمان آن رسیده که یک گزارش باگ ثبت کنید و درباره نحوه پوشش وضعیت خود در آزمون‌ها گفتگو کنید.

--use-sockets-instead-of-threads

همچنین ببینید: --use-cores-instead-of-threads

--use-cores-instead-of-threads

--use-cpus-instead-of-cores (obsolete)

تعیین می‌کند که GNU parallel چگونه تعداد CPUها را شمارش کند.

ابزار GNU parallel از این تعداد زمانی استفاده می‌کند که تعداد اسلات‌های کار (--jobs) به‌صورت نسبتی از تعداد CPUها محاسبه می‌شود (مثلاً %100 یا +1).

پردازنده‌ها (CPUها) را می‌توان به سه روش مختلف شمارش کرد:

-v

نمایش با جزئیات (Verbose).

کاری را که قرار است اجرا شود در stdout (خروجی استاندارد) چاپ می‌کند. با --silent می‌توان آن را لغو کرد.

از -v -v برای چاپ دستور دربرگیرنده ssh هنگام اجرای راه دور استفاده کنید.

همچنین ببینید: -t

--version

-V

نسخه GNU parallel را چاپ کرده و خارج می‌شود.

--workdir mydir

--wd mydir

کارها در دایرکتوری mydir اجرا خواهند شد. مقدار پیش‌فرض برای دستگاه محلی، دایرکتوری جاری و برای رایانه‌های راه دور، دایرکتوری ورود (login dir) است.

فایل‌های منتقل‌شده با استفاده از --transferfile و --return نسبت به mydir در رایانه‌های راه دور سنجیده خواهند شد.

مقدار ویژه ... برای mydir، دایرکتوری‌های کاری را زیر ~/.parallel/tmp/ ایجاد می‌کند. در صورت مشخص شدن --cleanup این دایرکتوری‌ها حذف خواهند شد.

مقدار ویژه . برای mydir از دایرکتوری کاری جاری استفاده می‌کند. اگر دایرکتوری کاری جاری زیر دایرکتوری خانگی (home dir) شما باشد، مقدار . به‌عنوان مسیر نسبی به دایرکتوری خانگی در نظر گرفته می‌شود. این بدان معناست که اگر دایرکتوری خانگی شما در رایانه‌های راه دور متفاوت باشد (مثلاً نام کاربری شما متفاوت باشد)، مسیر نسبی همچنان نسبت به دایرکتوری خانگی شما خواهد بود.

برای دیدن تفاوت، این دستورها را امتحان کنید:

parallel -S server pwd ::: ""
parallel --wd . -S server pwd ::: ""
parallel --wd ... -S server pwd ::: ""

مقدار mydir می‌تواند شامل رشته‌های جایگزینی GNU parallel باشد.

--wait

منتظر ماندن برای اتمام تمامی دستورات.

همراه با --semaphore یا --sqlmaster استفاده می‌شود.

همچنین ببینید: man sem

-X

چندین آرگومان با جایگزینی متنی (context replace). تا جایی که طول خط فرمان اجازه می‌دهد آرگومان درج می‌کند. اگر چندین کار به‌صورت موازی در حال اجرا باشند: آرگومان‌ها را به‌طور یکنواخت بین کارها توزیع می‌کند. برای جلوگیری از این رفتار از -j1 استفاده کنید.

اگر از {} استفاده نشود، آرگومان‌ها به انتهای خط اضافه می‌شوند. اگر {} به‌عنوان بخشی از یک کلمه استفاده شود (مانند pic{}.jpg)، کل کلمه تکرار خواهد شد. اگر {} چندین بار استفاده شود، هر {} با آرگومان‌ها جایگزین می‌شود.

به‌طور معمول -X عملکرد درستی دارد، در حالی که اگر {} به‌عنوان بخشی از یک کلمه استفاده شود، -m ممکن است نتایج غیرمنتظره‌ای بدهد.

پشتیبانی از -X همراه با --sshlogin محدود است و ممکن است ناموفق باشد.

همچنین ببینید: -m

--exit

-x

خروج در صورت فراتر رفتن از اندازه (گزینه -s را ببینید).

--xargs

چندین آرگومان. تا جایی که طول خط فرمان اجازه می‌دهد آرگومان درج می‌کند.

اگر از {} استفاده نشود، آرگومان‌ها به انتهای خط اضافه می‌شوند. اگر {} چندین بار استفاده شود، هر {} با تمامی آرگومان‌ها جایگزین خواهد شد.

پشتیبانی از --xargs همراه با --sshlogin محدود است و ممکن است ناموفق باشد.

همچنین ببینید: -X

مثال‌ها (EXAMPLES)

ببینید: man parallel_examples

توزیع بلوک‌های داده (SPREADING BLOCKS OF DATA)

گزینه‌های --round-robin، --pipe-part، --shard، --bin و --group-by همگی نسخه‌های تخصصی‌یافته --pipe هستند.

در ادامه n تعداد اسلات‌های کار است که توسط --jobs مشخص می‌شود. یک رکورد با --recstart شروع و با --recend پایان می‌یابد. معمولاً یک خط کامل است. یک تکه (chunk) تعدادی رکورد کامل است که اندازه آن تقریباً برابر با یک بلوک است. یک بلوک می‌تواند شامل نیمه‌رکورد باشد، اما یک تکه (chunk) نمی‌تواند.

گزینه --pipe به ازای هر تکه (chunk) یک کار را آغاز می‌کند. بلوک‌ها را از stdin (ورودی استاندارد) می‌خواند. پایان رکورد را در نزدیکی مرز بلوک پیدا می‌کند و تکه را به برنامه تحویل می‌دهد.

گزینه --pipe-part درست مانند --pipe معمولی، به ازای هر تکه یک کار را آغاز می‌کند. ابتدا پایان رکوردها را در نزدیکی تمام مرزهای بلوک در فایل پیدا کرده و سپس کارها را شروع می‌کند. با استفاده از --block -1، اندازه بلوک را روی size-of-file/n تنظیم می‌کند. در این حالت در مجموع n کار آغاز خواهد شد.

گزینه --round-robin در مجموع n کار را آغاز می‌کند. یک بلوک را خوانده و تکه را به هر کاری که آماده خواندن باشد تحویل می‌دهد. محتوا را تجزیه (parse) نمی‌کند، مگر برای شناسایی محل پایان رکورد تا اطمینان یابد که فقط رکوردهای کامل را منتقل می‌کند.

گزینه --shard در مجموع n کار را آغاز می‌کند. هر خط را برای خواندن رشته موجود در ستون مشخص‌شده تجزیه می‌کند. بر اساس این رشته، خط به یکی از n کار تحویل داده می‌شود. تمام خطوط دارای این رشته به همان اسلات کار داده خواهند شد.

گزینه --bin مانند --shard عمل می‌کند اما مقدار ستون باید عددی باشد و نشان‌دهنده شماره اسلات کاری است که خط به آن تحویل داده می‌شود. اگر مقدار بزرگتر از n باشد، مقدار n از آن کسر می‌شود تا زمانی که مقدار کوچکتر یا مساوی n شود.

گزینه --group-by به ازای هر تکه یک کار را آغاز می‌کند. مرزهای رکورد توسط --recend/--recstart تعیین نمی‌شوند. در عوض، رکورد توسط گروهی از خطوط که رشته یکسانی در یک ستون مشخص دارند تعریف می‌شود. بنابراین رشته ستون مشخص در مرز تکه تغییر می‌کند. با --pipe هر خط تجزیه می‌شود، با --pipe-part تنها چند خط برای یافتن مرز تکه بررسی می‌شوند.

گزینه --group-by می‌تواند با --round-robin یا --pipe-part ترکیب شود.

پسوندهای زمان (TIME POSTFIXES)

آرگومان‌هایی که مدت‌زمان را مشخص می‌کنند بر حسب ثانیه داده می‌شوند، اما می‌توان آن‌ها را به‌صورت اعداد اعشاری همراه با پسوندهای s، m، h یا d بیان کرد که عدد اعشاری را به ترتیب در 1، 60، 60*60 یا 60*60*24 ضرب می‌کنند. بنابراین این دو معادل یکدیگرند: 100000 و 1d3.5h16.6m4s.

پیشوندهای واحد (UNIT PREFIX)

بسیاری از آرگومان‌های عددی در GNU parallel می‌توانند دارای پسوند K، M، G، T، P، k، m، g، t یا p باشند که عدد را به ترتیب در 1024، 1048576، 1073741824، 1099511627776، 1125899906842624، 1000، 1000000، 1000000000، 1000000000000 یا 1000000000000000 ضرب می‌کنند.

حتی می‌توانید آن را به‌صورت یک عبارت ریاضی بنویسید. برای مثال 1000000 را می‌توان به‌صورت 1M-12*2.024*2k نوشت.

نقل‌قول و کوتیشن (QUOTING)

ابزار GNU parallel در برخورد با نقل‌قول‌ها بسیار منعطف و آسان‌گیر است. تنها کافی است کاراکترهایی را که معنای ویژه‌ای در شل دارند داخل نقل‌قول (کوتیشن) قرار دهید یا اسکیپ کنید:

( ) $ ` ' " < > ; | \

و بسته به زمینه (context)، این کاراکترها نیز باید کوت شوند:

~ & ! ? space * { #

بنابراین بیشتر افراد هرگز به چیزی بیشتر از قرار دادن '\' در جلوی کاراکترهای خاص نیاز نخواهند داشت.

اغلب می‌توانید به سادگی \' را در دو طرف هر ' قرار دهید:

perl -ne '/^\S+\s+\S+$/ and print $ARGV,"\n"' file

می‌تواند به این صورت کوت شود:

parallel perl -ne \''/^\S+\s+\S+$/ and print $ARGV,"\n"'\' ::: file

با این حال، زمانی که می‌خواهید از متغیر شل استفاده کنید، باید علامت $ را کوت/اسکیپ کنید. در اینجا مثالی با استفاده از $PARALLEL_SEQ آورده شده است. این متغیر توسط خود GNU parallel مقداردهی می‌شود، بنابراین ارزیابی $ باید توسط زیرشل (sub shell) آغازشده توسط GNU parallel انجام شود:

seq 10 | parallel -N2 echo seq:\$PARALLEL_SEQ arg1:{1} arg2:{2}

اگر متغیر پیش از شروع GNU parallel مقداردهی شده باشد، می‌توانید به این صورت عمل کنید:

VAR=this_is_set_before_starting
echo test | parallel echo {} $VAR

چاپ می‌کند: test this_is_set_before_starting

اگر متغیر شامل بیش از یک فاصله پشت سر هم باشد کمی پیچیده‌تر می‌شود:

VAR="two  spaces  between  each  word"
echo test | parallel echo {} \'"$VAR"\'

چاپ می‌کند: test two spaces between each word

اگر قرار نیست متغیر توسط شلی که GNU parallel را اجرا می‌کند ارزیابی شود بلکه باید توسط زیرشلی که توسط GNU parallel آغاز می‌شود ارزیابی گردد، در این صورت باید آن را کوت کنید:

echo test | parallel VAR=this_is_set_after_starting \; echo {} \$VAR

چاپ می‌کند: test this_is_set_after_starting

اگر متغیر شامل فاصله باشد کمی پیچیده‌تر است:

echo test |\
  parallel VAR='"two  spaces  between  each  word"' echo {} \'"$VAR"\'

چاپ می‌کند: test two spaces between each word

متغیر $$ یک متغیر شل حاوی شناسه فرآیند (process id) شل است. این دستور شناسه فرآیند شلی را که GNU parallel را اجرا می‌کند چاپ خواهد کرد:

seq 10 | parallel echo $$

و این دستور شناسه‌های فرآیند زیرشل‌های راه‌اندازی‌شده توسط GNU parallel را چاپ می‌کند:

seq 10 | parallel echo \$\$

اگر کاراکترهای خاص نباید توسط زیرشل ارزیابی شوند، باید از آن‌ها در برابر ارزیابی هم توسط شل آغازکننده GNU parallel و هم زیرشل محافظت کنید:

echo test | parallel echo {} \\\$VAR

چاپ می‌کند: test $VAR

ابزار GNU parallel می‌تواند با استفاده از -q از ارزیابی توسط زیرشل محافظت کند:

echo test | parallel -q echo {} \$VAR

چاپ می‌کند: test $VAR

این ویژگی به‌ویژه زمانی که نقل‌قول‌ها و کوتیشن‌های زیادی دارید بسیار کاربردی است. اگر می‌خواهید یک اسکریپت perl مانند زیر را اجرا کنید:

perl -ne '/^\S+\s+\S+$/ and print $ARGV,"\n"' file

باید به یکی از این شکل‌ها کوت شود:

ls | parallel perl -ne '/^\\S+\\s+\\S+\$/\ and\ print\ \$ARGV,\"\\n\"'
ls | parallel perl -ne \''/^\S+\s+\S+$/ and print $ARGV,"\n"'\'

توجه کنید که چگونه فاصله‌ها، کاراکترهای \'، "' و $' باید کوت شوند. ابزار GNU parallel می‌تواند با استفاده از گزینه -q کوتینگ را انجام دهد:

ls | parallel -q  perl -ne '/^\S+\s+\S+$/ and print $ARGV,"\n"'

با این حال، این بدان معناست که نمی‌توانید زیرشل را مجبور به تفسیر کاراکترهای خاص کنید. برای مثال به دلیل -q موارد زیر کار نخواهند کرد:

ls *.gz | parallel -q "zcat {} >{.}"
ls *.gz | parallel -q "zcat {} | bzip2 >{.}.bz2"

زیرا > و | باید توسط زیرشل تفسیر شوند.

اگر با خطاهایی مانند زیر مواجه شدید:

sh: -c: line 0: syntax error near unexpected token
sh: Syntax error: Unterminated quoted string
sh: -c: line 0: unexpected EOF while looking for matching `''
sh: -c: line 1: syntax error: unexpected end of file
zsh:1: no matches found:

می‌توانید استفاده از -q را امتحان کنید.

اگر از جایگزینی فرایند bash مانند <(cat foo) استفاده می‌کنید، می‌توانید -q و قرار دادن bash -c پیش از command را امتحان کنید:

ls | parallel -q bash -c 'wc -c <(echo {})'

یا برای جایگزینی خروجی:

ls | parallel -q bash -c \
  'tar c {} | tee >(gzip >{}.tar.gz) | bzip2 >{}.tar.bz2'

نتیجه‌گیری: اگر این موضوع گیج‌کننده است، می‌توانید با نوشتن یک اسکریپت کوچک یا یک تابع (به یاد داشته باشید که تابع را با export -f صادر کنید) و فراخوانی آن توسط GNU parallel، از درگیر شدن با نقل‌قول‌ها (کوتیشن) اجتناب کنید.

فهرست کردن کارهای در حال اجرا (LIST RUNNING JOBS)

اگر فهرستی از کارهای در حال اجرا می‌خواهید، می‌توانید دستور زیر را اجرا کنید:

killall -USR1 parallel

سپس GNU parallel کارهای در حال اجرا را در خروجی خطای استاندارد (stderr) چاپ خواهد کرد.

تکمیل کارهای در حال اجرا بدون شروع کارهای جدید (COMPLETE RUNNING JOBS BUT DO NOT START NEW JOBS)

اگر از شروع کارهای زیاد پشیمان شدید می‌توانید به سادگی اجرای GNU parallel را قطع کنید، اما اگر می‌خواهید مطمئن شوید که کارهای نیمه‌کاره باقی نمی‌مانند، باید سیگنال SIGHUP را به GNU parallel ارسال کنید:

killall -HUP parallel

این دستور به GNU parallel اطلاع می‌دهد که هیچ کار جدیدی را شروع نکند، اما قبل از خروج منتظر بماند تا کارهای در حال اجرا به پایان برسند.

متغیرهای محیطی (ENVIRONMENT VARIABLES)

$PARALLEL_HOME

دایرکتوری‌ای که در آن GNU parallel فایل‌های پیکربندی، سمافورها و اطلاعات کش بین فراخوانی‌ها را ذخیره می‌کند. اگر روی یک دایرکتوری ناموجود تنظیم شود، آن دایرکتوری ایجاد خواهد شد.

پیش‌فرض: $HOME/.parallel.

$PARALLEL_ARGHOSTGROUPS

هنگام استفاده از --hostgroups، ابزار GNU parallel این متغیر را روی گروه‌های میزبان (hostgroups) کار تنظیم می‌کند.

به یاد داشته باشید که علامت $ را کوت کنید تا توسط شل درست ارزیابی شود. یا از --plus و {agrp} استفاده کنید.

$PARALLEL_HOSTGROUPS

هنگام استفاده از --hostgroups، ابزار GNU parallel این متغیر را روی گروه‌های میزبانِ لاگین ssh که کار روی آن اجرا می‌شود تنظیم می‌کند.

به یاد داشته باشید که علامت $ را کوت کنید تا توسط شل درست ارزیابی شود. یا از --plus و {hgrp} استفاده کنید.

$PARALLEL_JOBSLOT

توسط GNU parallel مقداردهی می‌شود و می‌تواند در کارهای اجرا شده توسط GNU parallel استفاده شود. به یاد داشته باشید که علامت $ را کوت کنید تا توسط شل درست ارزیابی شود. یا از --plus و {slot} استفاده کنید.

متغیر $PARALLEL_JOBSLOT اسلات کار (jobslot) است. این مقدار برابر با {%} است مگر اینکه کار در حال تلاش مجدد باشد. برای جزئیات به {%} مراجعه کنید.

$PARALLEL_PID

توسط GNU parallel مقداردهی می‌شود و می‌تواند در کارهای اجرا شده توسط GNU parallel استفاده شود. به یاد داشته باشید که علامت $ را کوت کنید تا توسط شل درست ارزیابی شود.

این متغیر ارتباط مستقیم کارها با GNU parallel را ممکن می‌سازد.

مثال: اگر هر یک از کارها راه‌حلی را آزمایش کند و یکی از کارها راه‌حل را پیدا کند، آن کار می‌تواند با دستور kill -HUP $PARALLEL_PID به GNU parallel اعلام کند که کار دیگری را شروع نکند. این ویژگی فقط روی رایانه محلی کار می‌کند.

$PARALLEL_RSYNC_OPTS

گزینه‌هایی که به rsync ارسال می‌شوند. مقدار پیش‌فرض: -rlDzR.

$PARALLEL_SHELL

استفاده از این شل برای دستورات اجرا شده توسط GNU parallel:

$PARALLEL_SSH

ابزار GNU parallel به طور پیش‌فرض از دستور ssh برای دسترسی از راه دور استفاده می‌کند. این مقدار را می‌توان با $PARALLEL_SSH بازنویسی کرد، که مجدداً با --ssh قابل لغو است. همچنین می‌توان آن را به ازای هر سرور تنظیم کرد (ببینید: --sshlogin).

$PARALLEL_SSHHOST

توسط GNU parallel مقداردهی می‌شود و می‌تواند در کارهای اجرا شده توسط GNU parallel استفاده شود. به یاد داشته باشید که علامت $ را کوت کنید تا توسط شل درست ارزیابی شود. یا از --plus و {host} استفاده کنید.

متغیر $PARALLEL_SSHHOST بخش مربوط به میزبان (host) در یک خط sshlogin است. برای مثال:

4//usr/bin/specialssh user@host

تبدیل می‌شود به:

host

$PARALLEL_SSHLOGIN

توسط GNU parallel مقداردهی می‌شود و می‌تواند در کارهای اجرا شده توسط GNU parallel استفاده شود. به یاد داشته باشید که علامت $ را کوت کنید تا توسط شل درست ارزیابی شود. یا از --plus و {sshlogin} استفاده کنید.

این مقدار همان خط sshlogin است که تعداد ریسه‌ها (threads) از آن حذف شده است. برای مثال:

4//usr/bin/specialssh user@host

تبدیل می‌شود به:

/usr/bin/specialssh user@host

$PARALLEL_SEQ

توسط GNU parallel مقداردهی می‌شود و می‌تواند در کارهای اجرا شده توسط GNU parallel استفاده شود. به یاد داشته باشید که علامت $ را کوت کنید تا توسط شل درست ارزیابی شود.

متغیر $PARALLEL_SEQ شماره ترتیبی (توالی) کار در حال اجرا است.

مثال:

seq 10 | parallel -N2 \
  echo seq:'$'PARALLEL_SEQ arg1:{1} arg2:{2}

نماد {#} کوته‌نوشتی برای $PARALLEL_SEQ است.

$PARALLEL_TMUX

مسیر اجرایی tmux. در صورت عدم تنظیم، از tmux موجود در $PATH استفاده می‌شود.

$TMPDIR

دایرکتوری فایل‌های موقت.

همچنین ببینید: --tmpdir

$PARALLEL_REMOTE_TMPDIR

دایرکتوری فایل‌های موقت روی سرورهای راه دور.

همچنین ببینید: --tmpdir

$PARALLEL

متغیر محیطی $PARALLEL به عنوان گزینه‌های پیش‌فرض برای GNU parallel استفاده خواهد شد. اگر متغیر شامل نویسه‌های خاص شل باشد (مانند $، *، یا فاصله)، این نویسه‌ها باید با \ اسکیپ شوند.

مثال:

cat list | parallel -j1 -k -v ls
cat list | parallel -j1 -k -v -S"myssh user@server" ls

می‌تواند به صورت زیر نوشته شود:

cat list | PARALLEL="-kvj1" parallel ls
cat list | PARALLEL='-kvj1 -S myssh\ user@server' \
  parallel echo

توجه داشته باشید که \ پس از 'myssh' لازم است زیرا 'myssh' و 'user@server' باید یک آرگومان باشند.

همچنین ببینید: --profile

پروفایل پیش‌فرض (فایل پیکربندی) (DEFAULT PROFILE (CONFIG FILE))

فایل پیکربندی سراسری /etc/parallel/config و پس از آن فایل پیکربندی کاربر ~/.parallel/config (که قبلاً با نام .parallelrc شناخته می‌شد) در صورت وجود به نوبت خوانده خواهند شد. خطوطی که با '#' شروع شوند نادیده گرفته می‌شوند. قالب فایل می‌تواند شبیه متغیر محیطی $PARALLEL باشد، اما اغلب ساده‌تر است که هر گزینه را در یک خط جداگانه قرار دهید.

گزینه‌های مشخص‌شده در خط فرمان بالاترین اولویت را دارند، پس از آن متغیر محیطی $PARALLEL، سپس فایل پیکربندی کاربر ~/.parallel/config و در نهایت فایل پیکربندی سراسری /etc/parallel/config اولویت دارند.

توجه داشته باشید که هیچ فایلی که برای خواندن گزینه‌ها بررسی می‌شود، و همچنین متغیر محیطی $PARALLEL، نباید شامل گزینه‌های منسوخ‌شده مانند --tollef باشند.

فایل‌های پروفایل (PROFILE FILES)

اگر --profile تنظیم شده باشد، GNU parallel پروفایل را از آن فایل به جای فایل‌های پیکربندی سراسری یا کاربر خواهد خواند. می‌توانید چندین --profiles داشته باشید.

پروفایل‌ها در ~/.parallel جستجو می‌شوند. اگر نام با / شروع شود به عنوان مسیر مطلق در نظر گرفته می‌شود. اگر نام با ./ شروع شود به عنوان مسیر نسبی از دایرکتوری جاری در نظر گرفته می‌شود.

مثال: پروفایل برای اجرای یک دستور روی هر sshlogin در ~/.ssh/sshlogins و اضافه کردن پیشوند sshlogin به ابتدای خروجی:

echo --tag -S .. --nonall > ~/.parallel/nonall_profile
parallel -J nonall_profile uptime

مثال: پروفایل برای اجرای هر دستور با -j-1 و nice:

echo -j-1 nice > ~/.parallel/nice_profile
parallel -J nice_profile bzip2 -9 ::: *

مثال: پروفایل برای اجرای یک اسکریپت perl پیش از هر دستور:

echo "perl -e '\$a=\$\$; print \$a,\" \",'\$PARALLEL_SEQ',\" \";';" \
  > ~/.parallel/pre_perl
parallel -J pre_perl echo ::: *

توجه داشته باشید که چگونه $ و " باید با استفاده از \ کوت (اسکیپ) شوند.

مثال: پروفایل برای اجرای کارهای توزیع‌شده با nice روی رایانه‌های راه دور:

echo -S .. nice > ~/.parallel/dist
parallel -J dist --trc {.}.bz2 bzip2 -9 ::: *

وضعیت خروج (EXIT STATUS)

اگر یکی از مقادیر success=X،‏ success=Y% یا fail=Y% استفاده شده باشد، وضعیت خروج به --halt-on-error بستگی دارد.

0

تمام کارها بدون خطا اجرا شدند. اگر success=X استفاده شده باشد: X کار بدون خطا اجرا شدند. اگر success=Y% استفاده شده باشد: Y% کارها بدون خطا اجرا شدند.

1-100

برخی از کارها ناموفق بودند. وضعیت خروج تعداد کارهای ناموفق را نشان می‌دهد. اگر Y% استفاده شده باشد، وضعیت خروج درصد کارهای ناموفق است.

101

بیش از ۱۰۰ کار ناموفق بودند.

255

سایر خطاها.

-1 (در joblog و جدول SQL)

متوقف‌شده توسط Ctrl-C، پایان مهلت زمانی (timeout)، کمبود حافظه یا موارد مشابه.

-2 (در joblog و جدول SQL)

تابع skip() در {= =} فراخوانی شده است.

-1000 (در جدول SQL)

کار آماده اجرا است (تنظیم‌شده توسط --sqlmaster).

-1220 (در جدول SQL)

کار توسط ورکر برداشته شده است (تنظیم‌شده توسط --sqlworker).

اگر fail=1 استفاده شود، وضعیت خروج برابر با وضعیت خروج کارِ ناموفق خواهد بود.

تفاوت‌های بین GNU Parallel و جایگزین‌ها (DIFFERENCES BETWEEN GNU Parallel AND ALTERNATIVES)

ببینید: man parallel_alternatives

ایرادات (BUGS)

echo 1,2,3 | parallel -vkd, "echo 'a{}b'"

echo 1,2,3 | parallel -vkd, echo a{}b
echo 1,2,3 | parallel -vkd, "echo 'a'{}'b'"
echo 1,2,3 | parallel -vkd, "echo 'a'"{}"'b'"

sem --id diskio cat file | compute | sem --id diskio cat > file

sem --id read cat file | compute | sem --id write cat > file

Can't exec "command": No such file or directory

open3: exec of by command failed

/bin/bash: command: command not found

گزارش باگ‌ها (REPORTING BUGS)

گزارش باگ‌ها را به <parallel@gnu.org> یا https://savannah.gnu.org/bugs/?func=additem&group=parallel ارسال کنید.

هنگام نوشتن گزارش، لطفاً توجه داشته باشید که باید اطلاعات کافی به خواننده بدهید تا بتواند دقیقاً همان کاری را که شما اجرا کرده‌اید اجرا کند. بنابراین باید تمام داده‌ها و برنامه‌هایی را که برای نشان دادن مشکل استفاده می‌کنید، بگنجانید.

یک نمونه کامل و بی‌نقص از گزارش باگ را در این آدرس ببینید: https://lists.gnu.org/archive/html/bug-parallel/2015-01/msg00000.html

گزارش باگ شما باید همیشه شامل موارد زیر باشد:

• پیام خطایی که دریافت می‌کنید (در صورت وجود). اگر پیام خطا از طرف GNU parallel نیست، باید نشان دهید چرا فکر می‌کنید GNU parallel باعث آن شده است.
• خروجی کامل parallel --version. اگر از آخرین نسخه منتشرشده استفاده نمی‌کنید (ببینید https://ftp.gnu.org/gnu/parallel)، باید مشخص کنید چرا معتقدید مشکل در آن نسخه برطرف نشده است.
• یک مثال کمینه، کامل و قابل بازتولید (توضیحات را در https://stackoverflow.com/help/mcve ببینید).

  این باید یک مثال کامل باشد که دیگران بتوانند آن را اجرا کنند و مشکل را نشان دهد، شامل تمامی فایل‌های لازم برای اجرای مثال. این مثال ترجیحاً باید کوچک و ساده باشد، بنابراین سعی کنید تا حد امکان گزینه‌های اضافی را حذف کنید.

  ترکیبی از yes، seq، cat، echo، wc و sleep می‌تواند اکثر خطاها را بازتولید کند.

  اگر مثال شما به فایل‌های حجیم نیاز دارد، بررسی کنید آیا می‌توانید آن‌ها را با دستوراتی مانند seq 100000000 > bigfile یا yes | head -n 1000000000 > file ایجاد کنید. اگر به چندین ستون نیاز دارید: paste <(seq 1000) <(seq 1000 1999)

  اگر مثال شما نیازمند اجرای راه دور است، بررسی کنید آیا می‌توانید از localhost استفاده کنید - شاید با استفاده از یک نام کاربری دیگر.

  اگر به سیستم دیگری دسترسی دارید (شاید یک VirtualBox روی رایانه خودتان)، آزمایش کنید که آیا MCVE شما مشکل را روی آن سیستم نیز نشان می‌دهد یا خیر. اگر نشان نداد، بخش زیر را بخوانید.

• خروجی مثال شما و آنچه در مقابل انتظار داشتید. اگر مشکل شما به راحتی توسط دیگران قابل بازتولید نیست، خروجی ممکن است به آن‌ها در تشخیص مشکل کمک کند.
• اینکه آیا ویدیوهای مقدماتی (https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1) را تماشا کرده‌اید، آموزش (man parallel_tutorial) را مرور کرده‌اید و مثال‌ها (man parallel_examples) را خوانده‌اید یا خیر.

نویسنده (AUTHOR)

هنگام استفاده از GNU parallel در یک مقاله یا انتشار علمی، لطفاً ارجاع دهید:

O. Tange (2011): GNU Parallel - The Command-Line Power Tool, ;login: The USENIX Magazine, February 2011:42-47.

این کار به تأمین مالی توسعه بیشتر کمک می‌کند؛ و هیچ هزینه‌ای برای شما نخواهد داشت. اگر مبلغ ۱۰۰۰۰ یورو بپردازید، می‌توانید بدون ارجاع دادن از GNU Parallel استفاده کنید.

حق نشر (C) 2007-10-18 اوله تانگه (Ole Tange)، http://ole.tange.dk

حق نشر (C) 2008-2010 اوله تانگه (Ole Tange)، http://ole.tange.dk

حق نشر (C) 2010-2026 اوله تانگه (Ole Tange)، http://ole.tange.dk و بنیاد نرم‌افزارهای آزاد (Free Software Foundation, Inc).

بخش‌هایی از این راهنما که مربوط به سازگاری با xargs است، از راهنمای xargs در GNU findutils 4.4.2 الهام گرفته شده است.

مجوز (LICENSE)

این برنامه یک نرم‌افزار آزاد است؛ شما می‌توانید آن را تحت شرایط «مجوز عمومی همگانی گنو» (GNU GPL) همان‌طور که توسط بنیاد نرم‌افزارهای آزاد منتشر شده است، بازتوزیع کرده یا تغییر دهید؛ چه نسخه ۳ این مجوز یا (به انتخاب خودتان) هر نسخه بعدی دیگری.

این برنامه با این امید توزیع شده است که مفید واقع شود، اما بدون هرگونه ضمانت؛ حتی بدون ضمانت ضمنی قابل فروش بودن یا مناسب بودن برای یک هدف خاص. برای جزئیات بیشتر به «مجوز عمومی همگانی گنو» (GNU GPL) مراجعه کنید.

شما باید همراه با این برنامه یک نسخه از مجوز عمومی همگانی گنو را دریافت کرده باشید. در غیر این صورت، ببینید https://www.gnu.org/licenses.

وابستگی‌ها (DEPENDENCIES)

ابزار GNU parallel از Perl و ماژول‌های پرل Getopt::Long، IPC::Open3، Symbol، IO::File، POSIX و File::Temp استفاده می‌کند.

برای --csv از ماژول پرل Text::CSV استفاده می‌کند.

برای استفاده راه دور از rsync همراه با ssh استفاده می‌کند.

همچنین ببینید (SEE ALSO)

parallel_tutorial(1), env_parallel(1), parset(1), parsort(1), parallel_alternatives(1), parallel_design(7), niceload(1), sql(1), ssh(1), ssh-agent(1), sshpass(1), ssh-copy-id(1), rsync(1)