मेरे पास एक स्मृति भूख एप्लिकेशन है जो तत्वों के प्रत्येक संयोजन को संसाधित करने, सरणी की एक जोड़ी के माध्यम से पुनरावृत्त करता है। वर्तमान में यह स्क्रिप्ट बहुत रैम-भूख लगी है। यह लगभग 3 जीबी रैम का उपयोग कर समाप्त होता है।क्या स्मृति प्रक्रिया एक बड़ी प्रक्रिया या कई छोटी प्रक्रियाओं के साथ बेहतर है?
इसे और अधिक स्मृति एक बड़ी प्रक्रिया में तत्वों के प्रत्येक संयोजन कार्रवाई करने के लिए कुशल है:
मेरा प्रश्न है? या प्रत्येक संयोजन के लिए एक नया उपप्रजाय शुरू करना बेहतर है।
for i in param_set1:
for j in paramset2:
Do_A_Big_Job(i, j)
या विकल्प 2:
import subprocess
for i in param_set1:
for j in paramset2:
subprocess.call([Do_A_Big_Job_Script, i, j])
द्वारा "बेहतर", मेरा मतलब है "का उपयोग कम रैम"
दूसरे शब्दों में, यह बेहतर विकल्प 1 करना है।
धन्यवाद!
संपादित मैं स्मृति के उपयोग के बारे में स्पष्ट रूप से उत्सुक हूँ। जब प्रक्रिया समाप्त होती है, तो क्या यूनिक्स सिस्टम उस स्मृति को मुक्त करेगा? उचित रूप से अच्छी तरह लिखित लिपि के लिए पाइथन के कचरे के संग्रह से यह अधिक कुशल है? मेरे पास बहुत सारे कोर उपलब्ध नहीं हैं, इसलिए मैं उम्मीद करता हूं कि कई प्रक्रियाएं वैसे भी समानांतर में कम या ज्यादा चलेंगी।
मेमोरी उपयोग आप अपनी "नौकरियों" (आप कौन से चर निर्दिष्ट कर रहे हैं और मुक्त कर रहे हैं) पर क्या कर रहे हैं, इस पर निर्भर करता है कि आप उन्हें कैसे वितरित करते हैं। यदि प्रत्येक नौकरी बहुत मेमोरी का उपयोग करती है, तो उन्हें समानांतर में चलाना मेमोरी स्टैक कर देगा। एकमात्र रोमांच यह है कि यह * तेज हो सकता है। – asermax
मैं इसे एक उत्तर के रूप में पोस्ट करूंगा, लेकिन मुझे नहीं लगता कि यह वास्तव में एक उत्तर xD के रूप में योग्यता प्राप्त करता है, मैं बस यह इंगित करने की कोशिश कर रहा था कि आप गलत चीज़ पर सवाल उठा रहे हैं। आपका संपादन एक और सटीक प्रश्न प्रतीत होता है और किसी ऐसे व्यक्ति के लिए प्रतीक्षा करना उचित है जो उस विषय के बारे में जानता है। बीटीडब्ल्यू, यह प्रश्न को आसान बनाने के लिए कुछ टैग जोड़ने में मदद करेगा (जैसे यूनिक्स, मेमोरी, सबप्रोसेस, आदि) – asermax