प्रति प्रोसेसर

Question

जावा में, क्या यह पता लगाने के लिए एक प्रोग्रामेटिक तरीका है कि सीपीयू द्वारा कितने समवर्ती धागे समर्थित हैं?

अद्यतन

स्पष्ट करने के लिए, मैं धागे के साथ सीपीयू हथौड़ा की कोशिश नहीं कर रहा हूँ और मैं Runtime.getRuntime() के बारे में पता कर रहा हूँ। AvailableProcessors() फ़ंक्शन, जो मुझे जानकारी मैं का हिस्सा प्रदान करता है मैं देख रहा हूँ

• अगर मैं एक वर्ष 1 वर्ष सर्वर पर चल रहा हूँ, मैं 2 धागे मिल (1 धागा:

  मैं वहाँ एक रास्ता धुन थ्रेड पूल के आकार इतना है कि अगर करने के लिए स्वचालित रूप से पता लगाना चाहते हैं प्रति सीपीयू एक्स 2 के एक मनमानी गुणक 2)

• अगर मैं अब से दो साल इंटेल i7 क्वाड कोर पर स्विच करता हूं (जो प्रति कोर 2 धागे का समर्थन करता है), मुझे 16 धागे मिलते हैं (2 लॉजिकल थ्रेड प्रति CPU x 4 CPUs x मनमानी 2 के गुणक)।
• अगर, बजाय, मैं एक आठ कोर UltraSPARC टी 2 सर्वर (जो मूल प्रति 8 धागे का समर्थन करता है) का उपयोग, मैं 128 धागे मिल (सीपीयू प्रति 8 धागे x 8 सीपीयू x 2 की मनमानी गुणक)
• अगर मैं तैनात 30 अलग-अलग मशीनों के क्लस्टर पर एक ही सॉफ्टवेयर, संभावित रूप से अलग-अलग वर्षों में खरीदा गया, मुझे सीपीयू चश्मा पढ़ने और उनमें से प्रत्येक के लिए कॉन्फ़िगरेशन विकल्प सेट करने की आवश्यकता नहीं है।

Answer 1

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

रनटाइम कक्षा में availableProcessors() एक विधि है। क्या आप यही खोज रहे हैं?

Answer 2

एक गैर-हाइपरथ्रेडिंग सीपीयू कोर हमेशा एक थ्रेड चला सकता है। आप बहुत सारे धागे पैदा कर सकते हैं और सीपीयू उनके बीच स्विच करेगा।

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

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

Answer 3

यह वीएम का एक कार्य है, सीपीयू नहीं। यह प्रति धागे खपत ढेर की मात्रा के साथ करना है। जब आप ढेर पर जगह से बाहर निकलते हैं, तो आप कर चुके हैं। अन्य पोस्टर के साथ, मुझे संदेह है कि यदि आप थ्रेड गिनती के कारण हीप स्पेस को पार करते हैं तो इस बिंदु से पहले आपका ऐप अनुपयोगी हो जाता है।

यह discussion देखें।

Answer 4

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

यदि आप थ्रेड पूल का उपयोग करते हैं, तो इसका मतलब है कि थ्रेड पूल धागे की संख्या का प्रबंधन करता है क्योंकि थ्रेड बनाने से संसाधनों का उपभोग होता है। थ्रेड पूल रीसायकल धागे। इसका मतलब है कि कई लॉजिकल थ्रेड एक भौतिक धागे के अंदर एक के बाद दौड़ सकते हैं।

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

Edit1: आप स्पष्ट धागे उपयोग कर सकते हैं आपको लगता है थ्रेड पूल संसाधनों आप का उपयोग नहीं करता है। आप उस मामले में स्पष्ट रूप से धागे की संख्या का प्रबंधन कर सकते हैं।

Answer 5

प्रत्येक प्रोसेसर, या प्रोसेसर कोर, एक समय में बिल्कुल 1 चीज कर सकता है। हाइपरथ्रेडिंग के साथ, चीजें थोड़ा अलग होती हैं, लेकिन अधिकांश भाग के लिए जो अभी भी सच है, यही कारण है कि काम पर मेरी एचटी मशीन लगभग 50% से अधिक नहीं होती है, और यहां तक ​​कि जब यह 100% पर होती है, तो यह दो बार प्रोसेस नहीं कर रही है ।

आपको शायद सामान्य आर्किटेक्चर पर कुछ परीक्षण करना होगा, यह निर्धारित करने के लिए कि आप प्रत्येक सीपीयू पर कितने थ्रेड चलाने के लिए तैनात हैं। यदि आप बहुत सारे I/O की प्रतीक्षा कर रहे हैं तो बस 1 थ्रेड का उपयोग करना बहुत धीमा हो सकता है। बहुत सारे धागे चलाना चीजों को धीमा कर देगा क्योंकि प्रोसेसर को अक्सर धागे को स्विच करना होगा, जो काफी महंगा हो सकता है। मुझे यकीन नहीं है कि अगर आप कितने धागे चला सकते हैं, तो मुझे कोई कठोर कोडित सीमा है, लेकिन मुझे लगता है कि आपकी ऐप शायद किसी भी तरह की हार्ड सीमा तक पहुंचने से पहले बहुत अधिक थ्रेड स्विचिंग से क्रॉल पर आ जाएगी। आखिरकार, आपको इसे कॉन्फ़िगरेशन फ़ाइल में एक विकल्प के रूप में छोड़ देना चाहिए, ताकि आप अपने ऐप को आसानी से ट्यून कर सकें जो भी प्रोसेसर आप इसे चला रहे हैं।

Answer 6

जावा के भीतर प्रति CPU कोर समर्थित समर्थित थ्रेड की संख्या प्राप्त करने का कोई मानक तरीका नहीं है। आपकी सबसे अच्छी शर्त जावा सीपीयूआईडी उपयोगिता प्राप्त करना है जो आपको प्रोसेसर की जानकारी देता है, और फिर उस तालिका के खिलाफ मेल खाता है जो आपको उत्पन्न करना होगा जो आपको प्रति कोर धागे देता है कि प्रोसेसर "असली" संदर्भ स्विच के बिना प्रबंधित करता है।

-Adam

Answer 7

Runtime.availableProcessors तार्किक प्रोसेसर की संख्या (यानी हार्डवेयर धागे) नहीं शारीरिक कोर देता है। CR 5048379 देखें।