ນີ້ແມ່ນຄໍາສັ່ງຂະຫນານທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
NAME
parallel - ກໍ່ສ້າງແລະປະຕິບັດເສັ້ນຄໍາສັ່ງ shell ຈາກມາດຕະຖານ input ໃນຂະຫນານ
ສະຫຼຸບສັງລວມ
ຂະຫນານ [ທາງເລືອກ] [ຄໍາສັ່ງ [arguments]] < list_of_arguments
ຂະຫນານ [ທາງເລືອກ] [ຄໍາສັ່ງ [ການໂຕ້ຖຽງ]] ( ::: ການໂຕ້ຖຽງ | :::: argfile(s) ) ...
ຂະຫນານ --semaphore [ຕົວເລືອກ] ຄໍາສັ່ງ
#!/usr/bin/parallel --shebang [ທາງເລືອກ] [ຄໍາສັ່ງ [ການໂຕ້ຖຽງ]]
ລາຍລະອຽດ
GNU ຂະຫນານ ເປັນເຄື່ອງມືແກະສໍາລັບການປະຕິບັດວຽກເຮັດງານທໍາຂະຫນານກັນໂດຍນໍາໃຊ້ຫນຶ່ງຫຼືຫຼາຍຄອມພິວເຕີ. ກ
ວຽກສາມາດເປັນຄໍາສັ່ງດຽວຫຼື script ຂະຫນາດນ້ອຍທີ່ຕ້ອງໄດ້ດໍາເນີນການສໍາລັບແຕ່ລະເສັ້ນໃນ
ວັດສະດຸປ້ອນ. ການປ້ອນຂໍ້ມູນປົກກະຕິແມ່ນບັນຊີລາຍການຂອງໄຟລ໌, ບັນຊີລາຍຊື່ຂອງເຈົ້າພາບ, ບັນຊີລາຍຊື່ຜູ້ໃຊ້, ບັນຊີລາຍການ
ຂອງ URLs, ຫຼືບັນຊີລາຍຊື່ຂອງຕາຕະລາງ. ວຽກຍັງສາມາດເປັນຄໍາສັ່ງທີ່ອ່ານຈາກທໍ່. GNU
ຂະຫນານ ຫຼັງຈາກນັ້ນສາມາດແຍກການປ້ອນຂໍ້ມູນອອກເປັນທ່ອນໄມ້ແລະທໍ່ຕັນເຂົ້າໄປໃນແຕ່ລະຄໍາສັ່ງໃນ
ຂະຫນານ.
ຖ້າທ່ານໃຊ້ xargs ແລະ tee ໃນມື້ນີ້ທ່ານຈະເຫັນ GNU ຂະຫນານ ໃຊ້ງ່າຍຫຼາຍເປັນ GNU ຂະຫນານ
ຖືກຂຽນເພື່ອໃຫ້ມີທາງເລືອກດຽວກັນກັບ xargs. ຖ້າທ່ານຂຽນ loops ໃນແກະ, ທ່ານຈະພົບເຫັນ
GNU ຂະຫນານ ອາດຈະສາມາດທົດແທນ loops ສ່ວນໃຫຍ່ແລະເຮັດໃຫ້ພວກເຂົາແລ່ນໄວຂຶ້ນໂດຍການແລ່ນ
ຫຼາຍວຽກງານຂະຫນານ.
GNU ຂະຫນານ ໃຫ້ແນ່ໃຈວ່າຜົນຜະລິດຈາກຄໍາສັ່ງແມ່ນຜົນຜະລິດດຽວກັນກັບທີ່ເຈົ້າຈະໄດ້ຮັບ
ທ່ານດໍາເນີນການຄໍາສັ່ງຕາມລໍາດັບ. ນີ້ເຮັດໃຫ້ມັນເປັນໄປໄດ້ທີ່ຈະໃຊ້ຜົນຜະລິດຈາກ GNU ຂະຫນານ
ເປັນວັດສະດຸປ້ອນສໍາລັບໂຄງການອື່ນໆ.
ສໍາລັບແຕ່ລະສາຍຂອງ GNU ປ້ອນ ຂະຫນານ ຈະປະຕິບັດ ຄໍາສັ່ງ ກັບເສັ້ນເປັນການໂຕ້ຖຽງ. ຖ້າບໍ່ມີ
ຄໍາສັ່ງ ແມ່ນໃຫ້, ເສັ້ນຂອງການປ້ອນຂໍ້ມູນຖືກປະຕິບັດ. ຫຼາຍເສັ້ນຈະຖືກແລ່ນຂະໜານກັນ.
GNU ຂະຫນານ ສາມາດໃຊ້ແທນໄດ້ເລື້ອຍໆ xargs or cat | bash.
ຜູ້ອ່ານ ແນະນໍາ
ເລີ່ມຕົ້ນໂດຍການເບິ່ງວິດີໂອແນະນໍາສໍາລັບການແນະນໍາໄວ:
http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1
ຫຼັງຈາກນັ້ນ, ເບິ່ງທີ່ EXAMPLEs ຫຼັງຈາກບັນຊີລາຍຊື່ຂອງ OPTIONS. ນັ້ນຈະເຮັດໃຫ້ເຈົ້າມີຄວາມຄິດເຖິງອັນໃດ
GNU ຂະຫນານ ມີຄວາມສາມາດ.
ຈາກນັ້ນໃຊ້ເວລາໜຶ່ງຊົ່ວໂມງຍ່າງຜ່ານບົດສອນ (ຜູ້ຊາຍ parallel_tutorial). ເສັ້ນຄໍາສັ່ງຂອງເຈົ້າ
ຈະຮັກເຈົ້າສໍາລັບມັນ.
ສຸດທ້າຍທ່ານອາດຈະຕ້ອງການເບິ່ງສ່ວນທີ່ເຫຼືອຂອງຄູ່ມືນີ້ຖ້າຫາກວ່າທ່ານມີຄວາມຕ້ອງການພິເສດບໍ່ແມ່ນ
ກວມເອົາແລ້ວ.
OPTIONS
ຄໍາສັ່ງ ຄໍາສັ່ງທີ່ຈະປະຕິບັດ. ຖ້າ ຄໍາສັ່ງ ຫຼືການໂຕ້ຖຽງຕໍ່ໄປນີ້ມີການທົດແທນ
strings (ເຊັ່ນ: {}) ທຸກໆຕົວຢ່າງຈະຖືກປ່ຽນແທນດ້ວຍການປ້ອນຂໍ້ມູນ.
If ຄໍາສັ່ງ ແມ່ນໃຫ້, GNU ຂະຫນານ ແກ້ໄຂວຽກງານດຽວກັນກັບ xargsທີ່ຢູ່ ຖ້າຫາກວ່າ ຄໍາສັ່ງ is
ບໍ່ໄດ້ໃຫ້ GNU ຂະຫນານ ຈະປະຕິບັດຄ້າຍຄືກັນ cat | sh.
ໄດ້ ຄໍາສັ່ງ ຕ້ອງເປັນຄຳສັ່ງ, script, ຄຳສັ່ງປະກອບ, ຫຼືຟັງຊັນ.
ຖ້າມັນເປັນຟັງຊັນ Bash ເຈົ້າຕ້ອງການ ການສົ່ງອອກ -f ຫນ້າທີ່ທໍາອິດ. ເພື່ອໃຊ້ນາມແຝງ
ຄັດລອກສະພາບແວດລ້ອມເຕັມທີ່ອະທິບາຍພາຍໃຕ້ --env ແລະນໍາໃຊ້ env_parallel ແທນທີ່ຈະເປັນ
of ຂະຫນານ.
ຖ້າມັນເປັນຟັງຊັນ zsh ເຈົ້າຈະຕ້ອງໃຊ້ຟັງຊັນຜູ້ຊ່ວຍນີ້ ສົ່ງອອກ to
ສົ່ງອອກ ແລະຕັ້ງ $PARALLEL_SHELL ເປັນ bash:
ຟັງຊັນ exportf (){
ສົ່ງອອກ $(echo $1)="`whence -f $1 | sed -e "s/$1 //" `"
}
ຟັງຊັນ my_func(){
echo $1;
echo "ສະບາຍດີ";
}
ສົ່ງອອກ my_func
PARALLEL_SHELL=/ bin / bash parallel "my_func {}" ::: 1 2
ຄໍາສັ່ງບໍ່ສາມາດມີຕົວອັກສອນ \257 (macron: X).
{} ເສັ້ນເຂົ້າ. ສະຕຣິງທົດແທນນີ້ຈະຖືກແທນທີ່ດ້ວຍແຖວເຕັມທີ່ອ່ານຈາກ
ແຫຼ່ງປ້ອນຂໍ້ມູນ. ແຫຼ່ງປ້ອນຂໍ້ມູນແມ່ນປົກກະຕິ stdin (ວັດສະດຸປ້ອນມາດຕະຖານ), ແຕ່ຍັງສາມາດເຮັດໄດ້
ໄດ້ຮັບການມອບໃຫ້ -a, :::, ຫຼື ::::.
ສາຍການທົດແທນ {} ສາມາດປ່ຽນແປງໄດ້ດ້ວຍ -I.
ຖ້າເສັ້ນຄໍາສັ່ງບໍ່ມີສາຍທົດແທນຫຼັງຈາກນັ້ນ {} ຈະຖືກລວມເຂົ້າກັບ
ເສັ້ນຄໍາສັ່ງ.
{.} ເສັ້ນປ້ອນຂໍ້ມູນໂດຍບໍ່ມີການຂະຫຍາຍ. ສະຕຣິງທົດແທນນີ້ຈະຖືກແທນທີ່ດ້ວຍ
ການປ້ອນຂໍ້ມູນທີ່ມີສ່ວນຂະຫຍາຍອອກ. ຖ້າເສັ້ນປ້ອນເຂົ້າມີ . ຫຼັງຈາກສຸດທ້າຍ /
ສຸດທ້າຍ . ຈົນ ກ ່ ວາ ໃນ ຕອນ ທ້າຍ ຂອງ ຊ່ອຍ ແນ່ ຈະ ໄດ້ ຮັບ ການ ໂຍກ ຍ້າຍ ອອກ ແລະ {.} ຈະຖືກທົດແທນ
ກັບສ່ວນທີ່ເຫຼືອ. ຕົວຢ່າງ foo.jpg ກາຍເປັນ ຟູ, subdir/foo.jpg ກາຍເປັນ subdir/foo,
sub.dir/foo.jpg ກາຍເປັນ sub.dir/foo, sub.dir/bar ຍັງຄົງຢູ່ sub.dir/barທີ່ຢູ່ ຖ້າຫາກວ່າ
ເສັ້ນປ້ອນເຂົ້າບໍ່ມີ . ມັນຈະຍັງຄົງບໍ່ປ່ຽນແປງ.
ສາຍການທົດແທນ {.} ສາມາດປ່ຽນແປງໄດ້ດ້ວຍ --er.
ເພື່ອເຂົ້າໃຈການປ່ຽນສະຕຣິງເບິ່ງ {}.
{/} ຊື່ພື້ນຖານຂອງແຖວປ້ອນຂໍ້ມູນ. ສະຕຣິງທົດແທນນີ້ຈະຖືກແທນທີ່ດ້ວຍການປ້ອນຂໍ້ມູນ
ກັບພາກສ່ວນໄດເລກະທໍລີໄດ້ໂຍກຍ້າຍ.
ສາຍການທົດແທນ {/} ສາມາດປ່ຽນແປງໄດ້ດ້ວຍ --basenamereplace.
ເພື່ອເຂົ້າໃຈການປ່ຽນສະຕຣິງເບິ່ງ {}.
{//} ຊື່ຂອງສາຍປ້ອນຂໍ້ມູນ. string ການທົດແທນນີ້ຈະຖືກແທນທີ່ໂດຍ dir ຂອງ
ເສັ້ນເຂົ້າ. ເບິ່ງ ນາມສະກຸນ(1).
ສາຍການທົດແທນ {//} ສາມາດປ່ຽນແປງໄດ້ດ້ວຍ --dirnamereplace.
ເພື່ອເຂົ້າໃຈການປ່ຽນສະຕຣິງເບິ່ງ {}.
{/.} ຊື່ພື້ນຖານຂອງແຖວປ້ອນຂໍ້ມູນໂດຍບໍ່ມີການຂະຫຍາຍ. ສະຕຣິງທົດແທນນີ້ຈະເປັນ
ແທນທີ່ໂດຍການປ້ອນຂໍ້ມູນທີ່ມີໄດເລກະທໍລີແລະສ່ວນຂະຫຍາຍອອກ. ມັນເປັນ
ປະສົມປະສານຂອງ {/} ແລະ {.}.
ສາຍການທົດແທນ {/.} ສາມາດປ່ຽນແປງໄດ້ດ້ວຍ --basenameextensionreplace.
ເພື່ອເຂົ້າໃຈການປ່ຽນສະຕຣິງເບິ່ງ {}.
{#} (ການທົດສອບອັນຟາ)
ເລກລໍາດັບຂອງວຽກທີ່ຈະດໍາເນີນການ. ສະຕຣິງທົດແທນນີ້ຈະຖືກແທນທີ່ດ້ວຍ
ຈໍານວນລໍາດັບຂອງວຽກທີ່ກໍາລັງດໍາເນີນການ. ມັນປະກອບດ້ວຍຕົວເລກດຽວກັນກັບ
$PARALLEL_SEQ.
ສາຍການທົດແທນ {#} ສາມາດປ່ຽນແປງໄດ້ດ້ວຍ --seqreplace.
ເພື່ອເຂົ້າໃຈການປ່ຽນສະຕຣິງເບິ່ງ {}.
{%} (ການທົດສອບອັນຟາ)
ໝາຍເລກບ່ອນເຮັດວຽກ. ສະຕຣິງທົດແທນນີ້ຈະຖືກແທນທີ່ດ້ວຍຊ່ອງຂອງວຽກ
ຕົວເລກລະຫວ່າງ 1 ແລະຈໍານວນວຽກທີ່ຈະດໍາເນີນການຂະຫນານ. ຈະບໍ່ມີ 2
ວຽກທີ່ເຮັດວຽກໃນເວລາດຽວກັນກັບຕົວເລກບ່ອນເຮັດວຽກດຽວກັນ.
ສາຍການທົດແທນ {%} ສາມາດປ່ຽນແປງໄດ້ດ້ວຍ --slotreplace.
ເພື່ອເຂົ້າໃຈການປ່ຽນສະຕຣິງເບິ່ງ {}.
{n} ການໂຕ້ຖຽງຈາກແຫຼ່ງປ້ອນຂໍ້ມູນ n ຫຼື nການໂຕ້ຖຽງທີ. ການທົດແທນຕໍາແຫນ່ງນີ້
ສະຕຣິງຈະຖືກແທນທີ່ໂດຍການປ້ອນຂໍ້ມູນຈາກແຫຼ່ງປ້ອນຂໍ້ມູນ n (ເມື່ອໃຊ້ກັບ -a or
::::) ຫຼືກັບ n'th argument (ເມື່ອໃຊ້ກັບ -N) ຖ້າຫາກວ່າ n ແມ່ນທາງລົບມັນຫມາຍເຖິງ
ການ nການໂຕ້ຖຽງຄັ້ງສຸດທ້າຍ.
ເພື່ອເຂົ້າໃຈການປ່ຽນສະຕຣິງເບິ່ງ {}.
{n.} ການໂຕ້ຖຽງຈາກແຫຼ່ງປ້ອນຂໍ້ມູນ n ຫຼື n'th argument ໂດຍບໍ່ມີການຂະຫຍາຍ. ມັນເປັນ
ປະສົມປະສານຂອງ {n} ແລະ {.}.
ສະຕຣິງການປ່ຽນຕໍາແຫນ່ງນີ້ຈະຖືກແທນທີ່ໂດຍການປ້ອນຂໍ້ມູນຈາກການປ້ອນຂໍ້ມູນ
ແຫຼ່ງ n (ເມື່ອໃຊ້ກັບ -a or ::::) ຫຼືກັບ n'th argument (ເມື່ອໃຊ້ກັບ
-N). ການປ້ອນຂໍ້ມູນຈະເອົາສ່ວນຂະຫຍາຍອອກ.
ເພື່ອເຂົ້າໃຈສະຕຣິງປ່ຽນຕໍາແຫນ່ງເບິ່ງ {n}.
{n/} ຊື່ພື້ນຖານຂອງອາກິວເມັນຈາກແຫຼ່ງປ້ອນຂໍ້ມູນ n ຫຼື nການໂຕ້ຖຽງທີ. ມັນເປັນ
ປະສົມປະສານຂອງ {n} ແລະ {/}.
ສະຕຣິງການປ່ຽນຕໍາແຫນ່ງນີ້ຈະຖືກແທນທີ່ໂດຍການປ້ອນຂໍ້ມູນຈາກການປ້ອນຂໍ້ມູນ
ແຫຼ່ງ n (ເມື່ອໃຊ້ກັບ -a or ::::) ຫຼືກັບ n'th argument (ເມື່ອໃຊ້ກັບ
-N). ການປ້ອນຂໍ້ມູນຈະເອົາໄດເລກະທໍລີ (ຖ້າມີ) ອອກ.
ເພື່ອເຂົ້າໃຈສະຕຣິງປ່ຽນຕໍາແຫນ່ງເບິ່ງ {n}.
{n//} ຊື່ຂອງອາກິວເມັນຈາກແຫຼ່ງປ້ອນຂໍ້ມູນ n ຫຼື nການໂຕ້ຖຽງທີ. ມັນເປັນ
ປະສົມປະສານຂອງ {n} ແລະ {//}.
ສະຕຣິງການປ່ຽນຕໍາແຫນ່ງນີ້ຈະຖືກແທນທີ່ໂດຍ dir ຂອງວັດສະດຸປ້ອນຈາກ
ແຫຼ່ງເຂົ້າ n (ເມື່ອໃຊ້ກັບ -a or ::::) ຫຼືກັບ n'th argument (ເມື່ອໃຊ້
ກັບ -N) ເບິ່ງ ນາມສະກຸນ(1).
ເພື່ອເຂົ້າໃຈສະຕຣິງປ່ຽນຕໍາແຫນ່ງເບິ່ງ {n}.
{n/.} ຊື່ພື້ນຖານຂອງອາກິວເມັນຈາກແຫຼ່ງປ້ອນຂໍ້ມູນ n ຫຼື n'th argument ໂດຍບໍ່ມີການຂະຫຍາຍ.
ມັນເປັນການປະສົມປະສານຂອງ {n}, {/}, ແລະ {.}.
ສະຕຣິງການປ່ຽນຕໍາແຫນ່ງນີ້ຈະຖືກແທນທີ່ໂດຍການປ້ອນຂໍ້ມູນຈາກການປ້ອນຂໍ້ມູນ
ແຫຼ່ງ n (ເມື່ອໃຊ້ກັບ -a or ::::) ຫຼືກັບ n'th argument (ເມື່ອໃຊ້ກັບ
-N). ການປ້ອນຂໍ້ມູນຈະມີໄດເລກະທໍລີ (ຖ້າມີ) ແລະສ່ວນຂະຫຍາຍອອກ.
ເພື່ອເຂົ້າໃຈສະຕຣິງປ່ຽນຕໍາແຫນ່ງເບິ່ງ {n}.
{=perl ການສະແດງອອກ=}
ແທນທີ່ດ້ວຍການຄິດໄລ່ perl ການສະແດງອອກ. $_ ຈະມີອັນດຽວກັນກັບ {}. ຫລັງຈາກ
ການປະເມີນຜົນ perl ການສະແດງອອກ $_ ຈະຖືກນໍາໃຊ້ເປັນມູນຄ່າ. ມັນແມ່ນແນະນໍາໃຫ້
ພຽງແຕ່ປ່ຽນ $_ ແຕ່ທ່ານສາມາດເຂົ້າເຖິງ GNU ທັງຫມົດ ຂະຫນານພາຍໃນ
ຫນ້າທີ່ແລະໂຄງສ້າງຂໍ້ມູນ.
ໄດ້ {=perl ການສະແດງອອກ=} ຈະຕ້ອງຖືກມອບໃຫ້ເປັນສະຕຣິງດຽວ.
ເບິ່ງເພີ່ມເຕີມ: --rpl --parens
{=n perl ການສະແດງອອກ=}
ຕໍາແຫນ່ງທຽບເທົ່າ {= perl ການສະແດງອອກ =}. ເພື່ອເຂົ້າໃຈຕໍາແຫນ່ງ
ເບິ່ງຊ່ອຍແນ່ແທນ {n}.
ເບິ່ງເພີ່ມເຕີມ: {= perl ການສະແດງອອກ =} {n}.
::: ກະທູ້ທີ່
ໃຊ້ອາກິວເມັນຈາກແຖວຄໍາສັ່ງເປັນແຫຼ່ງປ້ອນຂໍ້ມູນແທນ stdin (ມາດຕະຖານ
ປ້ອນ). ບໍ່ເຫມືອນກັບທາງເລືອກອື່ນສໍາລັບ GNU ຂະຫນານ ::: ຖືກຈັດໃສ່ຫຼັງຈາກ ຄໍາສັ່ງ ແລະ
ກ່ອນການໂຕ້ຖຽງ.
ຕໍ່ໄປນີ້ແມ່ນທຽບເທົ່າ:
(echo file1; echo file2) | gzip ຂະຫນານ
ຂະຫນານ gzip ::: file1 file2
parallel gzip {} ::: file1 file2
ຂະຫນານ --arg-sep ,, gzip {} ,, file1 file2
ຂະຫນານ --arg-sep ,, gzip ,, file1 file2
ຂະຫນານ ::: "gzip file1" "gzip file2"
ເພື່ອຫຼີກເວັ້ນການປິ່ນປົວ ::: ເປັນການນໍາໃຊ້ພິເສດ --arg-sep ເພື່ອກໍານົດຕົວແຍກການໂຕ້ຖຽງ
ອັນອື່ນ. ເບິ່ງນຳ --arg-sep.
stdin (ວັດສະດຸປ້ອນມາດຕະຖານ) ຈະຖືກສົ່ງຜ່ານຂະບວນການທໍາອິດ.
ຖ້າຫຼາຍ ::: ໄດ້ຖືກມອບໃຫ້, ແຕ່ລະກຸ່ມຈະຖືກປະຕິບັດເປັນແຫຼ່ງນໍາເຂົ້າ, ແລະທັງຫມົດ
ການປະສົມຂອງແຫຼ່ງປ້ອນຂໍ້ມູນຈະຖືກສ້າງຂື້ນ. ຕົວຢ່າງ::: 1 2 ::: abc ຈະ
ຜົນໄດ້ຮັບໃນການປະສົມປະສານ (1,a) (1,b) (1,c) (2,a) (2,b) (2,c). ນີ້ແມ່ນເປັນປະໂຫຍດ
ສໍາລັບການປ່ຽນ nested for-loops.
::: ແລະ :::: ສາມາດໄດ້ຮັບການປະສົມ. ດັ່ງນັ້ນສິ່ງເຫຼົ່ານີ້ແມ່ນທຽບເທົ່າ:
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
:::: argfiles
ວິທີການຂຽນອີກ -a argfile1 -a argfile2 ...
::: ແລະ :::: ສາມາດປະສົມ.
ເບິ່ງ -a, ::: ແລະ --xapply.
-- null
-0 ໃຊ້ NUL ເປັນຕົວຂັ້ນ. ປົກກະຕິເສັ້ນປ້ອນເຂົ້າຈະລົງທ້າຍດ້ວຍ \n (ແຖວໃໝ່). ຖ້າພວກເຂົາສິ້ນສຸດ
ໃນ \0 (NUL), ຈາກນັ້ນໃຊ້ຕົວເລືອກນີ້. ມັນເປັນປະໂຫຍດສໍາລັບການປະມວນຜົນການໂຕ້ຖຽງທີ່ອາດຈະ
ມີ \n (ແຖວໃໝ່).
--arg-file ໄຟລ໌ປ້ອນຂໍ້ມູນ
-a ໄຟລ໌ປ້ອນຂໍ້ມູນ
ການນໍາໃຊ້ ໄຟລ໌ປ້ອນຂໍ້ມູນ ເປັນແຫຼ່ງປ້ອນຂໍ້ມູນ. ຖ້າທ່ານໃຊ້ຕົວເລືອກນີ້, stdin (ວັດສະດຸປ້ອນມາດຕະຖານ) ແມ່ນ
ໃຫ້ກັບຂະບວນການທໍາອິດ. ຖ້າບໍ່ດັ່ງນັ້ນ, stdin (ວັດສະດຸປ້ອນມາດຕະຖານ) ຖືກປ່ຽນເສັ້ນທາງ
ຈາກ /dev/null.
ຖ້າຫຼາຍ -a ແມ່ນໃຫ້, ແຕ່ລະຄົນ ໄຟລ໌ປ້ອນຂໍ້ມູນ ຈະຖືກປະຕິບັດເປັນແຫຼ່ງປ້ອນຂໍ້ມູນ, ແລະ
ການປະສົມທັງຫມົດຂອງແຫຼ່ງປ້ອນຂໍ້ມູນຈະຖືກສ້າງຂື້ນ. ຕົວຢ່າງ: ໄຟລ໌ ຟູ ປະກອບດ້ວຍ 1
2, ໄຟລ ພາທະນາຍຄວາມ ປະກອບດ້ວຍ a b c. -a ຟູ -a ພາທະນາຍຄວາມ ຈະສົ່ງຜົນໃຫ້ການປະສົມ
(1,a) (1,b) (1,c) (2,a) (2,b) (2,c). ນີ້ແມ່ນເປັນປະໂຫຍດສໍາລັບການທົດແທນການ nested for-
ວົງ.
ເບິ່ງ --xapply ແລະ {n}.
--arg-file-sep Sep-str
ການນໍາໃຊ້ Sep-str ແທນທີ່ :::: ເປັນສະຕຣິງຕົວແຍກລະຫວ່າງຄໍາສັ່ງແລະການໂຕ້ຖຽງ
ໄຟລ໌. ເປັນປະໂຫຍດຖ້າຫາກວ່າ :::: ຖືກນໍາໃຊ້ສໍາລັບບາງສິ່ງບາງຢ່າງອື່ນໂດຍຄໍາສັ່ງ.
ເບິ່ງເພີ່ມເຕີມ: ::::.
--arg-sep Sep-str
ການນໍາໃຊ້ Sep-str ແທນທີ່ ::: ເປັນສະຕຣິງຕົວແຍກ. ເປັນປະໂຫຍດຖ້າຫາກວ່າ ::: ຖືກນໍາໃຊ້ສໍາລັບການ
ບາງສິ່ງບາງຢ່າງອື່ນໂດຍຄໍາສັ່ງ.
ຍັງເປັນປະໂຫຍດຖ້າທ່ານໃຊ້ຄໍາສັ່ງ ::: ແຕ່ທ່ານຍັງຕ້ອງການອ່ານການໂຕ້ຖຽງຈາກ
stdin (ວັດສະດຸປ້ອນມາດຕະຖານ): ພຽງແຕ່ປ່ຽນ --arg-sep ໄປຫາສະຕຣິງທີ່ບໍ່ຢູ່ໃນ
ບັນທັດຄໍາສັ່ງ.
ເບິ່ງເພີ່ມເຕີມ: :::.
--bar ສະແດງຄວາມຄືບໜ້າເປັນແຖບຄວາມຄືບໜ້າ. ໃນແຖບແມ່ນສະແດງໃຫ້ເຫັນ: % ຂອງວຽກສໍາເລັດ,
ປະມານວິນາທີທີ່ເຫຼືອ, ແລະຈໍານວນວຽກເລີ່ມຕົ້ນ.
ມັນເຂົ້າກັນໄດ້ ສະຖຽນລະພາບ:
seq 1000 | ຂະຫນານ -j30 --bar '(echo {};ນອນ 0.1)' 2> >(zenity --progress
--auto-kill) | ຫອງນໍາ
--basefile ເອກະສານ
--bf ເອກະສານ
ເອກະສານ ຈະຖືກໂອນໄປຫາແຕ່ລະ sshlogin ກ່ອນທີ່ຈະເລີ່ມວຽກ. ມັນຈະເປັນ
ເອົາອອກຖ້າ --ທໍາຄວາມສະອາດ ມີການເຄື່ອນໄຫວ. ໄຟລ໌ອາດຈະເປັນສະຄຣິບເພື່ອແລ່ນ ຫຼືບາງອັນທົ່ວໄປ
ຂໍ້ມູນພື້ນຖານທີ່ຈໍາເປັນສໍາລັບວຽກ. ຫຼາຍ --bf ສາມາດຖືກກໍານົດໃຫ້ໂອນເພີ່ມເຕີມ
ເອກະສານພື້ນຖານ. ໄດ້ ເອກະສານ ຈະຖືກໂອນໄປດ້ວຍວິທີດຽວກັນ --ໂອນ.
--basenamereplace ທົດແທນ-str
--bnr ທົດແທນ-str
ໃຊ້ສະຕຣິງທົດແທນ ທົດແທນ-str ແທນທີ່ {/} ສໍາລັບຊື່ພື້ນຖານຂອງແຖວປ້ອນຂໍ້ມູນ.
--basenameextensionreplace ທົດແທນ-str
--bner ທົດແທນ-str
ໃຊ້ສະຕຣິງທົດແທນ ທົດແທນ-str ແທນທີ່ {/.} ສໍາລັບຊື່ພື້ນຖານຂອງແຖວປ້ອນຂໍ້ມູນ
ໂດຍບໍ່ມີການຂະຫຍາຍ.
--bg ດໍາເນີນການຄໍາສັ່ງໃນພື້ນຫລັງດັ່ງນັ້ນ GNU ຂະຫນານ ຈະບໍ່ລໍຖ້າສໍາລັບການສໍາເລັດຂອງ
ຄໍາສັ່ງກ່ອນທີ່ຈະອອກ. ນີ້ແມ່ນຄ່າເລີ່ມຕົ້ນຖ້າ --semaphore ຖືກກໍານົດ.
ເບິ່ງເພີ່ມເຕີມ: --fg, ຜູ້ຊາຍ sem.
ຫມາຍເຖິງ --semaphore.
--bibtex ພິມລາຍການ BibTeX ສໍາລັບ GNU ຂະຫນານ ແລະປິດການແຈ້ງເຕືອນການອ້າງອີງ.
-- ຕັນ ຂະຫນາດ
--block-size ຂະຫນາດ
ຂະຫນາດຂອງຕັນໃນ bytes. ຂະຫນາດສາມາດຖືກແກ້ໄຂດ້ວຍ K, M, G, T, P, k, m, g, t,
ຫຼື p ເຊິ່ງຈະຄູນຂະໜາດດ້ວຍ 1024, 1048576, 1073741824, 1099511627776,
1125899906842624, 1000, 1000000, 1000000000, 1000000000000, ຫຼື 1000000000000000
ຕາມລໍາດັບ.
GNU ຂະຫນານ ພະຍາຍາມຕອບສະຫນອງຂະຫນາດຕັນແຕ່ສາມາດປິດໄດ້ໂດຍຄວາມຍາວຂອງຫນຶ່ງ
ບັນທຶກ. ສໍາລັບເຫດຜົນການປະຕິບັດ ຂະຫນາດ ຄວນຈະໃຫຍ່ກວ່າບັນທຶກດຽວ.
ຂະຫນາດ ເລີ່ມຕົ້ນເປັນ 1M.
ເບິ່ງ -- ທໍ່ ສໍາລັບການນໍາໃຊ້ນີ້.
--ແມວ ສ້າງໄຟລ໌ຊົ່ວຄາວທີ່ມີເນື້ອຫາ. ປົກກະຕິ -- ທໍ່ ຈະໃຫ້ຂໍ້ມູນກັບ
ໂຄງການກ່ຽວກັບ stdin (ການປ້ອນຂໍ້ມູນມາດຕະຖານ). ກັບ --ແມວ GNU ຂະຫນານ ຈະສ້າງ
ໄຟລ໌ຊົ່ວຄາວທີ່ມີຊື່ໃນ {}, ດັ່ງນັ້ນທ່ານສາມາດເຮັດໄດ້: ຂະຫນານ -- ທໍ່ --ແມວ wc {}.
ເບິ່ງ --fifo.
--ທໍາຄວາມສະອາດ
ເອົາໄຟລ໌ທີ່ໂອນຍ້າຍອອກ. --ທໍາຄວາມສະອາດ ຈະເອົາໄຟລ໌ທີ່ຖືກໂອນຢູ່ໃນ
ຄອມພິວເຕີທາງໄກຫຼັງຈາກການປຸງແຕ່ງແມ່ນເຮັດໄດ້.
ຊອກຫາບັນທຶກຊື່ '*gz' | ຂະຫນານ \
--sshlogin server.example.com --transfer --return {.}.bz2 \
--cleanup "zcat {} | bzip -9 >{.}.bz2"
ກັບ --ໂອນ ໄຟລ໌ທີ່ຍົກຍ້າຍກັບຄອມພິວເຕີທາງໄກຈະໄດ້ຮັບການໂຍກຍ້າຍອອກໃນ
ຄອມພິວເຕີທາງໄກ. ໄດເລກະທໍລີທີ່ສ້າງຂຶ້ນຈະບໍ່ຖືກໂຍກຍ້າຍອອກ - ເຖິງແມ່ນວ່າພວກເຂົາຢູ່
ຫວ່າງເປົ່າ
ກັບ --ກັບຄືນ ໄຟລ໌ທີ່ໂອນຈາກຄອມພິວເຕີທາງໄກຈະໄດ້ຮັບການໂຍກຍ້າຍອອກໃນ
ຄອມພິວເຕີທາງໄກ. ໄດເລກະທໍລີທີ່ສ້າງຂຶ້ນຈະບໍ່ຖືກໂຍກຍ້າຍອອກ - ເຖິງແມ່ນວ່າພວກເຂົາຢູ່
ຫວ່າງເປົ່າ
--ທໍາຄວາມສະອາດ ຖືກລະເລີຍເມື່ອບໍ່ໄດ້ໃຊ້ກັບ --ໂອນ or --ກັບຄືນ.
--colsep regexp
-C regexp
ຕົວຂັ້ນຖັນ. ການປ້ອນຂໍ້ມູນຈະຖືກປະຕິບັດເປັນຕາຕະລາງທີ່ມີ regexp ການແຍກ
ຖັນ. ຖັນ n'th ສາມາດເຂົ້າເຖິງໄດ້ໂດຍໃຊ້ {n} or {n.}. ຕົວຢ່າງ {3} ແມ່ນວັນທີ 3
ຄໍລໍາ
--colsep implies --ຕັດ rl.
regexp ແມ່ນການສະແດງອອກປົກກະຕິ Perl: http://perldoc.perl.org/perlre.html
--ບີບອັດ
ບີບອັດໄຟລ໌ຊົ່ວຄາວ. ຖ້າຜົນຜະລິດແມ່ນໃຫຍ່ແລະບີບອັດຫຼາຍ, ມັນຈະເປັນ
ໃຊ້ພື້ນທີ່ດິສກ໌ໜ້ອຍລົງໃນ $TMPDIR ແລະອາດຈະໄວຂຶ້ນເນື່ອງຈາກ I/O ດິດໜ້ອຍລົງ.
GNU ຂະຫນານ ຈະພະຍາຍາມ lzop, ໝູ, gzip, pbzip2, plzip, bzip2, lzma, lzip, xz in
ຄໍາສັ່ງນັ້ນ, ແລະນໍາໃຊ້ທໍາອິດທີ່ມີຢູ່.
-- ໂປຣແກມບີບອັດ prg
--decompress-ໂຄງການ prg
ການນໍາໃຊ້ prg ສໍາລັບ (de)ການບີບອັດໄຟລ໌ຊົ່ວຄາວ. ມັນສົມມຸດວ່າ prg -dc ຈະ
decompress stdin (ວັດສະດຸປ້ອນມາດຕະຖານ) ໄປ stdout (ຜົນຜະລິດມາດຕະຖານ) ເວັ້ນເສຍແຕ່
--decompress-ໂຄງການ ແມ່ນໃຫ້.
--ctrlc ສົ່ງ SIGINT ໄປຫາວຽກງານທີ່ເຮັດວຽກຢູ່ໃນຄອມພິວເຕີທາງໄກ ດັ່ງນັ້ນຈຶ່ງຂ້າພວກມັນ.
--ຕົວຂັ້ນ ຂອບເຂດ
-d ຂອບເຂດ ລາຍການປ້ອນຂໍ້ມູນຖືກລະງັບໂດຍຕົວອັກສອນທີ່ລະບຸໄວ້. ວົງຢືມແລະ backslash ແມ່ນ
ບໍ່ພິເສດ; ທຸກໆຕົວລະຄອນໃນວັດສະດຸປ້ອນແມ່ນຖືກປະຕິບັດຕາມຕົວໜັງສື. ປິດການໃຊ້ງານໃນຕອນທ້າຍ -
of-file string, ເຊິ່ງຖືກປະຕິບັດຄືກັບການໂຕ້ຖຽງອື່ນໆ. ນີ້ສາມາດຖືກນໍາໃຊ້ໃນເວລາທີ່
ວັດສະດຸປ້ອນປະກອບດ້ວຍລາຍການທີ່ແຍກອອກຈາກແຖວໃໝ່, ເຖິງແມ່ນວ່າມັນເກືອບ
ສະເຫມີດີກວ່າທີ່ຈະອອກແບບໂປຼແກຼມຂອງທ່ານເພື່ອໃຊ້ --null ບ່ອນທີ່ເປັນໄປໄດ້. ໄດ້
ຕົວຂັ້ນທີ່ລະບຸອາດຈະເປັນຕົວອັກສອນດຽວ, ເປັນຕົວຂັ້ນ C-style escape ເຊັ່ນ:
\n, ຫຼືລະຫັດໜີບເລກຖານແປດ ຫຼືເລກຖານສິບຫົກ. ລະຫັດໜີເລກຖານສິບແປດ ແລະເລກຖານສິບຫົກ
ແມ່ນເຂົ້າໃຈສໍາລັບຄໍາສັ່ງ printf. ຕົວອັກສອນ Multibyte ບໍ່ແມ່ນ
ສະຫນັບສະຫນູນ.
--dirnamereplace ທົດແທນ-str
--dnr ທົດແທນ-str
ໃຊ້ສະຕຣິງທົດແທນ ທົດແທນ-str ແທນທີ່ {//} ສໍາລັບ dirname ຂອງ input line.
-E eof-str
ຕັ້ງຈຸດສິ້ນສຸດຂອງສາຍໄຟລ໌ເປັນ eof-str. ຖ້າການສິ້ນສຸດຂອງໄຟລ໌ string ເກີດຂຶ້ນເປັນ a
ແຖວຂອງການປ້ອນຂໍ້ມູນ, ສ່ວນທີ່ເຫຼືອຂອງການປ້ອນຂໍ້ມູນຖືກລະເລີຍ. ຖ້າບໍ່ -E neither -e ຖືກນໍາໃຊ້,
ບໍ່ມີຈຸດສິ້ນສຸດຂອງສາຍໄຟລ໌ຖືກໃຊ້.
--ຊັກຊ້າ ແຫ້ງ
ເລື່ອນການເລີ່ມຕົ້ນວຽກຕໍ່ໄປ ແຫ້ງ ວິນາທີ. GNU ຂະຫນານ ຈະຢຸດຊົ່ວຄາວ ແຫ້ງ ວິນາທີຫຼັງຈາກ
ເລີ່ມແຕ່ລະວຽກ. ແຫ້ງ ສາມາດໜ້ອຍກວ່າ 1 ວິນາທີ.
-- ແລ່ນແຫ້ງ
ພິມວຽກທີ່ຈະດໍາເນີນການ stdout (ຜົນຜະລິດມາດຕະຖານ), ແຕ່ບໍ່ໄດ້ດໍາເນີນການວຽກເຮັດງານທໍາ. ໃຊ້ -v
-v ເພື່ອລວມເອົາການຫໍ່ ssh/rsync ຖ້າວຽກຈະດໍາເນີນການຢູ່ໃນໄລຍະໄກ
ຄອມພິວເຕີ. ຢ່ານັບກ່ຽວກັບເລື່ອງນີ້, ເຖິງແມ່ນວ່າ, ຍ້ອນວ່າວຽກອາດຈະຖືກກໍານົດໄວ້
ຄອມພິວເຕີອື່ນ ຫຼືຄອມພິວເຕີທ້ອງຖິ່ນຖ້າ : ຢູ່ໃນລາຍການ.
--eof[=eof-str]
-e[eof-str]
ທາງເລືອກນີ້ແມ່ນຄໍາສັບຄ້າຍຄືສໍາລັບ -E ທາງເລືອກ. ໃຊ້ -E ແທນທີ່ຈະ, ເພາະວ່າມັນເປັນ POSIX
ສອດຄ້ອງກັບ xargs ໃນຂະນະທີ່ທາງເລືອກນີ້ບໍ່ແມ່ນ. ຖ້າ eof-str ຖືກລະເວັ້ນ, ບໍ່ມີ
ທ້າຍຂອງສາຍໄຟລ໌. ຖ້າບໍ່ -E neither -e ຖືກນໍາໃຊ້, ບໍ່ມີການສິ້ນສຸດຂອງສາຍໄຟລ໌ໄດ້ຖືກນໍາໃຊ້.
--env var (ການທົດສອບອັນຟາ)
ສຳເນົາຕົວແປສະພາບແວດລ້ອມ var. ນີ້ຈະສໍາເນົາ var ຕໍ່ກັບສະພາບແວດລ້ອມທີ່
ຄໍາສັ່ງແມ່ນດໍາເນີນການໃນ. ນີ້ແມ່ນເປັນປະໂຫຍດໂດຍສະເພາະແມ່ນສໍາລັບການປະຕິບັດທາງໄກ.
ໃນ Bash var ຍັງສາມາດເປັນຟັງຊັນ Bash - ພຽງແຕ່ຈື່ໄວ້ ການສົ່ງອອກ -f ໄດ້
ຫນ້າທີ່, ເບິ່ງ ຄໍາສັ່ງ.
ຕົວແປ '_' ແມ່ນພິເສດ. ມັນຈະຄັດລອກຕົວແປສະພາບແວດລ້ອມທັງຫມົດຍົກເວັ້ນສໍາລັບ
ທີ່ໄດ້ກ່າວມາໃນ ~/.parallel/ignored_vars.
ເພື່ອຄັດລອກ Bash arrays ທ່ານຕ້ອງການຟັງຊັນຕົວນໍາເຂົ້າ, ເນື່ອງຈາກວ່າ Bash arrays ບໍ່ສາມາດເປັນ
ສົ່ງອອກ:
import_array () {
local func=$1; ປ່ຽນ;
ສົ່ງອອກ $func='() {
'"$ (ສໍາລັບ arr ໃນ $@; ເຮັດ
ປະກາດ -p $arr|sed '1s/declare -./&g/'
ສໍາເລັດ)"'
}'
}
ປະກາດ -A assoc='([one]="1" [two]="2")'
ປະກາດ -a indexed='([0]="one" [1]="two")'
import_array my_importer assoc ຖືກດັດສະນີແລ້ວ
ຂະຫນານ --env my_importer \
'ຜູ້ນໍາເຂົ້າຂອງຂ້ອຍ; echo "{}" "${indexed[{}]}" "${assoc[${indexed[{}]}]}"' ::: "${!indexed[@]}"
ເພື່ອສຳເນົາສະພາບແວດລ້ອມເຕັມໃຫ້ໃຊ້ຟັງຊັນນີ້ (ເຊັ່ນ: ໂດຍໃສ່ໃນ .bashrc):
env_parallel() {
ສົ່ງອອກ parallel_bash_environment='() {
'"$(echo "shopt -s expand_aliases 2>/dev/null"; alias;typeset -p | grep -vFf <(readonly; echo GROUPS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_;typeset -f)"'
}'
# ດໍາເນີນການເປັນ: env_parallel [ຕົວເລືອກຂະຫນານປົກກະຕິ]
`ເຊິ່ງຂະໜານ` "$@"
ບໍ່ໄດ້ຕັ້ງ parallel_bash_environment
}
# ໂທເປັນ:
env_parallel [ຕົວເລືອກຂະໜານປົກກະຕິ]
ເບິ່ງເພີ່ມເຕີມ: --record-env.
--eta ສະແດງຕົວເລກທີ່ຄາດຄະເນຂອງວິນາທີກ່ອນທີ່ຈະສໍາເລັດ. ນີ້ບັງຄັບໃຫ້ GNU ຂະຫນານ
ເພື່ອອ່ານວຽກທັງໝົດກ່ອນທີ່ຈະເລີ່ມຊອກຫາຈໍານວນວຽກ. GNU ຂະຫນານ
ປົກກະຕິແລ້ວພຽງແຕ່ອ່ານວຽກຕໍ່ໄປທີ່ຈະດໍາເນີນການ. ຫມາຍເຖິງ - ແມ່ຍິງ.
--fg ດໍາເນີນການຄໍາສັ່ງໃນ foreground ດັ່ງນັ້ນ GNU ຂະຫນານ ຈະລໍຖ້າໃຫ້ສໍາເລັດຂອງ
ຄໍາສັ່ງກ່ອນທີ່ຈະອອກ.
ເບິ່ງ --bg, ຜູ້ຊາຍ sem.
ຫມາຍເຖິງ --semaphore.
--fifo ສ້າງ fifo ຊົ່ວຄາວທີ່ມີເນື້ອຫາ. ປົກກະຕິ -- ທໍ່ ຈະໃຫ້ຂໍ້ມູນກັບ
ໂຄງການກ່ຽວກັບ stdin (ການປ້ອນຂໍ້ມູນມາດຕະຖານ). ກັບ --fifo GNU ຂະຫນານ ຈະສ້າງ
fifo ຊົ່ວຄາວທີ່ມີຊື່ໃນ {}, ດັ່ງນັ້ນທ່ານສາມາດເຮັດໄດ້: ຂະຫນານ -- ທໍ່ --fifo wc {}.
ລະວັງ: ຖ້າຂໍ້ມູນບໍ່ໄດ້ອ່ານຈາກ fifo, ວຽກຈະປິດກັ້ນຕະຫຼອດໄປ.
ເບິ່ງ --ແມວ.
--filter-hosts
ເອົາ host ລົງ. ສໍາລັບແຕ່ລະເຈົ້າພາບຫ່າງໄກສອກຫຼີກ: ກວດເບິ່ງວ່າເຂົ້າສູ່ລະບົບຜ່ານ ssh ເຮັດວຽກ. ຖ້າ
not: ຢ່າໃຊ້ເຈົ້າພາບນີ້.
ໃນປັດຈຸບັນທ່ານສາມາດເຮັດໄດ້ ບໍ່ ເອົາໃຈໃສ່ --filter-hosts ໃນໂປຣໄຟລ໌, $PARALLEL,
/etc/parallel/config ຫຼືຄ້າຍຄືກັນ. ນີ້ແມ່ນຍ້ອນວ່າ GNU ຂະຫນານ ໃຊ້ GNU ຂະຫນານ
ເພື່ອຄິດໄລ່ນີ້, ດັ່ງນັ້ນທ່ານຈະໄດ້ຮັບ loop ທີ່ບໍ່ມີຂອບເຂດ. ນີ້ອາດຈະຖືກແກ້ໄຂໃນ a
ປ່ອຍຕົວຕໍ່ມາ.
--gnu ປະຕິບັດຕົວຄືກັບ GNU ຂະຫນານ. ທາງເລືອກນີ້ໄດ້ຮັບການນໍາໃຊ້ໃນປະຫວັດສາດ --ໂທເລຟ.
ໄດ້ --ໂທເລຟ ທາງເລືອກນີ້ແມ່ນບໍານານແລ້ວ, ແລະດັ່ງນັ້ນອາດຈະບໍ່ຖືກນໍາໃຊ້. --gnu ຖືກເກັບຮັກສາໄວ້
ສໍາລັບການເຂົ້າກັນໄດ້.
--ກຸ່ມ ຜົນຜະລິດກຸ່ມ. ຜົນໄດ້ຮັບຈາກແຕ່ລະວຽກແມ່ນຈັດກຸ່ມເຂົ້າກັນ ແລະຖືກພິມອອກເມື່ອໃດ
ຄໍາສັ່ງແມ່ນສໍາເລັດ. stderr (ຄວາມຜິດພາດມາດຕະຖານ) ທໍາອິດຕິດຕາມດ້ວຍ stdout
(ຜົນຜະລິດມາດຕະຖານ). ນີ້ໃຊ້ເວລາບາງ CPU. ໃນສະຖານະການທີ່ຫາຍາກ GNU ຂະຫນານ
ໃຊ້ເວລາເຖິງ CPU ຫຼາຍແລະຖ້າມັນຍອມຮັບໄດ້ວ່າຜົນໄດ້ຮັບຈາກທີ່ແຕກຕ່າງກັນ
ຄໍາສັ່ງແມ່ນປະສົມເຂົ້າກັນ, ຫຼັງຈາກນັ້ນປິດການທໍາງານການຈັດກຸ່ມກັບ -u ສາມາດເລັ່ງ GNU
ຂະຫນານ ໂດຍປັດໄຈຂອງ 10.
--ກຸ່ມ ເປັນຄ່າເລີ່ມຕົ້ນ. ສາມາດປີ້ນກັບ -u.
ເບິ່ງເພີ່ມເຕີມ: --line-buffer --ກຸ່ມ
- ຊ່ວຍ
-h ພິມບົດສະຫຼຸບຂອງຕົວເລືອກໃສ່ GNU ຂະຫນານ ແລະອອກຈາກການ.
--halt-on-error h
--ຢຸດ h
GNU ຄວນເຮັດແນວໃດ ຂະຫນານ ຢຸດຖ້າວຽກອື່ນລົ້ມເຫລວບໍ?
0 ຢ່າຢຸດຖ້າວຽກລົ້ມເຫລວ. ສະຖານະການອອກຈະເປັນຈໍານວນວຽກທີ່ລົ້ມເຫລວ.
ນີ້ແມ່ນຄ່າເລີ່ມຕົ້ນ.
1 ຢ່າເລີ່ມວຽກໃໝ່ ຖ້າວຽກໃດລົ້ມເຫລວ, ແຕ່ເຮັດວຽກທີ່ແລ່ນໃຫ້ສຳເລັດ
ລວມທັງການອະນາໄມ. ສະຖານະການອອກຈະເປັນສະຖານະການອອກຈາກສຸດທ້າຍ
ວຽກທີ່ລົ້ມເຫລວ.
2 ຂ້າວຽກທັງຫມົດໃນທັນທີແລະອອກໂດຍບໍ່ມີການທໍາຄວາມສະອາດ. ສະຖານະການອອກ
ຈະເປັນສະຖານະການອອກຈາກວຽກທີ່ລົ້ມເຫລວ.
1-99% ຖ້າ h% ຂອງວຽກທີ່ລົ້ມເຫລວແລະຕໍາ່ສຸດທີ່ 3: ຢ່າເລີ່ມວຽກໃຫມ່, ແຕ່
ເຮັດສໍາເລັດວຽກທີ່ເຮັດວຽກລວມທັງການທໍາຄວາມສະອາດ. ສະຖານະພາບທາງອອກຈະເປັນ
ອອກຈາກສະຖານະຈາກວຽກທີ່ລົ້ມເຫລວສຸດທ້າຍ.
--ຫົວ regexp
ໃຊ້ regexp ເປັນສ່ວນຫົວ. ສໍາລັບການນໍາໃຊ້ປົກກະຕິສ່ວນຫົວທີ່ກົງກັນ (ໂດຍປົກກະຕິທໍາອິດ
line: --ຫົວ '.*\n') ຈະຖືກແບ່ງອອກໂດຍນໍາໃຊ້ --colsep (ເຊິ່ງຈະເປັນຄ່າເລີ່ມຕົ້ນເປັນ '\t')
ແລະຊື່ຖັນສາມາດໃຊ້ເປັນຕົວແປທົດແທນໄດ້: {ຖັນ ຊື່}.
ສໍາລັບການ -- ທໍ່ ສ່ວນຫົວທີ່ກົງກັນຈະຖືກນຳໜ້າໃສ່ແຕ່ລະຜົນຜະລິດ.
--ຫົວ : ແມ່ນນາມແforງຂອງ --ຫົວ '.*\n'.
If regexp ແມ່ນຕົວເລກ, ມັນຈະກົງກັບຫຼາຍເສັ້ນນັ້ນ.
-I ທົດແທນ-str
ໃຊ້ສະຕຣິງທົດແທນ ທົດແທນ-str ແທນທີ່ {}.
--ປ່ຽນແທນ[=ທົດແທນ-str]
-i[ທົດແທນ-str]
ທາງເລືອກນີ້ແມ່ນຄໍາສັບຄ້າຍຄື -Iທົດແທນ-str if ທົດແທນ-str ຖືກກໍານົດ, ແລະສໍາລັບ
-I{} ຖ້າບໍ່ດັ່ງນັ້ນ. ຕົວເລືອກນີ້ຖືກປະຕິເສດ; ໃຊ້ -I ແທນທີ່ຈະເປັນ.
--joblog logfile
Logfile ສໍາລັບວຽກທີ່ຖືກປະຕິບັດ. ບັນທຶກບັນຊີລາຍການຂອງວຽກເຮັດງານທໍາທີ່ໄດ້ຮັບການ logfile ໃນ
ຕໍ່ໄປນີ້ຮູບແບບທີ່ແຍກອອກ TAB: ເລກລໍາດັບ, sshlogin, ເວລາເລີ່ມຕົ້ນເປັນວິນາທີ
ນັບຕັ້ງແຕ່ epoch, ແລ່ນເວລາເປັນວິນາທີ, bytes ໃນໄຟລ໌ທີ່ຖືກໂອນ, bytes ໃນໄຟລ໌
ກັບຄືນ, ອອກຈາກສະຖານະ, ສັນຍານ, ແລະຄໍາສັ່ງດໍາເນີນການ.
ເພື່ອປ່ຽນເວລາເປັນ ISO-8601 ຢ່າງເຂັ້ມງວດ, ເຮັດ:
perl -a -F"\t" - ບໍ່ 'chomp($F[2]=`ວັນທີ -d \@$F[2] +%FT%T`); ພິມ ເຂົ້າຮ່ວມ("\t",@F)'
ເບິ່ງ -- ຊີວະປະຫວັດຫຍໍ້.
--ວຽກ N
-j N
--max-procs N
-P N ຈໍານວນບ່ອນເຮັດວຽກ. ແລ່ນເຖິງ N ວຽກຂະໜານກັນ. 0 ຫມາຍຄວາມວ່າຫຼາຍເທົ່າທີ່ເປັນໄປໄດ້.
ຄ່າເລີ່ມຕົ້ນແມ່ນ 100% ເຊິ່ງຈະເຮັດວຽກຫນຶ່ງວຽກຕໍ່ CPU Core.
If --semaphore ຖືກຕັ້ງໄວ້ໃນຕອນຕົ້ນແມ່ນ 1 ດັ່ງນັ້ນຈຶ່ງເຮັດໃຫ້ mutex.
--ວຽກ +N
-j +N
--max-procs +N
-P +N ເພີ່ມ N ກັບຈໍານວນຂອງ CPU cores. ດໍາເນີນການຫຼາຍວຽກນີ້ໃນຂະຫນານ. ເບິ່ງນຳ
--use-cpus-intead-of-cores.
--ວຽກ -N
-j -N
--max-procs -N
-P -N ລົບ N ຈາກຈໍານວນຂອງ CPU cores. ດໍາເນີນການຫຼາຍວຽກນີ້ໃນຂະຫນານ. ຖ້າ
ຕົວເລກທີ່ປະເມີນແມ່ນຫນ້ອຍກວ່າ 1 ຈາກນັ້ນ 1 ຈະຖືກໃຊ້. ເບິ່ງນຳ
--use-cpus-intead-of-cores.
--ວຽກ N%
-j N%
--max-procs N%
-P N% ຄູນ N% ກັບຈໍານວນຂອງ CPU cores. ດໍາເນີນການຫຼາຍວຽກນີ້ໃນຂະຫນານ. ເບິ່ງ
ຍັງ --use-cpus-intead-of-cores.
--ວຽກ ຂັ້ນຕອນ
-j ຂັ້ນຕອນ
--max-procs ຂັ້ນຕອນ
-P ຂັ້ນຕອນ
ອ່ານພາລາມິເຕີຈາກໄຟລ໌. ໃຊ້ເນື້ອໃນຂອງ ຂັ້ນຕອນ ເປັນພາລາມິເຕີສໍາລັບ -j. ຕົວຢ່າງ
ຂັ້ນຕອນ ສາມາດປະກອບມີ string 100% ຫຼື +2 ຫຼື 10. ຖ້າ ຂັ້ນຕອນ ມີການປ່ຽນແປງເມື່ອ ກ
ວຽກເຮັດງານທໍາສໍາເລັດ, ຂັ້ນຕອນ ຖືກອ່ານອີກເທື່ອຫນຶ່ງແລະຈໍານວນວຽກໃຫມ່ໄດ້ຖືກຄິດໄລ່. ຖ້າ
ຕົວເລກແມ່ນຕໍ່າກວ່າແຕ່ກ່ອນ, ວຽກທີ່ເຮັດວຽກຈະຖືກອະນຸຍາດໃຫ້ສໍາເລັດແຕ່ໃຫມ່
ວຽກຈະບໍ່ໄດ້ຮັບການເລີ່ມຕົ້ນຈົນກ່ວາຈໍານວນວຽກທີ່ຕ້ອງການໄດ້ບັນລຸ. ນີ້
ເຮັດໃຫ້ມັນເປັນໄປໄດ້ທີ່ຈະປ່ຽນຈໍານວນວຽກທີ່ເຮັດວຽກພ້ອມໆກັນໃນຂະນະທີ່ GNU
ຂະຫນານ ກຳ ລັງແລ່ນ.
-- ຮັກສາຄໍາສັ່ງ
-k ຮັກສາລໍາດັບຂອງຜົນຜະລິດຄືກັນກັບຄໍາສັ່ງຂອງວັດສະດຸປ້ອນ. ປົກກະຕິຜົນຜະລິດຂອງວຽກ
ຈະຖືກພິມອອກທັນທີທີ່ວຽກສໍາເລັດ. ລອງໃຊ້ອັນນີ້ເພື່ອເບິ່ງຄວາມແຕກຕ່າງ:
ຂະຫນານ -j4 ນອນ {}\; echo {} ::: 2 1 4 3
ຂະຫນານ -j4 -k ນອນ {}\; echo {} ::: 2 1 4 3
ຖ້າໃຊ້ກັບ --onall or --nonall ຜົນຜະລິດຈະຈັດກຸ່ມໂດຍ sshlogin ໃນການຈັດຮຽງ
order
-L ເສັ້ນສູງສຸດ
ເມື່ອໃຊ້ກັບ -- ທໍ່: ອ່ານບັນທຶກຂອງ ເສັ້ນສູງສຸດ.
ເມື່ອໃຊ້ຢ່າງອື່ນ: ໃຊ້ຫຼາຍທີ່ສຸດ ເສັ້ນສູງສຸດ ເສັ້ນການປ້ອນຂໍ້ມູນທີ່ບໍ່ແມ່ນຫວ່າງເປົ່າຕໍ່ແຖວຄໍາສັ່ງ.
ຊ່ອງຫວ່າງຕໍ່ທ້າຍເຮັດໃຫ້ແຖວປ້ອນຂໍ້ມູນຖືກສືບຕໍ່ຢ່າງມີເຫດຜົນໃນການປ້ອນຂໍ້ມູນຕໍ່ໄປ
ເສັ້ນ.
-L 0 ຫມາຍຄວາມວ່າອ່ານຫນຶ່ງແຖວ, ແຕ່ໃສ່ 0 arguments ໃນເສັ້ນຄໍາສັ່ງ.
ຫມາຍເຖິງ -X ເວັ້ນເສຍແຕ່ວ່າ -m, --xargs, ຫຼື -- ທໍ່ ຖືກກໍານົດ.
--max-lines[=ເສັ້ນສູງສຸດ]
-l[ເສັ້ນສູງສຸດ]
ເມື່ອໃຊ້ກັບ -- ທໍ່: ອ່ານບັນທຶກຂອງ ເສັ້ນສູງສຸດ.
ເມື່ອໃຊ້ໃນທາງອື່ນ: ຄໍາສັບຄ້າຍຄື -L ທາງເລືອກ. ບໍ່ມັກ -L, ການ ເສັ້ນສູງສຸດ
ການໂຕ້ຖຽງແມ່ນທາງເລືອກ. ຖ້າ ເສັ້ນສູງສຸດ ບໍ່ໄດ້ລະບຸໄວ້, ມັນຕັ້ງໄວ້ໃນຕອນຕົ້ນ. ໄດ້ -l
ຕົວເລືອກຖືກຍົກເລີກເນື່ອງຈາກມາດຕະຖານ POSIX ລະບຸ -L ແທນທີ່ຈະເປັນ.
-l 0 ແມ່ນນາມແforງຂອງ -l 1.
ຫມາຍເຖິງ -X ເວັ້ນເສຍແຕ່ວ່າ -m, --xargs, ຫຼື -- ທໍ່ ຖືກກໍານົດ.
--line-buffer
Buffer ຜົນຜະລິດບົນພື້ນຖານເສັ້ນ. --ກຸ່ມ ຈະຮັກສາຜົນຜະລິດຮ່ວມກັນສໍາລັບການທັງຫມົດ
ວຽກງານ. --ກຸ່ມ ອະນຸຍາດໃຫ້ຜົນຜະລິດທີ່ຈະ mixup ກັບເຄິ່ງຫນຶ່ງເສັ້ນທີ່ມາຈາກການເຮັດວຽກຫນຶ່ງແລະ
ເຄິ່ງແຖວມາຈາກວຽກອື່ນ. --line-buffer ເຫມາະລະຫວ່າງສອງອັນນີ້: GNU
ຂະຫນານ ຈະພິມເຕັມເສັ້ນ, ແຕ່ຈະອະນຸຍາດໃຫ້ສໍາລັບການປະສົມສາຍທີ່ແຕກຕ່າງກັນ
ວຽກ.
--line-buffer ໃຊ້ພະລັງງານ CPU ຫຼາຍກ່ວາທັງສອງ --ກຸ່ມ ແລະ --ກຸ່ມ, ແຕ່ສາມາດເຮັດໄດ້
ຈະໄວກວ່າ --ກຸ່ມ ຖ້າ CPU ບໍ່ແມ່ນປັດໃຈຈໍາກັດ.
ເບິ່ງເພີ່ມເຕີມ: --ກຸ່ມ --ກຸ່ມ
-- ໂຫຼດ ໂຫຼດສູງສຸດ
ຢ່າເລີ່ມວຽກໃຫມ່ໃນຄອມພິວເຕີທີ່ໃຫ້, ເວັ້ນເສຍແຕ່ວ່າຈໍານວນຂະບວນການແລ່ນ
ໃນຄອມພິວເຕີແມ່ນຫນ້ອຍກ່ວາ ໂຫຼດສູງສຸດ. ໂຫຼດສູງສຸດ ໃຊ້ syntax ດຽວກັນກັບ --ວຽກ,
so 100% ສໍາລັບຫນຶ່ງຕໍ່ CPU ເປັນການຕັ້ງຄ່າທີ່ຖືກຕ້ອງ. ຄວາມແຕກຕ່າງພຽງແຕ່ແມ່ນ 0 ຊຶ່ງເປັນ
ແປເປັນ 0.01.
--ຜູ້ຄວບຄຸມ
-M ໃຊ້ ControlMaster ຂອງ ssh ເພື່ອເຮັດໃຫ້ການເຊື່ອມຕໍ່ ssh ໄວຂຶ້ນ. ເປັນປະໂຫຍດຖ້າວຽກເຮັດວຽກທາງໄກ
ແລະໄວຫຼາຍທີ່ຈະແລ່ນ. ອັນນີ້ຖືກປິດໄວ້ສໍາລັບ sshlogins ທີ່ລະບຸຂອງຕົນເອງ
ssh ຄໍາສັ່ງ.
--xargs ການໂຕ້ຖຽງຫຼາຍ. ໃສ່ການໂຕ້ຖຽງຫຼາຍເທົ່າທີ່ຄວາມຍາວຂອງແຖວຄໍາສັ່ງອະນຸຍາດໃຫ້.
If {} ບໍ່ໄດ້ໃຊ້ການໂຕ້ຖຽງຈະຖືກຕໍ່ທ້າຍກັບແຖວ. ຖ້າ {} ຖືກນໍາໃຊ້
ຫຼາຍຄັ້ງໃນແຕ່ລະ {} ຈະຖືກແທນທີ່ດ້ວຍການໂຕ້ຖຽງທັງຫມົດ.
ສະຫນັບສະຫນູນສໍາລັບ --xargs ກັບ --sshlogin ແມ່ນຈໍາກັດແລະອາດຈະລົ້ມເຫລວ.
ເບິ່ງ -X ສໍາລັບການທົດແທນສະພາບການ. ຖ້າສົງໃສໃຊ້ -X ເທົ່າທີ່ຈະເຮັດໄດ້
ສິ່ງທີ່ ຈຳ ເປັນ.
-m ການໂຕ້ຖຽງຫຼາຍ. ໃສ່ການໂຕ້ຖຽງຫຼາຍເທົ່າທີ່ຄວາມຍາວຂອງແຖວຄໍາສັ່ງອະນຸຍາດໃຫ້.
ຖ້າຫຼາຍວຽກຖືກດໍາເນີນການຂະຫນານ: ແຈກຢາຍການໂຕ້ຖຽງໃຫ້ເທົ່າທຽມກັນລະຫວ່າງ
ວຽກເຮັດງານທໍາ. ໃຊ້ -j1 ເພື່ອຫຼີກເວັ້ນການນີ້.
If {} ບໍ່ໄດ້ໃຊ້ການໂຕ້ຖຽງຈະຖືກຕໍ່ທ້າຍກັບແຖວ. ຖ້າ {} ຖືກນໍາໃຊ້
ຫຼາຍຄັ້ງໃນແຕ່ລະ {} ຈະຖືກແທນທີ່ດ້ວຍການໂຕ້ຖຽງທັງຫມົດ.
ສະຫນັບສະຫນູນສໍາລັບ -m ກັບ --sshlogin ແມ່ນຈໍາກັດແລະອາດຈະລົ້ມເຫລວ.
ເບິ່ງ -X ສໍາລັບການທົດແທນສະພາບການ. ຖ້າສົງໃສໃຊ້ -X ເທົ່າທີ່ຈະເຮັດໄດ້
ສິ່ງທີ່ ຈຳ ເປັນ.
-- minversion ສະບັບພາສາ
ພິມສະບັບ GNU ຂະຫນານ ແລະອອກ. ຖ້າຫາກວ່າສະບັບປະຈຸບັນຂອງ GNU ຂະຫນານ
ແມ່ນຫນ້ອຍກ່ວາ ສະບັບພາສາ ລະຫັດອອກແມ່ນ 255. ຖ້າບໍ່ດັ່ງນັ້ນມັນເປັນ 0.
ອັນນີ້ເປັນປະໂຫຍດສຳລັບສະຄຣິບທີ່ຂຶ້ນກັບຄຸນສົມບັດທີ່ສາມາດໃຊ້ໄດ້ຈາກບາງອັນເທົ່ານັ້ນ
ສະບັບຂອງ GNU ຂະຫນານ.
--nonall (ການທົດສອບເບຕ້າ)
--onall ໂດຍບໍ່ມີການໂຕ້ຖຽງ. ດໍາເນີນການຄໍາສັ່ງໃນຄອມພິວເຕີທັງຫມົດໃຫ້ກັບ --sshlogin
ແຕ່ບໍ່ໂຕ້ຖຽງ. GNU ຂະຫນານ ຈະເຂົ້າສູ່ລະບົບ --ວຽກ ຈໍານວນຂອງຄອມພິວເຕີໃນ
ຂະຫນານແລະດໍາເນີນການວຽກໃນຄອມພິວເຕີ. -j ປັບຈໍານວນຄອມພິວເຕີທີ່ຈະເຂົ້າສູ່ລະບົບ
ເຂົ້າໄປໃນຂະຫນານ.
ນີ້ເປັນປະໂຫຍດສໍາລັບການແລ່ນຄໍາສັ່ງດຽວກັນ (ເຊັ່ນ: uptime) ໃນບັນຊີລາຍຊື່ຂອງເຄື່ອງແມ່ຂ່າຍ.
--onall (ການທົດສອບເບຕ້າ)
ດໍາເນີນການວຽກທັງຫມົດໃນຄອມພິວເຕີທັງຫມົດທີ່ໃຫ້ກັບ --sshlogin. GNU ຂະຫນານ ຈະບັນທຶກ
ເຂົ້າໄປໃນ --ວຽກ ຈໍານວນຂອງຄອມພິວເຕີໃນຂະຫນານແລະດໍາເນີນການຫນຶ່ງວຽກເຮັດງານທໍາໃນເວລາທີ່
ຄອມພິວເຕີ. ຄໍາສັ່ງຂອງວຽກຈະບໍ່ມີການປ່ຽນແປງ, ແຕ່ບາງຄອມພິວເຕີອາດຈະ
ສໍາເລັດຮູບກ່ອນຄົນອື່ນ. -j ປັບຈໍານວນຄອມພິວເຕີເພື່ອເຂົ້າສູ່ລະບົບຂະຫນານ.
ເມື່ອນໍາໃຊ້ --ກຸ່ມ ຜົນຜະລິດຈະຖືກຈັດກຸ່ມໂດຍແຕ່ລະເຄື່ອງແມ່ຂ່າຍ, ດັ່ງນັ້ນຜົນຜະລິດທັງຫມົດ
ຈາກເຄື່ອງແມ່ຂ່າຍຫນຶ່ງຈະຖືກຈັດກຸ່ມເຂົ້າກັນ.
--output-as-files
--outputasfiles
--ໄຟລ໌ ແທນທີ່ຈະພິມຜົນຜະລິດໄປ stdout (ຜົນຜະລິດມາດຕະຖານ) ຜົນຜະລິດຂອງແຕ່ລະວຽກ
ຖືກບັນທຶກໄວ້ໃນໄຟລ໌ ແລະຊື່ໄຟລ໌ຈະຖືກພິມອອກ.
-- ທໍ່
--spreadstdin
ເຜີຍແຜ່ການປ້ອນຂໍ້ມູນໄປຫາວຽກໃນ stdin (ວັດສະດຸປ້ອນມາດຕະຖານ). ອ່ານບລັອກຂໍ້ມູນຈາກ stdin
(ການປ້ອນຂໍ້ມູນມາດຕະຖານ) ແລະໃຫ້ຂໍ້ມູນຫນຶ່ງບລັອກເປັນການປ້ອນຂໍ້ມູນໃຫ້ກັບວຽກໜຶ່ງ.
ຂະຫນາດຕັນແມ່ນຖືກກໍານົດໂດຍ -- ຕັນ. ຊ່ອຍແນ່ --ເລີ່ມໃໝ່ ແລະ --recend ບອກ
GNU ຂະຫນານ ການບັນທຶກເລີ່ມຕົ້ນ ແລະ/ຫຼືສິ້ນສຸດແນວໃດ. ບລັອກທີ່ອ່ານຈະມີສຸດທ້າຍ
ບັນທຶກບາງສ່ວນຖືກໂຍກຍ້າຍອອກກ່ອນທີ່ທ່ອນໄມ້ຈະຖືກສົ່ງໄປຫາວຽກ. ສ່ວນ
ບັນທຶກຈະຖືກນຳໜ້າໃສ່ບລັອກຕໍ່ໄປ.
If --ເລີ່ມໃໝ່ ໄດ້ຖືກມອບໃຫ້ນີ້ຈະຖືກໃຊ້ເພື່ອແບ່ງປັນໃນຕອນເລີ່ມຕົ້ນບັນທຶກ.
If --recend ໄດ້ຖືກມອບໃຫ້ນີ້ຈະຖືກໃຊ້ເພື່ອແບ່ງປັນໃນຕອນທ້າຍຂອງບັນທຶກ.
ຖ້າທັງສອງ --ເລີ່ມໃໝ່ ແລະ --recend ແມ່ນໃຫ້ທັງສອງຈະຕ້ອງຈັບຄູ່ເພື່ອຊອກຫາການແບ່ງປັນ
ຕໍາແຫນ່ງ.
ຖ້າບໍ່ --ເລີ່ມໃໝ່ neither --recend ແມ່ນໃຫ້ --recend ເລີ່ມຕົ້ນເປັນ '\n'. ມີ
ບໍ່ມີການນໍາໃຊ້ຕົວແຍກບັນທຶກ --recend "".
--ໄຟລ໌ ມັກໃຊ້ກັບ -- ທໍ່.
ເບິ່ງເພີ່ມເຕີມ: --ເລີ່ມໃໝ່, --recend, --fifo, --ແມວ, --ທໍ່.
--ທໍ່ (ການທົດສອບເບຕ້າ)
ພາກສ່ວນທໍ່ຂອງໄຟລ໌ທາງດ້ານຮ່າງກາຍ. --ທໍ່ ເຮັດວຽກຄ້າຍຄືກັນກັບ -- ທໍ່, ແຕ່ຫຼາຍ
ໄວກວ່າ. ມັນມີຂໍ້ຈໍາກັດຈໍານວນຫນຶ່ງ:
* ໄຟລ໌ຕ້ອງເປັນໄຟລ໌ຕົວຈິງ (ສາມາດຊອກຫາໄດ້) ແລະຕ້ອງໄດ້ຮັບການມອບໃຫ້ໂດຍໃຊ້ -a or
::::.
* ການນັບບັນທຶກ (-N) ແລະການນັບແຖວ (-L/-l) ບໍ່ໄດ້ເຮັດວຽກ.
--ທຳມະດາ ບໍ່ສົນໃຈໃດໆ --ໂປຣໄຟລ໌, $PARALLEL, ແລະ ~/.parallel/config ເພື່ອໃຫ້ໄດ້ຮັບການຄວບຄຸມຢ່າງເຕັມທີ່
ເສັ້ນຄໍາສັ່ງ (ໃຊ້ໂດຍ GNU ຂະຫນານ ພາຍໃນເມື່ອເອີ້ນດ້ວຍ --sshlogin).
--ບວກ ເປີດໃຊ້ສະຕຣິງທົດແທນເພີ່ມເຕີມ: {+/} {+.} {+..} {+...} {..} {...} {/ ..}
{/...}. ຄວາມຄິດທີ່ວ່າ '{+foo}' ກົງກັນກັບ '{foo}' ແລະ {} =
{+/}/{/} = {.}.{+.} = {+/}/{/.}.{+.} = {..}.{+..} = {+/}/{/ ..}.{+..} =
{...}.{+...} = {+/}/{/...}.{+...}
- ແມ່ຍິງ
ສະແດງໃຫ້ເຫັນຄວາມຄືບຫນ້າຂອງການຄິດໄລ່. ລາຍຊື່ຄອມພິວເຕີທີ່ກ່ຽວຂ້ອງກັບວຽກງານທີ່ມີ
ກວດພົບຈໍານວນຂອງ CPU cores ແລະຈໍານວນສູງສຸດຂອງວຽກທີ່ຈະດໍາເນີນການ. ຫຼັງຈາກການສະແດງໃຫ້ເຫັນ
ຄວາມຄືບຫນ້າສໍາລັບຄອມພິວເຕີແຕ່ລະຄົນ: ຈໍານວນຂອງວຽກເຮັດງານທໍາ, ຈໍານວນວຽກເຮັດງານທໍາສໍາເລັດ, ແລະ
ເປີເຊັນຂອງວຽກທັງໝົດທີ່ເຮັດໂດຍຄອມພິວເຕີເຄື່ອງນີ້. ອັດຕາສ່ວນພຽງແຕ່ຈະເປັນ
ສາມາດໃຊ້ໄດ້ຫຼັງຈາກວຽກທັງໝົດໄດ້ຖືກກຳນົດເປັນ GNU ຂະຫນານ ພຽງແຕ່ອ່ານຕໍ່ໄປ
ວຽກເມື່ອພ້ອມທີ່ຈະຈັດຕາຕະລາງ - ນີ້ແມ່ນເພື່ອຫຼີກເວັ້ນການເສຍເວລາແລະຄວາມຊົງຈໍາໂດຍ
ອ່ານທຸກຢ່າງໃນຕອນເລີ່ມຕົ້ນ.
ໂດຍການສົ່ງ GNU ຂະຫນານ SIGUSR2 ທ່ານສາມາດສະຫຼັບການເປີດ / ປິດ - ແມ່ຍິງ ເທິງ
ແລ່ນ GNU ຂະຫນານ ຂະບວນການ.
ເບິ່ງ --eta.
--max-args=ສູງສຸດທີ່ເຄຍ
-n ສູງສຸດທີ່ເຄຍ
ໃຊ້ຫຼາຍທີ່ສຸດ ສູງສຸດທີ່ເຄຍ ການໂຕ້ຖຽງຕໍ່ແຖວຄໍາສັ່ງ. ໜ້ອຍກວ່າ ສູງສຸດທີ່ເຄຍ ກະທູ້ທີ່
ຈະຖືກນໍາໃຊ້ຖ້າຫາກວ່າຂະຫນາດ (ເບິ່ງ -s option) ແມ່ນເກີນ, ເວັ້ນເສຍແຕ່ວ່າ -x ທາງເລືອກແມ່ນ
ໃຫ້, ໃນກໍລະນີ GNU ຂະຫນານ ຈະອອກ.
-n 0 ຫມາຍຄວາມວ່າອ່ານຫນຶ່ງ argument, ແຕ່ໃສ່ 0 argument ໃນເສັ້ນຄໍາສັ່ງ.
ຫມາຍເຖິງ -X ເວັ້ນເສຍແຕ່ວ່າ -m ຖືກກໍານົດ.
--max-replace-args=ສູງສຸດທີ່ເຄຍ
-N ສູງສຸດທີ່ເຄຍ
ໃຊ້ຫຼາຍທີ່ສຸດ ສູງສຸດທີ່ເຄຍ ການໂຕ້ຖຽງຕໍ່ແຖວຄໍາສັ່ງ. ມັກ -n ແຕ່ຍັງເຮັດໃຫ້
ສາຍການທົດແທນ {1} .. {ສູງສຸດທີ່ເຄຍ} ທີ່ສະແດງເຖິງການໂຕ້ຖຽງ 1.. ສູງສຸດທີ່ເຄຍທີ່ຢູ່ ຖ້າຫາກວ່າ
args ຫນ້ອຍເກີນໄປ {n} ຈະຫວ່າງເປົ່າ.
-N 0 ຫມາຍຄວາມວ່າອ່ານຫນຶ່ງ argument, ແຕ່ໃສ່ 0 argument ໃນເສັ້ນຄໍາສັ່ງ.
ນີ້ຈະຕັ້ງເຈົ້າຂອງ homedir ເປັນຜູ້ໃຊ້:
tr ':' '\n' < / etc / passwd | ຂະຫນານ -N7 chown {1} {6}
ຫມາຍເຖິງ -X ເວັ້ນເສຍແຕ່ວ່າ -m or -- ທໍ່ ຖືກກໍານົດ.
ເມື່ອໃຊ້ກັບ -- ທໍ່ -N ແມ່ນຈໍານວນບັນທຶກທີ່ຈະອ່ານ. ນີ້ແມ່ນບາງຢ່າງ
ຊ້າກວ່າ -- ຕັນ.
--max-line-length-ອະນຸຍາດ
ພິມຈໍານວນຕົວອັກສອນສູງສຸດທີ່ອະນຸຍາດໃຫ້ຢູ່ໃນເສັ້ນຄໍາສັ່ງແລະອອກ (ໃຊ້
ໂດຍ GNU ຂະຫນານ ຕົວຂອງມັນເອງເພື່ອກໍານົດຄວາມຍາວຂອງສາຍໃນຄອມພິວເຕີຫ່າງໄກສອກຫຼີກ).
--number-of-cpu
ພິມຈໍານວນ CPU ຕົວຈິງແລະອອກ (ໃຊ້ໂດຍ GNU ຂະຫນານ ຕົວຂອງມັນເອງກັບ
ກໍານົດຈໍານວນຂອງ CPU ທາງດ້ານຮ່າງກາຍຢູ່ໃນຄອມພິວເຕີຫ່າງໄກສອກຫຼີກ).
--ຈໍານວນຂອງແກນ
ພິມຈໍານວນຂອງ CPU cores ແລະອອກ (ໃຊ້ໂດຍ GNU ຂະຫນານ ຕົວຂອງມັນເອງເພື່ອກໍານົດ
ຈໍານວນຂອງ CPU cores ໃນຄອມພິວເຕີຫ່າງໄກສອກຫຼີກ).
-- ບໍ່ມີແຈ້ງການ
ຢ່າສະແດງແຈ້ງການອ້າງອີງ. ແຈ້ງການອ້າງອິງແມ່ນພິມຢູ່ໃນ stderr (ມາດຕະຖານ
error) ພຽງແຕ່ຖ້າ stderr (ຄວາມຜິດພາດມາດຕະຖານ) ເປັນ terminal, ຜູ້ໃຊ້ບໍ່ໄດ້ກໍານົດ.
-- ບໍ່ມີແຈ້ງການ, ແລະຜູ້ໃຊ້ບໍ່ໄດ້ດໍາເນີນການ --bibtex ຄັ້ງຫນຶ່ງ.
--ງາມ ຄວາມງາມ
ດໍາເນີນການຄໍາສັ່ງຢູ່ທີ່ງາມນີ້. ສໍາລັບຄໍາສັ່ງງ່າຍດາຍທ່ານພຽງແຕ່ສາມາດເພີ່ມ ງາມ in
ທາງຫນ້າຂອງຄໍາສັ່ງ. ແຕ່ຖ້າຄໍາສັ່ງປະກອບດ້ວຍຄໍາສັ່ງຍ່ອຍຫຼາຍ (ເຊັ່ນ:
ls|wc) ຫຼັງຈາກນັ້ນ, prepending ງາມ ຈະບໍ່ເຮັດວຽກສະ ເໝີ ໄປ. --ງາມ ຈະເຮັດໃຫ້ແນ່ໃຈວ່າຍ່ອຍທັງຫມົດ
ຄໍາສັ່ງແມ່ນງາມ.
--ໂຕ້ຕອບ
-p ເຕືອນຜູ້ໃຊ້ກ່ຽວກັບວ່າຈະດໍາເນີນການແຕ່ລະເສັ້ນຄໍາສັ່ງແລະອ່ານເສັ້ນຈາກ
ສະຖານີ. ພຽງແຕ່ແລ່ນເສັ້ນຄໍາສັ່ງຖ້າຄໍາຕອບເລີ່ມຕົ້ນດ້ວຍ 'y' ຫຼື 'Y'.
ຫມາຍເຖິງ -t.
--parens ວົງເລັບ
ໃຊ້ເພື່ອກຳນົດການເລີ່ມຕົ້ນ ແລະສິ້ນສຸດວົງເລັບສຳລັບ {= perl ການສະແດງອອກ =}. ຊ້າຍ ແລະ
ວົງເລັບທີ່ຖືກຕ້ອງສາມາດເປັນຕົວອັກສອນຫຼາຍຕົວ ແລະສົມມຸດວ່າຄືກັນ
ຄວາມຍາວ. ຄ່າເລີ່ມຕົ້ນແມ່ນ {==} ໃຫ້ {= ເປັນວົງເລັບເລີ່ມຕົ້ນ ແລະ =} ໃນຕອນທ້າຍ
ວົງເລັບ.
ການຕັ້ງຄ່າທີ່ເປັນປະໂຫຍດອີກອັນຫນຶ່ງແມ່ນ ,,,, ເຊິ່ງຈະເຮັດໃຫ້ທັງສອງວົງເລັບ ,,:
ຂະຫນານ --parens ,,,, echo foo ແມ່ນ ,,s/I/O/g,, ::: FII
ເບິ່ງເພີ່ມເຕີມ: --rpl {= perl ການສະແດງອອກ =}
--ໂປຣໄຟລ໌ ຊື່ໂປຣໄຟລ໌
-J ຊື່ໂປຣໄຟລ໌
ໃຊ້ໂປຣໄຟລ໌ ຊື່ໂປຣໄຟລ໌ ສໍາລັບທາງເລືອກ. ນີ້ແມ່ນເປັນປະໂຫຍດຖ້າຫາກວ່າທ່ານຕ້ອງການທີ່ຈະມີຫຼາຍ
ໂປຣໄຟລ໌. ທ່ານສາມາດມີຫນຶ່ງ profile ສໍາລັບການເຮັດວຽກໃນຂະຫນານໃນທ້ອງຖິ່ນ
ຄອມພິວເຕີແລະຂໍ້ມູນທີ່ແຕກຕ່າງກັນສໍາລັບການເຮັດວຽກໃນຄອມພິວເຕີທາງໄກ. ເບິ່ງ
ພາກສ່ວນ PROFILE FILES ສໍາລັບຕົວຢ່າງ.
ຊື່ໂປຣໄຟລ໌ ສອດຄ້ອງກັບໄຟລ໌ ~/.ຂະໜານ/ຊື່ໂປຣໄຟລ໌.
ທ່ານສາມາດໃຫ້ຫຼາຍໂປຣໄຟລ໌ໂດຍການເຮັດຊ້ຳ --ໂປຣໄຟລ໌. ຖ້າຫາກວ່າພາກສ່ວນຂອງໂປຣໄຟລ໌
ຂໍ້ຂັດແຍ່ງ, ຕໍ່ມາຈະຖືກນໍາໃຊ້.
ຄ່າເລີ່ມຕົ້ນ: config
--quote
-q ອ້າງ ຄໍາສັ່ງ. ນີ້ຈະອ້າງເຖິງເສັ້ນຄໍາສັ່ງດັ່ງນັ້ນຕົວອັກສອນພິເສດບໍ່ແມ່ນ
ຕີຄວາມຫມາຍໂດຍແກະ. ເບິ່ງພາກ QUOTING. ຄົນສ່ວນໃຫຍ່ຈະບໍ່ຕ້ອງການ
ນີ້. ການອ້າງອີງຖືກປິດການນຳໃຊ້ໂດຍຄ່າເລີ່ມຕົ້ນ.
--no-run-if-empty
-r ຖ້າ stdin (ວັດສະດຸປ້ອນມາດຕະຖານ) ພຽງແຕ່ມີຊ່ອງຫວ່າງ, ຢ່າດໍາເນີນການຄໍາສັ່ງ.
ຖ້າໃຊ້ກັບ -- ທໍ່ ນີ້ແມ່ນຊ້າ.
--noswap ຢ່າເລີ່ມວຽກໃໝ່ໃນຄອມພິວເຕີທີ່ໃຫ້ມາ ຖ້າມີທັງ swap-in ແລະ swap-out
ກິດຈະກໍາ.
ກິດຈະກໍາ swap ແມ່ນພຽງແຕ່ຕົວຢ່າງທຸກໆ 10 ວິນາທີຍ້ອນວ່າການເກັບຕົວຢ່າງໃຊ້ເວລາ 1 ວິນາທີ
ເພື່ອເຮັດແນວໃດ.
ກິດຈະກໍາການແລກປ່ຽນແມ່ນຄໍານວນເປັນ (swap-in) * ( swap-out) ຊຶ່ງໃນການປະຕິບັດແມ່ນດີ.
value: swapping out ບໍ່ແມ່ນບັນຫາ, swapping in ບໍ່ແມ່ນບັນຫາ, ແຕ່ທັງສອງ
ການ swapping ເຂົ້າແລະອອກປົກກະຕິແລ້ວຊີ້ໃຫ້ເຫັນບັນຫາ.
--record-env
ບັນທຶກຕົວແປສະພາບແວດລ້ອມໃນປະຈຸບັນໃນ ~/.parallel/ignored_vars. ນີ້ແມ່ນເປັນປະໂຫຍດ
ກ່ອນທີ່ຈະນໍາໃຊ້ --env _.
ເບິ່ງ --env.
--ເລີ່ມໃໝ່ ສາຍເລີ່ມຕົ້ນ
--recend ສາຍທ້າຍ
If --ເລີ່ມໃໝ່ ແມ່ນໃຫ້ ສາຍເລີ່ມຕົ້ນ ຈະຖືກໃຊ້ເພື່ອແຍກໃນຕອນເລີ່ມຕົ້ນບັນທຶກ.
If --recend ແມ່ນໃຫ້ ສາຍທ້າຍ ຈະຖືກໃຊ້ເພື່ອແຍກໃນຕອນທ້າຍບັນທຶກ.
ຖ້າທັງສອງ --ເລີ່ມໃໝ່ ແລະ --recend ແມ່ນໄດ້ຮັບສາຍພັນລວມ
endstringstartstring ຈະມີການຈັບຄູ່ເພື່ອຊອກຫາຕໍາແຫນ່ງແບ່ງແຍກ. ນີ້ແມ່ນເປັນປະໂຫຍດ
ຖ້າຢ່າງນັ້ນ ສາຍເລີ່ມຕົ້ນ or ສາຍທ້າຍ ແຂ່ງຂັນຢູ່ເຄິ່ງກາງຂອງບັນທຶກ.
ຖ້າບໍ່ --ເລີ່ມໃໝ່ neither --recend ແມ່ນໃຫ້ຫຼັງຈາກນັ້ນ --recend ເລີ່ມຕົ້ນເປັນ '\n'. ເຖິງ
ບໍ່ມີບັນທຶກການນໍາໃຊ້ຕົວແຍກ --recend "".
--ເລີ່ມໃໝ່ ແລະ --recend ຖືກນໍາໃຊ້ກັບ -- ທໍ່.
ການນໍາໃຊ້ --regexp ແປ --ເລີ່ມໃໝ່ ແລະ --recend ເປັນການສະແດງອອກປົກກະຕິ. ນີ້ແມ່ນ
ຊ້າ, ຢ່າງໃດກໍຕາມ.
--regexp ການນໍາໃຊ້ --regexp ແປ --ເລີ່ມໃໝ່ ແລະ --recend ເປັນການສະແດງອອກປົກກະຕິ. ນີ້ແມ່ນ
ຊ້າ, ຢ່າງໃດກໍຕາມ.
--remove-rec-sep
--removerecsep
--rrs ເອົາຂໍ້ຄວາມທີ່ກົງກັບ --ເລີ່ມໃໝ່ ແລະ --recend ກ່ອນທີ່ຈະທໍ່ມັນ
ຄໍາສັ່ງ.
ໃຊ້ກັບ -- ທໍ່.
-- ຜົນໄດ້ຮັບ ຄຳ ນຳ ໜ້າ
--res ຄຳ ນຳ ໜ້າ
ບັນທຶກຜົນຜະລິດເຂົ້າໄປໃນໄຟລ໌. ໄຟລ໌ຈະໄດ້ຮັບການເກັບຮັກສາໄວ້ໃນຕົ້ນໄມ້ລະບົບການຮາກຖານ
at ຄຳ ນຳ ໜ້າ. ພາຍໃນຕົ້ນໄມ້ໄດເລກະທໍລີນີ້, ແຕ່ລະຄໍາສັ່ງຈະສົ່ງຜົນໃຫ້ສອງໄຟລ໌:
ຄຳ ນຳ ໜ້າ/ /stdout ແລະ ຄຳ ນຳ ໜ້າ/ /stderr, ບ່ອນທີ່ ແມ່ນລໍາດັບຂອງ
ໄດເລກະທໍລີທີ່ເປັນຕົວແທນຂອງຫົວຂອງແຫຼ່ງປ້ອນຂໍ້ມູນ (ຖ້າໃຊ້ --ຫົວ :) ຫຼື
ຈໍານວນຂອງແຫຼ່ງຂໍ້ມູນແລະຄ່າທີ່ສອດຄ້ອງກັນ.
Eg:
parallel --header : --results foo echo {a} {b} ::: a I II ::: b III IIII
ຈະສ້າງໄຟລ໌:
foo/a/I/b/III/stderr
foo/a/I/b/III/stdout
foo/a/I/b/IIII/stderr
foo/a/I/b/IIII/stdout
foo/a/II/b/III/stderr
foo/a/II/b/III/stdout
foo/a/II/b/IIII/stderr
foo/a/II/b/IIII/stdout
ແລະ
parallel --results foo echo {1} {2} ::: I II ::: III IIII
ຈະສ້າງໄຟລ໌:
foo/1/I/2/III/stderr
foo/1/I/2/III/stdout
foo/1/I/2/IIII/stderr
foo/1/I/2/IIII/stdout
foo/1/II/2/III/stderr
foo/1/II/2/III/stdout
foo/1/II/2/IIII/stderr
foo/1/II/2/IIII/stdout
ເບິ່ງ --ໄຟລ໌, --ຫົວ, --joblog.
-- ຊີວະປະຫວັດຫຍໍ້ ສືບຕໍ່ຈາກວຽກທີ່ຍັງບໍ່ແລ້ວສຸດທ້າຍ. ໂດຍການອ່ານ --joblog ຫຼື -- ຜົນໄດ້ຮັບ dir
GNU ຂະຫນານ ຈະຄິດອອກວຽກທີ່ຍັງບໍ່ໄດ້ສໍາເລັດສຸດທ້າຍແລະສືບຕໍ່ຈາກນັ້ນ. ເປັນ
GNU ຂະຫນານ ພຽງແຕ່ເບິ່ງຕົວເລກລໍາດັບໃນ --joblog ຫຼັງຈາກນັ້ນ, ການປ້ອນຂໍ້ມູນ, ໄດ້
ຄໍາສັ່ງ, ແລະ --joblog ທັງຫມົດຕ້ອງບໍ່ມີການປ່ຽນແປງ; ຖ້າບໍ່ດັ່ງນັ້ນ GNU ຂະຫນານ ອາດຈະ
ດໍາເນີນການຄໍາສັ່ງທີ່ບໍ່ຖືກຕ້ອງ.
ເບິ່ງ --joblog, -- ຜົນໄດ້ຮັບ, --resume-ລົ້ມເຫລວ.
--resume-ລົ້ມເຫລວ
ລອງເຮັດໃໝ່ທັງໝົດທີ່ລົ້ມເຫລວ ແລະສືບຕໍ່ຈາກວຽກທີ່ຍັງບໍ່ແລ້ວສຸດທ້າຍ. ໂດຍການອ່ານ --joblog GNU
ຂະຫນານ ຈະຄິດອອກວຽກທີ່ລົ້ມເຫລວແລະດໍາເນີນການອີກເທື່ອຫນຶ່ງ. ຫຼັງຈາກນັ້ນມັນຈະ
ສືບຕໍ່ວຽກທີ່ຍັງບໍ່ແລ້ວສຸດທ້າຍແລະສືບຕໍ່ຈາກບ່ອນນັ້ນ. ເປັນ GNU ຂະຫນານ ພຽງແຕ່ເບິ່ງ
ຕົວເລກລໍາດັບໃນ --joblog ຫຼັງຈາກນັ້ນ, ການປ້ອນຂໍ້ມູນ, ຄໍາສັ່ງ, ແລະ --joblog ທັງຫມົດ
ຕ້ອງຍັງຄົງບໍ່ປ່ຽນແປງ; ຖ້າບໍ່ດັ່ງນັ້ນ GNU ຂະຫນານ ອາດຈະດໍາເນີນການຄໍາສັ່ງທີ່ບໍ່ຖືກຕ້ອງ.
ເບິ່ງ --joblog, -- ຊີວະປະຫວັດຫຍໍ້.
-- ພະຍາຍາມໃໝ່ n
ຖ້າວຽກລົ້ມເຫລວ, ລອງມັນໃໝ່ໃນຄອມພິວເຕີເຄື່ອງອື່ນທີ່ມັນບໍ່ລົ້ມເຫລວ. ເຮັດອັນນີ້
n ເທື່ອ. ຖ້າມີໜ້ອຍກວ່າ n ຄອມພິວເຕີໃນ --sshlogin GNU ຂະຫນານ ຈະຄືນໃ່
ໃຊ້ຄອມພິວເຕີທັງໝົດ. ນີ້ເປັນປະໂຫຍດຖ້າບາງວຽກລົ້ມເຫລວໂດຍບໍ່ມີເຫດຜົນທີ່ຊັດເຈນ
(ເຊັ່ນ: ຄວາມລົ້ມເຫຼວຂອງເຄືອຂ່າຍ).
--ກັບຄືນ ຊື່ເອກະສານ
ໂອນໄຟລ໌ຈາກຄອມພິວເຕີໄລຍະໄກ. --ກັບຄືນ ຖືກນໍາໃຊ້ກັບ --sshlogin ໃນເວລາທີ່
arguments ແມ່ນໄຟລ໌ຢູ່ໃນຄອມພິວເຕີທາງໄກ. ໃນເວລາທີ່ການປຸງແຕ່ງແມ່ນເຮັດໄດ້ໄຟລ໌
ຊື່ເອກະສານ ຈະຖືກໂອນຈາກຄອມພິວເຕີທາງໄກໂດຍໃຊ້ rsync ແລະຈະຖືກວາງໄວ້
ກ່ຽວຂ້ອງກັບການເຂົ້າສູ່ລະບົບເລີ່ມຕົ້ນ dir. ຕົວຢ່າງ
echo foo/bar.txt | ຂະຫນານ \
--sshlogin server.example.com --return {.}.out ແຕະ {.}.out
ນີ້ຈະໂອນໄຟລ໌ $HOME/foo/bar.out ຈາກຄອມພິວເຕີ
server.example.com ກັບໄຟລ໌ foo/bar.out ຫຼັງຈາກແລ່ນ ສໍາຜັດ foo/bar.out on
server.example.com.
echo /tmp/foo/bar.txt | ຂະຫນານ \
--sshlogin server.example.com --return {.}.out ແຕະ {.}.out
ນີ້ຈະໂອນໄຟລ໌ /tmp/foo/bar.out ຈາກຄອມພິວເຕີ server.example.com
ກັບໄຟລ໌ /tmp/foo/bar.out ຫຼັງຈາກແລ່ນ ສໍາຜັດ /tmp/foo/bar.out on
server.example.com.
ໄຟລ໌ຫຼາຍໄຟລ໌ສາມາດຖືກໂອນໂດຍການເຮັດຊ້ໍາທາງເລືອກຫຼາຍຄັ້ງ:
echo /tmp/foo/bar.txt | \
ຂະຫນານ --sshlogin server.example.com \
--return {.}.out --return {.}.out2 ແຕະ {.}.out {.}.out2
--ກັບຄືນ ມັກໃຊ້ກັບ --ໂອນ ແລະ --ທໍາຄວາມສະອາດ.
--ກັບຄືນ ຖືກລະເລີຍເມື່ອໃຊ້ກັບ --sshlogin : ຫຼືໃນເວລາທີ່ບໍ່ໄດ້ນໍາໃຊ້ກັບ --sshlogin.
--ຮອບ-ໂຣບິນ
--ຮອບ ປົກກະຕິແລ້ວ -- ທໍ່ ຈະໃຫ້ຕັນດຽວກັບແຕ່ລະຕົວຢ່າງຂອງຄໍາສັ່ງ. ກັບ
--ຮອບ-ໂຣບິນ ບລັອກທັງໝົດຈະຖືກຂຽນແບບສຸ່ມໃສ່ຄຳສັ່ງທີ່ເຮັດວຽກແລ້ວ.
ນີ້ແມ່ນເປັນປະໂຫຍດຖ້າຄໍາສັ່ງໃຊ້ເວລາດົນໃນການເລີ່ມຕົ້ນ.
-- ຮັກສາຄໍາສັ່ງ ຈະບໍ່ເຮັດວຽກກັບ --ຮອບ-ໂຣບິນ ເນື່ອງຈາກວ່າມັນເປັນໄປບໍ່ໄດ້ທີ່ຈະຕິດຕາມອັນໃດ
ຕັນ input ກົງກັບຜົນຜະລິດໃດ.
--rpl 'ໂຄດຄໍາສັ່ງ perl ການສະແດງອອກ'
ການນໍາໃຊ້ ໂຄດຄໍາສັ່ງ ເປັນ string ທົດແທນສໍາລັບ perl ການສະແດງອອກ. ນີ້ເຮັດໃຫ້ມັນເປັນໄປໄດ້
ກໍານົດສາຍການທົດແທນຂອງທ່ານເອງ. GNU ຂະຫນານ's 7 ສາຍທົດແທນແມ່ນ
ປະຕິບັດເປັນ:
--rpl '{} '
--rpl '{#} 1 $_=$job->seq()'
--rpl '{%} 1 $_=$job->slot()'
--rpl '{/} s:.*/::'
--rpl '{//} $Global::use{"File::Basename"} ||= eval "ໃຊ້ File::Basename; 1;"; $_ = dirname($_);'
--rpl '{/.} s:.*/:: ; s:\.[^/.]+$::;'
--rpl '{.} s:\.[^/.]+$::'
ຖ້າຜູ້ໃຊ້ກໍານົດການທົດແທນທີ່ເລີ່ມຕົ້ນດ້ວຍ '{' ມັນຍັງສາມາດຖືກນໍາໃຊ້ເປັນ a
ສະຕຣິງປ່ຽນຕຳແໜ່ງ (ເຊັ່ນ {2.}).
ມັນແນະນໍາໃຫ້ປ່ຽນພຽງແຕ່ $_ ແຕ່ທ່ານມີການເຂົ້າເຖິງ GNU ທັງຫມົດ
ຂະຫນານຫນ້າທີ່ພາຍໃນແລະໂຄງສ້າງຂໍ້ມູນ.
ຕໍ່ໄປນີ້ແມ່ນຕົວຢ່າງຫນຶ່ງ:
ເອົາ 2 ສ່ວນຂະຫຍາຍອອກ (ເຊັ່ນ: .tar.gz)
--rpl '{..} s:\.[^/.]+$::;s:\.[^/.]+$::;'
ຮັກສາພຽງແຕ່ການຂະຫຍາຍ
--rpl '{ext} s:.*\.::'
ລຳດັບວຽກແມ່ນຄູ່ ຫຼື ຄີກ?
--rpl '{odd} $_=$job->seq()%2?"odd":"even"'
ເບິ່ງເພີ່ມເຕີມ: {= perl ການສະແດງອອກ =} --parens
--max-chars=ສູງສຸດທີ່ເຄຍ
-s ສູງສຸດທີ່ເຄຍ
ໃຊ້ຫຼາຍທີ່ສຸດ ສູງສຸດທີ່ເຄຍ ຕົວອັກສອນຕໍ່ແຖວຄໍາສັ່ງ, ລວມທັງຄໍາສັ່ງແລະ
initial-arguments ແລະ terminating nulls ຢູ່ທ້າຍຂອງ argument strings.
ມູນຄ່າທີ່ໃຫຍ່ທີ່ສຸດທີ່ອະນຸຍາດແມ່ນຂຶ້ນກັບລະບົບ, ແລະຖືກຄິດໄລ່ເປັນ argument
ຂີດຈຳກັດຄວາມຍາວສຳລັບ exec, ຂະໜາດຂອງສະພາບແວດລ້ອມຂອງເຈົ້າໜ້ອຍລົງ. ຄ່າເລີ່ມຕົ້ນແມ່ນ
ສູງສຸດ.
ຫມາຍເຖິງ -X ເວັ້ນເສຍແຕ່ວ່າ -m ຖືກກໍານົດ.
--show-ຈໍາກັດ
ສະແດງຂໍ້ຈໍາກັດກ່ຽວກັບຄວາມຍາວເສັ້ນຄໍາສັ່ງທີ່ກໍານົດໂດຍການປະຕິບັດການ
ລະບົບແລະ -s ທາງເລືອກ. ທໍ່ການປ້ອນຂໍ້ມູນຈາກ /dev/null (ແລະບາງທີອາດຈະລະບຸ
--no-run-if-empty) ຖ້າເຈົ້າບໍ່ຕ້ອງການ GNU ຂະຫນານ ເຮັດຫຍັງ.
--semaphore
ເຮັດວຽກເປັນ semaphore ການນັບ. --semaphore ຈະເຮັດໃຫ້ເກີດ GNU ຂະຫນານ ເພື່ອເລີ່ມຕົ້ນ
ຄໍາສັ່ງ ໃນພື້ນຫລັງ. ເມື່ອຈໍານວນວຽກພ້ອມໆກັນໄດ້ບັນລຸ, GNU
ຂະຫນານ ຈະລໍຖ້າອັນໃດອັນໜຶ່ງອັນນີ້ໃຫ້ສຳເລັດກ່ອນທີ່ຈະເລີ່ມຄຳສັ່ງອື່ນ.
--semaphore implies --bg ເວັ້ນເສຍແຕ່ວ່າ --fg ຖືກກໍານົດ.
--semaphore implies --semaphorename `tty` ເວັ້ນເສຍແຕ່ວ່າ --semaphorename ຖືກກໍານົດ.
ໃຊ້ກັບ --fg, --ລໍຖ້າ, ແລະ --semaphorename.
ຄໍາສັ່ງ sem ແມ່ນນາມແforງຂອງ ຂະຫນານ --semaphore.
ເບິ່ງ ຜູ້ຊາຍ sem.
--semaphorename ຊື່
--id ຊື່
ການນໍາໃຊ້ ຊື່ ເປັນຊື່ຂອງ semaphore ໄດ້. ຄ່າເລີ່ມຕົ້ນແມ່ນຊື່ຂອງ tty ຄວບຄຸມ
(ຜົນຜະລິດຈາກ tty).
ຄ່າເລີ່ມຕົ້ນປົກກະຕິເຮັດວຽກຕາມທີ່ຄາດໄວ້ເມື່ອໃຊ້ແບບໂຕ້ຕອບ, ແຕ່ເມື່ອໃຊ້ໃນ
ບົດຂຽນ ຊື່ ຄວນຈະຖືກກໍານົດ. $$ or my_task_name ມັກຈະເປັນມູນຄ່າທີ່ດີ.
semaphore ຖືກເກັບໄວ້ໃນ ~/.parallel/semaphores/
ຫມາຍເຖິງ --semaphore.
ເບິ່ງ ຜູ້ຊາຍ sem.
--semaphoretimeout ແຫ້ງ
ຖ້າ semaphore ບໍ່ໄດ້ຖືກປ່ອຍອອກມາພາຍໃນວິນາທີ, ເອົາມັນໄປ.
ຫມາຍເຖິງ --semaphore.
ເບິ່ງ ຜູ້ຊາຍ sem.
--seqreplace ທົດແທນ-str
ໃຊ້ສະຕຣິງທົດແທນ ທົດແທນ-str ແທນທີ່ {#} ສໍາລັບຕົວເລກລໍາດັບວຽກ.
--shebang
--hashbang
GNU ຂະຫນານ ສາມາດເອີ້ນວ່າເປັນຄໍາສັ່ງ shebang (#!) ເປັນແຖວທໍາອິດຂອງ a
ສະຄຣິບ. ເນື້ອໃນຂອງໄຟລ໌ຈະຖືກປະຕິບັດເປັນແຫຼ່ງປ້ອນຂໍ້ມູນ.
ເຊັ່ນດຽວກັນນີ້:
#!/usr/bin/parallel --shebang -r traceroute
foss.org.my
debian.org
freenetproject.org
--shebang ຕ້ອງຕັ້ງເປັນທາງເລືອກທໍາອິດ.
ໃນ FreeBSD ປະມານ ຈໍາເປັນ:
#!/usr/bin/env -S ຂະຫນານ --shebang -r traceroute
foss.org.my
debian.org
freenetproject.org
--shebang-ຫໍ່
GNU ຂະຫນານ ສາມາດຂະໜານຕົວໜັງສືໂດຍການຫໍ່ເສັ້ນ shebang. ຖ້າໂຄງການ
ສາມາດດໍາເນີນການດັ່ງນີ້:
cat ການໂຕ້ຖຽງ | ຂະຫນານ the_program
ຫຼັງຈາກນັ້ນ, script ສາມາດຖືກປ່ຽນເປັນ:
#!/usr/bin/parallel --shebang-wrap /the/original/parser --with-options
ຕົວຢ່າງ
#!/usr/bin/parallel --shebang-wrap /usr/bin/python
ຖ້າຫາກວ່າໂຄງການສາມາດດໍາເນີນການດັ່ງນີ້:
ຂໍ້ມູນແມວ | ຂະຫນານ --pipe the_program
ຫຼັງຈາກນັ້ນ, script ສາມາດຖືກປ່ຽນເປັນ:
#!/usr/bin/parallel --shebang-wrap --pipe /the/original/parser --with-options
ຕົວຢ່າງ
#!/usr/bin/parallel --shebang-wrap --pipe /usr/bin/perl -w
--shebang-ຫໍ່ ຕ້ອງຕັ້ງເປັນທາງເລືອກທໍາອິດ.
--shellquote
ບໍ່ໄດ້ດໍາເນີນການຄໍາສັ່ງແຕ່ quotes ມັນ. ເປັນປະໂຫຍດສໍາລັບການເຮັດໃຫ້ຄໍາເວົ້າທີ່ປະກອບ
ຄໍາສັ່ງສໍາລັບ GNU ຂະຫນານ.
--skip-first-line
ຫ້າມໃຊ້ແຖວທຳອິດຂອງການປ້ອນຂໍ້ມູນ (ໃຊ້ໂດຍ GNU ຂະຫນານ ຕົວຂອງມັນເອງໃນເວລາທີ່ເອີ້ນວ່າ
--shebang).
--sshdelay ແຫ້ງ
ຊັກຊ້າເລີ່ມຕົ້ນ ssh ຕໍ່ໄປໂດຍ ແຫ້ງ ວິນາທີ. GNU ຂະຫນານ ຈະຢຸດຊົ່ວຄາວ ແຫ້ງ ວິນາທີ
ຫຼັງຈາກເລີ່ມແຕ່ລະ ssh. ແຫ້ງ ສາມາດໜ້ອຍກວ່າ 1 ວິນາທີ.
-S [ncpu/]sshlogin[,[ncpu/]sshlogin[,...]]
--sshlogin [ncpu/]sshlogin[,[ncpu/]sshlogin[,...]]
ແຈກຢາຍວຽກໃຫ້ຄອມພິວເຕີທາງໄກ. ວຽກຈະດໍາເນີນການຢູ່ໃນບັນຊີລາຍຊື່ຂອງໄລຍະໄກ
ຄອມພິວເຕີ. GNU ຂະຫນານ ຈະກໍານົດຈໍານວນຂອງ CPU cores ຢູ່ໃນໄລຍະໄກ
ຄອມພິວເຕີແລະດໍາເນີນການຈໍານວນຂອງວຽກເຮັດງານທໍາທີ່ລະບຸໄວ້ໂດຍ -j. ຖ້າຈໍານວນ ncpu is
ມອບໃຫ້ GNU ຂະຫນານ ຈະໃຊ້ຕົວເລກນີ້ສໍາລັບຈໍານວນຂອງ CPU cores ໃນ host.
ປົກກະຕິແລ້ວ ncpu ຈະບໍ່ຈໍາເປັນ.
An sshlogin ມີຮູບແບບ:
[sshcommand [ທາງເລືອກ]] [username@]hostname
sshlogin ຕ້ອງບໍ່ຕ້ອງການລະຫັດຜ່ານ.
sshlogin ':' ແມ່ນພິເສດ, ມັນຫມາຍຄວາມວ່າ 'ບໍ່ມີ ssh' ແລະດັ່ງນັ້ນຈຶ່ງຈະດໍາເນີນການຢູ່ໃນ
ຄອມພິວເຕີທ້ອງຖິ່ນ.
sshlogin '..' ແມ່ນພິເສດ, ມັນອ່ານ sshlogins ຈາກ ~/.parallel/sshloginfile
sshlogin '-' ແມ່ນພິເສດ, ເຊັ່ນດຽວກັນ, ມັນອ່ານ sshlogins ຈາກ stdin (ວັດສະດຸປ້ອນມາດຕະຖານ).
ເພື່ອລະບຸ sshlogins ເພີ່ມເຕີມໃຫ້ແຍກ sshlogins ໂດຍເຄື່ອງໝາຍຈຸດ ຫຼືເຮັດຊ້ຳຕົວເລືອກ
ຫຼາຍຄັ້ງ.
ຕົວຢ່າງ: ເບິ່ງ --sshloginfile.
ໂຮສທາງໄກຕ້ອງມີ GNU ຂະຫນານ ຕິດຕັ້ງ.
--sshlogin ເປັນທີ່ຮູ້ຈັກທີ່ຈະເຮັດໃຫ້ເກີດບັນຫາກັບ -m ແລະ -X.
--sshlogin ມັກໃຊ້ກັບ --ໂອນ, --ກັບຄືນ, --ທໍາຄວາມສະອາດ, ແລະ --trc.
--sshloginfile ຊື່ເອກະສານ (ການທົດສອບເບຕ້າ)
--slf ຊື່ເອກະສານ (ການທົດສອບເບຕ້າ)
ໄຟລ໌ທີ່ມີ sshlogins. ໄຟລ໌ປະກອບດ້ວຍ sshlogins ໃນແຖວແຍກຕ່າງຫາກ. ຫວ່າງເປົ່າ
ເສັ້ນ ແລະ ແຖວທີ່ເລີ່ມຕົ້ນດ້ວຍ '#' ແມ່ນຖືກລະເລີຍ. ຕົວຢ່າງ:
server.example.com
[email protected]
8/my-8-core-server.example.com
2/[email protected]
# ເຊີບເວີນີ້ມີ SSH ແລ່ນຢູ່ໃນພອດ 2222
ssh -p 2222 server.example.net
4/ssh -p 2222 quadserver.example.net
# ໃຊ້ໂປຣແກຣມ ssh ອື່ນ
myssh -p 2222 -l myusername hexacpu.example.net
# ໃຊ້ໂປຣແກມ ssh ທີ່ແຕກຕ່າງກັນກັບຈຳນວນຫຼັກເລີ່ມຕົ້ນ
//usr/local/bin/myssh -p 2222 -l myusername hexacpu.example.net
# ໃຊ້ໂປແກຼມ ssh ທີ່ແຕກຕ່າງກັນທີ່ມີ 6 cores
6//usr/local/bin/myssh -p 2222 -l myusername hexacpu.example.net
# ສົມມຸດ 16 cores ໃນຄອມພິວເຕີທ້ອງຖິ່ນ
16/:
ເມື່ອໃຊ້ໂປແກຼມ ssh ອື່ນ, ການໂຕ້ຖຽງສຸດທ້າຍຕ້ອງເປັນ hostname.
ຫຼາຍ --sshloginfile ຖືກອະນຸຍາດ.
GNU ຂະຫນານ ທໍາອິດຈະຊອກຫາໄຟລ໌ໃນ dir ໃນປັດຈຸບັນ; ຖ້າມັນລົ້ມເຫລວມັນເບິ່ງ
ສໍາລັບໄຟລ໌ໃນ ~/.ຂະໜານ.
sshloginfile '..' ແມ່ນພິເສດ, ມັນອ່ານ sshlogins ຈາກ ~/.parallel/sshloginfile
sshloginfile '.' ແມ່ນພິເສດ, ມັນອ່ານ sshlogins ຈາກ
/etc/parallel/sshloginfile
sshloginfile '-' ແມ່ນພິເສດ, ມັນອ່ານ sshlogins ຈາກ stdin (ມາດຕະຖານ.
ວັດສະດຸປ້ອນ).
ຖ້າ sshloginfile ຖືກປ່ຽນມັນຈະຖືກອ່ານຄືນເມື່ອວຽກສໍາເລັດເຖິງແມ່ນວ່າຢູ່ທີ່
ຫຼາຍທີ່ສຸດຄັ້ງຕໍ່ວິນາທີ. ນີ້ເຮັດໃຫ້ມັນເປັນໄປໄດ້ທີ່ຈະເພີ່ມແລະເອົາ hosts ໃນຂະນະທີ່
ແລ່ນ.
ນີ້ສາມາດຖືກນໍາໃຊ້ເພື່ອໃຫ້ມີ daemon ທີ່ປັບປຸງ sshloginfile ໃຫ້ມີພຽງແຕ່
ເຊີບເວີທີ່ຂຶ້ນ:
cp original.slf tmp2.slf
ໃນຂະນະທີ່ [1] ; ເຮັດ
ງາມຂະໜານ --nonall -j0 -k --slf original.slf --tag echo | perl 's/\t$//' > tmp.slf
ຖ້າຄວາມແຕກຕ່າງ tmp.slf tmp2.slf; ແລ້ວ
mv tmp.slf tmp2.slf
fi
ນອນ 10
ສຳເລັດແລ້ວ &
ຂະຫນານ --slf tmp2.slf ...
--slotreplace ທົດແທນ-str
ໃຊ້ສະຕຣິງທົດແທນ ທົດແທນ-str ແທນທີ່ {%} ສໍາລັບຈໍານວນບ່ອນເຮັດວຽກ.
--ງຽບ ງຽບ. ວຽກທີ່ຈະດໍາເນີນການຈະບໍ່ຖືກພິມອອກ. ນີ້ແມ່ນຄ່າເລີ່ມຕົ້ນ. ສາມາດເປັນ
ປີ້ນກັບ -v.
--tty ເປີດ terminal tty. ຖ້າ GNU ຂະຫນານ ຖືກນໍາໃຊ້ສໍາລັບການເລີ່ມຕົ້ນໂຄງການແບບໂຕ້ຕອບ
ຫຼັງຈາກນັ້ນ, ທາງເລືອກນີ້ອາດຈະຕ້ອງການ. ມັນຈະເລີ່ມຕົ້ນພຽງແຕ່ຫນຶ່ງວຽກເຮັດງານທໍາທີ່ໃຊ້ເວລາ (ie -j1),
ບໍ່ buffer ຜົນຜະລິດ (ie -u), ແລະມັນຈະເປີດ tty ສໍາລັບວຽກເຮັດງານທໍາ. ເມື່ອວຽກ
ແມ່ນແລ້ວ, ວຽກຕໍ່ໄປຈະໄດ້ຮັບ tty ໄດ້.
--tag ແທັກແຖວທີ່ມີການໂຕ້ຖຽງ. ແຕ່ລະເສັ້ນຜົນຜະລິດຈະຖືກນຳໜ້າດ້ວຍການໂຕ້ແຍ້ງ
ແລະ TAB (\t). ເມື່ອລວມເຂົ້າກັບ --onall or --nonall ສາຍຈະຖືກ prepended
ດ້ວຍ sshlogin ແທນ.
--tag ຖືກລະເລີຍໃນເວລາໃຊ້ -u.
--tagstring str
ແທັກແຖວດ້ວຍສະຕຣິງ. ແຕ່ລະເສັ້ນຜົນຜະລິດຈະຖືກນໍາມາດ້ວຍ str ແລະ TAB
(\t). str ສາມາດມີສະຕຣິງທົດແທນເຊັ່ນ {}.
--tagstring ຖືກລະເລີຍໃນເວລາໃຊ້ -u, --onall, ແລະ --nonall.
--tmpdir ນາມສະກຸນ
ໄດເລກະທໍລີສໍາລັບໄຟລ໌ຊົ່ວຄາວ. GNU ຂະຫນານ ປົກກະຕິແລ້ວ buffers ຜົນຜະລິດເຂົ້າໄປໃນ
ໄຟລ໌ຊົ່ວຄາວໃນ /tmp. ໂດຍການຕັ້ງຄ່າ --tmpdir ທ່ານສາມາດນໍາໃຊ້ dir ທີ່ແຕກຕ່າງກັນສໍາລັບການ
ໄຟລ໌. ການຕັ້ງຄ່າ --tmpdir ເທົ່າກັບການຕັ້ງຄ່າ $TMPDIR.
--tmux ການນໍາໃຊ້ tmux ສໍາລັບຜົນຜະລິດ. ເລີ່ມ ກ tmux session ແລະດໍາເນີນການແຕ່ລະວຽກຢູ່ໃນປ່ອງຢ້ຽມໃນນັ້ນ
ກອງປະຊຸມ. ບໍ່ມີຜົນຜະລິດອື່ນໃດຈະຖືກຜະລິດ.
--ຫມົດເວລາ h
ໝົດເວລາສຳລັບຄຳສັ່ງ. ຖ້າຄໍາສັ່ງເຮັດວຽກດົນກວ່າ h ວິນາທີມັນຈະໄດ້ຮັບ
ຖືກຂ້າຕາຍດ້ວຍ SIGTERM, ຕາມດ້ວຍ SIGTERM 200 ms ຕໍ່ມາ, ຕາມດ້ວຍ SIGKILL 200 ms.
ຕໍ່ມາ.
If h ຕິດຕາມດ້ວຍ % ຈາກນັ້ນເວລາໝົດເວລາຈະຖືກຄິດໄລ່ແບບໄດນາມິກເປັນ a
ເປີເຊັນຂອງເວລາແລ່ນສະເລ່ຍສະເລ່ຍ. ມີແຕ່ຄ່າ > 100% ເທົ່ານັ້ນທີ່ຈະເຂົ້າໃຈໄດ້.
-- verbose
-t ພິມວຽກທີ່ຈະດໍາເນີນການໃນ stderr (ຄວາມຜິດພາດມາດຕະຖານ).
ເບິ່ງ -v, -p.
--ໂອນ
ໂອນໄຟລ໌ໄປຫາຄອມພິວເຕີທາງໄກ. --ໂອນ ຖືກນໍາໃຊ້ກັບ --sshlogin ໃນເວລາທີ່
ການໂຕ້ຖຽງແມ່ນໄຟລ໌ແລະຄວນຈະຖືກໂອນໄປຫາຄອມພິວເຕີທາງໄກ. ໄຟລ໌
ຈະຖືກໂອນໂດຍໃຊ້ rsync ແລະຈະໄດ້ຮັບການເອົາໃຈໃສ່ກ່ຽວກັບການເລີ່ມຕົ້ນການເຮັດວຽກ dir.
ຖ້າເສັ້ນທາງປະກອບດ້ວຍ /./ ເສັ້ນທາງທີ່ຍັງເຫຼືອຈະກ່ຽວຂ້ອງກັບການເຮັດວຽກ dir.
ຕົວຢ່າງ
echo foo/bar.txt | ຂະຫນານ \
--sshlogin server.example.com --ໂອນ wc
ນີ້ຈະໂອນໄຟລ໌ foo/bar.txt ກັບຄອມພິວເຕີ server.example.com ການ
ເອກະສານ $HOME/foo/bar.txt ກ່ອນທີ່ຈະແລ່ນ wc foo/bar.txt on server.example.com.
echo /tmp/foo/bar.txt | ຂະຫນານ \
--sshlogin server.example.com --ໂອນ wc
ນີ້ຈະໂອນໄຟລ໌ foo/bar.txt ກັບຄອມພິວເຕີ server.example.com ການ
ເອກະສານ /tmp/foo/bar.txt ກ່ອນທີ່ຈະແລ່ນ wc /tmp/foo/bar.txt on server.example.com.
--ໂອນ ມັກໃຊ້ກັບ --ກັບຄືນ ແລະ --ທໍາຄວາມສະອາດ.
--ໂອນ ຖືກລະເລີຍເມື່ອໃຊ້ກັບ --sshlogin : ຫຼືໃນເວລາທີ່ບໍ່ໄດ້ນໍາໃຊ້ກັບ
--sshlogin.
--trc ຊື່ເອກະສານ
ໂອນ, ສົ່ງຄືນ, ອະນາໄມ. ມືສັ້ນສໍາລັບ:
--ໂອນ --ກັບຄືນ ຊື່ເອກະສານ --ທໍາຄວາມສະອາດ
--ຕັດ
ຕັດພື້ນທີ່ສີຂາວໃນການປ້ອນຂໍ້ມູນ.
n ບໍ່ມີການຕັດ. ການປ້ອນຂໍ້ມູນບໍ່ໄດ້ຖືກແກ້ໄຂ. ນີ້ແມ່ນຄ່າເລີ່ມຕົ້ນ.
l ຕັດຊ້າຍ. ເອົາພື້ນທີ່ສີຂາວອອກຈາກຈຸດເລີ່ມຕົ້ນຂອງການປ້ອນຂໍ້ມູນ. ຕົວຢ່າງ "a bc" -> "a bc".
r ຕັດຂວາ. ເອົາພື້ນທີ່ສີຂາວອອກຈາກທ້າຍຂອງວັດສະດຸປ້ອນ. ຕົວຢ່າງ "a bc" -> "a bc".
lr
rl ທັງສອງ trim. ເອົາພື້ນທີ່ສີຂາວອອກຈາກທັງຈຸດເລີ່ມຕົ້ນ ແລະຈຸດສິ້ນສຸດຂອງການປ້ອນຂໍ້ມູນ. ຕົວຢ່າງ "a bc"
-> "a bc". ນີ້ແມ່ນຄ່າເລີ່ມຕົ້ນຖ້າ --colsep ຖືກນໍາໃຊ້.
--ກຸ່ມ
-u ຍົກເລີກການອອກກຸ່ມ. ຜົນຜະລິດແມ່ນພິມໄວເທົ່າທີ່ເປັນໄປໄດ້ແລະຜ່ານ GNU ຂະຫນານ
ການປຸງແຕ່ງພາຍໃນ. ນີ້ອາດຈະເຮັດໃຫ້ຜົນຜະລິດຈາກຄໍາສັ່ງທີ່ແຕກຕ່າງກັນປະສົມ
ດັ່ງນັ້ນຄວນຖືກນໍາໃຊ້ພຽງແຕ່ຖ້າທ່ານບໍ່ສົນໃຈກັບຜົນຜະລິດ. ປຽບທຽບສິ່ງເຫຼົ່ານີ້:
ຂະຫນານ -j0 'ນອນ {};ສຽງ -n ເລີ່ມ{};ນອນ {};ສຽງ {}ສິ້ນສຸດ' ::: 1 2 3 4
ຂະຫນານ -u -j0 'ນອນ {};ສຽງ -n ເລີ່ມ{};ນອນ {};ສຽງ {}ສິ້ນສຸດ' ::: 1 2 3 4
ມັນຍັງປິດການໃຊ້ງານ --tag. GNU ຂະຫນານ ຜົນຜະລິດໄວຂຶ້ນດ້ວຍ -u. ປຽບທຽບຄວາມໄວຂອງ
ເຫຼົ່ານີ້:
parallel seq ::: 300000000 >/dev/null
parallel -u seq ::: 300000000 >/dev/null
parallel --line-buffer seq ::: 300000000 >/dev/null
ສາມາດປີ້ນກັບ --ກຸ່ມ.
ເບິ່ງເພີ່ມເຕີມ: --line-buffer --ກຸ່ມ
--ສ່ວນຂະຫຍາຍແທນທີ່ ທົດແທນ-str
--er ທົດແທນ-str
ໃຊ້ສະຕຣິງທົດແທນ ທົດແທນ-str ແທນທີ່ {.} ສໍາລັບ input line ບໍ່ມີ
ການຂະຫຍາຍ.
--use-cpus-intead-of-cores
ນັບຈໍານວນຂອງ CPU ທາງດ້ານຮ່າງກາຍແທນທີ່ຈະເປັນ CPU cores. ເມື່ອຄິດໄລ່ຈໍານວນເທົ່າໃດ
ວຽກທີ່ຈະດໍາເນີນການພ້ອມໆກັນກັບຈໍານວນຂອງ CPU cores ທີ່ທ່ານສາມາດຖາມ GNU
ຂະຫນານ ແທນທີ່ຈະເບິ່ງຈໍານວນ CPU ທາງດ້ານຮ່າງກາຍ. ນີ້ຈະເຮັດໃຫ້ຄວາມຮູ້ສຶກສໍາລັບ
ຄອມພິວເຕີທີ່ມີ hyperthreading ເປັນສອງວຽກທີ່ເຮັດວຽກຢູ່ໃນຫນຶ່ງ CPU ກັບ
hyperthreading ຈະເຮັດວຽກຊ້າກວ່າສອງວຽກທີ່ເຮັດວຽກຢູ່ໃນສອງ CPU ທາງດ້ານຮ່າງກາຍ. ບາງ
CPU ຫຼາຍຫຼັກສາມາດເຮັດວຽກໄດ້ໄວຂຶ້ນຖ້າມີພຽງ thread ດຽວແລ່ນຕໍ່ CPU ຕົວຈິງ.
ຜູ້ໃຊ້ສ່ວນໃຫຍ່ຈະບໍ່ຕ້ອງການທາງເລືອກນີ້.
-v ຄຳເວົ້າ. ພິມວຽກທີ່ຈະດໍາເນີນການໃນ stdout (ຜົນຜະລິດມາດຕະຖານ). ສາມາດປີ້ນກັບກັນໄດ້
ກັບ --ງຽບ. ເບິ່ງຕື່ມ -t.
ການນໍາໃຊ້ -v -v ເພື່ອພິມຄໍາສັ່ງ wrapping ssh ເມື່ອແລ່ນໄລຍະໄກ.
- ການປ່ຽນແປງ
-V ພິມສະບັບ GNU ຂະຫນານ ແລະອອກຈາກການ.
--workdir mydir
--wd mydir
ໂອນໄຟລ໌ໂດຍໃຊ້ --ໂອນ ແລະ --ກັບຄືນ ຈະເປັນພີ່ນ້ອງກັບ mydir on
ຄອມພິວເຕີທາງໄກ, ແລະຄໍາສັ່ງຈະຖືກປະຕິບັດໃນ dir mydir.
ພິເສດ mydir ມູນຄ່າ ... ຈະສ້າງ dirs ເຮັດວຽກພາຍໃຕ້ ~/.parallel/tmp/ on
ຄອມພິວເຕີທາງໄກ. ຖ້າ --ທໍາຄວາມສະອາດ ແມ່ນໃຫ້ dirs ເຫຼົ່ານີ້ຈະຖືກລຶບອອກ.
ພິເສດ mydir ມູນຄ່າ . ໃຊ້ dir ທີ່ເຮັດວຽກໃນປະຈຸບັນ. ຖ້າປະຈຸບັນເຮັດວຽກ
dir ແມ່ນຢູ່ລຸ່ມເຮືອນຂອງທ່ານ dir, ມູນຄ່າ . ຖືກປະຕິບັດເປັນເສັ້ນທາງພີ່ນ້ອງຂອງທ່ານ
ບ້ານ dir. ນີ້ຫມາຍຄວາມວ່າຖ້າຫາກວ່າ dir ເຮືອນຂອງທ່ານແຕກຕ່າງກັນໃນຄອມພິວເຕີຫ່າງໄກສອກຫຼີກ (eg
ຖ້າການເຂົ້າສູ່ລະບົບຂອງເຈົ້າແມ່ນແຕກຕ່າງກັນ) ເສັ້ນທາງພີ່ນ້ອງຈະຍັງຄົງເປັນພີ່ນ້ອງກັບເຮືອນຂອງເຈົ້າ
d.
ເພື່ອເບິ່ງຄວາມແຕກຕ່າງ, ພະຍາຍາມ:
ຂະຫນານ -S ເຄື່ອງແມ່ຂ່າຍ ນອນd ::: ""
ຂະຫນານ --wd . -S ເຄື່ອງແມ່ຂ່າຍ ນອນd ::: ""
ຂະຫນານ --wd ... -S ເຄື່ອງແມ່ຂ່າຍ ນອນd ::: ""
--ລໍຖ້າ ລໍຖ້າໃຫ້ຄໍາສັ່ງທັງຫມົດສໍາເລັດ.
ຫມາຍເຖິງ --semaphore.
ເບິ່ງ ຜູ້ຊາຍ sem.
-X ຫຼາຍ argument ທີ່ມີ context ແທນ. ໃສ່ການໂຕ້ຖຽງຫຼາຍເທົ່າທີ່ຄໍາສັ່ງ
ອະນຸຍາດຄວາມຍາວຂອງເສັ້ນ. ຖ້າຫຼາຍວຽກຖືກດໍາເນີນການຂະຫນານ: ແຈກຢາຍ
ການໂຕ້ຖຽງກັນລະຫວ່າງວຽກ. ໃຊ້ -j1 ເພື່ອຫຼີກເວັ້ນການນີ້.
If {} ບໍ່ໄດ້ໃຊ້ການໂຕ້ຖຽງຈະຖືກຕໍ່ທ້າຍກັບແຖວ. ຖ້າ {} ຖືກນໍາໃຊ້ເປັນ
ສ່ວນຫນຶ່ງຂອງຄໍາສັບຕ່າງໆ (ເຊັ່ນ ຮູບ{}.jpg) ຫຼັງຈາກນັ້ນຄໍາທັງຫມົດຈະຖືກຊ້ໍາ. ຖ້າ {} is
ໃຊ້ຫຼາຍຄັ້ງໃນແຕ່ລະ {} ຈະຖືກແທນທີ່ດ້ວຍການໂຕ້ຖຽງ.
ປົກກະຕິແລ້ວ -X ຈະເຮັດສິ່ງທີ່ຖືກຕ້ອງ, ໃນຂະນະທີ່ -m ສາມາດໃຫ້ຜົນໄດ້ຮັບທີ່ບໍ່ຄາດຄິດຖ້າ {}
ຖືກນໍາໃຊ້ເປັນສ່ວນຫນຶ່ງຂອງຄໍາ.
ສະຫນັບສະຫນູນສໍາລັບ -X ກັບ --sshlogin ແມ່ນຈໍາກັດແລະອາດຈະລົ້ມເຫລວ.
ເບິ່ງ -m.
--ອອກ
-x ອອກຖ້າຫາກວ່າຂະຫນາດ (ເບິ່ງ -s ທາງເລືອກ) ແມ່ນເກີນ.
--xapply ອ່ານແຫຼ່ງປ້ອນຂໍ້ມູນຫຼາຍເຊັ່ນ xapply. ຖ້າຫາກວ່າແຫຼ່ງຂໍ້ມູນຫຼາຍແມ່ນໄດ້ຮັບການໃຫ້, ຫນຶ່ງ
ການໂຕ້ຖຽງຈະຖືກອ່ານຈາກແຕ່ລະແຫຼ່ງປ້ອນຂໍ້ມູນ. ການໂຕ້ຖຽງສາມາດເປັນ
ເຂົ້າເຖິງໃນຄໍາສັ່ງເປັນ {1} .. {n}, ດັ່ງນັ້ນ {1} ຈະເປັນແຖວຈາກການປ້ອນຂໍ້ມູນທຳອິດ
ແຫຼ່ງ, ແລະ {6} ຈະອ້າງອີງເຖິງເສັ້ນທີ່ມີເລກແຖວດຽວກັນຈາກເລກທີ່ 6
ແຫຼ່ງປ້ອນຂໍ້ມູນ.
ປຽບທຽບສອງອັນນີ້:
parallel echo {1} {2} ::: 1 2 3 ::: abc
parallel --xapply echo {1} {2} ::: 1 2 3 ::: abc
ອາກິວເມັນຈະຖືກນຳກັບມາໃຊ້ໃໝ່ຖ້າແຫຼ່ງປ້ອນຂໍ້ມູນໃດໜຶ່ງມີ arguments ຫຼາຍກວ່າ
ອື່ນໆ:
parallel --xapply echo {1} {2} {3} ::: 1 2 ::: I II III ::: abcdefg
ເບິ່ງ --ຫົວ.
ຕົວຢ່າງ: ການເຮັດວຽກ as xargs -n1. ການໂຕ້ຖຽງ ເພີ່ມເຕີມ
GNU ຂະຫນານ ສາມາດເຮັດວຽກຄ້າຍຄືກັນກັບ xargs -n1.
ເພື່ອບີບອັດໄຟລ໌ html ທັງຫມົດໂດຍໃຊ້ gzip ແລ່ນ:
ຊອກຫາ . -yam '*.html' | ຂະຫນານ gzip --ດີທີ່ສຸດ
ຖ້າຊື່ໄຟລ໌ອາດມີການໃຊ້ແຖວໃໝ່ -0. ແທນ FOO BAR ດ້ວຍ FUBAR ໃນທຸກໄຟລ໌
ໃນ dir ແລະ subdirs ນີ້:
ຊອກຫາ . -ປະເພດ f -ພິມ0 | ຂະຫນານ -q0 perl -i -pe 's/FOO ບາ/FUBAR/g'
ຫມາຍເຫດ -q ແມ່ນຈໍາເປັນເພາະວ່າພື້ນທີ່ຢູ່ໃນ 'FOO BAR'.
ຕົວຢ່າງ: ອ່ານ ກະທູ້ທີ່ ຈາກ ຄໍາສັ່ງ ອອນໄລນ໌
GNU ຂະຫນານ ສາມາດເອົາການໂຕ້ຖຽງຈາກບັນທັດຄໍາສັ່ງແທນທີ່ຈະເປັນ stdin (ວັດສະດຸປ້ອນມາດຕະຖານ).
ເພື່ອບີບອັດໄຟລ໌ html ທັງຫມົດໃນ dir ໃນປັດຈຸບັນໂດຍໃຊ້ gzip ແລ່ນ:
ຂະຫນານ gzip --ດີທີ່ສຸດ ::: *.html
ເພື່ອປ່ຽນ *.wav ເປັນ *.mp3 ໂດຍໃຊ້ LAME ແລ່ນໜຶ່ງຂະບວນການຕໍ່ CPU core run:
ຂະຫນານ ແຜ່ນໃບຄ້າຍຄື {} -o {.}.mp3 ::: * .wav
ຕົວຢ່າງ: ການແຊກ ຫຼາຍ ກະທູ້ທີ່
ເມື່ອຍ້າຍໄຟລ໌ຫຼາຍອັນເຊັ່ນນີ້: mv *.log destdir ບາງຄັ້ງທ່ານຈະໄດ້ຮັບຄວາມຜິດພາດ:
ແຕກ: /bin/mv: ການໂຕ້ຖຽງ ບັນຊີລາຍຊື່ ເກີນໄປ ຍາວ
ເນື່ອງຈາກວ່າມີໄຟລ໌ຫຼາຍເກີນໄປ. ແທນທີ່ຈະທ່ານສາມາດເຮັດໄດ້:
ls | grep -E '\.log$' | ຂະຫນານ mv {} destdir
ນີ້ຈະດໍາເນີນການ mv ສໍາລັບແຕ່ລະໄຟລ໌. ມັນສາມາດເຮັດໄດ້ໄວຂຶ້ນຖ້າ mv ໄດ້ຮັບການໂຕ້ຖຽງຫຼາຍເທົ່າທີ່
ຈະເຫມາະກັບເສັ້ນ:
ls | grep -E '\.log$' | ຂະຫນານ -m mv {} destdir
ຕົວຢ່າງ: Context ທົດແທນ
ເພື່ອເອົາໄຟລ໌ອອກ ຮູບ0000.jpg .. ຮູບ9999.jpg ເຈົ້າສາມາດເຮັດໄດ້:
seq -w 0 9999 | ຂະຫນານ rm ຮູບ{}.jpg
ທ່ານຍັງສາມາດເຮັດໄດ້:
seq -w 0 9999 | perl -pe 's/.*)/pict$1.jpg/' | ຂະຫນານ -m rm
ທໍາອິດຈະດໍາເນີນການ rm 10000 ເທື່ອ, ໃນຂະນະທີ່ສຸດທ້າຍຈະດໍາເນີນການເທົ່ານັ້ນ rm ຫຼາຍເທື່ອທີ່ຕ້ອງການ
ຮັກສາຄວາມຍາວຂອງເສັ້ນຄໍາສັ່ງສັ້ນພຽງພໍທີ່ຈະຫຼີກເວັ້ນ ການໂຕ້ຖຽງ ບັນຊີລາຍຊື່ ເກີນໄປ ຍາວ (ໂດຍປົກກະຕິ
ແລ່ນ 1-2 ເທື່ອ).
ນອກນັ້ນທ່ານຍັງສາມາດດໍາເນີນການ:
seq -w 0 9999 | ຂະຫນານ -X rm ຮູບ{}.jpg
ນີ້ຍັງຈະດໍາເນີນການເທົ່ານັ້ນ rm ຫຼາຍຄັ້ງທີ່ຈໍາເປັນເພື່ອຮັກສາຄວາມຍາວຂອງເສັ້ນຄໍາສັ່ງສັ້ນ
ພຽງພໍ.
ຕົວຢ່າງ: Compute ສຸມ ວຽກເຮັດງານທໍາ ແລະ ການທົດແທນ
ຖ້າ ImageMagick ຖືກຕິດຕັ້ງ, ມັນຈະສ້າງຮູບຫຍໍ້ຂອງໄຟລ໌ jpg:
ແປງ -ເລຂາຄະນິດ 120 foo.jpg thumb_foo.jpg
ນີ້ຈະດໍາເນີນການກັບຈໍານວນການເຮັດວຽກຂອງ CPU-cores ໃນຂະຫນານສໍາລັບໄຟລ໌ jpg ທັງຫມົດໃນໄດເລກະທໍລີ:
ls * .jpg | ຂະຫນານ ແປງ -ເລຂາຄະນິດ 120 {} thumb_{}
ເພື່ອເຮັດມັນ recursively ໃຊ້ ຊອກຫາ:
ຊອກຫາ . -yam '*.jpg' | ຂະຫນານ ແປງ -ເລຂາຄະນິດ 120 {} {}_thumb.jpg
ສັງເກດເຫັນວິທີການໂຕ້ຖຽງຕ້ອງເລີ່ມຕົ້ນດ້ວຍ {} as {} ຈະປະກອບມີເສັ້ນທາງ (ເຊັ່ນ: ແລ່ນ ແປງ
-ເລຂາຄະນິດ 120 ./foo/bar.jpg thumb_./foo/bar.jpg ຈະແຈ້ງຈະຜິດ). ຄໍາສັ່ງຈະ
ສ້າງໄຟລ໌ເຊັ່ນ ./foo/bar.jpg_thumb.jpg.
ການນໍາໃຊ້ {.} ເພື່ອຫຼີກເວັ້ນການເພີ່ມ .jpg ໃນຊື່ໄຟລ໌. ຄໍາສັ່ງນີ້ຈະເຮັດໃຫ້ໄຟລ໌ຄ້າຍຄື
./foo/bar_thumb.jpg:
ຊອກຫາ . -yam '*.jpg' | ຂະຫນານ ແປງ -ເລຂາຄະນິດ 120 {} {.}_thumb.jpg
ຕົວຢ່າງ: ປ່ຽນແທນ ແລະ ຕົວຊີ້ທິດທາງ
ນີ້ຈະສ້າງໄຟລ໌ .gz-files ເວີຊັນທີ່ບໍ່ໄດ້ບີບອັດຖັດຈາກ .gz-files:
ຂະຫນານ zcat {} ">"{.} ::: *.gz
ການອ້າງອີງຂອງ > ເປັນສິ່ງຈໍາເປັນເພື່ອເລື່ອນການປ່ຽນເສັ້ນທາງ. ການແກ້ໄຂອີກປະການຫນຶ່ງແມ່ນເພື່ອອ້າງເຖິງ
ຄໍາສັ່ງທັງຫມົດ:
ຂະຫນານ "zcat {} >{.}" ::: *.gz
ຕົວອັກສອນພິເສດອື່ນໆ (ເຊັ່ນ: * ; $ > < | >> << ) ຍັງຈໍາເປັນຕ້ອງໄດ້ຮັບການໃສ່ໃນວົງຢືມ,
ຍ້ອນວ່າພວກມັນອາດຈະຖືກຕີຄວາມ ໝາຍ ໂດຍແກະແລະບໍ່ຖືກມອບໃຫ້ GNU ຂະຫນານ.
ຕົວຢ່າງ: ປະກອບ ຄໍາສັ່ງ
ວຽກສາມາດປະກອບດ້ວຍຫຼາຍຄໍາສັ່ງ. ນີ້ຈະພິມຈໍານວນໄຟລ໌ໃນແຕ່ລະ
ໄດເລກະທໍລີ:
ls | ຂະຫນານ 'ສຽງດັງ -n {}" "; ls {}|wc -l'
ເພື່ອເອົາຜົນຜະລິດໃນໄຟລ໌ທີ່ເອີ້ນວ່າ .dir:
ls | ຂະຫນານ '(ສຽງ -n {}" "; ls {}|wc -l) > {}.dir'
ເຖິງແມ່ນວ່າສະຄິບແກະຂະຫນາດນ້ອຍສາມາດດໍາເນີນການໂດຍ GNU ຂະຫນານ:
ຊອກຫາ . | ຂະຫນານ 'a={}; name=${a##*/}; ເທິງ=$(ສຽງ "$name" | tr "[:ຕ່ໍາກວ່າ:]"
"[:upper:]"); echo "$name - $upper"'
ls | ຂະຫນານ 'mv {} "$(ສຽງ {} | tr "[:ເທິງ:]" "[:ຕ່ໍາກວ່າ:]")"'
ໃຫ້ບັນຊີລາຍຊື່ຂອງ URLs, ລາຍຊື່ທຸກ URL ທີ່ບໍ່ສາມາດດາວໂຫລດໄດ້. ພິມຈໍານວນເສັ້ນແລະ
Url.
cat urlfile | ຂະຫນານ "wget {} 2>/ dev / null || grep -n {} urlfile"
ສ້າງໄດເລກະທໍລີ mirror ທີ່ມີຊື່ໄຟລ໌ດຽວກັນຍົກເວັ້ນໄຟລ໌ທັງຫມົດແລະ symlinks ຫວ່າງເປົ່າ
ໄຟລ໌.
cp -rs /the/source/dir mirror_dir; ຊອກຫາ mirror_dir -ປະເພດ l | ຂະຫນານ -m rm {} '&&' ສໍາຜັດ
{}
ຊອກຫາໄຟລ໌ທີ່ຢູ່ໃນບັນຊີລາຍຊື່ທີ່ບໍ່ມີຢູ່
cat file_list | ຂະຫນານ 'ຖ້າ [ ! -e {} ] ; ຫຼັງຈາກນັ້ນ echo {}; ຟີ
ຕົວຢ່າງ: ການໂທ Bash ຫນ້າທີ່
ຖ້າຄໍາສັ່ງທີ່ປະກອບຍາວກວ່າເສັ້ນ, ມັນຍາກທີ່ຈະອ່ານ. ໃນ Bash ທ່ານສາມາດເຮັດໄດ້
ໃຊ້ຟັງຊັນ. ພຽງແຕ່ຈື່ ການສົ່ງອອກ -f ຫນ້າທີ່.
ເຮັດເລີຍ() {
echo ເຮັດມັນສໍາລັບ $1
ນອນ 2
echo ສໍາເລັດດ້ວຍ $1
}
ສົ່ງອອກ -f doit
parallel doit ::: 1 2 3
doubleit() {
echo ເຮັດມັນສໍາລັບ $1 $2
ນອນ 2
echo ສໍາເລັດດ້ວຍ $1 $2
}
ສົ່ງອອກ -f doubleit
parallel doubleit ::: 1 2 3 ::: ab
ເພື່ອເຮັດສິ່ງນີ້ໃນເຄື່ອງແມ່ຂ່າຍຫ່າງໄກສອກຫຼີກ, ທ່ານຈໍາເປັນຕ້ອງໄດ້ໂອນຟັງຊັນໂດຍໃຊ້ --env:
parallel --env doit -S server doit ::: 1 2 3
parallel --env doubleit -S server doubleit ::: 1 2 3 ::: ab
ຖ້າສະພາບແວດລ້ອມຂອງທ່ານ (ນາມແຝງ, ຕົວແປແລະຫນ້າທີ່) ມີຂະຫນາດນ້ອຍທ່ານສາມາດຄັດລອກເຕັມ
ສະພາບແວດລ້ອມໂດຍບໍ່ຈໍາເປັນຕ້ອງ ການສົ່ງອອກ -f ຫຍັງ. ພຽງແຕ່ດໍາເນີນການນີ້ທໍາອິດ:
env_parallel() {
ສົ່ງອອກ parallel_bash_environment='() {
'"$(echo "shopt -s expand_aliases 2>/dev/null"; alias;typeset -p | grep -vFf <(readonly; echo GROUPS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_;typeset -f)"'
}'
# ແລ່ນເປັນ: env_parallel parallel_bash_environment "2>/dev/null;" ...
`ເຊິ່ງຂະໜານ` "$@"
ບໍ່ໄດ້ຕັ້ງ parallel_bash_environment
}
ແລະຫຼັງຈາກນັ້ນໂທຫາ:
env_parallel doit ::: 1 2 3
env_parallel doubleit ::: 1 2 3 ::: ab
env_parallel -S server doit ::: 1 2 3
env_parallel -S server doubleit ::: 1 2 3 ::: ab
ຕົວຢ່າງ: ຫນ້າທີ່ tester
ເພື່ອທົດສອບໂຄງການທີ່ມີຕົວກໍານົດການທີ່ແຕກຕ່າງກັນ:
tester() {
ຖ້າ (eval "$@") >&/dev/null; ແລ້ວ
perl -e 'printf "\033[30;102m[ OK ]\033[0m @ARGV\n"' "$@"
ອື່ນ
perl -e 'printf "\033[30;101m[FAIL]\033[0m @ARGV\n"' "$@"
fi
}
ສົ່ງອອກ -f tester
parallel tester my_program ::: arg1 arg2
parallel tester exit ::: 1 0 2 0
If my_program ລົ້ມເຫລວ FAIL ສີແດງຈະຖືກພິມຕາມດ້ວຍຄໍາສັ່ງທີ່ລົ້ມເຫລວ; ຖ້າບໍ່ດັ່ງນັ້ນ
ສີຂຽວ OK ຈະຖືກພິມຕາມດ້ວຍຄໍາສັ່ງ.
ຕົວຢ່າງ: ກຳ ຈັດອອກ ເອກະສານ ການຂະຫຍາຍ ໃນເວລາທີ່ ການປຸງແຕ່ງ ໄຟ
ໃນເວລາທີ່ການປຸງແຕ່ງໄຟລ໌ຖອນການຂະຫຍາຍໄຟລ໌ໂດຍນໍາໃຊ້ {.} ມັກຈະເປັນປະໂຫຍດ.
ສ້າງໄດເລກະທໍລີສໍາລັບແຕ່ລະ zip-file ແລະ unzip ມັນຢູ່ໃນ dir ວ່າ:
ຂະຫນານ 'mkdir {.}; cd {.}; unzip ../{}' ::: * .zip
ບີບອັດໄຟລ໌ .gz ທັງໝົດໃນໄດເລກະທໍລີປັດຈຸບັນໂດຍໃຊ້ bzip2 ແລ່ນ 1 ວຽກຕໍ່ CPU core ໃນ
ຂະຫນານ:
ຂະຫນານ "zcat {} | bzip2 >{.}.bz2 && rm {}" ::: *.gz
ປ່ຽນໄຟລ໌ WAV ທັງໝົດເປັນ MP3 ໂດຍໃຊ້ LAME:
ຊອກຫາ ສຽງດີ -ປະເພດ f -yam '*.wav' | ຂະຫນານ ແຜ່ນໃບຄ້າຍຄື {} -o {.}.mp3
ເອົາການແປງທັງຫມົດຢູ່ໃນໄດເລກະທໍລີດຽວກັນ:
ຊອກຫາ ສຽງດີ -ປະເພດ f -yam '*.wav' | ຂະຫນານ ແຜ່ນໃບຄ້າຍຄື {} -o mydir/{/.}.mp3
ຕົວຢ່າງ: ກຳ ຈັດອອກ ສອງ ເອກະສານ ການຂະຫຍາຍ ໃນເວລາທີ່ ການປຸງແຕ່ງ ໄຟ
ຖ້າທ່ານມີໄດເລກະທໍລີທີ່ມີໄຟລ໌ tar.gz ແລະຕ້ອງການການສະກັດເອົາເຫຼົ່ານີ້ຢູ່ໃນ dir ທີ່ສອດຄ້ອງກັນ
(ຕົວຢ່າງ foo.tar.gz ຈະຖືກສະກັດຢູ່ໃນ dir foo) ທ່ານສາມາດເຮັດໄດ້:
ຂະຫນານ --ບວກ 'mkdir {..}; tar -C {..} -xf {}' ::: *.tar.gz
ຕົວຢ່າງ: ດາວໂຫລດ 10 ຮູບພາບ ສໍາລັບການ ແຕ່ລະຄົນ of ໄດ້ ທີ່ຜ່ານມາ 30 ວັນ
ໃຫ້ພວກເຮົາສົມມຸດວ່າເວັບໄຊທ໌ເກັບຮູບພາບເຊັ່ນ:
http://www.example.com/path/to/YYYYMMDD_##.jpg
ເຊິ່ງ YYYYMMDD ແມ່ນວັນທີ ແລະ ## ແມ່ນຕົວເລກ 01-10. ນີ້ຈະດາວນ໌ໂຫລດຮູບພາບສໍາລັບການ
30 ມື້ທີ່ຜ່ານມາ:
ຂະຫນານ wget http://www.example.com/path/to/'$(ວັນທີ -d "ມື້ນີ້ -{1} ມື້"
+%Y%m%d)_{2}.jpg' ::: $( seq 30) ::: $( seq -w 10)
$(ວັນທີ -d "ມື້ນີ້ -{1} ມື້" +%Y%m%d) ຈະໃຫ້ວັນທີໃນ YYYYMMDD ກັບ {1} ມື້
ລົບ.
ຕົວຢ່າງ: ສໍາເນົາ ໄຟ as ສຸດທ້າຍ ແກ້ໄຂ ວັນ (ISO8601) ກັບ ເພີ່ມ random ຕົວເລກ
ຊອກຫາ . | ຂະຫນານ 'cp {} ../destdir/{= $a = int(10000*rand); $_ = `ວັນທີ -r "$_"
+%FT%T"$a"`; chomp; =}'
ຕົວຢ່າງ: ດິຈິຕອລ ໂມງ ກັບ "ກະພິບ" :
The : ໃນໂມງດິຈິຕອນກະພິບ. ເພື່ອເຮັດໃຫ້ແຖວອື່ນມີ ':' ແລະສ່ວນທີ່ເຫຼືອເປັນ ' ' a
perl expression ແມ່ນໃຊ້ເພື່ອເບິ່ງແຫຼ່ງປ້ອນຂໍ້ມູນທີ 3. ຖ້າຄ່າ modudo 2 ແມ່ນ 1: ໃຊ້
" : " ຖ້າບໍ່ດັ່ງນັ້ນໃຊ້ " " :
ຂະຫນານ -k echo {1}'{=3 $_=$_%2?":":" "=}'{2}{3} ::: {0..12} ::: {0..5} ::: {0..9}
ຕົວຢ່າງ: ການລວບລວມ ເນື້ອໃນ of ໄຟ
ນີ້:
ຂະຫນານ --header : echo x{X}y{Y}z{Z} \> x{X}y{Y}z{Z} \
::: X {1..5} ::: Y {01..10} ::: Z {1..5}
ຈະສ້າງໄຟລ໌ x1y01z1 .. x5y10z5. ຖ້າທ່ານຕ້ອງການລວມເອົາການຈັດກຸ່ມຜົນຜະລິດ
ໃນ x ແລະ z ທ່ານສາມາດເຮັດສິ່ງນີ້ໄດ້:
parallel eval 'cat {=s/y01/y*/=} > {=s/y01//=}' ::: *y01*
ສໍາລັບຄ່າທັງຫມົດຂອງ x ແລະ z ມັນດໍາເນີນການຄໍາສັ່ງເຊັ່ນ:
cat x1y*z1 > x1z1
ດັ່ງນັ້ນທ່ານສິ້ນສຸດດ້ວຍ x1z1 .. x1z5 ແຕ່ລະປະກອບດ້ວຍເນື້ອໃນຂອງຄ່າທັງຫມົດຂອງ y.
ຕົວຢ່າງ: ຂະ ໜາດ ຄັ້ງທໍາອິດ ຂະຫນານ ເວັບໄຊຕ໌ ຕົວກວາດເວັບ/ກະຈົກ
script ຂ້າງລຸ່ມນີ້ຈະລວບລວມຂໍ້ມູນແລະສະທ້ອນ URL ໃນຂະຫນານ. ມັນດາວໂຫລດຫນ້າທໍາອິດທີ່
ແມ່ນ 1 ຄລິກລົງ, ຫຼັງຈາກນັ້ນ 2 ຄລິກລົງ, ຫຼັງຈາກນັ້ນ 3; ແທນທີ່ຈະເປັນຄວາມເລິກປົກກະຕິທໍາອິດ, ບ່ອນທີ່
ລິ້ງຄ໌ລິ້ງທຳອິດໃນແຕ່ລະໜ້າຈະຖືກດຶງມາກ່ອນ.
ແລ່ນແບບນີ້:
PARALLEL=-j100 ./parallel-crawl http://gatt.org.yeslab.org/
ດຶງອອກຈາກ wget ສ່ວນຫນຶ່ງຖ້າທ່ານຕ້ອງການຕົວກວາດເວັບເທົ່ານັ້ນ.
ມັນເຮັດວຽກໂດຍການດຶງເອົາຫນ້າຈາກບັນຊີລາຍຊື່ຂອງ URLs ແລະຊອກຫາການເຊື່ອມຕໍ່ໃນຫນ້ານັ້ນ
ແມ່ນຢູ່ໃນ URL ເລີ່ມຕົ້ນດຽວກັນແລະທີ່ບໍ່ເຄີຍເຫັນ. ການເຊື່ອມຕໍ່ເຫຼົ່ານີ້ແມ່ນ
ເພີ່ມໃສ່ຄິວໃໝ່ແລ້ວ. ເມື່ອໜ້າທັງໝົດຈາກລາຍຊື່ສຳເລັດແລ້ວ, ຄິວໃໝ່ຈະຖືກຍ້າຍໄປ
ບັນຊີລາຍຊື່ຂອງ URLs ແລະຂະບວນການແມ່ນເລີ່ມຕົ້ນໃຫມ່ຈົນກ່ວາບໍ່ພົບການເຊື່ອມຕໍ່ທີ່ບໍ່ເຫັນ.
#!/ bin / bash
# ຕົວຢ່າງ http://gatt.org.yeslab.org/
URL=$1
# ຢູ່ພາຍໃນເລີ່ມຕົ້ນ dir
BASEURL=$(echo $URL | perl -pe 's:#.*::; s:(//.*/)[^/]*:$1:')
URLLIST=$(mktemp urllist.XXXX)
URLLIST2=$(mktemp urllist.XXXX)
SEEN=$(mktemp ເຫັນ.XXXX)
# Spider ເພື່ອໃຫ້ໄດ້ຮັບ URLs
ສະທ້ອນ $URL >$URLLIST
cp $URLLIST $SEEN
ໃນຂະນະທີ່ [ -s $URLLIST ] ; ເຮັດ
cat $URLLIST |
ຂະຫນານ lynx -listonly -image_links -dump {} \; wget -qm -l1 -Q1 {} \; echo Spidered: {} \>\&2 |
perl -ne 's/#.*//; s/\s+\d+.\s(\S+)$/$1/ ແລະເຮັດ {$seen{$1}++ ຫຼືພິມ }' |
grep -F $BASEURL |
grep -v -x -F -f $SEEN | tee -a $SEEN > $URLLIST2
mv $URLLIST2 $URLLIST
ເຮັດ
rm -f $URLLIST $URLLIST2 $SEEN
ຕົວຢ່າງ: ຂະບວນການ ໄຟ ຈາກ a tar ເອກະສານ ໃນຂະນະທີ່ ຖີ້ມ
ຖ້າໄຟລ໌ທີ່ຈະຖືກປຸງແຕ່ງຢູ່ໃນໄຟລ໌ tar ຫຼັງຈາກນັ້ນ unpacking ໄຟລ໌ຫນຶ່ງແລະປະມວນຜົນມັນ
ທັນທີອາດຈະໄວກ່ວາທໍາອິດ unpacking ໄຟລ໌ທັງຫມົດ.
tar f foo.tgz | perl - ບໍ່ 'ພິມ $l;$l=$_;END{ພິມ $l}' | ຂະຫນານ echo
Perl one-liner ແມ່ນຈໍາເປັນເພື່ອຫຼີກເວັ້ນສະພາບການແຂ່ງຂັນ.
ຕົວຢ່າງ: ຂຽນ ໃໝ່ a for-loop ແລະ a while-read-loop
for-loops ແບບນີ້:
(ສໍາລັບ x ໃນ `ບັນຊີລາຍຊື່ cat`; ເຮັດ
do_something $x
ເຮັດແລ້ວ) | process_output
ແລະ while-read-loops ຄືດັ່ງນີ້:
ບັນຊີລາຍຊື່ແມວ | (ໃນຂະນະທີ່ອ່ານ x; ເຮັດ
do_something $x
ເຮັດແລ້ວ) | process_output
ສາມາດຂຽນໄດ້ແບບນີ້:
cat ບັນຊີລາຍຊື່ | ຂະຫນານ do_something | process_output
ຕົວຢ່າງ: ຊອກຫາຊື່ເຈົ້າພາບໃດນຶ່ງໃນລາຍການທີ່ມີທີ່ຢູ່ IP 1.2.3 4:
cat hostsxt | ຂະຫນານ -P 100 ເຈົ້າພາບ | grep 1.2.3.4
ຖ້າການປຸງແຕ່ງຕ້ອງການຂັ້ນຕອນເພີ່ມເຕີມ, ວົງສໍາລັບແບບນີ້:
(ສໍາລັບ x ໃນ `ບັນຊີລາຍຊື່ cat`; ເຮັດ
no_extension=${x%.*};
do_something $x scale $no_extension.jpg
do_step2 <$x $no_extension
ເຮັດແລ້ວ) | process_output
ແລະ while-loops ຄືດັ່ງນີ້:
ບັນຊີລາຍຊື່ແມວ | (ໃນຂະນະທີ່ອ່ານ x; ເຮັດ
no_extension=${x%.*};
do_something $x scale $no_extension.jpg
do_step2 <$x $no_extension
ເຮັດແລ້ວ) | process_output
ສາມາດຂຽນໄດ້ແບບນີ້:
cat ບັນຊີລາຍຊື່ | ຂະຫນານ "ເຮັດ_ບາງສິ່ງບາງຢ່າງ {} ຂະຫນາດ {.}.jpg ; do_step2 <{} {.}" | process_output
ຕົວຢ່າງ: ຂຽນ ໃໝ່ ຮັງ for-loops
Nested for-loops ແບບນີ້:
(ສໍາລັບ x ໃນ `cat xlist`; ເຮັດ
ສໍາລັບ y ໃນ ` cat ylist` ; ເຮັດ
do_something $x $y
ເຮັດ
ເຮັດແລ້ວ) | process_output
ສາມາດຂຽນໄດ້ແບບນີ້:
ຂະຫນານ do_something {1} {2} :::: xlist ylist | process_output
Nested for-loops ແບບນີ້:
(ສໍາລັບເພດໃນ MF; ເຮັດ
ສໍາລັບຂະຫນາດ SML XL XXL ; ເຮັດ
echo $gender $size
ເຮັດ
ເຮັດແລ້ວ) | ຄັດ
ສາມາດຂຽນໄດ້ແບບນີ້:
ຂະຫນານ echo {1} {2} ::: M F ::: S M L XL XXL | ການຈັດລຽງ
ຕົວຢ່າງ: ຊອກ ໄດ້ ຕ່ ຳ ສຸດ ຄວາມແຕກຕ່າງ ລະຫວ່າງ ໄຟ
diff ແມ່ນດີສໍາລັບການຊອກຫາຄວາມແຕກຕ່າງໃນໄຟລ໌ຂໍ້ຄວາມ. diff | wc -l ໃຫ້ຕົວຊີ້ວັດຂອງ
ຂະຫນາດຂອງຄວາມແຕກຕ່າງ. ເພື່ອຊອກຫາຄວາມແຕກຕ່າງລະຫວ່າງໄຟລ໌ທັງຫມົດໃນ dir ໃນປັດຈຸບັນ
ເຮັດ:
ຂະຫນານ --tag 'ຄວາມແຕກຕ່າງ {1} {2} | wc -l' ::: * ::: * | ການຈັດລຽງ -nk3
ວິທີນີ້ມັນເປັນໄປໄດ້ທີ່ຈະເບິ່ງວ່າບາງໄຟລ໌ແມ່ນໃກ້ຊິດກັບໄຟລ໌ອື່ນໆ.
ຕົວຢ່າງ: for-loops ກັບ ຖັນ ຊື່
ເມື່ອເຮັດຫຼາຍ nested for-loops ມັນສາມາດຕິດຕາມຕົວແປ loop ໄດ້ງ່າຍຂຶ້ນ
ຖ້າຖືກຕັ້ງຊື່ແທນທີ່ຈະມີພຽງແຕ່ຕົວເລກ. ໃຊ້ --ຫົວ : ເພື່ອປ່ອຍໃຫ້ການໂຕ້ຖຽງທໍາອິດ
ເປັນນາມແຝງທີ່ມີຊື່ສໍາລັບສະຕຣິງປ່ຽນຕໍາແຫນ່ງ:
parallel --header : echo {gender} {size} ::: gender MF ::: size SML XL XXL
ອັນນີ້ຍັງໃຊ້ໄດ້ຖ້າໄຟລ໌ປ້ອນຂໍ້ມູນເປັນໄຟລ໌ທີ່ມີຖັນ:
cat addressbook.tsv | ຂະໜານ --colsep '\t' --header : echo {Name} {E-mail address}
ຕົວຢ່າງ: Count ໄດ້ ຄວາມແຕກຕ່າງ ລະຫວ່າງ ທັງຫມົດ ໄຟ in a dir
ການນໍາໃຊ້ -- ຜົນໄດ້ຮັບ ຜົນໄດ້ຮັບຈະຖືກບັນທຶກໄວ້ໃນ /tmp/diffcount*.
parallel --results /tmp/diffcount "diff -U 0 {1} {2} |tail -n +3 |grep -v '^@'|wc -l" ::: * ::: *
ເພື່ອເບິ່ງຄວາມແຕກຕ່າງລະຫວ່າງໄຟລ໌ A ແລະໄຟລ໌ B ເບິ່ງໄຟລ໌ '/tmp/diffcount/1/A/2/B'.
ຕົວຢ່າງ: ຄວາມໄວ up ໄວ ວຽກເຮັດງານທໍາ
ການເລີ່ມຕົ້ນວຽກຢູ່ໃນເຄື່ອງທ້ອງຖິ່ນໃຊ້ເວລາປະມານ 10 ms. ນີ້ສາມາດເປັນ overhead ໃຫຍ່ຖ້າຫາກວ່າ
ວຽກໃຊ້ເວລາ ms ຫນ້ອຍຫຼາຍທີ່ຈະດໍາເນີນການ. ເລື້ອຍໆທ່ານສາມາດຈັດກຸ່ມວຽກນ້ອຍໆຮ່ວມກັນໂດຍໃຊ້ -X ເຊິ່ງຈະ
ເຮັດໃຫ້ສ່ວນເກີນທີ່ມີຄວາມສໍາຄັນຫນ້ອຍລົງ. ປຽບທຽບຄວາມໄວຂອງສິ່ງເຫຼົ່ານີ້:
seq -w 0 9999 | ຮູບແຕະຂະໜານ{}.jpg
seq -w 0 9999 | ຂະໜານ -X touch pict{}.jpg
ຖ້າໂຄງການຂອງທ່ານບໍ່ສາມາດເອົາການໂຕ້ຖຽງຫຼາຍ, ຫຼັງຈາກນັ້ນທ່ານສາມາດນໍາໃຊ້ GNU ຂະຫນານ ວາງໄຂ່
ຫຼາຍ GNU ຂະຫນານs:
seq -w 0 999999 | parallel -j10 --pipe ຂະຫນານ -j0 touch pict{}.jpg
If -j0 ປົກກະຕິຈະສ້າງວຽກເຮັດງານທຳ 252 ຕໍາແໜ່ງ, ຈາກນັ້ນຂັ້ນເທິງຈະພະຍາຍາມສ້າງ 2520 ວຽກ. ເປັນປົກກະຕິ
ລະບົບ GNU/Linux ທ່ານສາມາດສ້າງວຽກ 32000 ໂດຍໃຊ້ເຕັກນິກນີ້ໂດຍບໍ່ມີບັນຫາ. ເພື່ອຍົກສູງ
ເພີ່ມຂີດຈຳກັດວຽກເຮັດງານທຳ 32000 ຄົນ /proc/sys/kernel/pid_max to 4194303
ຕົວຢ່າງ: ການນໍາໃຊ້ ຫອຍ ຕົວແປ
ເມື່ອນໍາໃຊ້ຕົວແປຂອງແກະ, ທ່ານຈໍາເປັນຕ້ອງອ້າງເຖິງພວກມັນຢ່າງຖືກຕ້ອງຍ້ອນວ່າພວກມັນອາດຈະຖືກແຍກ
ຢູ່ໃນພື້ນທີ່.
ສັງເກດເຫັນຄວາມແຕກຕ່າງລະຫວ່າງ:
V=("ບັນທຶກ 12\" ຂອງອ້າຍຂອງຂ້ອຍມີຄ່າ <\$\$\$>"'!' Foo Bar)
parallel echo ::: ${V[@]} # ອັນນີ້ອາດຈະບໍ່ແມ່ນສິ່ງທີ່ທ່ານຕ້ອງການ
ແລະ:
V=("ບັນທຶກ 12\" ຂອງອ້າຍຂອງຂ້ອຍມີຄ່າ <\$\$\$>"'!' Foo Bar)
ສຽງສະທ້ອນຂະໜານ ::: "${V[@]}"
ເມື່ອໃຊ້ຕົວແປໃນຄໍາສັ່ງຕົວຈິງທີ່ມີຕົວອັກສອນພິເສດ (ເຊັ່ນ: ຊ່ອງຫວ່າງ)
ເຈົ້າສາມາດອ້າງອີງເຂົາເຈົ້າໂດຍໃຊ້ '"$VAR"' ຫຼືໃຊ້ "'s ແລະ -q:
V="ນີ້ແມ່ນສອງ"
parallel echo "'$V'" ::: spaces
parallel -q echo "$V" ::: spaces
ຕົວຢ່າງ: ກຸ່ມ output ສາຍ
ໃນເວລາແລ່ນວຽກທີ່ສົ່ງຂໍ້ມູນອອກ, ທ່ານມັກຈະບໍ່ຕ້ອງການຜົນຜະລິດຂອງຫຼາຍວຽກ
ແລ່ນໄປພ້ອມກັນ. GNU ຂະຫນານ ຄ່າເລີ່ມຕົ້ນໃນການຈັດກຸ່ມຜົນຜະລິດຂອງແຕ່ລະວຽກ, ດັ່ງນັ້ນຜົນໄດ້ຮັບແມ່ນ
ພິມເມື່ອວຽກສໍາເລັດ. ຖ້າທ່ານຕ້ອງການພິມເສັ້ນເຕັມໃນຂະນະທີ່ວຽກຢູ່
ແລ່ນທີ່ທ່ານສາມາດນໍາໃຊ້ --line-buffer. ຖ້າທ່ານຕ້ອງການໃຫ້ຜົນຜະລິດຖືກພິມໄວເທົ່າທີ່ຈະໄວໄດ້
ທ່ານສາມາດໃຊ້ -u.
ປຽບທຽບຜົນຜະລິດຂອງ:
ຂະຫນານ traceroute ::: foss.org.my debian.org freenetproject.org
ກັບຜົນຜະລິດຂອງ:
ຂະຫນານ --line-buffer traceroute ::: foss.org.my debian.org freenetproject.org
ແລະ:
ຂະຫນານ -u traceroute ::: foss.org.my debian.org freenetproject.org
ຕົວຢ່າງ: Tag output ສາຍ
GNU ຂະຫນານ ຈັດກຸ່ມສາຍຜົນຜະລິດ, ແຕ່ວ່າມັນສາມາດຍາກທີ່ຈະເຫັນວ່າບ່ອນເຮັດວຽກທີ່ແຕກຕ່າງກັນ
ເລີ່ມຕົ້ນ. --tag prepends ການໂຕ້ຖຽງເພື່ອເຮັດໃຫ້ເຫັນໄດ້ຊັດເຈນ:
ຂະຫນານ --tag traceroute ::: foss.org.my debian.org freenetproject.org
--tag ເຮັດວຽກຮ່ວມກັບ --line-buffer ແຕ່ບໍ່ແມ່ນກັບ -u:
ຂະຫນານ --tag --line-buffer traceroute ::: foss.org.my debian.org freenetproject.org
ກວດເບິ່ງເວລາ uptime ຂອງເຄື່ອງແມ່ຂ່າຍໃນ ~/.parallel/sshloginfile:
ຂະຫນານ --tag -S .. --nonall uptime
ຕົວຢ່າງ: ໃຫ້ເກັບຮັກສາ ຄໍາສັ່ງ of output ດຽວກັນ as ຄໍາສັ່ງ of ການປ້ອນຂໍ້ມູນ
ໂດຍປົກກະຕິຜົນຜະລິດຂອງວຽກຈະຖືກພິມອອກທັນທີທີ່ມັນສໍາເລັດ. ບາງຄັ້ງທ່ານຕ້ອງການ
ຄໍາສັ່ງຂອງຜົນຜະລິດຍັງຄົງຄືກັນກັບຄໍາສັ່ງຂອງວັດສະດຸປ້ອນ. ນີ້ແມ່ນເລື້ອຍໆ
ທີ່ສໍາຄັນ, ຖ້າຫາກວ່າຜົນຜະລິດໄດ້ຖືກນໍາໃຊ້ເປັນ input ສໍາລັບລະບົບອື່ນ. -k ຈະເຮັດໃຫ້ແນ່ໃຈວ່າຄໍາສັ່ງ
ຜົນຜະລິດຈະຢູ່ໃນລໍາດັບດຽວກັນກັບການປ້ອນຂໍ້ມູນເຖິງແມ່ນວ່າວຽກຕໍ່ມາຈະສິ້ນສຸດກ່ອນວຽກກ່ອນຫນ້າ.
ເພີ່ມສະຕຣິງໃສ່ທຸກໆແຖວໃນໄຟລ໌ຂໍ້ຄວາມ:
cat ໄຟລ໌ຂໍ້ຄວາມ | ຂະຫນານ -k echo {} append_string
ຖ້າທ່ານເອົາອອກ -k ບາງສາຍອາດຈະອອກມາໃນຄໍາສັ່ງທີ່ບໍ່ຖືກຕ້ອງ.
ຕົວຢ່າງອີກອັນ ໜຶ່ງ ແມ່ນ traceroute:
ຂະຫນານ traceroute ::: foss.org.my debian.org freenetproject.org
ຈະໃຫ້ traceroute ຂອງ foss.org.my, debian.org ແລະ freenetproject.org, ແຕ່ວ່າມັນຈະເປັນ
ຈັດຮຽງຕາມວຽກໃດທີ່ສຳເລັດກ່ອນ.
ເພື່ອຮັກສາຄໍາສັ່ງຄືກັນກັບການດໍາເນີນການ input:
ຂະຫນານ -k traceroute ::: foss.org.my debian.org freenetproject.org
ນີ້ຈະເຮັດໃຫ້ແນ່ໃຈວ່າ traceroute ກັບ foss.org.my ຈະຖືກພິມອອກກ່ອນ.
ຕົວຢ່າງທີ່ສັບສົນຫຼາຍແມ່ນດາວໂຫຼດໄຟລ໌ຂະໜາດໃຫຍ່ເປັນຕ່ອນຂະໜານກັນ: ບາງອິນເຕີເນັດ
ການເຊື່ອມຕໍ່ຈະສົ່ງຂໍ້ມູນຫຼາຍຂຶ້ນຖ້າທ່ານດາວໂຫລດໄຟລ໌ແບບຂະຫນານ. ສໍາລັບການດາວໂຫຼດ
ໄຟລ໌ໃນຂະຫນານເບິ່ງ: "ຕົວຢ່າງ: ດາວໂຫລດ 10 ຮູບສໍາລັບແຕ່ລະ 30 ມື້ທີ່ຜ່ານມາ". ແຕ່ຖ້າ
ທ່ານກໍາລັງດາວນ໌ໂຫລດໄຟລ໌ຂະຫນາດໃຫຍ່ທີ່ທ່ານສາມາດດາວໂຫລດໄຟລ໌ເປັນ chunks ໃນຂະຫນານ.
ເພື່ອດາວໂຫລດ byte 10000000-19999999 ທ່ານສາມາດນໍາໃຊ້ curl:
curl -r 10000000-19999999 http://example.com/the/big/file > file.part
ເພື່ອດາວໂຫລດໄຟລ໌ 1 GB ພວກເຮົາຕ້ອງການ 100 10MB chunks ດາວໂຫຼດແລະປະສົມປະສານທີ່ຖືກຕ້ອງ
order
seq 0 99 | ຂະຫນານ -k curl -r \
{}0000000-{}9999999 http://example.com/the/big/file > ເອກະສານ
ຕົວຢ່າງ: ຂະຫນານ grep
grep -r greps recursively ຜ່ານໄດເລກະທໍລີ. ໃນ CPU multicore GNU ຂະຫນານ ສາມາດມັກ
ເລັ່ງອັນນີ້.
ຊອກຫາ . -ປະເພດ f | ຂະຫນານ -k -j150% -n 1000 -m grep -H -n ຄັກ {}
ນີ້ຈະດໍາເນີນການ 1.5 ວຽກຕໍ່ຫຼັກ, ແລະໃຫ້ 1000 ການໂຕ້ຖຽງ grep.
ຕົວຢ່າງ: Grepping n ສາຍ ສໍາລັບການ m ປົກກະຕິ ສຳ ນວນ.
ການແກ້ໄຂທີ່ງ່າຍດາຍທີ່ສຸດເພື່ອ grep ໄຟລ໌ໃຫຍ່ສໍາລັບ regexps ຫຼາຍແມ່ນ:
grep -f regexps.txt bigfile
ຫຼືຖ້າ regexps ແມ່ນສາຍຄົງທີ່:
grep -F -f regexps.txt bigfile
ມີ 2 ປັດໃຈຈໍາກັດ: CPU ແລະ disk I/O. CPU ແມ່ນງ່າຍທີ່ຈະວັດແທກ: ຖ້າ grep ໃຊ້ເວລາ
> 90% CPU (ເຊັ່ນ: ເມື່ອແລ່ນເທິງ), ຫຼັງຈາກນັ້ນ CPU ເປັນປັດໄຈຈໍາກັດ, ແລະການຂະຫນານ
ຈະເລັ່ງອັນນີ້. ຖ້າບໍ່ແມ່ນ, ແຜ່ນ I/O ແມ່ນປັດໃຈຈໍາກັດ, ແລະຂຶ້ນກັບ
ລະບົບ disk ມັນອາດຈະໄວຫຼືຊ້າກວ່າທີ່ຈະຂະຫນານ. ວິທີດຽວທີ່ຈະຮູ້ແນ່ນອນແມ່ນ
ການວັດແທກ.
ຖ້າ CPU ເປັນປັດໄຈຈໍາກັດການຂະຫນານຄວນເຮັດໃນ regexps:
cat regexp.txt | ຂະຫນານ --pipe -L1000 --round-robin grep -f - bigfile
ຖ້າເສັ້ນກົງກັບ regexps ຫຼາຍເສັ້ນ, ເສັ້ນອາດຈະຖືກຊ້ໍາກັນ. ຄໍາສັ່ງຈະເລີ່ມຕົ້ນຫນຶ່ງ
grep ຕໍ່ CPU ແລະອ່ານ bigfile ຫນຶ່ງຄັ້ງຕໍ່ CPU, ແຕ່ວ່າການເຮັດແບບຂະຫນານ, ທັງຫມົດຈະອ່ານ
ຍົກເວັ້ນອັນທໍາອິດຈະຖືກເກັບໄວ້ໃນ RAM. ອີງຕາມຂະຫນາດຂອງ regexp.txt ມັນອາດຈະເປັນ
ໄວກວ່າທີ່ຈະໃຊ້ --block 10m ແທນ -L1000. ຖ້າ regexp.txt ໃຫຍ່ເກີນໄປທີ່ຈະພໍດີກັບ RAM,
ເອົາ --round-robin ແລະປັບ -L1000. ນີ້ຈະເຮັດໃຫ້ bigfile ອ່ານຫຼາຍຄັ້ງ.
ບາງລະບົບການເກັບຮັກສາເຮັດວຽກໄດ້ດີກວ່າເມື່ອອ່ານຫຼາຍຊ່ອງຂະຫນານ. ນີ້ແມ່ນຄວາມຈິງ
ສໍາລັບບາງລະບົບ RAID ແລະບາງລະບົບໄຟລ໌ເຄືອຂ່າຍ. ເພື່ອຂະຫນານການອ່ານຂອງ
ໄຟລ໌ໃຫຍ່:
ຂະຫນານ --pipepart --block 100M -a bigfile -k grep -f regexp.txt
ນີ້ຈະແບ່ງ bigfile ເປັນ 100MB chunks ແລະດໍາເນີນການ grep ໃນແຕ່ລະ chunks ເຫຼົ່ານີ້. ເຖິງ
ຂະຫນານທັງການອ່ານ bigfile ແລະ regexp.txt ສົມທົບສອງອັນໂດຍໃຊ້ --fifo:
ຂະຫນານ --pipepart --block 100M -a bigfile --fifo cat regexp.txt \
\| ຂະຫນານ --pipe -L1000 --round-robin grep -f - {}
ຖ້າເສັ້ນກົງກັບຫຼາຍ regexps, ເສັ້ນອາດຈະຊໍ້າກັນ.
ຕົວຢ່າງ: ການນໍາໃຊ້ ໄລຍະໄກ ຄອມພິວເຕີ
ເພື່ອດໍາເນີນການຄໍາສັ່ງໃນຄອມພິວເຕີຫ່າງໄກສອກຫຼີກ SSH ຈໍາເປັນຕ້ອງໄດ້ຕັ້ງຄ່າແລະທ່ານຕ້ອງສາມາດເຂົ້າສູ່ລະບົບໄດ້
ໂດຍບໍ່ມີການໃສ່ລະຫັດຜ່ານ (ຄໍາສັ່ງ ssh-copy-id ແລະ ssh- ຕົວແທນ ອາດຈະຊ່ວຍໃຫ້ທ່ານເຮັດແນວນັ້ນ).
ຖ້າທ່ານຕ້ອງການເຂົ້າສູ່ລະບົບ cluster ທັງຫມົດ, ໂດຍປົກກະຕິທ່ານບໍ່ຕ້ອງການທີ່ຈະຍອມຮັບລະຫັດເຈົ້າພາບ
ສໍາລັບທຸກໆເຈົ້າພາບ. ທ່ານຕ້ອງການທີ່ຈະຍອມຮັບໃຫ້ເຂົາເຈົ້າຄັ້ງທໍາອິດແລະໄດ້ຮັບການເຕືອນຖ້າຫາກວ່າພວກເຂົາເຈົ້າແມ່ນເຄີຍ
ປ່ຽນແປງ. ເພື່ອເຮັດສິ່ງນີ້:
# ເພີ່ມເຄື່ອງແມ່ຂ່າຍໃສ່ sshloginfile
(echo servera; echo serverb) > .parallel/my_cluster
# ໃຫ້ແນ່ໃຈວ່າມີ .ssh/config
ແຕະ .ssh/config
cp .ssh/config .ssh/config.backup
# ປິດການໃຊ້ງານ StrictHostKeyChecking ຊົ່ວຄາວ
(echo 'Host *'; echo StrictHostKeyChecking no) >> .ssh/config
ຂະຫນານ --slf my_cluster --nonall true
# ເອົາການປິດການໃຊ້ງານ StrictHostKeyChecking
mv .ssh/config.backup .ssh/config
ເຊີບເວີໃນ .parallel/my_cluster ດຽວນີ້ໄດ້ຖືກເພີ່ມເຂົ້າໃນ .ssh/known_hosts.
ແລ່ນ echo on server.example.com:
seq 10 | ຂະຫນານ --sshlogin server.example.com echo
ເພື່ອດໍາເນີນການຄໍາສັ່ງໃນຄອມພິວເຕີທາງໄກຫຼາຍກວ່າຫນຶ່ງແລ່ນ:
seq 10 | ຂະຫນານ --sshlogin server.example.com,server2.example.net echo
ຫລື:
seq 10 | ຂະຫນານ --sshlogin server.example.com \
--sshlogin server2.example.net echo
ຖ້າຊື່ຜູ້ໃຊ້ເຂົ້າສູ່ລະບົບ ຟູ on server2.example.net ໃຊ້:
seq 10 | ຂະຫນານ --sshlogin server.example.com \
--sshlogin [email protected] echo
ຖ້າບັນຊີລາຍຊື່ຂອງເຈົ້າເປັນເຈົ້າພາບ server1-88.example.net ດ້ວຍການເຂົ້າສູ່ລະບົບ ຟູ:
seq 10 | ຂະຫນານ -Sfoo@server{1..88}.example.net echo
ເພື່ອແຈກຢາຍຄໍາສັ່ງໃຫ້ບັນຊີລາຍຊື່ຂອງຄອມພິວເຕີ, ສ້າງໄຟລ໌ ຄອມພິວເຕີຂອງຂ້ອຍ ມີທັງຫມົດ
ຄອມພິວເຕີ:
server.example.com
[email protected]
server3.example.com
ຈາກນັ້ນແລ່ນ:
seq 10 | ຂະຫນານ --sshloginfile mycomputers echo
ເພື່ອລວມເອົາຄອມພິວເຕີທ້ອງຖິ່ນໃຫ້ເພີ່ມ sshlogin ພິເສດ ':' ໃສ່ລາຍການ:
server.example.com
[email protected]
server3.example.com
:
GNU ຂະຫນານ ຈະພະຍາຍາມກໍານົດຈໍານວນຂອງ CPU cores ໃນແຕ່ລະໄລຍະໄກ
ຄອມພິວເຕີ, ແລະດໍາເນີນການຫນຶ່ງວຽກຕໍ່ CPU core - ເຖິງແມ່ນວ່າຄອມພິວເຕີຫ່າງໄກສອກຫຼີກບໍ່ມີ
ຈໍານວນດຽວກັນຂອງ CPU cores.
ຖ້າຈໍານວນຂອງ CPU cores ໃນຄອມພິວເຕີຫ່າງໄກສອກຫຼີກບໍ່ໄດ້ກໍານົດຢ່າງຖືກຕ້ອງເປັນຈໍານວນ
ສາມາດເພີ່ມ CPU cores ຢູ່ທາງຫນ້າ. ໃນທີ່ນີ້ຄອມພິວເຕີມີ 8 ແກນ CPU.
seq 10 | ຂະຫນານ --sshlogin 8/server.example.com echo
ຕົວຢ່າງ: ການໂອນ of ໄຟ
ເພື່ອບີບອັດໄຟລ໌ gzipped ຄືນໃໝ່ດ້ວຍ bzip2 ການນໍາໃຊ້ຄອມພິວເຕີທາງໄກ:
ຊອກຫາບັນທຶກ/ -name '*.gz' | \
ຂະຫນານ --sshlogin server.example.com \
--transfer "zcat {} | bzip2 -9 >{.}.bz2"
ນີ້ຈະສະແດງລາຍການ .gz-files ໃນ ຂໍ້ມູນບັນທຶກ ໄດເລກະທໍລີແລະໄດເລກະທໍລີທັງຫມົດຂ້າງລຸ່ມນີ້. ຫຼັງຈາກນັ້ນມັນຈະ
ໂອນໄຟລ໌ໄປຫາ server.example.com ໄປຫາໄດເລກະທໍລີທີ່ສອດຄ້ອງກັນໃນ $HOME/ບັນທຶກທີ່ຢູ່ ສຸດ
server.example.com ໄຟລ໌ຈະຖືກບີບອັດຄືນໃໝ່ໂດຍໃຊ້ zcat ແລະ bzip2 ສົ່ງຜົນໃຫ້
ໄຟລ໌ທີ່ສອດຄ້ອງກັນກັບ .gz ທົດແທນດ້ວຍ .bz2.
ຖ້າຫາກວ່າທ່ານຕ້ອງການທີ່ໄດ້ຮັບໄຟລ໌ bz2 ໄດ້ຮັບການຍົກຍ້າຍກັບຄືນໄປບ່ອນຄອມພິວເຕີທ້ອງຖິ່ນເພີ່ມ
--ກັບຄືນ {.}.bz2:
ຊອກຫາບັນທຶກ/ -name '*.gz' | \
ຂະຫນານ --sshlogin server.example.com \
--transfer --return {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"
ຫຼັງຈາກ recompressing ແມ່ນເຮັດໄດ້ .bz2-file ຖືກໂອນກັບຄືນໄປບ່ອນຄອມພິວເຕີຂອງທ້ອງຖິ່ນ
ແລະໃສ່ຕໍ່ໄປກັບຕົ້ນສະບັບ .gz-ໄຟລ.
ຖ້າຫາກວ່າທ່ານຕ້ອງການລົບໄຟລ໌ທີ່ຍົກຍ້າຍໃນຄອມພິວເຕີຫ່າງໄກສອກຫຼີກເພີ່ມ --ທໍາຄວາມສະອາດ. ນີ້
ຈະເອົາທັງໄຟລ໌ທີ່ຍົກຍ້າຍກັບຄອມພິວເຕີຫ່າງໄກສອກຫຼີກແລະໄຟລ໌ທີ່ຍົກຍ້າຍ
ຈາກຄອມພິວເຕີທາງໄກ:
ຊອກຫາບັນທຶກ/ -name '*.gz' | \
ຂະຫນານ --sshlogin server.example.com \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"
ຖ້າຫາກວ່າທ່ານຕ້ອງການດໍາເນີນການໃນຄອມພິວເຕີຈໍານວນຫນຶ່ງເພີ່ມຄອມພິວເຕີກັບ --sshlogin ບໍ່ວ່າຈະໃຊ້ ',' ຫຼື
ຫຼາຍ --sshlogin:
ຊອກຫາບັນທຶກ/ -name '*.gz' | \
ຂະຫນານ --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"
ທ່ານສາມາດເພີ່ມຄອມພິວເຕີທ້ອງຖິ່ນໂດຍໃຊ້ --sshlogin :. ນີ້ຈະປິດການທໍາງານການຖອນແລະ
ການໂອນສໍາລັບຄອມພິວເຕີທ້ອງຖິ່ນເທົ່ານັ້ນ:
ຊອກຫາບັນທຶກ/ -name '*.gz' | \
ຂະຫນານ --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--sshlogin : \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"
ປົກກະຕິແລ້ວ --ໂອນ, --ກັບຄືນ ແລະ --ທໍາຄວາມສະອາດ ຖືກນໍາໃຊ້ຮ່ວມກັນ. ພວກເຂົາສາມາດສັ້ນລົງໄດ້
--trc:
ຊອກຫາບັນທຶກ/ -name '*.gz' | \
ຂະຫນານ --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--sshlogin : \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"
ກັບໄຟລ໌ ຄອມພິວເຕີຂອງຂ້ອຍ ປະກອບດ້ວຍບັນຊີລາຍຊື່ຂອງຄອມພິວເຕີທີ່ມັນກາຍເປັນ:
ຊອກຫາບັນທຶກ/ -name '*.gz' | ຂະຫນານ --sshloginfile mycomputers \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"
ຖ້າໄຟລ ~/.parallel/sshloginfile ມີບັນຊີລາຍຊື່ຂອງຄອມພິວເຕີມືສັ້ນພິເສດ
-S .. ສາມາດນໍາໃຊ້:
ຊອກຫາບັນທຶກ/ -name '*.gz' | ຂະໜານ -S.. \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"
ຕົວຢ່າງ: ການແຈກຢາຍ ການເຮັດວຽກ to ທ້ອງຖິ່ນ ແລະ ໄລຍະໄກ ຄອມພິວເຕີ
ປ່ຽນ *.mp3 ເປັນ *.ogg ແລ່ນໜຶ່ງຂະບວນການຕໍ່ CPU core ໃນຄອມພິວເຕີທ້ອງຖິ່ນ ແລະເຊີບເວີ2:
ຂະຫນານ --trc {.}.ogg -S server2,: \
'mpg321 -w - {} | oggenc -q0 - -o {.}.ogg' ::: *.mp3
ຕົວຢ່າງ: ເຮັດວຽກ ໄດ້ ດຽວກັນ ຄໍາສັ່ງ on ໄລຍະໄກ ຄອມພິວເຕີ
ເພື່ອດໍາເນີນການຄໍາສັ່ງ uptime ໃນຄອມພິວເຕີທາງໄກທີ່ທ່ານສາມາດເຮັດໄດ້:
ຂະຫນານ --tag --nonall -S server1,ເຊີບເວີ2 uptime
--nonall ອ່ານບໍ່ມີການໂຕ້ຖຽງ. ຖ້າຫາກທ່ານມີບັນຊີລາຍການຂອງວຽກເຮັດງານທໍາທີ່ທ່ານຕ້ອງການດໍາເນີນການໃນຄອມພິວເຕີແຕ່ລະທ່ານ
ສາມາດເຮັດໄດ້:
ຂະຫນານ --tag --onall -S server1,ເຊີບເວີ2 echo ::: 1 2 3
ເອົາ --tag ຖ້າທ່ານບໍ່ຕ້ອງການ sshlogin ເພີ່ມກ່ອນຜົນຜະລິດ.
ຖ້າທ່ານມີ host ຫຼາຍໃຊ້ '-j0' ເພື່ອເຂົ້າເຖິງ host ຫຼາຍຂະຫນານ.
ຕົວຢ່າງ: ຂະຫນານ rsync
rsync ເປັນເຄື່ອງມືທີ່ດີ, ແຕ່ບາງຄັ້ງມັນຈະບໍ່ຕື່ມແບນວິດທີ່ມີຢູ່. ນີ້ແມ່ນ
ມັກຈະເປັນບັນຫາໃນເວລາທີ່ການຄັດລອກໄຟລ໌ຂະຫນາດໃຫຍ່ຫຼາຍຜ່ານການເຊື່ອມຕໍ່ຄວາມໄວສູງ.
ຕໍ່ໄປນີ້ຈະເລີ່ມຕົ້ນຫນຶ່ງ rsync ຕໍ່ໄຟລ໌ໃຫຍ່ໃນ src-dir to dest-dir ຢູ່ໃນເຊີບເວີ
fooserver:
cd src-dir; ຊອກຫາ . -ປະເພດ f -ຂະຫນາດ + 100000 | ຂະຫນານ -v ssh fooserver mkdir -p
/dest-dir/{//}\;rsync -s -Havesh {} fooserver:/dest-dir/{}
dirs ທີ່ສ້າງຂຶ້ນອາດຈະສິ້ນສຸດດ້ວຍການອະນຸຍາດທີ່ບໍ່ຖືກຕ້ອງແລະໄຟລ໌ຂະຫນາດນ້ອຍກວ່າຈະບໍ່ຖືກ
ໂອນ. ເພື່ອແກ້ໄຂການແລ່ນເຫຼົ່ານັ້ນ rsync ເວລາສຸດທ້າຍ:
rsync -Havesh src-dir/ fooserver:/dest-dir/
ຖ້າທ່ານບໍ່ສາມາດຍູ້ຂໍ້ມູນໄດ້, ແຕ່ຕ້ອງການດຶງພວກມັນແລະໄຟລ໌ທີ່ເອີ້ນວ່າ digits.png
(ເຊັ່ນ: 000000.png) ເຈົ້າອາດຈະສາມາດເຮັດໄດ້:
seq -w 0 99 | ຂະຫນານ rsync -Havesh fooserver:src-path/*{}.png destdir/
ຕົວຢ່າງ: ການນໍາໃຊ້ ຫຼາຍ ວັດສະດຸປ້ອນ in ຫນຶ່ງ ຄໍາສັ່ງ
ສຳເນົາໄຟລ໌ເຊັ່ນ foo.es.ext ໄປໃສ່ foo.ext:
ls *.ແມ່ນ.* | perl -pe 'ພິມ; s/\.es//' | ຂະຫນານ -N2 cp {1} {2}
ຄໍາສັ່ງ perl spits ອອກ 2 ແຖວສໍາລັບການປ້ອນຂໍ້ມູນແຕ່ລະຄົນ. GNU ຂະຫນານ ໃຊ້ເວລາ 2 ວັດສະດຸປ້ອນ (ການນໍາໃຊ້ -N2)
ແລະແທນທີ່ {1} ແລະ {2} ດ້ວຍວັດສະດຸປ້ອນ.
ນັບເປັນຖານສອງ:
ຂະຫນານ -k echo ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1
ພິມຕົວເລກໃສ່ດ້ານກົງກັນຂ້າມຂອງຕາຍຫົກດ້ານ:
ຂະຫນານ --xapply -a <(ຂໍ້ 6) -a <(ຂໍ້ 6 -1 1) echo
ຂະຫນານ --xapply echo :::: <(ຂໍ້ 6) <(ຂໍ້ 6 -1 1)
ປ່ຽນໄຟລ໌ຈາກ subdirs ທັງໝົດເປັນໄຟລ໌ PNG ທີ່ມີຕົວເລກຕິດຕໍ່ກັນ (ເປັນປະໂຫຍດສໍາລັບການສ້າງ
ປ້ອນ PNG ສໍາລັບ ffmpeg):
ຂະຫນານ --xapply -a < (ຊອກຫາ . -ປະເພດ f | ຈັດລຽງ) -a <(ຂໍ້ $(ຊອກຫາ . -ປະເພດ f|wc -l)) ແປງ
{1} {2}.png
ສະບັບທົດແທນ:
ຊອກຫາ . -ປະເພດ f | ການຈັດລຽງ | ຂະຫນານ ແປງ {} {#}.png
ຕົວຢ່າງ: ການນໍາໃຊ້ a ຕາຕະລາງ as ການປ້ອນຂໍ້ມູນ
ເນື້ອໃນຂອງ table_file.tsv:
ຟູ ບາ
ບາສ Quux
ແລ່ນ:
cmd -o bar -i foo
cmd -o quux -i baz
ທ່ານສາມາດດໍາເນີນການ:
ຂະຫນານ -a table_file.tsv --colsep '\t' cmd -o {2} -i {1}
ໝາຍເຫດ: ຄ່າເລີ່ມຕົ້ນຂອງ GNU ຂະຫນານ ແມ່ນເພື່ອເອົາຊ່ອງຫວ່າງອ້ອມຖັນ. ເພື່ອຮັກສາ
ຍະຫວ່າງ:
ຂະຫນານ -a table_file.tsv --ຕັດ n --colsep '\t' cmd -o {2} -i {1}
ຕົວຢ່າງ: ການດໍາເນີນງານ ໄດ້ ດຽວກັນ ຄໍາສັ່ງ 10 ເວລາ
ຖ້າທ່ານຕ້ອງການດໍາເນີນການຄໍາສັ່ງດຽວກັນກັບ arguments ດຽວກັນ 10 ເທື່ອໃນຂະຫນານທ່ານສາມາດເຮັດໄດ້
ເຮັດ:
seq 10 | ຂະຫນານ -n0 my_command my_args
ຕົວຢ່າງ: ການເຮັດວຽກ as cat | sh. ຊັບພະຍາກອນ ລາຄາບໍ່ແພງ ວຽກເຮັດງານທໍາ ແລະ ການປະເມີນຜົນ
GNU ຂະຫນານ ສາມາດເຮັດວຽກຄ້າຍຄືກັນກັບ cat | sh.
ວຽກທີ່ບໍ່ມີຊັບພະຍາກອນແມ່ນວຽກທີ່ໃຊ້ CPU, disk I/O ແລະເຄືອຂ່າຍ I/O ໜ້ອຍຫຼາຍ.
Ping ເປັນຕົວຢ່າງຂອງວຽກທີ່ບໍ່ມີຊັບພະຍາກອນ. wget ແມ່ນເກີນໄປ - ຖ້າຫນ້າເວັບມີຂະຫນາດນ້ອຍ.
ເນື້ອໃນຂອງໄຟລ໌ jobs_to_run:
ping -c 1 10.0.0.1
wget http://example.com/status.cgi?ip=10.0.0.1
ping -c 1 10.0.0.2
wget http://example.com/status.cgi?ip=10.0.0.2
...
ping -c 1 10.0.0.255
wget http://example.com/status.cgi?ip=10.0.0.255
ເພື່ອດໍາເນີນການ 100 ຂະບວນການພ້ອມກັນເຮັດ:
ຂະຫນານ -j 100 < jobs_to_run
ຍ້ອນວ່າບໍ່ມີ ຄໍາສັ່ງ ວຽກງານຈະຖືກປະເມີນໂດຍແກະ.
ຕົວຢ່າງ: ການປະມວນຜົນ a ຂະຫນາດໃຫຍ່ ເອກະສານ ການນໍາໃຊ້ ເພີ່ມເຕີມ core
ເພື່ອປະມວນຜົນໄຟລ໌ຂະຫນາດໃຫຍ່ຫຼືຜົນຜະລິດຈໍານວນຫນຶ່ງທີ່ທ່ານສາມາດນໍາໃຊ້ -- ທໍ່ ເພື່ອແຍກຂໍ້ມູນອອກເປັນທ່ອນໄມ້
ແລະທໍ່ທ່ອນໄມ້ເຂົ້າໄປໃນໂຄງການປຸງແຕ່ງ.
ຖ້າຫາກວ່າໂຄງການແມ່ນ gzip -9 ເຈົ້າສາມາດເຮັດໄດ້:
cat ໄຟລ໌ໃຫຍ່ | ຂະຫນານ -- ທໍ່ --recend '' -k gzip -9 >bigfile.gz
ນີ້ຈະແບ່ງອອກ ໄຟລ໌ໃຫຍ່ ເຂົ້າໄປໃນທ່ອນໄມ້ 1 MB ແລະສົ່ງໄປທີ່ gzip -9 ໃນຂະຫນານ. ຫນຶ່ງ gzip
ຈະດໍາເນີນການຕໍ່ CPU core. ຜົນຜະລິດຂອງ gzip -9 ຈະຖືກເກັບຮັກສາໄວ້ໃນຄໍາສັ່ງແລະບັນທຶກໄວ້
bigfile.gz
gzip ເຮັດວຽກໄດ້ດີຖ້າຜົນຜະລິດຖືກຄັດຕິດ, ແຕ່ການປຸງແຕ່ງບາງຢ່າງບໍ່ເຮັດວຽກເຊັ່ນນັ້ນ -
ສໍາລັບຕົວຢ່າງ, ການຈັດລຽງ. ສໍາລັບ GNU ນີ້ ຂະຫນານ ສາມາດເອົາຜົນໄດ້ຮັບຂອງແຕ່ລະຄໍາສັ່ງເຂົ້າໄປໃນໄຟລ໌.
ນີ້ຈະຈັດຮຽງໄຟລ໌ຂະຫນາດໃຫຍ່ໃນຂະຫນານ:
cat ໄຟລ໌ໃຫຍ່ | ຂະຫນານ -- ທໍ່ --ໄຟລ໌ ການຈັດລຽງ | ຂະຫນານ -Xj1 ການຈັດລຽງ -m {} ';' rm {}
>bigfile.sort
ທີ່ນີ້ ໄຟລ໌ໃຫຍ່ ຖືກແບ່ງອອກເປັນທ່ອນໄມ້ປະມານ 1MB, ແຕ່ລະບລັອກທີ່ລົງທ້າຍດ້ວຍ '\n' (ເຊິ່ງແມ່ນ
ຄ່າເລີ່ມຕົ້ນສໍາລັບ --recend). ແຕ່ລະທ່ອນໄມ້ຖືກສົ່ງກັບ ການຈັດລຽງ ແລະຜົນຜະລິດຈາກ ການຈັດລຽງ ຖືກບັນທຶກໄວ້ໃນ
ໄຟລ໌. ໄຟລ໌ເຫຼົ່ານີ້ຖືກສົ່ງໄປຫາທີສອງ ຂະຫນານ ທີ່ເນັ້ນ ການຈັດລຽງ -m ຢູ່ໃນໄຟລ໌ກ່ອນ
ມັນເອົາໄຟລ໌ອອກ. ຜົນຜະລິດໄດ້ຖືກບັນທຶກໄວ້ bigfile.sort.
GNU ຂະຫນານ's -- ທໍ່ ສູງສຸດແມ່ນປະມານ 100 MB/s ເພາະວ່າທຸກ byte ຕ້ອງຖືກຄັດລອກ
ຜ່ານ GNU ຂະຫນານ. ແຕ່ຖ້າ ໄຟລ໌ໃຫຍ່ ເປັນໄຟລ໌ GNU ທີ່ແທ້ຈິງ (ສາມາດຊອກຫາໄດ້). ຂະຫນານ ສາມາດ by-pass
ການຄັດລອກແລະສົ່ງພາກສ່ວນໂດຍກົງກັບໂຄງການ:
ຂະຫນານ --ທໍ່ -- ຕັນ 100m -a ໄຟລ໌ໃຫຍ່ --ໄຟລ໌ ການຈັດລຽງ | ຂະຫນານ -Xj1 ການຈັດລຽງ -m {} ';' rm
{} >bigfile.sort
ຕົວຢ່າງ: ເຮັດວຽກ ເພີ່ມເຕີມ ກ່ວາ 250 ວຽກເຮັດງານທໍາ ວິທີແກ້ໄຂ
ຖ້າຫາກວ່າທ່ານຕ້ອງການທີ່ຈະດໍາເນີນການຈໍານວນຂະຫນາດໃຫຍ່ຂອງວຽກຂະຫນານ, ຫຼັງຈາກນັ້ນທ່ານອາດຈະມົນຕີໄດ້
ຂອບເຂດຈໍາກັດຂອງ filehandle ເຊິ່ງມັກຈະປະມານ 250 ວຽກ. ຖ້າຫາກວ່າທ່ານເປັນຜູ້ໃຊ້ super ທ່ານສາມາດຍົກສູງບົດບາດໄດ້
ຈໍາກັດໃນ /etc/security/limits.conf ແຕ່ເຈົ້າຍັງສາມາດໃຊ້ວິທີແກ້ໄຂບັນຫານີ້ໄດ້. ມືຈັບໄຟລ໌
ຂີດຈຳກັດແມ່ນຕໍ່ຂະບວນການ. ນັ້ນຫມາຍຄວາມວ່າຖ້າທ່ານພຽງແຕ່ສ້າງ GNU ຫຼາຍຂຶ້ນ ຂະຫນານs ຫຼັງຈາກນັ້ນແຕ່ລະຄົນ
ເຂົາເຈົ້າສາມາດເຮັດວຽກໄດ້ 250 ຕໍາແໜ່ງ. ນີ້ຈະເພີ່ມຂຶ້ນເຖິງ 2500 ວຽກເຮັດງານທໍາ:
cat ການປ້ອນຂໍ້ມູນຂອງຂ້ອຍ | ຂະຫນານ -- ທໍ່ -N 50 --ຮອບ-ໂຣບິນ -j50 ຂະຫນານ -j50 your_prg
ນີ້ຈະເຮັດໃຫ້ເກີດການເຮັດວຽກສູງເຖິງ 62500 (ໃຊ້ຢ່າງລະມັດລະວັງ - ທ່ານຕ້ອງການ RAM 64 GB ເພື່ອເຮັດສິ່ງນີ້, ແລະ.
ທ່ານອາດຈະຈໍາເປັນຕ້ອງໄດ້ເພີ່ມຂຶ້ນ /proc/sys/kernel/pid_max):
cat ການປ້ອນຂໍ້ມູນຂອງຂ້ອຍ | ຂະຫນານ -- ທໍ່ -N 250 --ຮອບ-ໂຣບິນ -j250 ຂະຫນານ -j250 your_prg
ຕົວຢ່າງ: ການເຮັດວຽກ as mutex ແລະ ການນັບ ປະເພດ
ຄໍາສັ່ງ sem ແມ່ນນາມແforງຂອງ ຂະຫນານ --semaphore.
Semaphore ການນັບຈະເຮັດໃຫ້ຈໍານວນວຽກທີ່ກໍານົດໃຫ້ເລີ່ມຕົ້ນໃນພື້ນຫລັງ.
ເມື່ອຈໍານວນວຽກທີ່ເຮັດວຽກຢູ່ໃນພື້ນຫລັງ, GNU sem ຈະລໍຖ້າຫນຶ່ງໃນເຫຼົ່ານີ້
ເພື່ອໃຫ້ສໍາເລັດກ່ອນທີ່ຈະເລີ່ມຄໍາສັ່ງອື່ນ. sem --ລໍຖ້າ ຈະລໍຖ້າໃຫ້ທຸກວຽກເຮັດ
ສົມບູນ.
ດໍາເນີນການ 10 ວຽກພ້ອມກັນໃນພື້ນຫຼັງ:
ສໍາລັບຂ້າພະເຈົ້າໃນ *.log ; ເຮັດ
ແອັກໂກ້ $ i
sem -j10 gzip $i ";" echo ເຮັດແລ້ວ
ເຮັດ
sem --ລໍຖ້າ
mutex ເປັນ semaphore ການນັບທີ່ອະນຸຍາດໃຫ້ເຮັດວຽກພຽງແຕ່ຫນຶ່ງວຽກ. ນີ້ຈະແກ້ໄຂໄຟລ໌
ໄຟລ໌ຂອງຂ້ອຍ ແລະ prepends ໄຟລ໌ດ້ວຍແຖວທີ່ມີຕົວເລກ 1 ຫາ 3.
seq 3 | parallel sem sed -i -e 'i{}' myfile
As ໄຟລ໌ຂອງຂ້ອຍ ສາມາດໃຫຍ່ຫຼາຍມັນເປັນສິ່ງສໍາຄັນພຽງແຕ່ຂະບວນການຫນຶ່ງແກ້ໄຂໄຟລ໌ດຽວກັນ
ເວລາ.
ຕັ້ງຊື່ semaphore ເພື່ອໃຫ້ມີ semaphores ທີ່ແຕກຕ່າງກັນຫຼາຍການເຄື່ອນໄຫວໃນເວລາດຽວກັນ:
seq 3 | parallel sem --id mymutex sed -i -e 'i{}' myfile
ຕົວຢ່າງ: ເລີ່ມຕົ້ນ ບັນນາທິການ ກັບ ຊື່ໄຟລ໌ ຈາກ stdin (ມາດຕະຖານ ວັດສະດຸປ້ອນ)
ທ່ານສາມາດນໍາໃຊ້ GNU ຂະຫນານ ເພື່ອເລີ່ມຕົ້ນໂຄງການແບບໂຕ້ຕອບເຊັ່ນ emacs ຫຼື vi:
cat ບັນຊີລາຍຊື່ໄຟລ໌ | ຂະຫນານ --tty -X emacs
cat ບັນຊີລາຍຊື່ໄຟລ໌ | ຂະຫນານ --tty -X vi
ຖ້າຫາກວ່າມີໄຟລ໌ຫຼາຍກ່ວາຈະເຫມາະໃນບັນຊີຄໍາສັ່ງດຽວ, ບັນນາທິການຈະໄດ້ຮັບການເລີ່ມຕົ້ນ
ອີກເທື່ອຫນຶ່ງກັບໄຟລ໌ທີ່ຍັງເຫຼືອ.
ຕົວຢ່າງ: ເຮັດວຽກ sudo
sudo ຕ້ອງການລະຫັດຜ່ານເພື່ອດໍາເນີນການຄໍາສັ່ງເປັນ root. ມັນ cache ການເຂົ້າເຖິງ, ສະນັ້ນທ່ານພຽງແຕ່ຕ້ອງການ
ເພື່ອໃສ່ລະຫັດຜ່ານອີກຄັ້ງຖ້າທ່ານບໍ່ໄດ້ໃຊ້ sudo ສໍາລັບໃນຂະນະທີ່.
ຄໍາສັ່ງ:
parallel sudo echo ::: ນີ້ແມ່ນຄວາມຄິດທີ່ບໍ່ດີ
ບໍ່ດີ, ຍ້ອນວ່າທ່ານຈະຖືກເຕືອນສໍາລັບລະຫັດຜ່ານ sudo ສໍາລັບແຕ່ລະວຽກ. ເຈົ້າສາມາດ
ບໍ່ວ່າຈະເຮັດ:
sudo echo ນີ້
parallel sudo echo ::: ເປັນຄວາມຄິດທີ່ດີ
ຫລື:
sudo parallel echo ::: ນີ້ແມ່ນຄວາມຄິດທີ່ດີ
ວິທີນີ້ທ່ານພຽງແຕ່ຕ້ອງໃສ່ລະຫັດຜ່ານ sudo ຫນຶ່ງຄັ້ງ.
ຕົວຢ່າງ: GNU ຂະຫນານ as ຄິວ ລະບົບ/ຊຸດ ຜູ້ຈັດການ
GNU ຂະຫນານ ສາມາດເຮັດວຽກເປັນລະບົບແຖວວຽກທີ່ງ່າຍດາຍຫຼືຜູ້ຈັດການ batch. ແນວຄວາມຄິດແມ່ນເພື່ອວາງ
ວຽກງານເຂົ້າໄປໃນໄຟລ໌ແລະມີ GNU ຂະຫນານ ອ່ານຈາກນັ້ນຢ່າງຕໍ່ເນື່ອງ. ເປັນ GNU ຂະຫນານ
ຈະຢຸດຢູ່ໃນຕອນທ້າຍຂອງໄຟລ໌ທີ່ພວກເຮົາໃຊ້ ຫາງ ເພື່ອສືບຕໍ່ການອ່ານ:
ທີ່ແທ້ຈິງ >ແຖວວຽກ; ຫາງ -n+0 -f ແຖວວຽກ | ຂະຫນານ
ເພື່ອສົ່ງວຽກຂອງເຈົ້າໄປຫາຄິວ:
echo my_command my_arg >> ແຖວວຽກ
ແນ່ນອນເຈົ້າສາມາດໃຊ້ -S ເພື່ອແຈກຢາຍວຽກໃຫ້ຄອມພິວເຕີທາງໄກ:
ທີ່ແທ້ຈິງ >ແຖວວຽກ; ຫາງ -f ແຖວວຽກ | ຂະຫນານ -S ..
ມີບັນຫາເລັກນ້ອຍໃນເວລາທີ່ໃຊ້ GNU ຂະຫນານ ເປັນລະບົບແຖວ / ຜູ້ຈັດການ batch: ທ່ານມີ
ເພື່ອສົ່ງຈໍານວນ JobSlot ກ່ອນທີ່ພວກເຂົາຈະເລີ່ມຕົ້ນ, ແລະຫຼັງຈາກນັ້ນທ່ານສາມາດສົ່ງຫນຶ່ງ
ໃນເວລານັ້ນ, ແລະວຽກຈະເລີ່ມຕົ້ນທັນທີຖ້າມີຊ່ອງຫວ່າງຟຣີ. ຜົນຜະລິດຈາກ
ວຽກທີ່ເຮັດວຽກຫຼືສໍາເລັດແລ້ວຈະຖືກຍຶດຄືນແລະຈະຖືກພິມອອກເມື່ອ JobSlots ມີວຽກຫຼາຍຂຶ້ນ
ໄດ້ຖືກເລີ່ມຕົ້ນແລ້ວ (ເວັ້ນເສຍແຕ່ວ່າທ່ານໃຊ້ --ungroup ຫຼື -u, ໃນກໍລະນີໃດກໍ່ຕາມ, ຜົນໄດ້ຮັບຈາກວຽກ
ຖືກພິມອອກທັນທີ). ຕົວຢ່າງ: ຖ້າທ່ານມີ 10 jobslots ຫຼັງຈາກນັ້ນຜົນໄດ້ຮັບຈາກຄັ້ງທໍາອິດ
ວຽກທີ່ສໍາເລັດແລ້ວຈະຖືກພິມອອກພຽງແຕ່ເມື່ອວຽກ 11 ໄດ້ເລີ່ມຕົ້ນ, ແລະຜົນຜະລິດທີສອງ
ວຽກທີ່ສໍາເລັດແລ້ວຈະຖືກພິມອອກເມື່ອວຽກ 12 ໄດ້ເລີ່ມຕົ້ນ.
ການນໍາໃຊ້ --eof ເພື່ອເຮັດໃຫ້ GNU ຂະຫນານ ອອກ, ຫາງ ຍັງຈໍາເປັນຕ້ອງໄດ້ບັງຄັບໃຫ້ອອກ:
tail -n+0 -f command-list.txt |
(parallel --eof=EXIT {}; echo ຂະຫນານແມ່ນເຮັດແລ້ວ;
(seq 1000 >> command-list.txt &);
echo Done ຕື່ມຂໍ້ມູນ dummy ບັງຄັບໃຫ້ຫາງອອກ)
ຕົວຢ່າງ: GNU ຂະຫນານ as dir processor
ຖ້າຫາກວ່າທ່ານມີ dir ທີ່ຜູ້ໃຊ້ໄດ້ຫຼຸດລົງໄຟລ໌ທີ່ຈະຕ້ອງໄດ້ຮັບການປຸງແຕ່ງທ່ານສາມາດເຮັດສິ່ງນີ້ໃນ
GNU/Linux (ຖ້າທ່ານຮູ້ຫຍັງ ແຈ້ງລໍຖ້າ ຖືກເອີ້ນຢູ່ໃນເວທີອື່ນໆຍື່ນບົດລາຍງານ bug):
ແຈ້ງລໍຖ້າ -q -m -r -e ຍ້າຍໄປ -e CLOSE_WRITE -- ຮູບແບບ %w%f my_dir | ຂະຫນານ -u echo
ນີ້ຈະດໍາເນີນການຄໍາສັ່ງ echo ໃນແຕ່ລະໄຟລ໌ທີ່ໃສ່ເຂົ້າໄປໃນ my_dir ຫຼື subdirs ຂອງ my_dir.
ແນ່ນອນເຈົ້າສາມາດໃຊ້ -S ເພື່ອແຈກຢາຍວຽກໃຫ້ຄອມພິວເຕີທາງໄກ:
ແຈ້ງລໍຖ້າ -q -m -r -e ຍ້າຍໄປ -e CLOSE_WRITE -- ຮູບແບບ %w%f my_dir | ຂະຫນານ -S .. -u
echo
ຖ້າໄຟລ໌ທີ່ຈະຖືກປຸງແຕ່ງຢູ່ໃນໄຟລ໌ tar ຫຼັງຈາກນັ້ນ unpacking ໄຟລ໌ຫນຶ່ງແລະປະມວນຜົນມັນ
ທັນທີອາດຈະໄວກ່ວາທໍາອິດ unpacking ໄຟລ໌ທັງຫມົດ. ຕັ້ງຄ່າໂຮງງານຜະລິດ dir ເປັນ
ຂ້າງເທິງແລະ unpack ເຂົ້າໄປໃນ dir ໄດ້.
ການນໍາໃຊ້ GNU Parallel ເປັນ dir processor ມີຂໍ້ຈໍາກັດດຽວກັນກັບການນໍາໃຊ້ GNU Parallel ເປັນ
ລະບົບຄິວ/ຜູ້ຈັດການຊຸດ.
ອ້າງອີງ
GNU ຂະຫນານ ແມ່ນເສລີຫຼາຍໃນການອ້າງອີງ. ທ່ານພຽງແຕ່ຕ້ອງການອ້າງອີງຕົວອັກສອນທີ່ມີ
ຄວາມຫມາຍພິເສດໃນແກະ:
( ) $` ' " < > ; | \
ແລະອີງຕາມສະພາບການເຫຼົ່ານີ້ຈໍາເປັນຕ້ອງໄດ້ອ້າງເຖິງ, ເຊັ່ນດຽວກັນ:
~ & # ! ? ຊ່ອງ * {
ເພາະສະນັ້ນ, ຄົນສ່ວນໃຫຍ່ຈະບໍ່ຕ້ອງການການອ້າງອີງຫຼາຍກວ່າການວາງ '\' ຢູ່ຕໍ່ໜ້າ
ລັກສະນະພິເສດ.
ເລື້ອຍໆເຈົ້າສາມາດໃສ່ \ 'ປະມານທຸກໆ ':
perl -ne '/^\S+\s+\S+$/ ແລະພິມໄຟລ໌ $ARGV,\n"'
ສາມາດອ້າງອີງ:
ຂະຫນານ perl -ne \''/^\S+\s+\S+$/ ແລະພິມ $ARGV,"\n"'\' ::: ໄຟລ໌
ຢ່າງໃດກໍຕາມ, ເມື່ອທ່ານຕ້ອງການໃຊ້ຕົວແປຂອງແກະ, ທ່ານຈໍາເປັນຕ້ອງອ້າງເຖິງ $-sign. ນີ້ແມ່ນ
ຕົວຢ່າງການໃຊ້ $PARALLEL_SEQ. ຕົວແປນີ້ຖືກກໍານົດໂດຍ GNU ຂະຫນານ ຕົວຂອງມັນເອງ, ດັ່ງນັ້ນ
ການປະເມີນຜົນຂອງ $ ຕ້ອງເຮັດໂດຍ sub shell ທີ່ເລີ່ມຕົ້ນໂດຍ GNU ຂະຫນານ:
seq 10 | ຂະຫນານ -N2 echo seq:\$PARALLEL_SEQ arg1:{1} arg2:{2}
ຖ້າຕົວແປຖືກຕັ້ງກ່ອນ GNU ຂະຫນານ ເລີ່ມຕົ້ນທີ່ທ່ານສາມາດເຮັດໄດ້ນີ້:
VAR=this_is_set_before_starting
echo ການທົດສອບ | ຂະຫນານ echo {} $VAR
ພິມ: ການທົດສອບ this_is_set_before_starting
ມັນເປັນເລື່ອງທີ່ຫຍຸ້ງຍາກເລັກນ້ອຍຖ້າຕົວແປມີຫຼາຍກວ່າໜຶ່ງຊ່ອງຕິດຕໍ່ກັນ:
VAR="ສອງ spaces ລະຫວ່າງ ແຕ່ລະຄົນ ຄໍາ"
echo ການທົດສອບ | ຂະຫນານ echo {} \'"$VAR"\'
ພິມ: ການທົດສອບ ສອງ spaces ລະຫວ່າງ ແຕ່ລະຄົນ ຄໍາ
ຖ້າຕົວແປບໍ່ຄວນຖືກປະເມີນໂດຍແກະເລີ່ມຕົ້ນ GNU ຂະຫນານ ແຕ່ຈະ
ປະເມີນໂດຍ sub shell ເລີ່ມໂດຍ GNU ຂະຫນານ, ຫຼັງຈາກນັ້ນທ່ານຈໍາເປັນຕ້ອງອ້າງອີງມັນ:
echo ການທົດສອບ | ຂະຫນານ VAR=this_is_set_after_starting \; echo {} \$VAR
ພິມ: ການທົດສອບ this_is_set_after_starting
ມັນເປັນເລື່ອງທີ່ຫຍຸ້ງຍາກເລັກນ້ອຍຖ້າຕົວແປມີພື້ນທີ່:
echo ການທົດສອບ | ຂະຫນານ VAR='"ສອງ spaces ລະຫວ່າງ ແຕ່ລະຄົນ ຄໍາ"' echo {} \'"$VAR"\'
ພິມ: ການທົດສອບ ສອງ spaces ລະຫວ່າງ ແຕ່ລະຄົນ ຄໍາ
$$ ແມ່ນຕົວແປຂອງ shell ທີ່ມີ id ຂະບວນການຂອງ shell. ນີ້ຈະພິມ
process id ຂອງ shell ແລ່ນ GNU ຂະຫນານ:
seq 10 | ຂະຫນານ echo $$
ແລະນີ້ຈະພິມ ids ຂະບວນການຂອງແກະຍ່ອຍທີ່ເລີ່ມຕົ້ນໂດຍ GNU ຂະຫນານ.
seq 10 | ຂະຫນານ echo \$\$
ຖ້າລັກສະນະພິເສດບໍ່ຄວນຖືກປະເມີນໂດຍ sub shell ຫຼັງຈາກນັ້ນທ່ານຈໍາເປັນຕ້ອງ
ປົກປ້ອງມັນຈາກການປະເມີນຈາກທັງສອງແກະທີ່ເລີ່ມຕົ້ນ GNU ຂະຫນານ ແລະເປືອກຍ່ອຍ:
echo ການທົດສອບ | ຂະຫນານ echo {} \\\$VAR
ພິມ: ການທົດສອບ $VAR
GNU ຂະຫນານ ສາມາດປ້ອງກັນການປະເມີນໂດຍ sub shell ໂດຍໃຊ້ -q:
echo ການທົດສອບ | ຂະຫນານ -q echo {} \$VAR
ພິມ: ການທົດສອບ $VAR
ນີ້ແມ່ນເປັນປະໂຫຍດໂດຍສະເພາະຖ້າທ່ານມີຄໍາອ້າງອີງຫຼາຍ. ຖ້າທ່ານຕ້ອງການແລ່ນສະຄິບ perl
ເຊັ່ນນີ້:
perl - ບໍ່ '/^\S+\s+\S+$/ ແລະ ພິມ $ARGV,"\n"' ເອກະສານ
ມັນຈໍາເປັນຕ້ອງໄດ້ອ້າງເຖິງນີ້:
ls | ຂະຫນານ perl - ບໍ່ '/^\\S+\\s+\\S+\$/\ ແລະ\ ພິມ\ \$ARGV,\"\\n\"' ls | ຂະຫນານ perl
- ບໍ່ \''/^\S+\s+\S+$/ ແລະ ພິມ $ARGV,"\n"'\'
ສັງເກດເຫັນວິທີ spaces, \'s, "'s, ແລະ $'s ຈໍາເປັນຕ້ອງຖືກອ້າງອີງ. GNU ຂະຫນານ ສາມາດເຮັດໄດ້ quoting ໂດຍ
ການນໍາໃຊ້ທາງເລືອກ -q:
ls | ຂະຫນານ -q perl - ບໍ່ '/^\S+\s+\S+$/ ແລະ ພິມ $ARGV,"\n"'
ຢ່າງໃດກໍຕາມ, ນີ້ຫມາຍຄວາມວ່າທ່ານບໍ່ສາມາດເຮັດໃຫ້ sub shell ຕີຄວາມຫມາຍລັກສະນະພິເສດ. ສໍາລັບ
ຕົວຢ່າງຍ້ອນ -q ນີ້ຈະບໍ່ເຮັດວຽກ:
ls *.gz | ຂະຫນານ -q "zcat {} >{.}"
ls *.gz | ຂະຫນານ -q "zcat {} | bzip2 >{.}.bz2"
ເພາະ > ແລະ | ຈໍາເປັນຕ້ອງໄດ້ຮັບການຕີຄວາມຫມາຍໂດຍ sub shell.
ຖ້າຫາກທ່ານໄດ້ຮັບຄວາມຜິດພາດເຊັ່ນ:
sh: -c: line 0: syntax error ໃກ້ token ທີ່ບໍ່ຄາດຄິດ
sh: syntax error: unterminated quoted string
sh: -c: line 0: EOF ທີ່ບໍ່ຄາດຄິດໃນຂະນະທີ່ຊອກຫາການຈັບຄູ່ `''
sh: -c: line 1: syntax error: unexpected end of file
ຫຼັງຈາກນັ້ນ, ທ່ານອາດຈະລອງໃຊ້ -q.
ຖ້າທ່ານກໍາລັງໃຊ້ bash ຂະບວນການທົດແທນເຊັ່ນ <(ແມວ ຟູ) ຫຼັງຈາກນັ້ນທ່ານອາດຈະພະຍາຍາມ -q ແລະ
ລໍຖ້າ ຄໍາສັ່ງ ກັບ bash -c:
ls | ຂະຫນານ -q bash -c 'ຫອງນໍາ -c <(ສຽງ {})'
ຫຼືສໍາລັບການທົດແທນຜົນຜະລິດ:
ls | ຂະຫນານ -q bash -c 'tar c {} | tee >(gzip >{}.tar.gz) | bzip2 >{}.tar.bz2'
ສະຫຼຸບ: ເພື່ອຫຼີກເວັ້ນການຈັດການກັບບັນຫາການອ້າງອີງມັນອາດຈະງ່າຍຂຶ້ນພຽງແຕ່ຂຽນ a
script ຂະຫນາດນ້ອຍຫຼືຫນ້າທີ່ (ຈື່ ການສົ່ງອອກ -f ຟັງຊັນ) ແລະມີ GNU ຂະຫນານ ໂທ
that
LIST ແລ່ນ JOBS
ຖ້າທ່ານຕ້ອງການບັນຊີລາຍຊື່ຂອງວຽກທີ່ເຮັດວຽກຢູ່, ທ່ານສາມາດດໍາເນີນການໄດ້:
killall -USR1 ຂະຫນານ
GNU ຂະຫນານ ຫຼັງຈາກນັ້ນຈະພິມວຽກເຮັດງານທໍາໃນປັດຈຸບັນກ່ຽວກັບ stderr (ຄວາມຜິດພາດມາດຕະຖານ).
COMPLETE ແລ່ນ JOBS ແຕ່ DO ບໍ່ START NEW JOBS
ຖ້າທ່ານເສຍໃຈທີ່ເລີ່ມຕົ້ນຫຼາຍວຽກ, ທ່ານສາມາດທໍາລາຍ GNU ໄດ້ ຂະຫນານ, ແຕ່ຖ້າທ່ານຕ້ອງການ
ໃຫ້ແນ່ໃຈວ່າທ່ານບໍ່ມີວຽກເຮັດສໍາເລັດເຄິ່ງຫນຶ່ງທີ່ທ່ານຄວນສົ່ງສັນຍານ ໄລຍະເປົ້າໝາຍ ກັບ GNU
ຂະຫນານ:
killall -ເວລາກາງຄືນ ຂະຫນານ
ນີ້ຈະບອກ GNU ຂະຫນານ ທີ່ຈະບໍ່ເລີ່ມວຽກໃຫມ່, ແຕ່ລໍຖ້າຈົນກ່ວາໃນປັດຈຸບັນ
ວຽກທີ່ເຮັດວຽກແມ່ນສໍາເລັດກ່ອນທີ່ຈະອອກ.
ENVIRONMENT ຄວາມຮັບຜິດຊອບ
$PARALLEL_PID
ຕົວແປສະພາບແວດລ້ອມ $PARALLEL_PID ຖືກກໍານົດໂດຍ GNU ຂະຫນານ ແລະແມ່ນສັງເກດເຫັນ
ວຽກເຮັດງານທໍາໄດ້ເລີ່ມຕົ້ນຈາກ GNU ຂະຫນານ. ນີ້ເຮັດໃຫ້ມັນເປັນໄປໄດ້ສໍາລັບວຽກເຮັດງານທໍາທີ່ຈະ
ຕິດຕໍ່ສື່ສານໂດຍກົງກັບ GNU ຂະຫນານ. ຈືຂໍ້ມູນການທີ່ຈະອ້າງເຖິງ $, ສະນັ້ນມັນໄດ້ຮັບ
ປະເມີນໂດຍແກະທີ່ຖືກຕ້ອງ.
ຕົວຢ່າງ: ຖ້າແຕ່ລະວຽກທົດສອບການແກ້ໄຂແລະຫນຶ່ງຂອງວຽກເຮັດງານທໍາຊອກຫາທາງອອກ
ວຽກເຮັດງານທໍາສາມາດບອກ GNU ຂະຫນານ ບໍ່ໃຫ້ເລີ່ມວຽກຫຼາຍໂດຍ: ຂ້າ -ເວລາກາງຄືນ
$PARALLEL_PID. ນີ້ພຽງແຕ່ເຮັດວຽກຢູ່ໃນຄອມພິວເຕີທ້ອງຖິ່ນ.
$PARALLEL_SHELL (ການທົດສອບອັນຟາ)
ໃຊ້ shell ນີ້ shell ສໍາລັບຄໍາສັ່ງທີ່ດໍາເນີນການໂດຍ GNU Parallel:
· $PARALLEL_SHELL. ຖ້າບໍ່ໄດ້ກໍານົດການນໍາໃຊ້:
·ແກະທີ່ເລີ່ມຕົ້ນ GNU Parallel. ຖ້າມັນບໍ່ສາມາດກໍານົດໄດ້:
· $SHELL. ຖ້າບໍ່ໄດ້ກໍານົດການນໍາໃຊ້:
· / ຖັງ / sh
$PARALLEL_SEQ
$PARALLEL_SEQ ຈະຖືກຕັ້ງເປັນເລກລຳດັບຂອງວຽກທີ່ເຮັດວຽກຢູ່. ຈື່ໄວ້
quote the $, ສະນັ້ນມັນໄດ້ຮັບການປະເມີນໂດຍ shell ທີ່ຖືກຕ້ອງ.
ຕົວຢ່າງ:
seq 10 | ຂະຫນານ -N2 echo seq:'$'PARALLEL_SEQ arg1:{1} arg2:{2}
$TMPDIR Directory ສໍາລັບໄຟລ໌ຊົ່ວຄາວ. ເບິ່ງ: --tmpdir.
$PARALLEL
ຕົວແປສະພາບແວດລ້ອມ $PARALLEL ຈະຖືກໃຊ້ເປັນຕົວເລືອກເລີ່ມຕົ້ນສຳລັບ GNU
ຂະຫນານ. ຖ້າຕົວແປມີຕົວອັກສອນ shell ພິເສດ (ເຊັ່ນ: $, *, ຫຼື space)
ຫຼັງຈາກນັ້ນ, ເຫຼົ່ານີ້ຈໍາເປັນຕ້ອງຖືກຫລົບຫນີດ້ວຍ \.
ຕົວຢ່າງ:
cat ບັນຊີລາຍຊື່ | ຂະຫນານ -j1 -k -v ls
ສາມາດຂຽນເປັນ:
cat ບັນຊີລາຍຊື່ | PARALLEL="-kvj1" ຂະຫນານ ls
cat ບັນຊີລາຍຊື່ | ຂະຫນານ -j1 -k -v -S"myssh user@server" ls
ສາມາດຂຽນເປັນ:
cat ບັນຊີລາຍຊື່ | PARALLEL='-kvj1 -S myssh\ user@server' ຂະຫນານ echo
ສັງເກດເຫັນ \ ຢູ່ກາງແມ່ນຈໍາເປັນເພາະວ່າ 'myssh' ແລະ 'user@server' ຈະຕ້ອງເປັນ
ຫນຶ່ງໂຕ້ຖຽງ.
ຄ່າເລີ່ມຕົ້ນ ຂໍ້ມູນ (CONFIG ໄຟລ໌)
ໄຟລ໌ການຕັ້ງຄ່າທົ່ວໂລກ /etc/parallel/config, ຕິດຕາມດ້ວຍໄຟລ໌ການຕັ້ງຄ່າຜູ້ໃຊ້
~/.parallel/config (ເມື່ອກ່ອນເອີ້ນວ່າ .parallelrc) ຈະຖືກອ່ານໃນທາງກັບກັນຖ້າພວກມັນມີຢູ່.
ແຖວທີ່ເລີ່ມຕົ້ນດ້ວຍ '#' ຈະຖືກລະເລີຍ. ຮູບແບບສາມາດປະຕິບັດຕາມສະພາບແວດລ້ອມໄດ້
ຕົວແປ $PARALLEL, ແຕ່ມັນມັກຈະງ່າຍກວ່າທີ່ຈະພຽງແຕ່ໃສ່ແຕ່ລະທາງເລືອກໃນແຖວຂອງຕົນເອງ.
ຕົວເລືອກຕ່າງໆໃນບັນທັດຄໍາສັ່ງແມ່ນມີຄວາມສຳຄັນ, ຕິດຕາມດ້ວຍຕົວແປສະພາບແວດລ້ອມ
$PARALLEL, ໄຟລ໌ການຕັ້ງຄ່າຜູ້ໃຊ້ ~/.parallel/config, ແລະສຸດທ້າຍທົ່ວໂລກ
ໄຟລ໌ການຕັ້ງຄ່າ /etc/parallel/config.
ໃຫ້ສັງເກດວ່າບໍ່ມີໄຟລ໌ທີ່ອ່ານສໍາລັບທາງເລືອກ, ຫຼືຕົວແປສະພາບແວດລ້ອມ $PARALLEL, ອາດຈະ
ມີທາງເລືອກໃນການອອກບໍານານເຊັ່ນ: --ໂທເລຟ.
ຂໍ້ມູນ ເອກະສານ
If --ໂປຣໄຟລ໌ ຕັ້ງ, GNU ຂະຫນານ ຈະອ່ານໂປຣໄຟລ໌ຈາກໄຟລ໌ນັ້ນແທນທີ່ຈະເປັນທົ່ວໂລກ
ຫຼືໄຟລ໌ການຕັ້ງຄ່າຜູ້ໃຊ້. ທ່ານສາມາດມີຫຼາຍ --ໂປຣໄຟລ໌.
ຕົວຢ່າງ: Profile ສໍາລັບແລ່ນຄໍາສັ່ງຢູ່ໃນທຸກ sshlogin ໃນ ~/.ssh/sshlogins ແລະ prepend
ຜົນໄດ້ຮັບກັບ sshlogin:
echo --tag -S.. --nonall > ~/.parallel/n
ຂະຫນານ -Jn uptime
ຕົວຢ່າງ: Profile ສໍາລັບແລ່ນທຸກຄໍາສັ່ງກັບ -j-1 ແລະ ງາມ
echo -j-1 ງາມ > ~/.parallel/nice_profile
ຂະຫນານ -J nice_profile bzip2 -9 ::: *
ຕົວຢ່າງ: ໂປຣໄຟລ໌ສຳລັບການແລ່ນສະຄຣິບ perl ກ່ອນທຸກຄຳສັ່ງ:
echo "perl -e '\$a=\$\$; ພິມ \$a,\" \",'\$PARALLEL_SEQ',\" \";';" > ~/.parallel/pre_perl
ຂະຫນານ -J pre_perl echo ::: *
ໃຫ້ສັງເກດວ່າ $ ແລະ " ຈໍາເປັນຕ້ອງຖືກອ້າງອີງແນວໃດໂດຍໃຊ້ \.
ຕົວຢ່າງ: Profile ສໍາລັບແລ່ນວຽກແຈກຢາຍກັບ ງາມ ໃນຄອມພິວເຕີທາງໄກ:
echo -S .. ງາມ > ~/.parallel/dist
ຂະຫນານ -J dist --trc {.}.bz2 bzip2 -9 ::: *
ອອກ STATUS
If --halt-on-error 0 ຫຼືບໍ່ໄດ້ລະບຸໄວ້:
0 ວຽກທັງໝົດເຮັດວຽກໂດຍບໍ່ມີຂໍ້ຜິດພາດ.
1-253 ບາງວຽກລົ້ມເຫລວ. ສະຖານະການອອກໃຫ້ຈໍານວນວຽກທີ່ລົ້ມເຫລວ
254 ຫຼາຍກວ່າ 253 ວຽກທີ່ລົ້ມເຫລວ.
255 ຂໍ້ຜິດພາດອື່ນໆ.
If --halt-on-error 1 ຫຼື 2: ອອກຈາກສະຖານະຂອງວຽກທີ່ລົ້ມເຫລວ.
ຄວາມແຕກຕ່າງ BETWEEN GNU ຂະຫນານ ແລະ ບັນຫາອື່ນໆ
ມີຫຼາຍໆໂຄງການທີ່ມີບາງຫນ້າທີ່ເຮັດວຽກຂອງ GNU ຂະຫນານ. GNU ຂະຫນານ
ພະຍາຍາມລວມເອົາການທໍາງານທີ່ດີທີ່ສຸດໂດຍບໍ່ມີການເສຍສະລະຄວາມສະດວກໃນການນໍາໃຊ້.
ບົດສະຫຼຸບ ຕາຕະລາງ
ລັກສະນະຕໍ່ໄປນີ້ແມ່ນຢູ່ໃນບາງເຄື່ອງມືທີ່ປຽບທຽບໄດ້:
ປັດໄຈນໍາເຂົ້າ
I1. ການໂຕ້ຖຽງສາມາດອ່ານໄດ້ຈາກ stdin
I2. ການໂຕ້ຖຽງສາມາດອ່ານໄດ້ຈາກໄຟລ໌
I3. ການໂຕ້ຖຽງສາມາດອ່ານໄດ້ຈາກຫຼາຍໄຟລ໌
I4. ການໂຕ້ຖຽງສາມາດອ່ານໄດ້ຈາກເສັ້ນຄໍາສັ່ງ
I5. ການໂຕ້ຖຽງສາມາດອ່ານໄດ້ຈາກຕາຕະລາງ
I6. ການໂຕ້ຖຽງສາມາດອ່ານໄດ້ຈາກໄຟລ໌ດຽວກັນໂດຍໃຊ້ #! (ເຊບັງ)
I7. ການປ້ອນຂໍ້ມູນແບບສາຍເປັນຄ່າເລີ່ມຕົ້ນ (ການອ້າງອີງຂອງຕົວອັກສອນພິເສດບໍ່ຈໍາເປັນ)
ການຫມູນໃຊ້ວັດສະດຸປ້ອນ
M1. ຄໍາສັ່ງປະກອບ
M2. ການໂຕ້ຖຽງຫຼາຍອັນສາມາດຕື່ມຂໍ້ມູນໃສ່ເສັ້ນປະຕິບັດໄດ້
M3. ການໂຕ້ຖຽງສາມາດຖືກໃສ່ທຸກບ່ອນໃນເສັ້ນການປະຕິບັດ
M4. ການໂຕ້ຖຽງຫຼາຍສາມາດຖືກໃສ່ທຸກບ່ອນໃນເສັ້ນການປະຕິບັດ
M5. ການໂຕ້ຖຽງສາມາດຖືກແທນທີ່ດ້ວຍບໍລິບົດ
M6. ການປ້ອນຂໍ້ມູນສາມາດຖືກປະຕິບັດເປັນເສັ້ນປະຕິບັດທີ່ສົມບູນ
Outputs
O1. ການຈັດກຸ່ມຜົນຜະລິດເພື່ອໃຫ້ຜົນຜະລິດຈາກວຽກທີ່ແຕກຕ່າງກັນບໍ່ປະສົມກັນ
O2. ສົ່ງ stderr (ຄວາມຜິດພາດມາດຕະຖານ) ໄປ stderr (ຄວາມຜິດພາດມາດຕະຖານ)
O3. ສົ່ງ stdout (ຜົນຜະລິດມາດຕະຖານ) ໄປ stdout (ຜົນຜະລິດມາດຕະຖານ)
O4. ຄໍາສັ່ງຂອງຜົນຜະລິດສາມາດຄືກັນກັບຄໍາສັ່ງຂອງວັດສະດຸປ້ອນ
O5. Stdout ມີພຽງແຕ່ stdout (ຜົນຜະລິດມາດຕະຖານ) ຈາກຄໍາສັ່ງ
O6. Stderr ມີພຽງແຕ່ stderr (ຄວາມຜິດພາດມາດຕະຖານ) ຈາກຄໍາສັ່ງ
ການບໍລິຫານ
E1. ແລ່ນວຽກຂະຫນານ
E2. ລາຍຊື່ວຽກທີ່ເຮັດວຽກ
E3. ສໍາເລັດການແລ່ນວຽກ, ແຕ່ບໍ່ໄດ້ເລີ່ມຕົ້ນວຽກເຮັດງານທໍາໃຫມ່
E4. ຈໍານວນຂອງການເຮັດວຽກສາມາດຂຶ້ນກັບຈໍານວນຂອງ cpus
E5. ສໍາເລັດການແລ່ນວຽກ, ແຕ່ຢ່າເລີ່ມວຽກໃຫມ່ຫຼັງຈາກຄວາມລົ້ມເຫລວຄັ້ງທໍາອິດ
E6. ຈໍານວນຂອງວຽກແລ່ນສາມາດປັບໄດ້ໃນຂະນະທີ່ແລ່ນ
ການປະຕິບັດທາງໄກ
R1. ວຽກສາມາດດໍາເນີນການໄດ້ໃນຄອມພິວເຕີທາງໄກ
R2. Basefiles ສາມາດໂອນໄດ້
R3. ໄຟລ໌ການໂຕ້ຖຽງສາມາດໂອນໄດ້
R4. ໄຟລ໌ຜົນໄດ້ຮັບສາມາດໄດ້ຮັບການໂອນ
R5. ທໍາຄວາມສະອາດຂອງໄຟລ໌ທີ່ຍົກຍ້າຍ
R6. ບໍ່ມີໄຟລ໌ config ທີ່ຈໍາເປັນ
R7. ຢ່າແລ່ນຫຼາຍກວ່າ MaxStartups ຂອງ SSHD ສາມາດຈັດການໄດ້
R8. ຄໍາສັ່ງ SSH ທີ່ສາມາດກໍານົດໄດ້
R9. ລອງອີກຄັ້ງຖ້າການເຊື່ອມຕໍ່ແຕກເປັນບາງໂອກາດ
ເຊມໂຟຣ
S1. ຄວາມເປັນໄປໄດ້ໃນການເຮັດວຽກເປັນ mutex
S2. ຄວາມເປັນໄປໄດ້ໃນການເຮັດວຽກເປັນ semaphore ການນັບ
ຕໍາດົນ
- = ບໍ່
x = ບໍ່ສາມາດໃຊ້ໄດ້
ID = ແມ່ນ
ເນື່ອງຈາກທຸກໂຄງການສະບັບໃຫມ່ບໍ່ໄດ້ທົດສອບຕາຕະລາງອາດຈະລ້າສະໄຫມ. ກະລຸນາຍື່ນ
ລາຍງານຂໍ້ຜິດພາດຖ້າທ່ານພົບຂໍ້ຜິດພາດ (ເບິ່ງການລາຍງານຂໍ້ຜິດພາດ).
ຂະຫນານ: I1 I2 I3 I4 I5 I6 I7 M1 M2 M3 M4 M5 M6 O1 O2 O3 O4 O5 O6 E1 E2 E3 E4 E5 E6 R1 R2
R3 R4 R5 R6 R7 R8 R9 S1 S2
xargs: I1 I2 - - - - - - M2 M3 - - - - O2 O3 - O5 O6 E1 - - - - - - - - -
-x - - - -
ຊອກຫາ -exec: - - - x - x - - M2 M3 - - - - - O2 O3 O4 O5 O6 - - - - - - -
- - - - - - - xx
ເຮັດໃຫ້ -j: - - - - - - - - - - - - - O1 O2 O3 - x O6 E1 - - - E5 - - - -
- - - - - - - -.
ppss: I1 I2 - - - - I7 M1 - M3 - - M6 O1 - - x - - E1 E2 ?E3 E4 - - R1 R2 R3 R4
- - ?R7 ? ? - -
pexec: I1 I2 - I4 I5 - - M1 - M3 - - M6 O1 O2 O3 - O5 O6 E1 - - E4 - E6 R1 - -
- - R6 - - - S1 -
xjobs: TODO - ກະລຸນາຍື່ນບົດລາຍງານ bug ຖ້າທ່ານຮູ້ວ່າຄຸນລັກສະນະໃດແດ່ທີ່ xjobs ສະຫນັບສະຫນູນ (ເບິ່ງ
ລາຍງານຂໍ້ບົກພ່ອງ).
prll: TODO - ກະລຸນາຍື່ນລາຍງານ bug ຖ້າເຈົ້າຮູ້ວ່າຄຸນສົມບັດ prll ຮອງຮັບຫຍັງແດ່ (ເບິ່ງ
ລາຍງານຂໍ້ບົກພ່ອງ).
dxargs: TODO - ກະລຸນາຍື່ນລາຍງານຂໍ້ບົກພ່ອງຖ້າທ່ານຮູ້ວ່າ dxargs ຮອງຮັບຄຸນສົມບັດໃດແດ່ (ເບິ່ງ
ລາຍງານຂໍ້ບົກພ່ອງ).
mdm/middelman: TODO - ກະລຸນາຍື່ນລາຍງານຂໍ້ຜິດພາດຖ້າທ່ານຮູ້ວ່າ mdm/middelman ມີລັກສະນະໃດແດ່
ສະຫນັບສະຫນູນ (ເບິ່ງການລາຍງານຂໍ້ບົກພ່ອງ).
xapply: TODO - ກະລຸນາຍື່ນລາຍງານ bug ຖ້າຫາກວ່າທ່ານຮູ້ວ່າຄຸນນະສົມບັດ xapply ສະຫນັບສະຫນູນ (ເບິ່ງ
ລາຍງານຂໍ້ບົກພ່ອງ).
paexec: TODO - ກະລຸນາຍື່ນບົດລາຍງານ bug ຖ້າທ່ານຮູ້ວ່າຄຸນສົມບັດໃດທີ່ paexec ສະຫນັບສະຫນູນ (ເບິ່ງ
ລາຍງານຂໍ້ບົກພ່ອງ).
ladon: TODO - ກະລຸນາຍື່ນລາຍງານ bug ຖ້າເຈົ້າຮູ້ວ່າລັກສະນະໃດແດ່ທີ່ ladon ສະຫນັບສະຫນູນ (ເບິ່ງ
ລາຍງານຂໍ້ບົກພ່ອງ).
ClusterSSH: TODO - ກະລຸນາຍື່ນລາຍງານຂໍ້ຜິດພາດຖ້າທ່ານຮູ້ວ່າ ClusterSSH ຮອງຮັບຄຸນສົມບັດໃດແດ່.
(ເບິ່ງການລາຍງານຂໍ້ບົກພ່ອງ).
ຄວາມແຕກຕ່າງ BETWEEN xargs ແລະ GNU ຂະຫນານ
xargs ສະເຫນີບາງຄວາມເປັນໄປໄດ້ດຽວກັນກັບ GNU ຂະຫນານ.
xargs ປະຕິບັດບໍ່ດີກັບຕົວອັກສອນພິເສດ (ເຊັ່ນ: ຊ່ອງ, ' ແລະ ") ເພື່ອເບິ່ງບັນຫາໃຫ້ພະຍາຍາມ
ນີ້:
ແຕະທີ່ສໍາຄັນ_file
ແຕະ 'not important_file'
ບໍ່* | xargs rm
mkdir -p "ບັນທຶກ 12 ຂອງອ້າຍຂອງຂ້ອຍ"
ls | xargs rmdir
ທ່ານສາມາດກໍານົດ -0 or -d "\n", ແຕ່ເຄື່ອງກໍາເນີດວັດສະດຸປ້ອນຈໍານວນຫຼາຍບໍ່ໄດ້ຖືກປັບປຸງໃຫ້ເຫມາະສົມສໍາລັບການນໍາໃຊ້ null
ເປັນຕົວແຍກແຕ່ຖືກປັບປຸງໃຫ້ເໝາະສົມ ແຖວໃໝ່ ເປັນຕົວແຍກ. ຕົວຢ່າງ ຫົວຫນ້າ, ຫາງ, ງຸ່ມ, ls, echo,
sed, tar -v, perl (-0 ແລະ \0 ແທນ \n), ຊອກຫາສະຖານທີ່ (ຕ້ອງໃຊ້ -0), ຊອກຫາ (ຕ້ອງການ
ການນໍາໃຊ້ -ພິມ0), grep (ຮຽກຮ້ອງໃຫ້ຜູ້ໃຊ້ໃຊ້ -z or -Z), ການຈັດລຽງ (ຕ້ອງໃຊ້ -z).
ດັ່ງນັ້ນ GNU ຂະຫນານການແຍກແຖວໃໝ່ຂອງສາມາດຖືກຈຳລອງດ້ວຍ:
cat | xargs -d "\n" -n1 ຄໍາສັ່ງ
xargs ສາມາດດໍາເນີນການຈໍານວນຂອງວຽກເຮັດງານທໍາຂະຫນານກັນ, ແຕ່ວ່າບໍ່ມີການສະຫນັບສະຫນູນສໍາລັບການແລ່ນຈໍານວນ.
of-cpu-cores ວຽກຂະຫນານ.
xargs ບໍ່ມີການສະຫນັບສະຫນູນສໍາລັບການຈັດກຸ່ມຜົນຜະລິດໄດ້, ດັ່ງນັ້ນຜົນຜະລິດອາດຈະດໍາເນີນການຮ່ວມກັນ, ຕົວຢ່າງ
ເຄິ່ງທໍາອິດຂອງເສັ້ນແມ່ນມາຈາກຂະບວນການຫນຶ່ງແລະເຄິ່ງສຸດທ້າຍຂອງເສັ້ນແມ່ນມາຈາກອີກ
ຂະບວນການ. ຕົວຢ່າງ ຂະຫນານ grep ບໍ່ສາມາດເຮັດໄດ້ດ້ວຍຄວາມເຊື່ອຖື xargs ເນື່ອງຈາກວ່ານີ້. ເຖິງ
ເບິ່ງນີ້ໃນການປະຕິບັດພະຍາຍາມ:
ຂະໜານ perl -e '\$a=\"1{}\"x10000000\;ພິມ\ $a,\"\\n\"' '>' {} ::: abcdef
ls -labcdef
parallel -kP4 -n1 grep 1 > out.par ::: abcdef
echo abcdef | xargs -P4 -n1 grep 1 > out.xargs-unbuf
echo abcdef | xargs -P4 -n1 grep --line-buffered 1 > out.xargs-linebuf
echo abcdef | xargs -n1 grep 1 > out.xargs-serial
ls -l ອອກ*
md5 ຜົນລວມ *
xargs ບໍ່ມີການສະຫນັບສະຫນູນສໍາລັບການຮັກສາຄໍາສັ່ງຂອງຜົນຜະລິດໄດ້, ສະນັ້ນຖ້າຫາກວ່າວຽກເຮັດງານທໍາໃນ
ການນໍາໃຊ້ຂະຫນານ xargs ຜົນຜະລິດຂອງວຽກທີສອງບໍ່ສາມາດຖືກເລື່ອນອອກໄປຈົນຮອດວຽກທໍາອິດ
ແມ່ນແລ້ວ.
xargs ບໍ່ມີການສະຫນັບສະຫນູນສໍາລັບການເຮັດວຽກໃນຄອມພິວເຕີທາງໄກ.
xargs ບໍ່ມີການສະຫນັບສະຫນູນສໍາລັບການທົດແທນສະພາບການ, ດັ່ງນັ້ນທ່ານຈະຕ້ອງໄດ້ສ້າງການໂຕ້ຖຽງ.
ຖ້າເຈົ້າໃຊ້ຕົວປ່ຽນແທນໃນ xargs (-I) ທ່ານບໍ່ສາມາດບັງຄັບ xargs ການນໍາໃຊ້ຫຼາຍກ່ວາຫນຶ່ງ
ການໂຕ້ຖຽງ.
ອ້າງໃນ xargs ເຮັດວຽກຄື -q ໃນ GNU ຂະຫນານ. ນີ້ຫມາຍຄວາມວ່າຄໍາສັ່ງປະກອບແລະ
ການປ່ຽນເສັ້ນທາງຮຽກຮ້ອງໃຫ້ມີການນໍາໃຊ້ bash -c.
ls | ຂະຫນານ "ຫອງນໍາ {} > {}.ຫອງນໍາ"
ກາຍເປັນ (ສົມມຸດວ່າທ່ານມີ 8 ແກນ)
ls | xargs -d "\n" 8 -PXNUMX. -I {} bash -c "ຫອງນໍາ {} > {}.ຫອງນໍາ"
ແລະ
ls | ຂະຫນານ "ສຽງດັງ {}; ls {}|wc"
ກາຍເປັນ (ສົມມຸດວ່າທ່ານມີ 8 ແກນ)
ls | xargs -d "\n" 8 -PXNUMX. -I {} bash -c "ສຽງດັງ {}; ls {}|wc"
ຄວາມແຕກຕ່າງ BETWEEN ຊອກຫາ -ປະຕິບັດ ແລະ GNU ຂະຫນານ
ຊອກຫາ -ປະຕິບັດ ສະເຫນີບາງຄວາມເປັນໄປໄດ້ດຽວກັນກັບ GNU ຂະຫນານ.
ຊອກຫາ -ປະຕິບັດ ພຽງແຕ່ເຮັດວຽກກ່ຽວກັບໄຟລ໌. ດັ່ງນັ້ນການປະມວນຜົນການປ້ອນຂໍ້ມູນອື່ນໆ (ເຊັ່ນ: ເຈົ້າພາບຫຼື URLs) ຈະ
ຮຽກຮ້ອງໃຫ້ມີການສ້າງວັດສະດຸປ້ອນເຫຼົ່ານີ້ເປັນໄຟລ໌. ຊອກຫາ -ປະຕິບັດ ບໍ່ມີການສະຫນັບສະຫນູນສໍາລັບການແລ່ນຄໍາສັ່ງໃນ
ຂະຫນານ.
ຄວາມແຕກຕ່າງ BETWEEN ເຮັດໃຫ້ -j ແລະ GNU ຂະຫນານ
ເຮັດໃຫ້ -j ສາມາດເຮັດວຽກຂະຫນານໄດ້, ແຕ່ຕ້ອງການ Makefile ຫັດຖະກໍາເພື່ອເຮັດສິ່ງນີ້. ຜົນໄດ້ຮັບນັ້ນ
ໃນການອ້າງອີງເພີ່ມເຕີມເພື່ອໃຫ້ໄດ້ຮັບຊື່ໄຟລ໌ທີ່ມີແຖວໃຫມ່ທີ່ຈະເຮັດວຽກໄດ້ຖືກຕ້ອງ.
ເຮັດໃຫ້ -j ບໍ່ມີການສະຫນັບສະຫນູນສໍາລັບການຈັດກຸ່ມຜົນຜະລິດ, ດັ່ງນັ້ນຜົນຜະລິດອາດຈະດໍາເນີນການຮ່ວມກັນ, e.g
ເຄິ່ງທໍາອິດຂອງເສັ້ນແມ່ນມາຈາກຂະບວນການຫນຶ່ງແລະເຄິ່ງສຸດທ້າຍຂອງເສັ້ນແມ່ນມາຈາກອີກ
ຂະບວນການ. ຕົວຢ່າງ ຂະຫນານ grep ບໍ່ສາມາດເຮັດໄດ້ດ້ວຍຄວາມເຊື່ອຖື ເຮັດໃຫ້ -j ເນື່ອງຈາກວ່ານີ້.
(GNU ຮຸ່ນຕົ້ນໆ ຂະຫນານ ໄດ້ ຖືກ ປະ ຕິ ບັດ coincidently ການ ນໍາ ໃຊ້ ເຮັດໃຫ້ -j).
ຄວາມແຕກຕ່າງ BETWEEN ppss ແລະ GNU ຂະຫນານ
ppss ຍັງເປັນເຄື່ອງມືສໍາລັບການເຮັດວຽກໃນຂະຫນານ.
ຜົນໄດ້ຮັບຂອງ ppss ແມ່ນຂໍ້ມູນສະຖານະພາບແລະດັ່ງນັ້ນຈຶ່ງບໍ່ເປັນປະໂຫຍດສໍາລັບການນໍາໃຊ້ເປັນການປ້ອນຂໍ້ມູນສໍາລັບ
ຄໍາສັ່ງອື່ນ. ຜົນຜະລິດຈາກວຽກເຮັດງານທໍາໄດ້ຖືກເອົາໃສ່ໃນໄຟລ໌.
ບໍ່ສາມາດປ່ຽນສະຕຣິງແທນອາກິວເມັນ ($ITEM) ໄດ້. ການໂຕ້ຖຽງຕ້ອງໄດ້ຮັບການອ້າງອີງ - ດັ່ງນັ້ນ
arguments ທີ່ມີຕົວອັກສອນພິເສດ (space '"&!*) ອາດຈະເຮັດໃຫ້ເກີດບັນຫາຫຼາຍກວ່າຫນຶ່ງ
ບໍ່ຮອງຮັບການໂຕ້ຖຽງ. ຊື່ໄຟລ໌ທີ່ມີແຖວໃໝ່ບໍ່ໄດ້ຖືກປະມວນຜົນຢ່າງຖືກຕ້ອງ.
ເມື່ອອ່ານການປ້ອນຂໍ້ມູນຈາກໄຟລ໌ null ບໍ່ສາມາດໃຊ້ເປັນຕົວສິ້ນສຸດໄດ້. ppss ຈໍາເປັນຕ້ອງໄດ້ອ່ານ
ໄຟລ໌ປ້ອນຂໍ້ມູນທັງໝົດກ່ອນທີ່ຈະເລີ່ມວຽກໃດນຶ່ງ.
ຂໍ້ມູນຜົນຜະລິດແລະສະຖານະພາບຖືກເກັບໄວ້ໃນ ppss_dir ແລະດັ່ງນັ້ນຈຶ່ງຮຽກຮ້ອງໃຫ້ມີການເຮັດຄວາມສະອາດໃນເວລາທີ່
ສໍາເລັດ. ຖ້າ dir ບໍ່ໄດ້ຖືກໂຍກຍ້າຍອອກກ່ອນທີ່ຈະແລ່ນ ppss ອີກເທື່ອຫນຶ່ງມັນອາດຈະເຮັດໃຫ້ບໍ່ມີຫຍັງທີ່ຈະ
ເກີດຂຶ້ນເປັນ ppss ຄິດວ່າວຽກງານແມ່ນແລ້ວ. GNU ຂະຫນານ ປົກກະຕິຈະບໍ່ຈໍາເປັນ
ການເຮັດຄວາມສະອາດຖ້າແລ່ນຢູ່ໃນທ້ອງຖິ່ນແລະພຽງແຕ່ຕ້ອງການເຮັດຄວາມສະອາດຖ້າຢຸດຜິດປົກກະຕິແລະ
ແລ່ນໄລຍະໄກ (--ທໍາຄວາມສະອາດ ອາດຈະບໍ່ສໍາເລັດຖ້າຫາກວ່າຢຸດເຊົາຜິດປົກກະຕິ). ຕົວຢ່າງ ຂະຫນານ
grep ຈະຮຽກຮ້ອງໃຫ້ມີການປະມວນຜົນເພີ່ມເຕີມຖ້າຂຽນໂດຍໃຊ້ ppss.
ສໍາລັບລະບົບຫ່າງໄກສອກຫຼີກ PPSS ຕ້ອງການ 3 ຂັ້ນຕອນ: config, deploy, and start. GNU ຂະຫນານ ພຽງແຕ່
ຮຽກຮ້ອງໃຫ້ມີຂັ້ນຕອນຫນຶ່ງ.
ຕົວຢ່າງ ຈາກ ppss MANUAL
ນີ້ແມ່ນຕົວຢ່າງຈາກ ppssຫນ້າຄູ່ມືຂອງທຽບເທົ່າໂດຍໃຊ້ GNU ຂະຫນານ:
1 ./ppss.sh standalone -d /path/to/files -c 'gzip '
1 ຊອກຫາ /path/to/files -type f | gzip ຂະຫນານ
2 ./ppss.sh standalone -d /path/to/files -c 'cp "$ITEM" /destination/dir '
2 ຊອກຫາ /path/to/files -type f | parallel cp {} /destination/dir
3 ./ppss.sh standalone -f list-of-urls.txt -c 'wget -q '
3 ຂະຫນານ -a list-of-urls.txt wget -q
4 ./ppss.sh standalone -f list-of-urls.txt -c 'wget -q "$ITEM"'
4 ຂະຫນານ -a list-of-urls.txt wget -q {}
5 ./ppss config -C config.cfg -c 'encode.sh ' -d /source/dir -m 192.168.1.100 -u ppss -k
ppss-key.key -S ./encode.sh -n nodes.txt -o /some/output/dir --upload --download ; ./ppss
deploy -C config.cfg ; ./ppss start -C config
5 # ຂະໜານບໍ່ໃຊ້ config. ຖ້າທ່ານຕ້ອງການຊື່ຜູ້ໃຊ້ອື່ນໃສ່ໃນ nodes.txt:
user@hostname
5 ຊອກຫາແຫຼ່ງ/dir -type f | ຂະຫນານ --sshloginfile nodes.txt --trc {.}.mp3 lame -a {} -o
{.}.mp3 --preset standard --quiet
6 ./ppss ຢຸດ -C config.cfg
6 killall -TERM ຂະຫນານ
7 ./ppss ຢຸດຊົ່ວຄາວ -C config.cfg
7 ກົດ: CTRL-Z ຫຼື killall -SIGTSTP ຂະຫນານ
8 ./ppss ສືບຕໍ່ -C config.cfg
8 ປ້ອນ: fg ຫຼື killall -SIGCONT ຂະຫນານ
9 ສະຖານະ ./ppss.sh -C config.cfg
9 killall -SIGUSR2 ຂະໜານ
ຄວາມແຕກຕ່າງ BETWEEN ເປເຊກ ແລະ GNU ຂະຫນານ
ເປເຊກ ຍັງເປັນເຄື່ອງມືສໍາລັບການເຮັດວຽກໃນຂະຫນານ.
ຕົວຢ່າງ ຈາກ ເປເຊກ MANUAL
ນີ້ແມ່ນຕົວຢ່າງຈາກ ເປເຊກຫນ້າຂໍ້ມູນຂອງທຽບເທົ່າໂດຍໃຊ້ GNU ຂະຫນານ:
1 pexec -o sqrt-%s.dat -p "$(seq 10)" -e NUM -n 4 -c -- \
'echo "scale=10000;sqrt($NUM)" | bc'
1 seq 10 | ຂະຫນານ -j4 'echo "scale=10000;sqrt({})" | bc > sqrt-{}.dat'
2 pexec -p "$(ls myfiles*.ext)" -i %s -o %s.sort -- sort
2 ls myfiles*.ext | ການຈັດຮຽງຂະໜານ {}">{}.sort"
3 pexec -f image.list -n auto -e B -u star.log -c -- \
'fistar $B.fits -f 100 -F id,x,y,flux -o $B.star'
3 ຂະຫນານ -a image.list \
'fistar {}.fits -f 100 -F id,x,y,flux -o {}.star' 2>star.log
4 pexec -r *.png -e IMG -c -o - -- \
'ປ່ຽນ $IMG ${IMG%.png}.jpeg ; "echo $IMG: ແລ້ວໆ"'
4 ls *.png | parallel 'ປ່ຽນ {} {.}.jpeg; ສຽງສະທ້ອນ {}: ແລ້ວໆ'
5 pexec -r *.png -i %s -o %s.jpg -c 'pngtopnm | pnmtojpeg'
5 ls *.png | ຂະຫນານ 'pngtopnm < {} | pnmtojpeg > {}.jpg'
6 ສໍາລັບ p ໃນ *.png ; ເຮັດສຽງສະທ້ອນ ${p%.png} ; ເຮັດແລ້ວ | \
pexec -f - -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'
6 ls *.png | ຂະຫນານ 'pngtopnm < {} | pnmtojpeg > {.}.jpg'
7 LIST=$(ສຳລັບ p ໃນ *.png ; do echo ${p%.png} ; ແລ້ວໆ)
pexec -r $LIST -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'
7 ls *.png | ຂະຫນານ 'pngtopnm < {} | pnmtojpeg > {.}.jpg'
8 pexec -n 8 -r *.jpg -y unix -e IMG -c \
'pexec -j -m blockread -d $IMG | \
jpegtopnm | pnmscale 0.5 | pnmtojpeg | \
pexec -j -m blockwrite -s th_$IMG'
8 ລວມ GNU ຂະຫນານ ແລະ GNU sem.
8 ls *jpg | parallel -j8 'sem --id blockread cat {} | jpegtopnm |' \
' pnmscale 0.5 | pnmtojpeg | sem --id blockwrite cat > th_{}'
8 ຖ້າການອ່ານແລະການຂຽນຖືກເຮັດຢູ່ໃນແຜ່ນດຽວກັນ, ນີ້ອາດຈະໄວກວ່າພຽງແຕ່ຂະບວນການດຽວເທົ່ານັ້ນ
ຈະເປັນການອ່ານຫຼືການຂຽນ:
8 ls *jpg | parallel -j8 'sem --id diskio cat {} | jpegtopnm |' \
' pnmscale 0.5 | pnmtojpeg | sem --id diskio cat > th_{}'
ຄວາມແຕກຕ່າງ BETWEEN xjobs ແລະ GNU ຂະຫນານ
xjobs ຍັງເປັນເຄື່ອງມືສໍາລັບການເຮັດວຽກໃນຂະຫນານ. ມັນພຽງແຕ່ສະຫນັບສະຫນູນການເຮັດວຽກຢູ່ໃນຂອງທ່ານ
ຄອມພິວເຕີທ້ອງຖິ່ນ.
xjobs ປະຕິບັດບໍ່ດີກັບລັກສະນະພິເສດຄືກັນກັບ xargs. ເບິ່ງພາກ ຄວາມແຕກຕ່າງ
BETWEEN xargs ແລະ GNU ຂະຫນານ.
ນີ້ແມ່ນຕົວຢ່າງຈາກ xjobsໜ້າຜູ້ຊາຍທີ່ທຽບເທົ່າໂດຍໃຊ້ GNU ຂະຫນານ:
1 ls -1 *.zip | xjobs unzip
1 ls *.zip | unzip ຂະຫນານ
2 ls -1 *.zip | xjobs -n unzip
2 ls *.zip | ຂະຫນານ unzip >/dev/null
3 ຊອກຫາ. -name '*.bak' | xjobs gzip
3 ຊອກຫາ. -name '*.bak' | gzip ຂະຫນານ
4 ls -1 *.jar | sed 's/\.*\)/\1 > \1.idx/' | xjobs jar tf
4 ls *.jar | ກະປ໋ອງຂະໜານ tf {} '>' {}.idx
5 xjobs -s script
5 cat script | ຂະໜານ
6 mkfifo /var/run/my_named_pipe; xjobs -s /var/run/my_named_pipe & echo unzip 1.zip >>
/var/run/my_named_pipe; echo tar cf /backup/myhome.tar /home/me >> /var/run/my_named_pipe
6 mkfifo /var/run/my_named_pipe; cat /var/run/my_named_pipe | parallel & echo unzip 1.zip
>> /var/run/my_named_pipe; echo tar cf /backup/myhome.tar /home/me >>
/var/run/my_named_pipe
ຄວາມແຕກຕ່າງ BETWEEN prll ແລະ GNU ຂະຫນານ
prll ຍັງເປັນເຄື່ອງມືສໍາລັບການເຮັດວຽກໃນຂະຫນານ. ມັນບໍ່ຮອງຮັບການແລ່ນວຽກຢູ່
ຄອມພິວເຕີທາງໄກ.
prll ຊຸກຍູ້ໃຫ້ໃຊ້ນາມແຝງ BASH ແລະຟັງຊັນ BASH ແທນສະຄຣິບ. GNU ຂະຫນານ
ຈະບໍ່ສະຫນັບສະຫນູນນາມແຝງແລ່ນ (ເບິ່ງວ່າເປັນຫຍັງ
http://www.perlmonks.org/index.pl?node_id=484296). ຢ່າງໃດກໍຕາມ, scripts, ຄໍາສັ່ງປະກອບ, ຫຼື
ຟັງຊັນທີ່ສົ່ງອອກດ້ວຍ ການສົ່ງອອກ -f ເຮັດວຽກໄດ້ດີ.
prll ສ້າງຂໍ້ມູນສະຖານະພາບຫຼາຍຢ່າງກ່ຽວກັບ stderr (ຄວາມຜິດພາດມາດຕະຖານ) ເຊິ່ງເຮັດໃຫ້ມັນ
ຍາກກວ່າທີ່ຈະໃຊ້ stderr (ຄວາມຜິດພາດມາດຕະຖານ) ຜົນໄດ້ຮັບຂອງວຽກໂດຍກົງເປັນການປ້ອນຂໍ້ມູນສໍາລັບຄົນອື່ນ
ໂຄງການ.
ນີ້ແມ່ນຕົວຢ່າງຈາກ prllໜ້າຜູ້ຊາຍທີ່ທຽບເທົ່າໂດຍໃຊ້ GNU ຂະຫນານ:
prll -s 'mogrify -flip $1' *.jpg
ຂະຫນານ mogrify -flip ::: *.jpg
ຄວາມແຕກຕ່າງ BETWEEN dxargs ແລະ GNU ຂະຫນານ
dxargs ຍັງເປັນເຄື່ອງມືສໍາລັບການເຮັດວຽກໃນຂະຫນານ.
dxargs ບໍ່ໄດ້ຈັດການກັບວຽກພ້ອມກັນຫຼາຍກວ່າ MaxStartups ຂອງ SSHD. dxargs is
ສ້າງຂຶ້ນພຽງແຕ່ສໍາລັບວຽກໄລຍະໄກ, ແຕ່ບໍ່ຮອງຮັບການໂອນໄຟລ໌.
ຄວາມແຕກຕ່າງ BETWEEN mdm/ຄົນກາງ ແລະ GNU ຂະຫນານ
ຄົນກາງ(mdm) ຍັງເປັນເຄື່ອງມືສໍາລັບການເຮັດວຽກໃນຂະຫນານ.
ນີ້ແມ່ນ shellscripts ຂອງ http://mdm.berlios.de/usage.html ported ກັບ GNU ຂະຫນານ:
seq 19 | ຂະຫນານ buffon -o - | ການຈັດລຽງ -n > ຜົນ
cat ໄຟ | ຂະຫນານ cmd
ຊອກຫາ dir -execdir sem cmd {} \;
ຄວາມແຕກຕ່າງ BETWEEN xapply ແລະ GNU ຂະຫນານ
xapply ສາມາດແລ່ນວຽກຂະໜານກັນຢູ່ໃນຄອມພິວເຕີທ້ອງຖິ່ນ.
ນີ້ແມ່ນຕົວຢ່າງຈາກ xapplyໜ້າຜູ້ຊາຍທີ່ທຽບເທົ່າໂດຍໃຊ້ GNU ຂະຫນານ:
1 xapply '(cd %1 && make all)' */
1 ຂະຫນານ 'cd {} && ເຮັດໃຫ້ທັງຫມົດ' ::: */
2 xapply -f 'diff %1 ../version5/%1' manifest | ເພີ່ມເຕີມ
2 ຄວາມແຕກຕ່າງຂະໜານ {} ../version5/{} < manifest | ເພີ່ມເຕີມ
3 xapply -p/dev/null -f 'diff %1 %2' manifest1 checklist1
3 parallel --xapply diff {1} {2} :::: manifest1 checklist1
4 xapply 'indent' *.c
4 ຂະຫນານ indent ::: *.c
5 ຊອກຫາ ~ksb/bin -type f ! -perm -111 -ພິມ | xapply -f -v 'chmod a+x' -
5 ຊອກຫາ ~ksb/bin -type f ! -perm -111 -ພິມ | ຂະໜານ -v chmod a+x
6 ຊອກຫາ */ -... | fmt 960 1024 | xapply -f -i /dev/tty 'vi' -
6 sh <(ຊອກຫາ */ -... | parallel -s 1024 echo vi)
6 ຊອກຫາ */ -... | parallel -s 1024 -Xuj1 vi
7 ຊອກຫາ ... | xapply -f -5 -i /dev/tty 'vi' - - - - -
7 sh <(ຊອກຫາ... |parallel -n5 echo vi)
7 ຊອກຫາ ... |ຂະໜານ -n5 -uj1 vi
8 xapply -fn "" / etc / passwd
8 ຂະຫນານ -k echo / etc / passwd
9 tr ':' '\012' / etc / passwd | xapply -7 -nf 'chown %1 %6' - - - - - -
9 tr ':' '\012' / etc / passwd | ຂະຫນານ -N7 chown {1} {6}
10 xapply '[ -d %1/RCS ] || ສຽງສະທ້ອນ %1' */
10 ຂະໜານ '[ -d {}/RCS ] || ສະທ້ອນ {}' ::: */
11 xapply -f '[ -f %1 ] && echo %1' ລາຍການ | ...
11 ຂະໜານ '[ -f {} ] && echo {}' < ລາຍການ | ...
ຄວາມແຕກຕ່າງ BETWEEN paexec ແລະ GNU ຂະຫນານ
paexec ສາມາດດໍາເນີນການວຽກເຮັດງານທໍາຂະຫນານທັງໃນຄອມພິວເຕີໃນທ້ອງຖິ່ນແລະຫ່າງໄກສອກຫຼີກ.
paexec ຕ້ອງການຄໍາສັ່ງເພື່ອພິມເສັ້ນເປົ່າເປັນຜົນຜະລິດສຸດທ້າຍ. ນີ້ຫມາຍຄວາມວ່າທ່ານຈະ
ຕ້ອງຂຽນ wrapper ສໍາລັບໂຄງການສ່ວນໃຫຍ່.
paexec ມີບ່ອນເພິ່ງພາອາໄສວຽກເພື່ອໃຫ້ວຽກສາມາດຂຶ້ນກັບວຽກອື່ນທີ່ຈະຖືກປະຕິບັດ
ສໍາເລັດ. ປະເພດຂອງຜູ້ຊາຍທີ່ທຸກຍາກ ເຮັດໃຫ້.
ນີ້ແມ່ນຕົວຢ່າງຈາກ paexecຕົວຢ່າງຂອງແຄັດຕາລັອກທີ່ທຽບເທົ່າໂດຍໃຊ້ GNU
ຂະຫນານ:
1_div_X_run:
../../paexec -s -l -c "`pwd`/1_div_X_cmd" -n +1 <
ສຽງສະທ້ອນຂະໜານ {} '|' `pwd`/1_div_X_cmd <
all_substr_run:
../../paexec -lp -c "`pwd`/all_substr_cmd" -n +3 <
ສຽງສະທ້ອນຂະໜານ {} '|' `pwd`/all_substr_cmd <
cc_wrapper_run:
../../paexec -c "env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd" \
-n 'host1 host2' \
-t '/usr/bin/ssh -x' <
ສຽງສະທ້ອນຂະໜານ {} '|' "env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd" \
-S host1,host2 <
# ອັນນີ້ບໍ່ຄືກັນ, ແຕ່ຫຼີກລ້ຽງການຫໍ່
ຂະຫນານ gcc -O2 -c -o {.}.o {} \
-S host1,host2 <
topper_run:
../../paexec -lp -c "`pwd`/toupper_cmd" -n +10 <
ສຽງສະທ້ອນຂະໜານ {} '|' ./toupper_cmd <
# ໂດຍບໍ່ມີການຫໍ່:
parallel echo {}'| awk {print\ topper\(\$0\)}' <
ຄວາມແຕກຕ່າງ BETWEEN ແຜນທີ່ ແລະ GNU ຂະຫນານ
ແຜນທີ່ ເຫັນວ່າມັນເປັນລັກສະນະທີ່ຈະມີລັກສະນະຫນ້ອຍແລະໃນການເຮັດດັ່ງນັ້ນມັນຍັງຈັດການມຸມ
ກໍລະນີທີ່ບໍ່ຖືກຕ້ອງ. GNU ຫຼາຍ ຂະຫນານລະຫັດຂອງແມ່ນເພື່ອຈັດການກໍລະນີແຈຢ່າງຖືກຕ້ອງ
ທຸກໆແພລະຕະຟອມ, ດັ່ງນັ້ນທ່ານຈະບໍ່ໄດ້ຮັບຄວາມແປກໃຈທີ່ຫນ້າເສົ້າໃຈຖ້າຜູ້ໃຊ້ຕົວຢ່າງບັນທຶກໄຟລ໌
ເອີ້ນວ່າ: My ອ້າຍ 12 " records.txt
ແຜນທີ່ຕົວຢ່າງຂອງການສະແດງວິທີການຈັດການກັບຕົວອັກສອນພິເສດລົ້ມເຫລວໃນລັກສະນະພິເສດ:
echo "ການປິ່ນປົວ" > ອ້າຍຂອງຂ້ອຍ \ 12\"\ ບັນທຶກ
ls | ແຜນທີ່ 'echo -n `gzip< "%" | wc -c`; echo -n '*100/'; wc -c< "%"' | bc
ມັນເຮັດວຽກກັບ GNU ຂະຫນານ:
ls | ຂະຫນານ 'echo -n `gzip < {} | wc -c`; echo -n '*100/'; wc -c < {}' | bc
ແລະທ່ານສາມາດໄດ້ຮັບເຖິງແມ່ນວ່າຊື່ໄຟລ໌ prepended:
ls | ຂະຫນານ --tag '(echo -n `gzip < {} | wc -c`'*100/'; wc -c < {}) | bc'
ແຜນທີ່ ບໍ່ມີການສະຫນັບສະຫນູນສໍາລັບການຈັດກຸ່ມ. ດັ່ງນັ້ນ, ນີ້ເຮັດໃຫ້ຜົນໄດ້ຮັບທີ່ບໍ່ຖືກຕ້ອງໂດຍບໍ່ມີການເຕືອນໃດໆ:
ຂະໜານ perl -e '\$a=\"1{}\"x10000000\;ພິມ\ $a,\"\\n\"' '>' {} ::: abcdef
ls -labcdef
parallel -kP4 -n1 grep 1 > out.par ::: abcdef
ແຜນທີ່ -p 4 'grep 1' abcdef > out.map-unbuf
ແຜນທີ່ -p 4 'grep --line-buffered 1' abcdef > out.map-linebuf
ແຜນທີ່ -p 1 'grep --line-buffered 1' abcdef > out.map-serial
ls -l ອອກ*
md5 ຜົນລວມ *
ເອກະສານສະແດງໃຫ້ເຫັນການແກ້ໄຂ, ແຕ່ບໍ່ພຽງແຕ່ປະສົມ stdout (ຜົນຜະລິດມາດຕະຖານ)
ກັບ stderr (ຄວາມຜິດພາດມາດຕະຖານ) ມັນຍັງລົ້ມເຫລວຢ່າງສົມບູນສໍາລັບວຽກທີ່ແນ່ນອນ (ແລະອາດຈະເປັນ
ພິຈາລະນາອ່ານໄດ້ຫນ້ອຍ):
parallel echo -n {} ::: 1 2 3
ແຜນທີ່ -p 4 'echo -n %2>&1 | sed -e "s/^/$$:/"' 1 2 3 | ຄັດ | ຕັດ -f2- -d:
ແຜນທີ່ ບໍ່ສາມາດຈັດການທາງເລືອກທີ່ມັດໄວ້ໄດ້: ແຜນທີ່ -vp 0 echo ນີ້ ຂໍ້ເທັດຈິງ
ແຜນທີ່ ບໍ່ມີຕົວແຍກ argument ຢູ່ໃນເສັ້ນຄໍາສັ່ງ, ແຕ່ໃຊ້ argument ທໍາອິດ
ເປັນຄໍາສັ່ງ. ນີ້ເຮັດໃຫ້ການອ້າງອີງຍາກຂຶ້ນເຊິ່ງອີກເທື່ອຫນຶ່ງອາດຈະສົ່ງຜົນກະທົບຕໍ່ການອ່ານໄດ້. ປຽບທຽບ:
ແຜນທີ່ -p 2 perl\\\ -ne\\\ \\\'/^\\\\ S+\\\\s+\\\\\\S+\\$/\\\ ແລະ\\\\ ພິມ\\ \\\$ARGV,\\\"\\\\n\\\"\\\' *
ຂະໜານ -q perl -ne '/^\S+\s+\S+$/ ແລະພິມ $ARGV,"\n"' ::: *
ແຜນທີ່ ສາມາດເຮັດໄດ້ຫຼາຍການໂຕ້ຖຽງກັບການທົດແທນສະພາບການ, ແຕ່ບໍ່ແມ່ນໂດຍບໍ່ມີການທົດແທນສະພາບ:
parallel --xargs echo 'BEGIN{'{}'}END' ::: 1 2 3
ແຜນທີ່ ບໍ່ໄດ້ກໍານົດຄ່າອອກໂດຍອີງຕາມວ່າຫນຶ່ງໃນວຽກທີ່ລົ້ມເຫລວ:
parallel false :::1 || echo Job ລົ້ມເຫລວ
ແຜນທີ່ຜິດ 1 || echo ບໍ່ເຄີຍແລ່ນ
ແຜນທີ່ ຕ້ອງການ Perl v5.10.0 ເຮັດໃຫ້ມັນຍາກທີ່ຈະໃຊ້ໃນລະບົບເກົ່າ.
ແຜນທີ່ ບໍ່ມີວິທີທີ່ຈະໃຊ້ % ໃນຄໍາສັ່ງ (GNU Parallel ມີ -I ເພື່ອລະບຸອັນອື່ນ
ສະຕຣິງແທນທີ່ກວ່າ {}).
ໂດຍການອອກແບບ ແຜນທີ່ ແມ່ນທາງເລືອກທີ່ບໍ່ເຂົ້າກັນໄດ້ກັບ xargs, ມັນບໍ່ມີການປະຕິບັດວຽກຫ່າງໄກສອກຫຼີກ, a
ວິທີການທີ່ມີໂຄງສ້າງຂອງຜົນໄດ້ຮັບການປະຫຍັດ, ແຫຼ່ງຂໍ້ມູນຫຼາຍ, ຕົວຊີ້ວັດຄວາມຄືບຫນ້າ, ກໍານົດໄດ້
ບັນທຶກຕົວຂັ້ນ (ສະເພາະຕົວຂັ້ນພາກສະຫນາມ), ການບັນທຶກວຽກທີ່ດໍາເນີນການກັບຄວາມເປັນໄປໄດ້ທີ່ຈະສືບຕໍ່,
ຮັກສາຜົນຜະລິດຢູ່ໃນຄໍາສັ່ງດຽວກັນກັບການປ້ອນຂໍ້ມູນ, --pipe processing, ແລະ dynamically
ໝົດເວລາ.
ຄວາມແຕກຕ່າງ BETWEEN ລາດອນ ແລະ GNU ຂະຫນານ
ລາດອນ ສາມາດດໍາເນີນການຫຼາຍວຽກໃນໄຟລ໌ຂະຫນານ.
ລາດອນ ພຽງແຕ່ເຮັດວຽກຢູ່ໃນໄຟລ໌ແລະວິທີດຽວທີ່ຈະລະບຸໄຟລ໌ແມ່ນການນໍາໃຊ້ສະຕຣິງ glob ທີ່ອ້າງອີງ
(ເຊັ່ນ: \*.jpg). ມັນເປັນໄປບໍ່ໄດ້ທີ່ຈະລາຍຊື່ໄຟລ໌ດ້ວຍຕົນເອງ.
ໃນຖານະເປັນສະຕຣິງທົດແທນ, ມັນໃຊ້ FULLPATH DIRNAME BASENAME EXT RELDIR RELPATH
ເຫຼົ່ານີ້ສາມາດຖືກຈໍາລອງໂດຍໃຊ້ GNU ຂະຫນານ ໂດຍການວາງອັນນີ້ ~/.parallel/config:
--rpl 'FULLPATH $_=::shell_quote($_);chomp($_=qx{readlink -f $_});'
--rpl 'DIRNAME $_=::shell_quote(::dirname($_));chomp($_=qx{readlink -f $_});'
--rpl 'BASENAME s:.*/:;s:\.[^/.]+$::;'
--rpl 'EXT s:.*\.::'
--rpl 'RELDIR $_=::shell_quote($_);chomp(($_,$c)=qx{readlink -f $_;pwd});s:\Q$c/\E::; $_=::dirname($_);'
--rpl 'RELPATH $_=::shell_quote($_);chomp(($_,$c)=qx{readlink -f $_;pwd});s:\Q$c/\E::; '
ລາດອນ ປະຕິບັດບໍ່ດີກັບຊື່ໄຟລ໌ທີ່ມີ "ແລະແຖວໃຫມ່, ແລະມັນລົ້ມເຫລວສໍາລັບຜົນຜະລິດຂະຫນາດໃຫຍ່
ຫຼາຍກວ່າ 200k:
ladon '*' -- seq 36000 | ຫອງນໍາ
ຕົວຢ່າງ ຈາກ ລາດອນ MANUAL
ມັນສົມມຸດວ່າ '--rpl's ຂ້າງເທິງແມ່ນຖືກໃສ່ໃນ ~/.parallel/config ແລະວ່າມັນແມ່ນການດໍາເນີນການ
ພາຍໃຕ້ແກະທີ່ຮອງຮັບ '**' globbing (ເຊັ່ນ zsh):
1 ladon "**/*.txt" -- echo RELPATH
1 parallel echo RELPATH ::: **/*.txt
2 ລາດອນ "~/ເອກະສານ/**/*.pdf" -- shasum FULLPATH > hashes.txt
2 ຂະຫນານ shasum FULLPATH ::: ~/ເອກະສານ/**/*.pdf > hashes.txt
3 ladon -m thumbs/RELDIR "**/*.jpg" loading="lazy" -- convert FULLPATH -thumbnail 100x100^ -gravity
ຂະໜາດກາງ 100x100 thumbs/RELPPATH
3 ຂະໜານ mkdir -p thumbs/RELDIR\; ປ່ຽນ FULLPATH -thumbnail 100x100^ -ສູນກາວິທັດ
-extent 100x100 thumbs/RELPATH ::: **/*.jpg
4 ລາດອນ "~/ດົນຕີ/*.wav" -- lame -V 2 FULLPATH DIRNAME/BASENAME.mp3
4 parallel lame -V 2 FULLPATH DIRNAME/BASENAME.mp3 ::: ~/ດົນຕີ/* .wav
ຄວາມແຕກຕ່າງ BETWEEN ClusterSSH ແລະ GNU ຂະຫນານ
ClusterSSH ແກ້ໄຂບັນຫາທີ່ແຕກຕ່າງຈາກ GNU ຂະຫນານ.
ClusterSSH ເປີດປ່ອງຢ້ຽມ terminal ສໍາລັບແຕ່ລະຄອມພິວເຕີແລະການນໍາໃຊ້ປ່ອງຢ້ຽມຕົ້ນສະບັບທີ່ທ່ານສາມາດດໍາເນີນການໄດ້
ຄໍາສັ່ງດຽວກັນຢູ່ໃນຄອມພິວເຕີທັງຫມົດ. ໂດຍທົ່ວໄປແລ້ວນີ້ແມ່ນໃຊ້ສໍາລັບການຄຸ້ມຄອງຫຼາຍໆຢ່າງ
ຄອມພິວເຕີທີ່ເກືອບຄືກັນ.
GNU ຂະຫນານ ແລ່ນຄໍາສັ່ງດຽວກັນ (ຫຼືແຕກຕ່າງກັນ) ທີ່ມີການໂຕ້ຖຽງທີ່ແຕກຕ່າງກັນໃນຂະຫນານ
ອາດຈະໃຊ້ຄອມພິວເຕີທາງໄກເພື່ອຊ່ວຍຄອມພິວເຕີ. ຖ້າມີຄອມພິວເຕີຫຼາຍກວ່າໜຶ່ງໜ່ວຍຢູ່ໃນລາຍການ
-S GNU ຂະຫນານ ອາດຈະໃຊ້ພຽງແຕ່ຫນຶ່ງຂອງເຫຼົ່ານີ້ (ເຊັ່ນ: ຖ້າມີ 8 ວຽກທີ່ຈະດໍາເນີນການແລະຫນຶ່ງ
ຄອມພິວເຕີມີ 8 ແກນ).
GNU ຂະຫນານ ສາມາດໃຊ້ເປັນ ClusterSSH ລຸ້ນຄົນທຸກຍາກໄດ້:
ຂະຫນານ --nonall -S server-a, server-b do_stuff ຟູ ພາທະນາຍຄວາມ
ໃຊ້ຂະຫນານອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net
