विशिष्ट प्रोसेसर कोर

Question

पर विशिष्ट थ्रेड बाध्यकारी मैंने कॉलेज में समांतर प्रसंस्करण के साथ थोड़ा सा शब्द दिया है और अब मैं इसे बेहतर बनाने की कोशिश कर रहा हूं। मैं कोड लिख सकता हूं जो समानांतर में चलाया जा सकता है और फिर थ्रेड शुरू कर सकता है, लेकिन इसके बाद मैं धागे के नियंत्रण पर नियंत्रण खो देता हूं। मैं जानना चाहता हूं कि मैं थ्रेड को चीजों पर कैसे नियंत्रित कर सकता हूं उदाहरण के लिए एक विशिष्ट प्रोसेसर कोर को एक विशिष्ट थ्रेड बांधें।

मुझे ज्यादातर सी ++ में दिलचस्पी है, लेकिन मैंने जावा में इसका कुछ कोडिंग किया है, इसलिए उन उत्तरों का भी स्वागत है।

Answer 1

मैं जावा परिप्रेक्ष्य में जवाब दे रहा हूं: यह संभव नहीं है। सबसे अच्छा आप क्या नियंत्रित कर सकते हैं thread priority है। कुछ CPU/core पर चलाने के लिए जावा को मजबूर करने के लिए, आपको इसे प्लेटफ़ॉर्म विशिष्ट तरीके से करना होगा। उदाहरण के लिए, आप प्रक्रिया टैब में प्रक्रिया का पता लगाकर कार्य प्रबंधक में ऐसा कर सकते हैं, प्रक्रिया में प्रक्रिया (आमतौर पर java.exe) पर क्लिक करके सेट एफ़िनिटी सेट करें और सीपीयू/कोर पर टिकटें।

आप अनुमान लगा सकते हैं, यह वास्तव में विश्व स्तर पर आत्मीयता सेट, धागे आप जावा में बनाने के आधार पर नहीं।

Answer 2

विंडोज़ पर, आप थ्रेड के लिए प्रोसेसर एफ़िनिटी सेट करने के लिए SetThreadAffinityMask का उपयोग कर सकते हैं।

Answer 3

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

बेवकूफ लेकिन तेजी से खारिज किए गए विचार यह है कि बढ़ते धागे (कारण के भीतर) ऐसे सिस्टम के लिए थ्रूपुट बढ़ाता है। हालांकि, साक्ष्य बढ़ रहा है कि जब सही ढंग से डिज़ाइन किया गया है, तो अधिकांश प्रोसेसिंग के लिए बहुत कम धागे का उपयोग करने वाले समाधान उच्च-समवर्ती समाधानों को काफी हद तक बेहतर कर सकते हैं - कभी-कभी दस, या यहां तक ​​कि एक सौ के कारकों से।

इसका मुख्य कारण संदर्भ स्विचिंग है। संदर्भ स्विचिंग वह प्रक्रिया है जिसमें एक सीपीयू वर्तमान थ्रेड के लिए कैश-रैम (यदि आप भाग्यशाली हैं) या मुख्य रैम (यदि आप नहीं हैं) के लिए अपने कामकाजी माहौल को फ्लश करते हैं, और अगले थ्रेड के लिए कामकाजी माहौल में पढ़ते हैं - और यह सबसे महंगी परिचालनों में से एक है जो कम विलंबता प्रणाली कर सकता है।

यदि आप संदर्भ स्विचिंग को कम करना चाहते हैं जहां कम विलंबता सर्वोपरि है, तो कुछ महत्वपूर्ण प्रक्रियाएं एक कोर या सीपीयू थ्रेड के लिए सबसे अच्छी तरह से प्रतिबंधित हो सकती हैं। जहां कई धागे के लिए उन महत्वपूर्ण थ्रेड-प्रतिबंधित प्रक्रियाओं द्वारा प्रबंधित डेटा को पढ़ने या लिखने के लिए जरूरी है, तो आप "विघटनकर्ता" पैटर्न को देखना चाहेंगे, जो एक रिंग बफर का उपयोग करता है और बहुत तेज़ चतुर चालों को बहुत तेजी से अनुमति देता है साझा डेटा तक पहुंच, जबकि उस डेटा पर एक विशेष लॉक की आवश्यकता होती है (नीचे लिंक)।

जावा में ओएस-स्वतंत्र तरीके से थ्रेड एफ़िनिटी (सीपीयू बाइंडिंग) कार्यों को प्राप्त करने के लिए, आप पीटर लॉरी की जावा थ्रेड एफ़िनिटी लाइब्रेरी का उपयोग कर सकते हैं, जो नीचे भी लिंक किया गया है। यह भी ध्यान दें कि पीटर एक पाठक धागे को एक हाइपर-थ्रेडेड कोर के एक हाइपर-थ्रेड से बांधता है, और एक लेखक को थ्रेड करता है, एक चाल जिसे मैं सराहनीय लाभों पर विचार कर सकता हूं (हालांकि मैंने इसे आजमाया नहीं है)।

बार्नी

http://lmax-exchange.github.io/disruptor/

https://github.com/peter-lawrey/Java-Thread-Affinity/wiki/How-it-works