समानांतर गणना में प्रत्येक कर्नेल को सीपीयू कोर कैसे वितरित किया जाता है?
बस यह सुनिश्चित करना चाहता हूं कि प्रश्न पूछने से पहले मैं सही ढंग से समझूं। मैंने कुछ लोगों को यह कहते हुए देखा कि Mathematica में कुछ फ़ंक्शन स्वचालित रूप से मल्टी-कोर का उपयोग करेंगे (मैं उन लोगों का उल्लेख नहीं कर रहा हूं जिन्हें हम समानांतर करते हैं, लेकिन उन जैसे का उल्लेख करते हुए NIntegrate
), इसलिए मुझे लगता है कि अगर मेरे पास 2 कोर हैं, तो यह तेजी से होगा कोर। इसलिए मेरे सवाल हैं, अगर मेरे पास निम्नलिखित जैसा कोई कोड है:ParallelTable[NIntegrate[x, {x, 1, 3}], {loop, 1, 3}]
मुझे लगता है कि तीन गुठली लॉन्च की जाएगी। अगर मेरे पास 4 कोर हैं, तो ये चार कोर प्रत्येक कर्नेल को कैसे वितरित किए जाते हैं? (चूंकि मुझे लगता है कि प्रत्येक कर्नेल फ़ंक्शन एकीकरण की संपत्ति के आधार पर मल्टी-कोर का उपयोग कर सकता है)
जवाब
आपका स्वागत है no-b, m.se एम के बारे में अनंत सीखने के लिए एक महान समुदाय है!
मुझे लगता है कि आपके पास कुछ गलत धारणाएं हैं:
सबसे पहले, यहां तक कि एकल-थ्रेडेड ऑपरेशन कई कोर पर थ्रेड कर सकते हैं। एक अच्छा ऑपरेटिंग सिस्टम इससे बचने की कोशिश करता है, लेकिन हर इतने-इतने सेकंड में, यह दूसरे कोर में बदल सकता है, या यह कई कोर पर लोड को विभाजित कर सकता है - हालांकि बाद वाले आमतौर पर विस्तारित समय के लिए नहीं होते हैं।
दूसरा, आप यह नहीं मान सकते हैं कि NIntegrate हमेशा सभी आदानों के लिए समानांतर होगा , और विशेष रूप से आप यह नहीं मान सकते कि NIntegrate पूरे गणना समय के लिए समानांतर होगा। यह केवल इनिशियलाइज़ेशन के लिए या अंत में या बीच में चुनिंदा कार्यों के लिए समानांतर हो सकता है। उदाहरण के लिए,
Do[Do[NIntegrate[x,{x,1,3}],{3}],{100000}]
यदि आप मुख्य उपयोग को देखते हैं (नहीं: प्रक्रिया का उपयोग, जैसे एक साधारण कार्य प्रबंधक में) - यदि आप लिनक्स पर हैं, तो आप शीर्ष पर चल सकते हैं और 1 हिट कर सकते हैं - आप देखेंगे कि यह 99% समय व्यतीत करता है एक कोर। यह कुछ समय बाद कोर को स्विच कर सकता है, लेकिन फिर आप उस कोर के लिए 99% देखते हैं । इसलिए मैं NIntegrate को कई कोर में नहीं देखता, कम से कम हर समय (शायद सेकंड के अंश के लिए)। यह अलग-अलग NIntegrate आदानों के लिए भिन्न हो सकता है, लेकिन यह सरल उदाहरण दिखाता है कि NIntegrate हमेशा गणना नहीं करता है और इसकी गणना की पूरी अवधि के लिए नहीं।
एम समानता के ढांचे के साथ यह नहीं बदलता है, यह वास्तव में एक ऑपरेटिंग सिस्टम मामला है। ParallelTable (और brethren) के साथ आप अधिक प्रक्रियाओं से प्रसंस्करण कार्यों की आपूर्ति कर रहे हैं, और कोर के लिए ओ / एस शेड्यूल कैसे पूरी तरह से ओ / एस तक है। तो आप वास्तव में समानांतर प्रक्रियाओं की समझ से कोर को असाइनमेंट "वापस" नहीं कर सकते।
कुछ हद तक एक स्पर्शरेखा:
Scala, Java या C # (या कई अन्य भाषाओं) में आप थ्रेड लेवल पर टास्क शेड्यूल कर सकते हैं। लेकिन फिर भी यह ओ / एस से लेकर कोर टू शेड्स टू कोर तक है। जावा के vmstat के साथ आपके पास थ्रेड्स का अद्भुत दृश्य है (क्षैतिज पट्टियां जो समय के साथ बढ़ती हैं, प्रति थ्रेड एक), मुझे लगता है कि आप वास्तव में किस चीज में रुचि रखते हैं कि थ्रेड्स में चीजें कैसे काम करती हैं, जरूरी नहीं कि धागे कोर को कैसे सौंपे जाएं। । उस के साथ हालांकि कहा, थ्रेड्स एक सॉफ्टवेयर अवधारणा है, हार्डवेयर अवधारणा नहीं है, एक कोर को यह नहीं पता है कि एक धागा क्या है। लेकिन मुझे लगता है कि एक थ्रेड एनालिसिस आपको कोर को असाइनमेंट, और कोर स्विचिंग, और हर कोर के वर्कलोड के प्रतिशत के रूप में कंसीडर समझने के लिए और अधिक बताएगा, पूरी तरह से ओ / एस तक है।
कुछ कार्य हैं जो स्वचालित रूप से कई कोर का उपयोग करते हैं। वे कितने कोर का उपयोग करते हैं, उनमें से कुछ सेटिंग्स द्वारा निर्धारित किया जाता है SystemOptions["ParallelOptions"]
।
यदि आप उप-केंद्रों पर ऐसे कार्यों का उपयोग करते हैं, तो वे केवल एक कोर का उपयोग करेंगे। आप इसे देख कर सत्यापित कर सकते हैं ParallelEvaluate@SystemOptions["ParallelOptions"]
। ध्यान दें कि सभी थ्रेड काउंट सबकुर्नेल पर 1 पर सेट हैं।
आम तौर पर, स्पष्ट समानांतरीकरण (जैसे ParallelTable
) कुछ कार्यों के अंतर्निहित समानांतर के रूप में कुशल नहीं है। इस प्रकार, यदि आपकी अड़चन एक ऐसा कार्य है जो पहले से ही समानांतर में चलता है, तो अतिरिक्त समानांतरकरण को ParallelTable
संबंधित कार्यों के साथ लागू करने से यह धीमा हो जाएगा (या कम से कम यह मेरे द्वारा जांचे गए सभी मामलों में धीमा हो गया)।