जवाबों:
कोड घनत्व शिथिलता को संदर्भित करता है कि एक अनुरोधित कार्रवाई करने के लिए कितने माइक्रोप्रोसेसर निर्देश, और प्रत्येक निर्देश कितना स्थान लेता है। सामान्यतया, एक निर्देश कम जगह लेता है और एक अनुदेश जो माइक्रोप्रोसेसर कर सकता है, प्रति निर्देश जितना अधिक काम करता है, उतनी ही घनी होती है।
मैंने देखा कि आपने 'आर्म' टैग के साथ अपना प्रश्न टैग किया है; मैं एआरएम निर्देशों का उपयोग करके कोड घनत्व को चित्रित कर सकता हूं।
मान लें कि आप स्मृति में एक स्थान से दूसरे स्थान पर डेटा के ब्लॉक को कॉपी करना चाहते हैं। वैचारिक रूप से, आपका उच्च स्तरीय कोड कुछ इस तरह दिखाई देगा:
void memcpy(void *dest, void *source, int count_bytes)
{
char *s, *d;
s = source; d = dest;
while(count_bytes--) { *d++ = *s++; }
}अब एक साधारण माइक्रोप्रोसेसर के लिए एक सरल संकलक इसे निम्न में से कुछ के रूप में परिवर्तित कर सकता है:
movl r0, count_bytes
movl r1, s
movl r2, d
loop: ldrb r3, [r1]
strb [r2], r3
movl r3, 1
add r1, r3
add r2, r3
sub r0, r3
cmp r0, 0
bne loop(मेरा एआरएम थोड़ा कठोर है, लेकिन आप इस विचार को प्राप्त करते हैं)
अब यह एक बहुत ही सरल संकलक और एक बहुत ही सरल माइक्रोप्रोसेसर होगा, लेकिन आप उदाहरण से देख सकते हैं कि हम लूप के 8 निर्देश प्रति देख रहे हैं (7 यदि हम '1' को दूसरे रजिस्टर में ले जाते हैं और लोड को स्थानांतरित करते हैं लूप के बाहर)। यह वास्तव में घना नहीं है। कोड घनत्व भी प्रदर्शन को प्रभावित करता है; यदि आपका लूप लंबा है, क्योंकि कोड घने नहीं है, तो आपको लूप को होल्ड करने के लिए अधिक अनुदेश कैश की आवश्यकता हो सकती है। अधिक कैश का मतलब एक अधिक महंगा प्रोसेसर है, लेकिन फिर जटिल निर्देश डिकोडिंग का अर्थ है कि अनुरोधित निर्देश को समझने के लिए अधिक ट्रांजिस्टर, इसलिए यह एक क्लासिक इंजीनियरिंग समस्या है।
इस संबंध में एआरएम बहुत अच्छा है। हर निर्देश सशर्त हो सकता है, अधिकांश निर्देश रजिस्टरों के मूल्य को बढ़ा या घटा सकते हैं, और अधिकांश निर्देश वैकल्पिक रूप से प्रोसेसर के झंडे को अपडेट कर सकते हैं। एआरएम पर और मामूली उपयोगी संकलक के साथ, एक ही लूप कुछ इस तरह दिख सकता है:
movl r0, count_bytes
movl r1, s
movl r2, d
loop: ldrb r3, [r1++]
strb [r2++], r3
subs r0, r0, 1
bne loopजैसा कि आप देख सकते हैं, मुख्य लूप अब 4 निर्देश है। कोड अधिक घना है क्योंकि मुख्य लूप में प्रत्येक निर्देश अधिक करता है। इसका आम तौर पर मतलब है कि आप किसी दिए गए मेमोरी के साथ अधिक कर सकते हैं, क्योंकि इसका कम उपयोग यह वर्णन करने के लिए किया जाता है कि कार्य कैसे करें।
अब देशी एआरएम कोड में अक्सर शिकायत होती है कि यह सुपर-सघन नहीं था; यह दो मुख्य कारणों के कारण है: पहला, 32 बिट्स एक भयानक "लंबी" निर्देश है, इसलिए बहुत सारे बिट्स सरल निर्देशों के लिए बर्बाद हो रहे हैं, और दूसरा, एआरएम के स्वभाव के कारण कोड फूला हुआ है: प्रत्येक और प्रत्येक निर्देश 32 है बिट्स बिना किसी अपवाद के। इसका मतलब है कि बड़ी संख्या में 32-बिट शाब्दिक मूल्य हैं जिन्हें आप केवल एक रजिस्टर में लोड नहीं कर सकते हैं। अगर मैं r0 में "0x12345678" लोड करना चाहता था, तो मैं एक निर्देश कैसे कोड करूं जिसमें न केवल 0x12345678 हो, बल्कि "लोड शाब्दिक टू r0" का वर्णन करता है? वास्तविक ऑपरेशन को कोड करने के लिए कोई बिट नहीं बचा है। एआरएम लोड शाब्दिक निर्देश एक दिलचस्प छोटा जानवर है, और एआरएम कोडांतरक को सामान्य कोडांतरकों की तुलना में थोड़ा चालाक होना चाहिए, क्योंकि इसे "पकड़" करना है
वैसे भी, इन शिकायतों का जवाब देने के लिए, एआरएम थम्ब मोड के साथ आया था। निर्देश के अनुसार 32 बिट्स के बजाय, अनुदेश लंबाई लगभग सभी निर्देशों के लिए 16 बिट्स और शाखाओं के लिए 32 बिट्स है। थम्ब मोड के साथ कुछ बलिदान थे, लेकिन बड़े और इन बलिदानों को बनाना आसान था क्योंकि थम्ब ने आपको निर्देश की लंबाई कम करके कोड घनत्व में 40% सुधार जैसा कुछ प्राप्त किया।
एक निर्देश सेट का "कोड घनत्व" इस बात का एक उपाय है कि आप दिए गए प्रोग्राम मेमोरी की कितनी मात्रा में सामान प्राप्त कर सकते हैं, या प्रोग्राम मेमोरी की कितनी बाइट्स आपको किसी दिए गए कार्यशीलता को संग्रहीत करने की आवश्यकता है।
जैसा कि एंड्रयू कोहल्समिथ ने बताया, यहां तक कि एक ही एमसीयू पर, अलग-अलग संकलक अलग-अलग कोड घनत्व प्राप्त कर सकते हैं।
आपको Miro Samek द्वारा "कंप्यूटर की दुनिया के कीड़े" पढ़ने का आनंद मिल सकता है , जो विभिन्न प्रकार के MCU की तुलना करता है।