multithreading - अनलॉक म्यूटेक्स को लॉक करना कितना कुशल है? म्यूटेक्स की कीमत क्या है?




locking mutex (3)

निम्न स्तर की भाषा (सी, सी ++ या जो भी हो) में: मेरे पास म्यूटेक्स का गुच्छा (जैसे कि पर्थ्रेड मुझे या जो भी मूल सिस्टम लाइब्रेरी प्रदान करता है) या किसी ऑब्जेक्ट के लिए एक भी है।

म्यूटेक्स को लॉक करना कितना कुशल है? मैं कितने असेंबलर निर्देशों की संभावना है और वे कितना समय लेते हैं (मामले में म्यूटेक्स अनलॉक है)?

म्यूटेक्स की कीमत कितनी है? क्या वास्तव में बहुत सारे म्यूटेक्स होने की समस्या है? या क्या मैं अपने कोड में जितना म्यूटेक्स वैरिएबल फेंक सकता हूं क्योंकि मेरे पास int variables हैं और इससे कोई फर्क नहीं पड़ता?

(मुझे यकीन नहीं है कि विभिन्न हार्डवेयर के बीच कितने मतभेद हैं। यदि वहां है, तो मैं उनके बारे में भी जानना चाहूंगा। लेकिन ज्यादातर, मुझे सामान्य हार्डवेयर के बारे में दिलचस्पी है।)

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


मेरे पास म्यूटेक्स का एक गुच्छा या ऑब्जेक्ट के लिए एक भी विकल्प है।

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

म्यूटेक्स को लॉक करना कितना कुशल है? मैं कितने असेंबलर निर्देशों की संभावना है और वे कितना समय लेते हैं (मामले में म्यूटेक्स अनलॉक है)?

सटीक असेंबलर निर्देश म्यूटेक्स के कम से कम ओवरहेड हैं - मेमोरी / कैश कोहेरेंसी गारंटी मुख्य ओवरहेड हैं। और कम अक्सर एक विशेष ताला लिया जाता है - बेहतर।

म्यूटेक्स दो प्रमुख हिस्सों (oversimplifying) से बना है: (1) एक ध्वज यह इंगित करता है कि म्यूटेक्स बंद है या नहीं और (2) प्रतीक्षा कतार।

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

अनलॉक म्यूटेक्स लॉक करना वाकई सस्ता है। अनलॉकिंग mutex w / o विवाद भी सस्ता है।

म्यूटेक्स की कीमत कितनी है? क्या वास्तव में बहुत सारे म्यूटेक्स होने की समस्या है? या क्या मैं अपने कोड में जितना म्यूटेक्स वैरिएबल फेंक सकता हूं क्योंकि मेरे पास int variables हैं और इससे कोई फर्क नहीं पड़ता?

आप अपनी इच्छानुसार अपने कोड में जितना म्यूटेक्स वैरिएबल फेंक सकते हैं। आप केवल उस स्मृति की मात्रा से सीमित हैं जो आप आवंटित कर सकते हैं।

सारांश। उपयोगकर्ता-स्थान ताले (और विशेष रूप से म्यूटेक्स) सस्ते होते हैं और किसी भी सिस्टम सीमा के अधीन नहीं होते हैं। लेकिन उनमें से बहुत से डिबगिंग के लिए दुःस्वप्न मंत्रमुग्ध करते हैं। सरल तालिका:

  1. कम ताले का मतलब अधिक विवाद (धीमी सिस्कोल, सीपीयू स्टाल) और कम समांतरता है
  2. कम ताले का मतलब है बहु-थ्रेडिंग समस्याओं को डीबग करने में कम समस्याएं।
  3. अधिक ताले का मतलब कम विवाद और उच्च समांतरता है
  4. अधिक ताले का अर्थ अनावश्यक deadlocks में चलाने की संभावना अधिक है।

आवेदन के लिए एक संतुलित लॉकिंग योजना को पाया जाना चाहिए और बनाए रखा जाना चाहिए, आमतौर पर # 2 और # 3 को संतुलित करना चाहिए।

(*) कम अक्सर लॉक किए गए म्यूटेक्स के साथ समस्या यह है कि यदि आपके आवेदन में बहुत अधिक लॉकिंग है, तो यह अन्य CPUs के डेटा कैश से म्यूटेक्स मेमोरी को फ्लश करने के लिए इंटर-सीपीयू / कोर यातायात का अधिक कारण बनता है। कैश coherency। कैश फ्लश हल्के वजन वाले इंटरप्ट्स की तरह होते हैं और सीपीयू द्वारा पारदर्शी रूप से संभाले जाते हैं - लेकिन वे तथाकथित stalls ("स्टाल" के लिए खोज) पेश करते हैं।

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

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


कार्यान्वयन के आधार पर लागत अलग-अलग होगी लेकिन आपको दो चीजों को ध्यान में रखना चाहिए:

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

एकल प्रोसेसर सिस्टम पर, आप आमतौर पर डेटा को परमाणु रूप से बदलने के लिए पर्याप्त लंबे समय तक इंटरप्ट अक्षम कर सकते हैं। बहु-प्रोसेसर सिस्टम test-and-set रणनीति का उपयोग कर सकते हैं।

उन दोनों मामलों में, निर्देश अपेक्षाकृत कुशल हैं।

इस बात के लिए कि क्या आपको एक विशाल डेटा संरचना के लिए एक म्यूटेक्स प्रदान करना चाहिए, या इसमें कई म्यूटेक्स हैं, इनमें से प्रत्येक अनुभाग के लिए, यह एक संतुलित कार्य है।

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


यह उस पर निर्भर करता है जिसे आप वास्तव में "म्यूटेक्स", ओएस मोड और आदि कहते हैं।

कम से कम यह एक इंटरलॉक मेमोरी ऑपरेशन की लागत है। यह अपेक्षाकृत भारी ऑपरेशन है (अन्य आदिम असेंबलर कमांड की तुलना में)।

हालांकि, यह बहुत अधिक हो सकता है। यदि आप "mutex" को कर्नेल ऑब्जेक्ट (यानी - ओएस द्वारा प्रबंधित ऑब्जेक्ट) कहते हैं और उपयोगकर्ता मोड में चलाते हैं - इस पर प्रत्येक ऑपरेशन कर्नेल मोड लेनदेन की ओर जाता है, जो बहुत भारी है।

उदाहरण के लिए इंटेल कोर डुओ प्रोसेसर, विंडोज एक्सपी पर। इंटरलाक्ड ऑपरेशन: लगभग 40 सीपीयू चक्र लेता है। कर्नेल मोड कॉल (यानी सिस्टम कॉल) - लगभग 2000 सीपीयू चक्र।

यदि यह मामला है - तो आप महत्वपूर्ण वर्गों का उपयोग करने पर विचार कर सकते हैं। यह एक कर्नेल म्यूटेक्स और इंटरलॉक मेमोरी एक्सेस का एक संकर है।







blocking