10

मैं नीचे से एक की तरह एक सरल एकल पिरोया प्रक्रिया को चलाने कहते हैं:कई प्रोसेसर/कोर पर एक थ्रेडेड प्रक्रिया क्यों निष्पादित होती है?

public class SirCountALot { 
    public static void main(String[] args) { 
     int count = 0; 
     while (true) { 
      count++; 
     } 
    } 
} 

(यह जावा है, क्योंकि मैं क्या कर रहा हूँ से परिचित है कि है, लेकिन मैं यह वास्तव में कोई फर्क नहीं पड़ता संदेह है)

मेरे पास एक आई 7 प्रोसेसर (4 कोर, या 8 हाइपरथ्रेडिंग गिनती है), और मैं विंडोज 7 64-बिट चला रहा हूं इसलिए मैंने सीपीयू उपयोग को देखने के लिए Sysinternals Process Explorer को निकाल दिया, और उम्मीद के अनुसार मुझे लगता है कि यह लगभग 20% सभी उपलब्ध सीपीयू के।

Graph showing 20% CPU usage across all cores

लेकिन जब मैं विकल्प को चालू सीपीयू प्रति 1 ग्राफ को दिखाने के लिए, मुझे लगता है कि 4 "कोर" के बजाय का 1 इस्तेमाल किया जा रहा सभी कोर से अधिक, CPU उपयोग फैला हुआ है:

Graph showing erratic CPU usage on each core totaling around 20% usage

इसके बजाय मैं अपेक्षा करता हूं कि 1 कोर अधिकतम हो गया है, लेकिन यह तब होता है जब मैं प्रक्रिया के लिए एक कोर को एफ़िनिटी सेट करता हूं।

Graph showing most of recent CPU usage to be confined to first core

क्यों काम का बोझ अलग कोर में बांटा गया है? कैशिंग के साथ कई कोर गड़बड़ पर वर्कलोड को विभाजित नहीं करना होगा या अन्य प्रदर्शन दंड लगाना होगा?

क्या यह एक कोर के अति ताप को रोकने के सामान्य कारण के लिए है? या क्या कोई गहरा कारण है?

संपादित करें: मुझे पता है कि ऑपरेटिंग सिस्टम शेड्यूलिंग के लिए ज़िम्मेदार है, लेकिन मैं जानना चाहता हूं कि यह "परेशान" क्यों है। निश्चित रूप से एक बेवकूफ दृष्टिकोण से, एक (ज्यादातर *) सिंगल-थ्रेडेड प्रक्रिया को 1 कोर पर चिपकाकर आसान & जाने का अधिक प्रभावी तरीका है?

* मैं ज्यादातर एकल पिरोया कई theads है क्योंकि यहाँ कहते हैं, लेकिन उनमें से 2 कुछ भी कर रहे हैं:

Screenshot showing number of threads from Eclipse Screenshot showing number of threads in Process Explorer process properties

+2

छोटे nitpick कोशिश कर के खिलाफ एक तर्क हो सकता है; यह कह रहा है कि यह एक थ्रेडेड प्रक्रिया सही नहीं होगी। JVM आंतरिक finalizers, कचरा कलेक्टरों आदि जैसे गृह व्यवस्था प्रयोजनों यह संभव है असली काम प्रत्येक थ्रेड से करवाने के लिए उस के लिए एक से अधिक थ्रेड spawns, JVM धागे डब्ल्यू धागे, जो फिर से प्रसार को स्पष्ट करने वाले असली ज पर मैप किए जाते /। –

+0

मुझे लगता है कि कैस्पर का मतलब _non-daemon_ धागे था। – Santosh

+0

@ SanjayT.Sharma हाँ, मैं एक छोटा सा सरलीकृत और शायद एक गैर-प्रबंधित भाषा में एक नमूना कार्यक्रम देना चाहिए;) हालांकि तरह मैंने कहा, मैं दृढ़ता से संदेह है कि यह JVM यह कर नहीं है (और अगर यह मानचित्रण है JVM? -> HW धागे और कहा कि जिम्मेदार है, यही कारण है कि मानचित्रण लगातार बदल रहा है) – Caspar

