बिना शर्त शाखा और बिना शर्त कूद (एमआईपीएस में निर्देश) के बीच क्या अंतर है?

Question

आप Wikipedia या short summary for students पर देख सकते हैं। हर कोई कहता है कि एक ही चीज़ के लिए दो निर्देश हैं। लेकिन कोई नहीं बताता क्यों?

Answer 1

शाखाएं शर्तों की अनुमति देती हैं। लेकिन शर्तों के लिए अनुमति निर्देश में अधिक बिट्स लेता है। इसलिए, एक शाखा का पता केवल 2^16 बिट्स है और केवल आपको 2^15 - 1 निर्देश पिछड़े या 2^15 निर्देशों को आगे बढ़ाने की अनुमति देता है।

एक कूद बिना शर्त है और स्थिति को छोड़कर बचाई गई बिट्स पते के लिए उपयोग की जा सकती हैं। एक कूद 26 बिट पते के लिए अनुमति देता है और इसलिए शाखा की तुलना में कोड में आगे बढ़ सकता है। सशर्त नहीं होने की कीमत पर।

Answer 2

शाखाएं (b) पीसी-रिश्तेदार विस्थापन का उपयोग करते हैं जबकि कूदता है (j) पूर्ण पते का उपयोग करते हैं। स्थिति-स्वतंत्र कोड के लिए भेद महत्वपूर्ण है। इसके अलावा, अप्रत्यक्ष नियंत्रण हस्तांतरण (jr, रजिस्टर मान का उपयोग करके केवल कूदों का उपयोग किया जा सकता है)।

Answer 3

जैसा कि पहले से ही उल्लेख किया गया है, शाखा में कम बिट्स हैं, एक छोटी सी सीमा है और सापेक्ष है। जंप में अधिक बिट्स हैं और पूर्ण है।

इस उदाहरण

b l0 
nop 
beq $0,$1,l1 
nop 
j l2 
nop 

l0: .word 0,0 
l1: .word 0,0 
l2: .word 0,0 

ले लो और आप प्राप्त इस

00000000 <l0-0x1c>: 
    0: 10000006 b 1c <l0> 
    4: 00000000 nop 
    8: 10010006 beq zero,at,24 <l1> 
    c: 00000000 nop 
    10: 0800000b j 2c <l2> 
    14: 00000000 nop 
    18: 00000000 nop 

0000001c <l0>: 
    ... 

00000024 <l1>: 
    ... 

0000002c <l2>: 
    ... 

अब क्या अन्य उत्तर उल्लेख किया है नहीं हो सकता है कि बिना शर्त शाखा एन्कोड किया गया है, कम से कम gnu कोडांतरक द्वारा होता है, एक ही रजिस्टर के साथ बराबर, एक शाखा के रूप में। मिप्स में कोई शर्त शाखा नहीं है, अगर शाखा बराबर है और शाखा अगर मैं बता सकता हूं तो बराबर नहीं है।

आप ऊपर से देखते हैं कि 0xB का उपयोग करता है जो शब्द पता, 0xB * 4 = 0x2C गंतव्य का पता है, जहां सशर्त संबंध पीसी को संबोधित करते हैं (हस्ताक्षर_ऑफसेट * 4) जहां पीसी = instruct_address + 4; या गंतव्य पता प्राप्त करने के लिए instruct_address + 4 + (sign_offset * 4) लें।

कूद के लिए जे के बजाय शाखा के लिए उपनाम बी का उपयोग करने से स्थिति स्वतंत्र कोड बन जाएगी। जंप नहीं होगा, अगर आप चारों ओर घूमते हैं तो फिर से लिंक करना होगा, क्योंकि कूदने के बजाए शाखाओं का उपयोग करने के लिए शायद निकटतम कूदता है, भले ही यह उपनाम हो। यदि आप एक शुद्धवादी हैं तो आप असली निर्देश beq $ 0, $ 0, लेबल का उपयोग कर सकते हैं या किसी भी रजिस्टर beq $ 4, $ 4, लेबल चुन सकते हैं। रजिस्टर 0 विशेष और तेज़ होना बेहतर विकल्प हो सकता है।

Answer 4

एमआईपीएस में एक कूद और बिना शर्त शाखा, समान नहीं हैं।

दोनों शाखाएं और कूद निर्देश प्रोग्राम काउंटर रजिस्टर में डेटा लिखते हैं ताकि अगले fetch चक्र पर, प्रोग्राम मेमोरी में अगले निर्देश के बजाय एक अलग निर्देश प्राप्त किया जाएगा। उस अर्थ में, वे एक ही प्रकार के ऑपरेशन करते हैं।

जहां वे भिन्न हैं कि शाखाएं सशर्त हैं, वे केवल कुछ निर्देशों को पूरा करने के लिए अगले निर्देश को निष्पादित करने के लिए बदलते हैं। इसे if कथन में या फ़ंक्शन कॉल करके निष्पादन कोड में अंतर से चित्रित किया जा सकता है।

if (a == 0) { 
    a = 1 
} 
setAtoOne() 

if बयान a = 1 केवल a = 0 यदि सेट करने के लिए दिए गए निर्देश में कूदता है। समारोह उस निर्देश पर कूद जाएगा चाहे।

