पाली, संकेत और गति एमके के मुद्दे पर

"सब कुछ के लिए एक कारण खोजें और आप बहुत कुछ समझेंगे"

शायद मेरे नियमित पाठकों (ठीक है, यह नहीं हो सकता है कि वे याद नहीं करते) कि मेरी पोस्ट में मैं हैरान था कि अहस्ताक्षरित विशेषता का उपयोग बाहरी उपकरणों के रजिस्टरों का वर्णन करने के लिए किया गया था। टिप्पणियों में, यह सुझाव दिया गया था कि यह बदलाव पाली के दौरान अपरिभाषित व्यवहार से बचने के लिए किया गया था और मैं सहमत था। जैसा कि मैंने हाल ही में खोजा है, इस विशेषता के उपयोग का एक और कारण है और इसे न केवल रजिस्टरों पर लागू किया जा सकता है, बल्कि सामान्य चर के लिए भी लागू किया जा सकता है।

तो, हम शुरू कर रहे हैं।


एक सरल कोड उदाहरण और AVR कमांड सिस्टम के साथ MK के लिए संगत कोडांतरक कोड पर विचार करें, हमेशा की तरह godbolt.org पर प्राप्त किया गया। (इसका अर्थ है कि अनुकूलन सक्षम है और चर r24 रजिस्टर में स्थित है)

int8_t byte; byte = byte << 1; 

 clr r25 sbrc r24,7 com r25 lsl r24 rol r25 

और देखते हैं कि ऑपरेशन में पाँच टीमें लगती हैं?

नोट: यदि कोई टिप्पणी में आपको बताता है कि इस खंड (और बाद वाले) को 2 कॉलम में कैसे व्यवस्थित किया जाए, तो मैं आभारी रहूंगा।

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

सही करने के लिए स्थानांतरण बेहतर नहीं है

 byte = byte >> 1; clr r25 sbrc r24,7 com r25 asr r25 ror r24 

- वही पांच टीमें। इस बीच, यह स्पष्ट है कि वास्तव में, अंतिम ऑपरेशन करने के लिए, आपको एक ही कमांड की आवश्यकता है

 sr r24 

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

 byte = byte >> (int8_t) 1; 

- "पूरी तरह से" शब्द से, लेकिन विकल्प नहीं है

  byte=(uint8_t) byte >> 1; 

थोड़ा बेहतर परिणाम देता है

 ldi r25,lo8(0) asr r25 ror r24 

- तीन टीमें, चूंकि पूरे विस्तार के लिए अब एक ही टीम रहती है - यह बेहतर है, हालांकि सही नहीं है, एक ही तस्वीर के लिए

 byte=(uint8_t) byte << 1; 

- तीन टीमें। ठीक है, अतिरिक्त जातियों को न लिखने के लिए, हम चर को बिना बताए बनाते हैं

 uint8_t byteu; 

और बिंगो - कोडांतरक कोड पूरी तरह से हमारी अपेक्षाओं को पूरा करता है

 byteu = byteu << 1; lsr r24 

यह अजीब है कि यह कैसे प्रतीत होता है, क्या अंतर है, एक चर के सही प्रकार को तुरंत इंगित करने के लिए, या इसे सीधे एक ऑपरेशन में लाने के लिए - लेकिन यह पता चला है कि एक अंतर है।

आगे के अध्ययनों से पता चला है कि कोडांतरक कोड चर के प्रकार को ध्यान में रखता है जिसके परिणाम को सौंपा गया है, क्योंकि

 byteu = byte << 1; 

ठीक काम करता है और न्यूनतम कोड, और विकल्प पैदा करता है

 byte = byteu << 1; 

तीन टीमों के बिना नहीं कर सकते।

निश्चित रूप से, इस तरह के व्यवहार को भाषा के मानक में वर्णित किया गया है, मैं उन लोगों से पूछता हूं जो कमेंटरी में जानते हैं, लेकिन एक बार फिर मैं गर्व से घोषणा करूंगा कि "चुच्ची एक पाठक नहीं है" और मैं कहानी जारी रखूंगा।

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

