एआरएम कॉर्टेक्स: बिट बैंडिंग म्युटेक्स का उपयोग कर

Question

यह देखते हुए कि, पर एआरएम कॉर्टेक्स एम 3, मैं कर सकते हैं:

• atomically एक बिट एक बिट पढ़
• atomically सेट
• atomically स्पष्ट एक बिट

मैं कैसे ऑपरेशनों के म्युटेक्स शैली सेट के लिए इन गठजोड़ कर सकते हैं:

try lock 
take lock 
release lock 

ऐसा लगता है कि try_lock या take_lock को दो परिचालनों की आवश्यकता होगी जो परमाणु नहीं होंगे।

क्या मुझे इसे पूरा करने के लिए और अधिक नियंत्रण की आवश्यकता है? वैश्विक इंटरप्ट को अक्षम करें, लेकिन ऐसा लगता है कि एक और अधिक शल्य चिकित्सा दृष्टिकोण होना चाहिए।

Answer 1

आपका rwl_TryLock() लॉक पहले से ही विफल होने पर विफलता वापस नहीं करता है (आपका कंपाइलर कम से कम एक कोड के बारे में चेतावनी देना चाहिए पथ जिसमें कोई वापसी मूल्य नहीं है)। प्रयास करें निम्नलिखित:।

int rwl_TryLock(volatile uint32_t *lock, int who){ 

    Var_SetBit_BB((uint32_t)lock, who); 
    if(*lock == (1<<who)){ // check that we have exclusive access 
     // got the lock! 
     return 1; 
    } 

    // do not have the lock 
    Var_ResetBit_BB((uint32_t)lock, who); // clear the lock flag 
    return 0; 
} 

ध्यान दें कि ऊपर रिकर्सिवली ही लॉक का दावा (के लिए यानी काम नहीं करेगा, यदि who == 1 द्वारा निर्दिष्ट कार्य पहले से ही ताला है और इसे फिर से दावा करने के लिए कोशिश करता है, इसके बाद के संस्करण कोड नहीं होगा सही ढंग से काम करें), लेकिन यह आपके मूल के बारे में भी सच था।

इसके अलावा, कॉरटेक्स एम 3 पर इंटरप्ट को अक्षम/सक्षम किया जा सकता है (यह एक एनवीआईसी रजिस्टर के लिए एक साधारण अपडेट है)। क्या आप सुनिश्चित हैं कि लॉक डेटा संरचनाओं को सरल बनाने के लिए कोड को रखने के लिए आपका सिस्टम इंटरप्ट विलंबता के अतिरिक्त कुछ चक्रों के साथ नहीं रह सकता है (जो आमतौर पर सही करने के लिए आसान है)?

Answer 2

कुछ खोज के बाद जानकारी के लिए कुछ:।

" एआरएम कॉर्टेक्स-एम 3 बिट बैंडिंग एआरएम के माइक्रोकंट्रोलर कोर संकेतबाहु लागू करने के लिए अभी तक एक और तरीका प्रदान करता है बिट बैंड उर्फ ​​क्षेत्र में चर लिखने की पहुंच एक परमाणु का कारण बनता है सिस्टम बस स्तर पर बिट-बैंड क्षेत्र में स्मृति स्थान पर पढ़ने-संशोधित-लेखन पहुंच। यह सेमफोरों में अनुवाद कैसे करता है? बिट-बैंड क्षेत्र में एक चर सेमेफोर के लिए कंटेनर के रूप में कार्य कर सकता है। प्रत्येक ग्राहक "का मालिक" उस कंटेनर में थोड़ा सा। जब भी किसी क्लाइंट को सेमफोर का दावा करने की आवश्यकता होती है, तो यह बिट-बैंड उपनाम क्षेत्र में संबंधित स्थान पर 1 लिखकर अपना स्वयं का सेट सेट करता है। फिर यह कंटेनर (बिट-बैंड क्षेत्र) को पढ़ेगा डी जांचें कि कोई अन्य बिट सेट नहीं है, जिसका अर्थ है कि ग्राहक ने सैमफोर पर सफलतापूर्वक दावा किया है। यदि अन्य बिट्स सेट किए गए हैं, तो क्लाइंट को फिर से अपना खुद का साफ़ करना होगा, और फिर से प्रयास करना होगा (शायद प्रतीक्षा के बाद)। " (source)

यहाँ मेरी कच्चे तेल है (untested) व्याख्या:

/* 
* Frees a lock. 
* 
* @note lock must point to a fully aligned 32 bit integer. 
* (atomically set to 0) 
* 
* @returns 1 if successfull 
*/ 
int rwl_FreeLock(volatile uint32_t *lock){ 
    *lock = 0; 
    return 1; // always successful 
} 

/* 
* Attempts to acquire a lock 
* @param who is the client taking the lock 
* @lock pointer to the mutex (uint32_t value in memory) 
* @note lock must point to a fully aligned 32 bit integer. 
* (atomically set to 1 only if set to 0) 
*/ 
int rwl_TryLock(volatile uint32_t *lock, int who){ 
    // initial check of lock 
    if(*lock == 0){ 
     Var_SetBit_BB((uint32_t)lock, who); 
     if(*lock == (1<<who)){ // check that we still have exclusive access 
      // got the lock! 
      return 1; 
     } else { 
        // do not have the lock 
      Var_ResetBit_BB((uint32_t)lock, who); // clear the lock flag 
      return 0; 
     } 
    } 
} 

Var_Set_BB/Var_Reset_BB:। सेट/साफ एक बिट का उपयोग कर बिट बैंडिंग (परमाणु)

हालांकि, यह करता है काम नहीं !!!

Answer 3

मैंने कभी भी एआरएम पर बिट-बैंडिंग का उपयोग नहीं किया है; इसके बजाय मेरे झुकाव सभी ऐसे परिचालनों के लिए लोड-अनन्य/स्टोर-सशर्त उपयोग करना होगा। पुराना मान लोड करने के लिए एक लूप का उपयोग करें, नए मान की गणना करें, और इसे वापस लिखने के लिए एक सशर्त स्टोर का उपयोग करें।लूप जब तक सशर्त स्टोर सफल नहीं हो जाता है (जो शायद यह दूसरी बार होगा, अगर यह पहले नहीं होता है)।

Answer 4

बिट बैंडिंग इस स्थिति के लिए काम नहीं करेगा। यह डिवाइस रजिस्टर फ़ाइलों और आपकी याददाश्त में बिट्स सेट करने का एक बहुत ही साफ तरीका है। अपने सेमफोर/म्यूटेक्स को लागू करने के लिए लोड एक्सक्लूसिव और स्टोर एक्सक्लूसिव निर्देशों का उपयोग करें। यहां एक उदाहरण दस्तावेज़ है जिसका उपयोग आप इन निर्देशों का उपयोग करके एक सेमफोर लागू कर सकते हैं और यह बताता है कि यह कैसे काम करता है।

http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0439b/CHDDIGAC.html

कहा जा रहा है, तो आपको दो बातें ताला तक पहुँचने का प्रयास करते हैं बिट बैंडिंग का उपयोग करके अपने mutexes की स्मृति पदचिह्न को कम कर सकते हैं ...