इस मामले में, हम एक शाखा के बारे में बात कर रहे हैं जहां स्थिति हमेशा सत्य होती है। यह करने के लिए निर्दिष्ट ऑफसेट सिर्फ लेखन का एक और तरीका

beq $zero, $zero, (int)offset 

$ शून्य हमेशा शून्य $ के बराबर है, इसलिए यह हमेशा शाखाओं। ऐसा लगता है कि अगर

if (true) { a = 1 } 

शाखा और कूद निर्देशों के बीच एक और अंतर है। जंप निर्देश एक पूर्ण पता निर्दिष्ट करते हैं जिसे पीसी सेट किया जाएगा, जबकि शाखा निर्देश प्रोग्राम काउंटर में पते को ऑफ़सेट करते हैं।

PC = 32-bit address # Jump 
PC += 16-bits lower 

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

सभी एमआईपीएस निर्देश 1 शब्द (यानी 4 बाइट/32-बिट्स) लंबे हैं। उनमें निर्देश के लिए एक आईडी है (जिसे ओप-कोड कहा जाता है) जो निर्देश को निष्पादित करने के लिए आवश्यक अन्य जानकारी के साथ 6 बिट्स है। यह रजिस्टरों या 'तत्काल' मानों की आईडी हो सकती है, मूल रूप से निर्देश में एन्कोड किए गए पूर्णांक। 0xFFFFFFFF -

MIPS में स्मृति में प्रत्येक बाइट 0x00000000 के बीच में कोई पता नहीं है। उन बाइट्स में से एक को पाने के लिए हमें पता निर्दिष्ट करने की आवश्यकता है। यदि रजिस्टर में पते को स्टोर करने के लिए भाग्यशाली थे तो हम केवल jr और रजिस्टर में पहले से संग्रहीत पते का उपयोग करेंगे। हालांकि, हम नहीं हैं।

यह समस्याग्रस्त हो जाता है, हमारे पास हमारे निर्देशों के लिए केवल 32 बिट हैं और हमें उस सीमा में पते निर्दिष्ट करने के लिए उन सभी बिट्स की आवश्यकता होगी। हमें प्रोसेसर द्वारा निर्देश की पहचान करने के लिए 6 बिट्स को भी छोड़ना पड़ा। अब हम 26 बिट्स के साथ छोड़ दिया गया है।

इससे भी बदतर बात यह है कि जब हम शाखा करते हैं, तो हमें दो रजिस्टरों को निर्दिष्ट करने के लिए 10 अतिरिक्त बिट्स की आवश्यकता होती है, जिन्हें हम अपनी हालत के लिए तुलना कर रहे हैं। समाधान ऑफसेट का उपयोग करना है।

मान लें कि हम पता 0x12345678 में हैं और हम स्मृति j 0x1234567c में अगले पते पर एक बिना शर्त कूद को क्रियान्वित कर रहे हैं। यह असेंबली कोड है और मैं दिखाऊंगा कि इसे मशीन कोड में कैसे अनुवादित किया जाता है और निष्पादित किया जाता है।

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

jump 0001 0010 0011 0100 0101 0110 0111 1100 
jump 00010010 0011 0100 0101 0110 0111 1100 
0000 1000 1000 1101 0001 0101 1001 1111 #in machine code # jump op = 0000 10

When we execute this we take

00 1000 1101 0001 0101 1001 1111 
0000 0000 1000 1101 0001 0101 1001 1111 # extend >> 6 
0000 0010 0011 0100 0101 0110 0111 1100 # << 2

Then we AND the PC (where we're executing from) and 0xf0000000

0001 0010 0011 0100 0101 0110 0111 1000 
1111 0000 0000 0000 0000 0000 0000 0000 
AND 
0001 0000 0000 0000 0000 0000 0000 0000 

We know take the result of this and OR it with our instruction integer

0001 0000 0000 0000 0000 0000 0000 0000 
0000 0010 0011 0100 0101 0110 0111 1100 
OR 
0001 0010 0011 0100 0101 0110 0111 1100 

Which is 0x1234567c और जहां हम जाना चाहते हैं, अब हम वहां कूदते हैं। यही कारण है कि आप अपने वर्तमान निर्देश से 256 एमबी (2^28 बिट्स) से आगे नहीं कूद सकते हैं (जब तक कि आप jr रजिस्टर के मूल्य पर कूद नहीं जाते)

शाखाओं के लिए एक ही मूल विचार है, सिवाय इसके कि आप भी 2 रजिस्टरों की तुलना की जा रही है (जिसके लिए 10 बिट्स की आवश्यकता होती है) ताकि आपके पास केवल 16 बिट्स हों जिनका उपयोग आप ऑफ़सेट करने के लिए कर सकते हैं, इसलिए आप शाखाओं तक क्यों नहीं कूद सकते हैं।

आम तौर पर, यह ठीक है क्योंकि हम ज्यादातर प्रक्रियाओं के भीतर शाखाओं का उपयोग करते हैं, लूप को लागू करने और सशर्त असाइनमेंट करने के लिए।

यह MIPS वास्तुकला के डिजाइन के सभी परिणाम है। निर्देशों के लिए पूरी तरह से संभव होना संभव था जहां शाखाओं और कूदों के बीच एकमात्र अंतर सशर्त पहलू हो और जहां 'बिना शर्त' शाखा एक बिना शर्त कूद के समान व्यवहार करे।