यह पता चला है कि सामान्य रूप से बदलाव के साथ, सब कुछ बेहद दिलचस्प है, चलो पदों की संख्या में वृद्धि करना शुरू करें जब बाईं ओर शिफ्ट किया जाए और परिणाम देखें: << 1 1 घड़ी चक्र लेता है, << 2 - 2, << 3 - 3, 4 - 2 अप्रत्याशित रूप से, कंपाइलर ने पेचीदा अनुकूलन लागू किया

 swap r24 andi r24,lo8(-16) 

जहाँ s WAP कमांड बाइट में दो निबल्स को स्वैप करता है। इसके अलावा, अंतिम अनुकूलन के आधार पर << 5 - 3, << 6 - 4, << 7 - 3 फिर अप्रत्याशित रूप से, एक और अनुकूलन है

 ror r24 clr r24 ror r24 

स्थानांतरण बिट का उपयोग किया जाता है, << 8 - 0 उपाय, चूंकि यह केवल 0 निकला है, आगे देखने का कोई मतलब नहीं है।

वैसे, यहां आपके लिए एक दिलचस्प काम है - आप किस न्यूनतम समय के लिए ऑपरेशन कर सकते हैं

 uint16_t byteu; byteu = byteu << 4; 

जिसका अनुवाद 0x1234 से 0x2340 है। स्पष्ट समाधान 4 बार आदेशों के एक जोड़े को निष्पादित करना है

 lsl rl rol rh 

4 * 2 = 8 उपायों की ओर जाता है, मैं जल्दी से एक विकल्प के साथ आया

 swap rl ; 1243 swap rh ; 2143 andi rh,0xf0 ; 2043 mov tmp,rl andi tmp,0x0f or rh,tmp ; 2343 andi rl,0xf0 ; 2340 

जिसमें 7 उपायों और एक मध्यवर्ती रजिस्टर की आवश्यकता होती है। इसलिए, कंपाइलर 6 कमांड्स का कोड जेनरेट करता है और कोई इंटरमीडिएट रजिस्टर नहीं करता है - कूल, यस।


आमतौर पर, 16-बिट संख्याओं के लिए, हस्ताक्षरित और अहस्ताक्षरित संख्याओं के बीच का अंतर बाईं ओर स्थानांतरित होने पर गायब हो जाता है, यह उस तरह अजीब है।

आइए अपने बाइट्स पर वापस जाएं और दाईं ओर बढ़ना शुरू करें। जैसा कि हम याद करते हैं, एक हस्ताक्षरित बाइट के लिए हमारे पास 5 घड़ी चक्र हैं, एक अहस्ताक्षरित बाइट के लिए - 3 और यह समय कम नहीं किया जा सकता है। या सब एक ही, आप कर सकते हैं - हाँ, आप कर सकते हैं, लेकिन यह एक बहुत ही अजीब तरीका है (अनुकूलन के साथ जीसीसी चालू - "यह एक बहुत ही अजीब जगह है"), अर्थात्

 byteu = (byteu >> 1) & 0x7F; 

जो साइन के दोनों वेरिएंट के लिए बिल्कुल एक कमांड उत्पन्न करता है। उपयुक्त और विकल्प

  byteu = (byteu & 0xFE) >> 1; 

लेकिन केवल एक अहस्ताक्षरित संख्या के लिए, एक हस्ताक्षरित के साथ सब कुछ और भी निराशाजनक हो जाता है - 7 उपाय, इसलिए हम केवल पहले विकल्प का पता लगाना जारी रखते हैं।

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

2 और इसी तरह शिफ्ट्स से पता चला कि साइन बिट का भुगतान करना महत्वपूर्ण है, लेकिन संख्या शुरू में अहस्ताक्षरित है, सामान्य रूप से, कुछ कचरा प्राप्त होता है, "लेकिन यह काम करता है," केवल एक चीज है जो इस बारे में कहा जा सकता है।

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