उत्तर

17

ओएस निर्धारण के लिए जिम्मेदार है। यह थ्रेड को रोकने के लिए स्वतंत्र है और इसे फिर से दूसरे सीपीयू पर शुरू करें। यह तब भी करेगा जब मशीन कुछ भी नहीं कर रही है।

प्रक्रिया सीपीयू के चारों ओर ले जाया गया है क्योंकि ओएस यह नहीं मानता कि हर बार एक ही CPU पर थ्रेड चलाने के लिए कोई कारण नहीं है।

इस कारण से मैंने लॉक धागे को एक सीपीयू में लाइब्रेरी लिखा है, इसलिए यह चारों ओर नहीं चलेगा और अन्य धागे से बाधित नहीं होगा। यह विलंबता को कम करता है और थ्रूपुट में सुधार करता है लेकिन उस धागे के लिए एक सीपीयू को टायर करता है। यह लिनक्स के लिए काम करता है, शायद आप इसे विंडोज के लिए अनुकूलित कर सकते हैं। https://github.com/peter-lawrey/Java-Thread-Affinity/wiki/Getting-started

+0

यह प्रति सेकंड एक प्रक्रिया को कई बार व्यवधान के 99% निष्क्रिय नहीं कर रहे हैं मतलब है। (लिनक्स पर 100/एस) यह याद रखना अधिक काम है कि एक प्रक्रिया आखिरी बार चल रही थी और उस सीपीयू को वरीयता में किसी अन्य को असाइन करने का प्रयास करें, इसके बजाय यह इसे अगले मुफ्त सीपीयू को असाइन करता है। –

+0

मुझे लगता है कि मैं पर्याप्त स्पष्ट नहीं कर सकता; मुझे पता है कि ओएस शेड्यूलिंग करता है, और आप दूसरे ग्राफ में देख सकते हैं कि मैंने प्रक्रिया के लिए एफ़िनिटी सेट की है, इसलिए यह केवल पहले कोर का उपयोग करता है। मैं क्या जानना चाहता हूं * ओएस क्यों सभी उपलब्ध कोरों पर एकल "सक्रिय" धागा शेड्यूल करता है? – Caspar

+0

बातचीत सवाल क्यों वापस बजाय सिर्फ (जो यह क्या करता है) अगले मुक्त सीपीयू को यह बताए राउंड रोबिन का उपयोग का एक ही सीपीयू के लिए अच्छी तरह से काम कोई फर्क नहीं पड़ता कि कितने सीपीयू व्यस्त हैं एक धागा बताए रखने के लिए होगा है। प्रत्येक सीपीयू को आवंटित करने से प्रत्येक बार एक सीपीयू बहुत व्यस्त हो सकता है (इसमें दो धागे चलते हैं) जबकि अन्य सीपीयू निष्क्रिय होते हैं। –

1

मैं भी उम्मीद होती है यह अच्छी तरह से सीपीयू और ओएस द्वारा उद्देश्य पर किया जा सकता है तो के रूप में कोशिश करते हैं और सीपीयू मरने पर थर्मल लोड प्रसार करने के लिए ...

तो यह बारी बारी से होगा (अद्वितीय/एकल) कोर से कोर तक धागा।

और वह बेशक यह भी मुश्किल से लड़ने के लिए (विशेष रूप से के रूप में, व्यवहार में, आप अक्सर बेहतर सुधार/देखेंगे बस ट्यूनिंग द्वारा एप्लिकेशन को स्वयं वैसे भी सुधार करने)

+0

दिलचस्प। क्या आप जानते हैं कि विंडोज/लिनक्स यह सुनिश्चित करने के लिए करते हैं, या यह एक परिकल्पना है? (इसके अलावा, स्टैक ओवरफ्लो में आपका स्वागत है:) – Leeor

+0

मैंने यह स्पष्ट रूप से ओएसएक्स और विंडोज पर देखा है। मैं लिनक्स के लिए इसकी अपेक्षा करता हूं लेकिन इसे कभी सत्यापित करने की कोशिश नहीं करता। – Camlin

संबंधित मुद्दे