सी ++ 11

Question

में धागे का प्रदर्शन मुझे mutex के प्रदर्शन में रुचि है और नवीनतम gcc में pthreads और उबंटू विकास पर्यावरण के आधार पर धागे के साथ संदेश भेज रहा है। इसके लिए एक अच्छी सामान्य समस्या डाइनिंग दार्शनिक है जहां प्रत्येक दार्शनिक लह और दाहिने हाथ पड़ोसी के साथ साझा किया गया lh और rh कांटा का उपयोग करता है। मैं अपने क्वाड कोर प्रोसेसर व्यस्त रखने के लिए दार्शनिकों की संख्या 99 तक बढ़ाता हूं।

int result = try_lock(forks[lhf], forks[rhf]); 

ऊपर कोड मेरी दार्शनिक दो कांटे वे के साथ खाने की जरूरत हड़पने के लिए प्रयास करने के लिए अनुमति देता है।

// if the forks are locked then start eating 
    if (result == -1) 
    { 
     state[j] = philosophers::State::Eating; 
     eating[j]++; 
     if (longestWait < waiting[j]) 
     { 
      longestWait = waiting[j]; 
     } 
     waiting[j] = 0; 
    } else { 
     state[j] = philosophers::State::Thinking; 
     thinking[j]++; 
     waiting[j]++; 
    } 

ऊपर कोड पर नज़र रखता है मेरी दार्शनिकों खाने प्रगति या सोच के आधार अगर वे दो कांटे आरक्षित लेते हैं।

{ 
     testEnd te(eating[j]+thinking[j]-1); 
     unique_lock<mutex> lk(cycleDone); 
     endCycle.wait(lk, te); 
    } 

ऊपर कोड इंतजार कर रहा है सभी दार्शनिकों चयन इस समय के बाद दार्शनिक एक नया प्रयास करने के लिए स्वतंत्र है को पूरा करने के लिए:

if (philosophers::State::Eating == state[j]) 
    { 
     state[j] = philosophers::State::Thinking; 
     forks[lhf].unlock(); 
     forks[rhf].unlock(); 
    } 

मैं एक मुख्य थ्रेड कि दार्शनिकों और चाल पर नज़र रखता है है उन्हें एक चक्र से अगले तक जो उन्हें खाने के लिए लगभग 10 सेकंड की अनुमति देता है और जितना संभव हो उतना सोच सकता है। परिणाम लगभग 9540 चक्र हैं जिनमें कुछ दार्शनिक भूखे हैं और अन्य खाने के लिए बहुत सारे हैं और बहुत सोचने का समय है! तो मैं जारी करने और सोचने के लिए खाने दार्शनिकों की आवश्यकता होती है न कि एक बहुत छोटे से ब्रेक के बाद एक ही कांटे बकवाद से खाने से अधिक को रोकने के लिए भुखमरी और अधिक प्रतीक्षा न मेरी दार्शनिकों की रक्षा के लिए तो मैं अधिक तर्क जोड़ने की जरूरत है:

// protect the philosopher against starvation 
    if (State::Thinking == previous) 
    { 
     result = try_lock(forks[lhf], forks[rhf]); 
    } 

अब मेरे पास 9 5 9 चक्र हैं जिनमें हर दार्शनिक को खाने के अपेक्षाकृत समान हिस्से (2620 - 2681) मिलते हैं और 14 की सबसे लंबी प्रतीक्षा के साथ सोचते हैं। बुरा नहीं। लेकिन मैं संतुष्ट नहीं हूं इसलिए अब मैं सभी म्यूटेक्स और ताले से छुटकारा पाता हूं और यहां तक ​​कि चक्रों में खाने वाले दार्शनिकों और अजीब चक्रों में खाने वाले अजीब दार्शनिकों के साथ इसे सरल बना देता हूं। मैं दार्शनिकों

while (counter < counters[j]) 
{ 
    this_thread::yield(); 
} 

खाने या एक वैश्विक चक्र काउंटर का उपयोग कर कई बार सोच से एक दार्शनिक रोकता सिंक कर रहा है की एक सरल विधि का उपयोग करें। वही समय अवधि और दार्शनिक 36400 खाने के साथ 73543 चक्रों का प्रबंधन करते हैं और 3 से अधिक चक्र इंतजार नहीं करते हैं। तो मेरे लॉक के साथ मेरा सरल एल्गोरिदम दोनों तेज़ है और विभिन्न धागे के बीच प्रसंस्करण का बेहतर वितरण है।

क्या कोई इस समस्या को हल करने के लिए बेहतर तरीके से सोच सकता है? मुझे डर है कि जब मैं कई धागे के साथ एक जटिल प्रणाली को लागू करता हूं कि यदि मैं पारंपरिक म्यूटेक्स और संदेश पास करने वाली तकनीकों का पालन करता हूं तो मैं अपने सिस्टम में विभिन्न धागे पर आवश्यक और संभावित असंतुलित प्रसंस्करण की तुलना में धीमी गति से समाप्त हो जाऊंगा।

Answer 1

यह सी ++ में थ्रेडिंग के मुद्दों का पता लगाने का एक दिलचस्प तरीका है।

विशिष्ट बिंदुओं को संबोधित करने के लिए:

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

दुर्भाग्यवश, सबसे अच्छा जवाब मैं आपको दे सकता हूं कि यह एक अच्छी तरह से स्थापित डर है।शेड्यूलिंग और सिंक्रनाइज़ेशन की लागत एप्लिकेशन के लिए बहुत विशिष्ट है, हालांकि - यह एक बड़ी प्रणाली को डिजाइन करते समय एक इंजीनियरिंग निर्णय बन जाता है। सबसे पहले और सबसे महत्वपूर्ण, शेड्यूलिंग एनपी-हार्ड (http://en.wikipedia.org/wiki/Multiprocessor_scheduling) है लेकिन अच्छे अनुमान हैं।

जहां तक ​​आपका विशेष उदाहरण है, मुझे लगता है कि आपके द्वारा मौजूद परिणामों के आधार पर सामान्य निष्कर्ष निकालना मुश्किल है - एक प्राथमिक होम होम प्वाइंट है: मोटे अनाज सिंक्रनाइज़ेशन और ठीक अनाज सिंक्रनाइज़ेशन के बीच व्यापार बंद है। यह अच्छी तरह से अध्ययन की समस्या है और कुछ शोध सहायक हो सकते हैं (उदाहरण के लिए http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=744377&tag=1)।

कुल मिलाकर, यह एक इंजीनियरिंग समस्या पर छूता है जो उस समस्या के लिए विशिष्ट होगा जो आप हल करना चाहते हैं, ऑपरेटिंग सिस्टम और हार्डवेयर।