Bash
समानांतर

परिचय

वाक्य - विन्यास

1. समानांतर [विकल्प] [कमांड [तर्क]] <list_of_arguments>

पैरामीटर

फ़ाइलों की सूची पर दोहराए जाने वाले कार्यों को समानांतर करें

यदि आप अपने कंप्यूटर के संसाधनों (यानी सीपीयू और रैम) का अधिक उपयोग करते हैं, तो कई दोहराए जाने वाले कार्यों को अधिक कुशलता से किया जा सकता है। नीचे समानांतर में कई नौकरियां चलाने का एक उदाहरण है।

मान लीजिए कि आपके पास < list of files > , तो ls से आउटपुट कहें। इसके अलावा, इन फ़ाइलों को bz2 संपीड़ित करें और कार्यों के निम्न क्रम को उन पर संचालित करने की आवश्यकता है।

1. bzcat को stdout में उपयोग करके bz2 फ़ाइलों को bzcat करें
2. Grep grep <some key word> का उपयोग करके विशिष्ट कीवर्ड () के साथ ग्रीप (जैसे फ़िल्टर) लाइनें
3. पाइप को एक एकल gzipped फ़ाइल में gzip का उपयोग करके आउटपुट किया जाना है

थोड़ी देर लूप का उपयोग करके इसे चलाना इस तरह दिखाई दे सकता है

filenames="file_list.txt"
while read -r line
do
name="$line"
     ## grab lines with puppies in them
     bzcat $line | grep puppies | gzip >> output.gz
done < "$filenames"

जीएनयू समानांतर का उपयोग करते हुए, हम केवल एक बार करके 3 समानांतर नौकरियों को चला सकते हैं

parallel -j 3 "bzcat {} | grep puppies" ::: $( cat filelist.txt ) | gzip > output.gz

यह कमांड सरल, संक्षिप्त और अधिक कुशल है जब फ़ाइलों और फ़ाइल का आकार बड़ा होता है। नौकरियों को parallel द्वारा शुरू किया जाता है, विकल्प -j 3 3 समानांतर नौकरियों की शुरूआत करता है और समानांतर नौकरियों के लिए इनपुट ::: द्वारा लिया जाता है। आउटपुट को अंततः gzip > output.gz पाइप किया gzip > output.gz

STDIN को समानांतर करें

अब, आइए कल्पना करें कि हमारे पास 1 बड़ी फ़ाइल (जैसे 30 जीबी) है जिसे बदलने की आवश्यकता है, लाइन से लाइन। कहें कि हमारे पास एक स्क्रिप्ट है, convert.sh , जो यह <task> । हम इस फ़ाइल की सामग्री को अंदर लेने के लिए समानांतर रूप से स्टड कर सकते हैं और इस तरह के विखंडू में काम कर सकते हैं

<stdin> | parallel --pipe --block <block size> -k <task> > output.txt

जहां <stdin> cat <file> जैसी किसी भी चीज़ से उत्पन्न हो सकता है।

एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण के रूप में, हमारा कार्य nl -n rz । कोई भी फ़ाइल लें, मेरा data.bz2 होगा, और इसे <stdin>

bzcat data.bz2 | nl | parallel --pipe --block 10M -k nl -n rz | gzip > ouptput.gz

उपरोक्त उदाहरण bzcat data.bz2 | nl से <stdin> लेता है bzcat data.bz2 | nl , जहाँ मैंने nl को अवधारणा के प्रमाण के रूप में शामिल किया था कि अंतिम आउटपुट output.gz उस क्रम में सहेजा जाएगा जो उसे प्राप्त हुआ था। फिर, parallel <stdin> को 10 MB आकार में विखंडित करता है, और प्रत्येक कबाड़ के लिए इसे nl -n rz से गुज़रता है जहाँ यह केवल उचित रूप से उचित संख्याओं को जोड़ता है (आगे के विवरणों के लिए nl --help देखें)। विकल्प - --pipe कई नौकरियों में विभाजित करने के लिए parallel <stdin> बताता है और -- block ब्लॉकों के आकार को निर्दिष्ट करता है। विकल्प -k निर्दिष्ट करता है कि आदेश बनाए रखा जाना चाहिए।

आपका अंतिम आउटपुट कुछ इस तरह दिखना चाहिए

000001       1  <data>
000002       2  <data>
000003       3  <data>
000004       4  <data>
000005       5  <data>
 ... 
000587  552409  <data>
000588  552410  <data>
000589  552411  <data>
000590  552412  <data>
000591  552413  <data>

मेरी मूल फ़ाइल में 552,413 लाइनें थीं। पहला कॉलम समानांतर नौकरियों का प्रतिनिधित्व करता है, और दूसरा कॉलम मूल लाइन नंबरिंग का प्रतिनिधित्व करता है जिसे चंक्स में parallel में पारित किया गया था। आपको ध्यान देना चाहिए कि दूसरे कॉलम में आदेश (और फ़ाइल के बाकी) बनाए रखा है।