x86 LWARX और STWCX

Question

के बराबर समकक्ष मैं LWARX और STWCX (जैसा कि पावरपीसी प्रोसेसर पर पाया गया है) या x86 प्लेटफॉर्म पर समान कार्यक्षमता को लागू करने का एक तरीका ढूंढ रहा हूं। साथ ही, ऐसी चीजों के बारे में जानने के लिए सबसे अच्छी जगह कहां होगी (यानी लॉक/प्रतीक्षा-मुक्त प्रोग्रामिंग के लिए अच्छे लेख/वेब साइट/फ़ोरम)।

---

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

int* IncrementAndRetrieve(int **ptr) 
{ 
    int val; 
    int *pval; 
    do 
    { 
    // fetch the pointer to the value 
    pval = *ptr; 

    // if its NULL, then just return NULL, the smart pointer 
    // will then become NULL as well 
    if(pval == NULL) 
     return NULL; 

    // Grab the reference count 
    val = lwarx(pval); 

    // make sure the pointer we grabbed the value from 
    // is still the same one referred to by 'ptr' 
    if(pval != *ptr) 
     continue; 

    // Increment the reference count via 'stwcx' if any other threads 
    // have done anything that could potentially break then it should 
    // fail and try again 
    } while(!stwcx(pval, val + 1)); 
    return pval; 
} 

मैं वास्तव में कुछ है कि नकल करता LWARX और STWCX अच्छी तरह सटीक इस बंद को खींचने के लिए (मैं CompareExchange, स्वैप के साथ ऐसा कर या कार्यों मैं अब तक के लिए मिल गया है डालने का एक तरीका को समझ नहीं सकता की जरूरत है x86)।

धन्यवाद

Answer 1

जैसा कि माइकल ने उल्लेख किया है, आप शायद जो देख रहे हैं वह cmpxchg निर्देश है।

यह इंगित करना महत्वपूर्ण है कि इसे पूरा करने की पीपीसी विधि Load Link/Store Conditional (एलएल/एससी) के रूप में जानी जाती है, जबकि x86 आर्किटेक्चर Compare And Swap (सीएएस) का उपयोग करता है। एलएल/एससी में सीएएस की तुलना में मजबूत अर्थशास्त्र है कि कंडीशन किए गए पते पर मूल्य में किए गए किसी भी बदलाव से दुकान विफल हो जाएगी, भले ही अन्य परिवर्तन मूल्य को उस मूल्य के साथ बदल देता है जिस पर लोड की स्थिति थी। दूसरी ओर, सीएएस इस मामले में सफल होगा। इसे एबीए समस्या के रूप में जाना जाता है (अधिक जानकारी के लिए सीएएस लिंक देखें)।

आप x86 आर्किटेक्चर पर मजबूत अर्थ विज्ञान की जरूरत है, तो आप इसे x86s दोहरी-चौड़ाई की तुलना और स्वैप (DWCAS) अनुदेश cmpxchg8b, या x86_64 के तहत cmpxchg16b का उपयोग करके अनुमान लगा सकता है। यह आपको सामान्य रूप से सामान्य की बजाय, लगातार दो लगातार 'प्राकृतिक आकार' शब्दों को स्वैप करने की अनुमति देता है। मूल विचार दो शब्दों में से एक है जिसमें ब्याज का मूल्य होता है, और दूसरे में हमेशा 'उत्परिवर्तन गिनती' होती है। यद्यपि यह तकनीकी रूप से समस्या को खत्म नहीं करता है, लेकिन उत्परिवर्तन काउंटर की संभावनाओं के बीच लपेटने की संभावना इतनी कम है कि यह अधिकांश उद्देश्यों के लिए एक उचित विकल्प है।

Answer 2

86 सीधे "आशावादी संगामिति" का समर्थन नहीं करता पीपीसी करता है - बल्कि, संगामिति के लिए 86 के समर्थन के लिए एक "ताला उपसर्ग" पर आधारित है, here देखते हैं। (एक्सएचजीजी जैसे कुछ तथाकथित "परमाणु" निर्देश वास्तव में LOCK उपसर्ग को जोर देकर अपने परमाणुता प्राप्त करते हैं, चाहे असेंबली कोड प्रोग्रामर ने वास्तव में इसे कोड किया हो या नहीं)। यह वास्तव में "बम-सबूत" नहीं है, इसे राजनयिक रूप से डालने के लिए (वास्तव में, यह दुर्घटनाग्रस्त है, मैं कहूंगा ;-)।

Answer 3

आप शायद निर्देशों के cmpxchg परिवार की तलाश में हैं।

समकक्ष व्यवहार प्राप्त करने के लिए आपको लॉक निर्देश के साथ इन्हें पहले से करना होगा।

क्या उपलब्ध है इसके त्वरित विवरण के लिए here पर एक नज़र डालें।

आप की संभावना इस के समान कुछ के साथ खत्म हो जाएगा:

mov ecx,dword ptr [esp+4] 
mov edx,dword ptr [esp+8] 
mov eax,dword ptr [esp+12] 
lock cmpxchg dword ptr [ecx],edx 
ret 12 

आप this paper पढ़ना चाहिए ...

संपादित

अद्यतन प्रश्न के उत्तर में, आप कर रहे हैं Boost shared_ptr जैसे कुछ करने की तलाश में? यदि ऐसा है, तो उस कोड और उस निर्देशिका में फ़ाइलों को देखें - वे निश्चित रूप से आपको शुरू कर देंगे।

Answer 4

जो आप करने की कोशिश कर रहे हैं वह आपके द्वारा अपेक्षित तरीके से काम नहीं करेगा। आपने जो कार्यान्वित किया है वह इंटरलाक्ड इंस्ट्रक्शन फ़ंक्शन (Win32 फ़ंक्शन; असेंबली: एक्सएडीडी) के साथ किया जा सकता है।

कारण यह है कि आपका कोड ऐसा नहीं करता है जो आपको लगता है कि यह एक और धागा अभी भी stwcx को अमान्य किए बिना * ptr और stwcx के दूसरे पढ़ने के बीच मान को बदल सकता है।

Answer 5

यदि आप 64 बिट्स पर हैं और खुद को 1 टीबी ढेर कहने के लिए सीमित करते हैं, तो आप काउंटर को 24 अप्रयुक्त शीर्ष बिट्स में पैक कर सकते हैं। यदि आपके पास गठबंधन पॉइंटर्स शब्द हैं तो नीचे 5 बिट भी उपलब्ध हैं। यदि LWARX और STWCX पूरे कैश लाइन को अमान्य

int* IncrementAndRetrieve(int **ptr) 
{ 
    int val; 
    int *unpacked; 
    do 
    { 
    val = *ptr; 
    unpacked = unpack(val); 

    if(unpacked == NULL) 
     return NULL; 
    // pointer is on the bottom 
    } while(!cas(unpacked, val, val + 1)); 
    return unpacked; 
} 

Answer 6

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

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