शैल स्क्रिप्टिंग

Question

में समांतर प्रसंस्करण या थ्रेडिंग मैं खोल में एक स्क्रिप्ट लिख रहा हूं जिसमें एक कमांड चल रहा है और 2 मिनट ले रहा है। हर बार। इसके अलावा, हम इसके साथ कुछ भी नहीं कर सकते हैं। लेकिन अगर मैं इस आदेश को स्क्रिप्ट में 100 बार चलाने के लिए चाहता हूं तो कुल समय 200min होगा। और यह एक बड़ा मुद्दा पैदा करेगा। कोई भी 200min के लिए इंतजार नहीं करना चाहता। मैं जो चाहता हूं वह सभी 100 आज्ञाओं को समानांतर चलाने के लिए है ताकि आउटपुट 2min में आ जाएगा या कुछ और समय हो सकता है लेकिन 200min नहीं ले सकता है।

इसकी सराहना की जाएगी, अगर कोई भी शरीर किसी भी तरह से मेरी सहायता कर सकता है।

Answer 1

... सभी 100 आदेशों parallely चलाने ताकि उत्पादन 2 मिनट

यह तभी संभव है यदि आप अपने सिस्टम पर 200 प्रोसेसरों में आ जाएगा।

समानांतर में कमांड चलाने के लिए शेल स्क्रिप्ट में ऐसी कोई उपयोगिता/कमांड नहीं है। आप क्या कर सकते पृष्ठभूमि में अपने आदेश चला जाता है:

for ((i=0;i<200;i++)) 
do 
    MyCommand & 
done 

& (पृष्ठभूमि) के साथ

, प्रत्येक निष्पादन जितनी जल्दी हो सके निर्धारित है। लेकिन यह गारंटी नहीं देता है कि आपका कोड कम से कम 200 मिनट में निष्पादित किया जाएगा। यह निर्भर करता है कि आपके सिस्टम पर कितने प्रोसेसर हैं।

यदि आपके पास केवल एक प्रोसेसर है और कमांड का प्रत्येक निष्पादन (2min लगता है) 2 मिनट के लिए कुछ गणना कर रहा है, तो प्रोसेसर कुछ काम कर रहा है, जिसका अर्थ है कि कोई चक्र बर्बाद नहीं हुआ है। इस मामले में, समानांतर में कमांड चलाने में मदद नहीं मिल रही है क्योंकि, केवल एक प्रोसेसर है जो भी मुफ़्त नहीं है। इसलिए, प्रक्रियाएं सिर्फ उनकी बारी को निष्पादित करने की प्रतीक्षा कर रही हैं।

यदि आपके पास एक से अधिक प्रोसेसर हैं, तो उपर्युक्त विधि (लूप के लिए) कुल निष्पादन समय को कम करने में मदद कर सकती है।

Answer 2

@KingsIndian के रूप में, आप पृष्ठभूमि कार्यों को कर सकते हैं, जो कि उन्हें समानांतर में चलाने देता है। इसके अलावा, आप भी इस प्रक्रिया आईडी के आधार पर उन पर नज़र रख सकते हैं:

#!/bin/bash 

# Function to be backgrounded 
track() { 
    sleep $1 
    printf "\nFinished: %d\n" "$1" 
} 

start=$(date '+%s') 

rand3="$(jot -s\ -r 3 5 10)" 

# If you don't have `jot` (*BSD/OSX), substitute your own numbers here. 
#rand3="5 8 10" 

echo "Random numbers: $rand3" 

# Make an associative array in which you'll record pids. 
declare -A pids 

# Background an instance of the track() function for each number, record the pid. 
for n in $rand3; do 
    track $n & 
    pid=$! 
    echo "Backgrounded: $n (pid=$pid)" 
    pids[$pid]=$n 
done 

# Watch your stable of backgrounded processes. 
# If a pid goes away, remove it from the array. 
while [ -n "${pids[*]}" ]; do 
    sleep 1 
    for pid in "${!pids[@]}"; do 
    if ! ps "$pid" >/dev/null; then 
     unset pids[$pid] 
     echo "unset: $pid" 
    fi 
    done 
    if [ -z "${!pids[*]}" ]; then 
    break 
    fi 
    printf "\rStill waiting for: %s ... " "${pids[*]}" 
done 

printf "\r%-25s \n" "Done." 
printf "Total runtime: %d seconds\n" "$((`date '+%s'` - $start))" 

तुम भी coprocesses पर बैश प्रलेखन पर एक नज़र रखना चाहिए।

Answer 3

GNU Parallel वह वही है जो आप चाहते हैं, जब तक कि आप पहिया को फिर से शुरू नहीं करना चाहते। यहाँ कुछ और अधिक विस्तृत examples, लेकिन इसके बारे में कम कर रहे हैं:

ls | parallel gzip # gzip all files in a directory