हमें माइक्रोप्रोसेसर 8085 में "एनओपी" यानी ऑपरेशन के निर्देश की आवश्यकता क्यों नहीं है?

19

माइक्रोप्रोसेसर 8085 निर्देश में, एक मशीन नियंत्रण ऑपरेशन "एनओपी" (कोई ऑपरेशन नहीं) है। मेरा सवाल यह है कि हमें ऑपरेशन की आवश्यकता क्यों है? मेरा मतलब है कि अगर हमें कार्यक्रम समाप्त करना है तो हम एचएलटी या आरएसटी 3 का उपयोग करेंगे। या यदि हम अगले निर्देश पर जाना चाहते हैं तो हम अगले निर्देश देंगे। लेकिन कोई ऑपरेशन क्यों नहीं? क्याज़रुरत है?

microprocessor

— Demietra95
स्रोत

5

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

— प्लूटोनियम तस्कर

Ohkay। लेकिन एनओपी का इस्तेमाल करने से स्पेस भी बढ़ रहा है। जबकि हमारा प्राथमिक लक्ष्य इसे कम जगह बनाना है।

— डेमिट्रा 95

* मेरा मतलब है कि हमारा लक्ष्य किसी समस्या को छोटा करना है। तो क्या यह भी एक समस्या नहीं है?

— डेमिट्रा 95

2

Thats क्यों यह बुद्धिमानी से इस्तेमाल किया जाना चाहिए। अन्यथा आपका पूरा कार्यक्रम एनओपी का सिर्फ एक गुच्छा होगा।

— प्लूटोनियम तस्कर

34

सीपीयू और एमसीयू में एनओपी (या एनओओपी, नो-ऑपरेशन) निर्देश का एक उपयोग आपके कोड में थोड़ा, पूर्वानुमानित, विलंब सम्मिलित करना है। यद्यपि एनओपी कोई ऑपरेशन नहीं करते हैं, लेकिन उन्हें संसाधित करने में कुछ समय लगता है (सीपीयू को ऑपकोड प्राप्त करना और डिकोड करना पड़ता है, इसलिए इसे कुछ कम समय ऐसा करने की आवश्यकता होती है)। जब तक NOP निर्देश निष्पादित करने के लिए 1 CPU चक्र "व्यर्थ" है (आमतौर पर सीपीयू / MCU डेटाशीट से सटीक संख्या का अनुमान लगाया जा सकता है), इसलिए N NOPs को क्रम में रखना एक अनुमानित विलंब सम्मिलित करने का एक आसान तरीका है:

$t_{delay} = N \cdot T_{clock} \cdot K$

जहां K एक NOP निर्देश के प्रसंस्करण के लिए आवश्यक चक्रों (सबसे अधिक बार 1) की संख्या है, और घड़ी की अवधि है। $T_{clock}$

तुम ऐसा क्यों करोगे? सीपीयू को अपने काम को पूरा करने के लिए बाहरी (शायद धीमा) उपकरणों के लिए थोड़ा इंतजार करने के लिए सीपीयू को मजबूर करने के लिए उपयोगी हो सकता है और डेटा को रिपोर्ट कर सकता है, अर्थात एनओपी सिंक्रनाइज़ेशन प्रयोजनों के लिए उपयोगी है।

एनओपी पर संबंधित विकिपीडिया पृष्ठ भी देखें ।

एक अन्य उपयोग मेमोरी और अन्य "असेंबली ट्रिक्स" में कुछ पते पर कोड को संरेखित करना है, जैसा कि प्रोग्रामर पर इस धागे में भी बताया गया है। और स्टैकऑवरफ्लो पर इस अन्य थ्रेड में ।

विषय पर एक और दिलचस्प लेख ।

Google पुस्तक पृष्ठ का यह लिंक विशेष रूप से 8085 CPU को संदर्भित करता है। अंश:

प्रत्येक एनओपी निर्देश लाने, डिकोडिंग और निष्पादित करने के लिए चार घड़ियों का उपयोग करता है।

EDIT (एक टिप्पणी में व्यक्त चिंता को संबोधित करने के लिए)

यदि आप गति के बारे में चिंता कर रहे हैं, तो ध्यान रखें कि (समय) दक्षता केवल एक पैरामीटर है। यह सब आवेदन पर निर्भर करता है: यदि आप 10-बिलियन आंकड़ा गणना करने के लिए चाहते हैं , तो शायद अपने ही चिंता का विषय गति हो सकता है। दूसरी ओर, यदि आप ADC के माध्यम से MCU से जुड़े तापमान सेंसरों से डेटा लॉग करना चाहते हैं, तो गति आमतौर पर इतनी महत्वपूर्ण नहीं है, लेकिन ADC को सही ढंग से प्रतीक्षा करने के लिए प्रत्येक रीडिंग को सही ढंग से पूरा करने की अनुमति देना आवश्यक है । इस मामले में अगर MCU पूरी तरह से अविश्वसनीय डेटा प्राप्त करने के लिए पर्याप्त जोखिम का इंतजार नहीं करता है (मैं मानता हूं कि यह उस डेटा को तेजी से प्राप्त करेगा , हालांकि: ओ)। $\pi$

— लोरेंजो डोनाटी मोनिका का समर्थन करता है
स्रोत

3

बहुत सी चीजें (विशेष रूप से यूसी को बाहरी ड्राइविंग करने वाले आउटपुट) subject डी के स्थिर होने और घड़ी की धार के बीच न्यूनतम समय १०० हम ’जैसे समय की कमी के अधीन हैं, या must आईआर एलईडी को 1 मेगाहर्ट्ज पर ब्लिंक करना चाहिए’। इसलिए (सटीक) देरी की अक्सर आवश्यकता होती है।

— राउटर वैन ओइजेन

6

NOPs सीरियल प्रोटोकॉल को बिट-बैंग करते समय सही होने के लिए उपयोगी हो सकते हैं। यदि प्रोग्राम काउंटर दूषित हो जाता है (जैसे PSU गड़बड़, एक दुर्लभ गामा किरण घटना, आदि द्वारा प्रभाव) और एक में कोड को निष्पादित करना शुरू कर देता है, तो वे दुर्लभ स्थितियों के लिए एक कोल्ड-स्टार्ट वेक्टर के लिए एक छलांग के बाद अनुपयोगी कोड स्थान को भरने के लिए उपयोगी हो सकते हैं। अन्यथा कोड स्थान का खाली भाग।

— Techydude

6

अटारी 2600 वीडियो कंप्यूटर सिस्टम (कारतूस पर संग्रहीत प्रोग्राम चलाने के लिए दूसरा वीडियो गेम कंसोल) पर, प्रोसेसर प्रत्येक स्कैन लाइन में बिल्कुल 76 चक्र चलाएगा, और कई ऑपरेशनों की शुरुआत के बाद कुछ सटीक संख्या में चक्रों को करने की आवश्यकता होगी स्कैन लाइन। उस प्रोसेसर पर, प्रलेखित "एनओपी" निर्देश में दो चक्र होते हैं, लेकिन कोड के लिए एक अन्यथा बेकार तीन-चक्र अनुदेश का उपयोग करने के लिए एक सटीक संख्या को देरी से पैड करने के लिए कोड बनाना भी आम है। कोड को तेजी से चलाने से पूरी तरह से विकृत प्रदर्शन होगा।

— सुपरकैट

1

देरी के लिए एनओपी का उपयोग गैर-वास्तविक समय प्रणालियों पर भी समझ में आ सकता है, जहां I / O डिवाइस लगातार संचालन के बीच न्यूनतम समय लगाता है, लेकिन अधिकतम नहीं। उदाहरण के लिए, कई नियंत्रकों पर, एक बाइट को एसपीआई पोर्ट से स्थानांतरित करने पर आठ सीपीयू चक्र लगेंगे। कोड जो कुछ भी नहीं करता है, लेकिन मेमोरी से बाइट्स प्राप्त करता है और उन्हें SPI पोर्ट पर आउटपुट करता है, थोड़ा बहुत तेजी से चल सकता है, लेकिन यह तर्क देने के लिए कि प्रत्येक बाइट के लिए SPI पोर्ट तैयार है या नहीं, यह परीक्षण करने के लिए तर्क को जोड़ देगा। एनओपी या दो को जोड़ने से कोड अधिकतम उपलब्ध गति को प्राप्त करने की अनुमति दे सकता है ...

— सुपरकाट

1

... उस मामले में जहां कोई व्यवधान नहीं हैं। यदि कोई बाधा आती है, तो एनओपी अनावश्यक रूप से समय बर्बाद करेगा, लेकिन एक या दो एनओपी द्वारा व्यर्थ किया गया समय यह निर्धारित करने के लिए आवश्यक समय से कम होगा कि क्या कोई व्यवधान उन्हें अनावश्यक बनाता है।

— सुपरकट

8

अन्य उत्तर केवल एक एनओपी पर विचार कर रहे हैं जो वास्तव में किसी बिंदु पर निष्पादित होता है - जिसका उपयोग आमतौर पर किया जाता है, लेकिन यह एनओपी का एकमात्र उपयोग नहीं है।

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

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

बेशक, पुराने जमाने में यह बहुत अधिक उपयोग किया जाता था, जब इन छोटे और ऑनलाइन जैसे पैच बनाने के लिए उपयोगी था । आज, आप सिर्फ एक recompiled बाइनरी वितरित करेंगे और इसके साथ किया जाएगा। अभी भी कुछ ऐसे लोग हैं जो पैचिंग NOPs का उपयोग करते हैं (निष्पादित या नहीं, और हमेशा शाब्दिक नहीं NOP- उदाहरण के लिए, Windows MOV EDI, EDIऑनलाइन पैचिंग के लिए उपयोग करता है - यह उसी तरह है जहां आप सिस्टम लाइब्रेरी को अपडेट कर सकते हैं, जबकि सिस्टम वास्तव में चल रहा है, बिना पुनरारंभ की आवश्यकता के)।

तो आखिरी सवाल यह है कि किसी चीज़ के लिए एक समर्पित निर्देश क्यों है जो वास्तव में कुछ भी नहीं करता है?

यह एक वास्तविक निर्देश है - जब डिबगिंग या विधानसभा को सौंपना महत्वपूर्ण है। जैसे निर्देश MOV AX, AXबिल्कुल वैसा ही करेंगे, लेकिन इरादे को इतनी स्पष्टता से इंगित न करें।
गद्दी - "कोड" जो कि कोड के समग्र प्रदर्शन को बेहतर बनाने के लिए है जो कि संरेखण पर निर्भर करता है। यह कभी निष्पादित करने के लिए नहीं है। कुछ डिबगर बस अपनी असहमति में NOPs को छिपाते हैं।
यह संकलक के अनुकूलन के लिए अधिक स्थान देता है - फिर भी उपयोग किया जाने वाला पैटर्न यह है कि आपको संकलन के दो चरण मिल गए हैं, पहला सरल है और बहुत सारे अनावश्यक असेंबली कोड का उत्पादन कर रहा है, जबकि दूसरा साफ करता है, पते के संदर्भों को फिर से बताता है और हटाता है बाहरी निर्देश। यह अक्सर JIT- संकलित भाषाओं में भी देखा जाता है - .NET के IL और JVM के बाइट-कोड दोनों का उपयोग NOPबहुत अधिक है; वास्तविक संकलित असेंबली कोड अब उन नहीं है। यह ध्यान दिया जाना चाहिए कि वे x86- NOPs नहीं हैं , हालांकि।
यह पढ़ने के लिए ऑनलाइन डिबगिंग दोनों को आसान बनाता है (प्री- NOPजीम्ड मेमोरी सभी होगी- s, असंतुष्ट को पढ़ने में बहुत आसान बनाता है) और हॉट-पैचिंग के लिए (हालांकि मैं अब तक एडिट और विजुअल स्टूडियो में जारी रखना पसंद करता हूं: P)।

NOP को निष्पादित करने के लिए, कुछ और बिंदु हैं:

प्रदर्शन, ज़ाहिर है - यह 8085 में ऐसा क्यों नहीं था, लेकिन यहां तक कि 80486 में पहले से ही एक पाइपलाइन किए गए अनुदेश निष्पादन था, जो थोड़ा पेचीदा "कुछ भी नहीं" करता है।
जैसा कि देखा गया है MOV EDI, EDI, शाब्दिक की तुलना में अन्य प्रभावी NOP हैं NOP। MOV EDI, EDIx86 पर 2-बाइट NOP के रूप में सर्वश्रेष्ठ प्रदर्शन है। यदि आपने दो NOPएस का उपयोग किया है , तो निष्पादित करने के लिए दो निर्देश होंगे।

संपादित करें:

वास्तव में, @DmitryGrigoryev के साथ चर्चा ने मुझे इस बारे में थोड़ा और सोचने के लिए मजबूर किया, और मुझे लगता है कि यह इस प्रश्न / उत्तर के लिए एक मूल्यवान अतिरिक्त है, इसलिए मुझे कुछ अतिरिक्त बिट्स जोड़ने दें:

पहले, बिंदु, स्पष्ट रूप से - एक निर्देश क्यों होगा जो कुछ पसंद करता है mov ax, ax? उदाहरण के लिए, आइए 8086 मशीन कोड के मामले को देखें (386 मशीन कोड से भी पुराना):

Opcode के साथ एक समर्पित NOP निर्देश है 0x90। यह अभी भी समय है जब कई लोगों ने विधानसभा में लिखा, आप पर ध्यान दें। यहां तक कि अगर कोई समर्पित NOPनिर्देश नहीं था , तब भी NOPकीवर्ड (अन्य नाम / mnemonic) अभी भी उपयोगी होगा और उस पर मैप करेगा।
MOVवास्तव में जैसे निर्देश कई अलग-अलग opcodes को मैप करते हैं, क्योंकि जो समय और स्थान को बचाता है - उदाहरण के लिए, mov al, 42" alरजिस्टर करने के लिए तत्काल बाइट ले जाएं ", जो कि "तत्काल" तर्क होने के नाते 0xB02A( 0xB0ओपोड 0x2Aहोने के नाते) अनुवाद करता है। ताकि दो बाइट्स लगें।
इसके लिए कोई शॉर्टकट ओपकोड नहीं है mov al, al(क्योंकि यह मूल रूप से करने के लिए एक बेवकूफी है), इसलिए आपको mov al, rmbअधिभार ("रजिस्टर या मेमोरी") का उपयोग करना होगा । यह वास्तव में तीन बाइट्स लेता है । (हालांकि यह संभवतः कम विशिष्ट का उपयोग करेगा mov rb, rmb, जिसके लिए केवल दो बाइट्स लेने चाहिए mov al, al- तर्क बाइट का उपयोग स्रोत और लक्ष्य रजिस्टर दोनों को निर्दिष्ट करने के लिए किया जाता है; अब आप जानते हैं कि 8086 में केवल 8 रजिस्टर क्यों थे: डी)। तुलना करें NOP, जो एक एकल बाइट अनुदेश है! यह मेमोरी और समय पर बचाता है, क्योंकि 8086 में मेमोरी पढ़ना अभी भी काफी महंगा था - टेप या फ्लॉपी या कुछ और से उस प्रोग्राम को लोड करने का उल्लेख नहीं करना।

तो कहाँ से xchg ax, axआता है? आपको बस अन्य xhcgनिर्देशों के opcodes को देखना होगा । आप देखेंगे 0x86, 0x87और अंत में, 0x91- 0x97। तो इसके nopसाथ ऐसा 0x90लगता है जैसे एक बहुत अच्छा फिट है xchg ax, ax(जो, फिर से, एक xchg"अधिभार" नहीं है - आपको xchg rb, rmbदो बाइट्स में उपयोग करना होगा )। और वास्तव में, मुझे पूरा यकीन है कि यह उस समय की सूक्ष्म वास्तुकला का एक अच्छा पक्ष-प्रभाव था - अगर मैं सही ढंग से याद करता हूं, तो 0x90-0x97"xchg, रजिस्टरों पर अभिनय करना axऔर " ax- di( ऑपरेंड सममित होने के कारण, इसने आपको पूरी रेंज दी, जिसमें nop भी शामिल है xchg ax, ax; ध्यान दें कि ऑर्डर है ax, cx, dx, bx, sp, bp, si, di- bxबाद है dx,ax; याद रखें, रजिस्टर नाम वर्णक्रमीय हैं, आदेशित नाम नहीं हैं - संचायक, काउंटर, डेटा, आधार, स्टैक पॉइंटर, बेस पॉइंटर, सोर्स इंडेक्स, गंतव्य सूचकांक)। उसी दृष्टिकोण का उपयोग अन्य ऑपरेंड के लिए भी किया जाता था, उदाहरण के लिए mov someRegister, immediateसेट। एक तरह से, आप इस बारे में सोच सकते हैं जैसे कि ओपोड वास्तव में एक पूर्ण बाइट नहीं था - अंतिम कुछ बिट्स "वास्तविक" ओपेरा के लिए "एक तर्क" हैं।

यह सब कहा, x86 पर, nopएक वास्तविक निर्देश माना जा सकता है, या नहीं। मूल माइक्रो-आर्किटेक्चर ने इसे एक वेरिएंट के रूप में माना था xchgयदि मैं सही तरीके से याद करता हूं, लेकिन इसे वास्तव nopमें विनिर्देश में नामित किया गया था । और चूंकि xchg ax, axवास्तव में एक निर्देश के रूप में कोई मतलब नहीं है, आप देख सकते हैं कि 8086 के डिजाइनरों ने निर्देश डिकोडिंग में ट्रांजिस्टर और रास्ते पर कैसे बचाया, इस तथ्य का दोहन करके कि 0x90प्राकृतिक रूप से किसी चीज़ का पूरी तरह से "नॉपी" होना।

दूसरी ओर, i8051 के लिए पूरी तरह से डिज़ाइन किया गया ओपकोड है nop- 0x00। किंदा व्यावहारिक। अनुदेश डिजाइन मूल रूप से संचालन के लिए उच्च निबल और ऑपरेंड के चयन के लिए कम निबल उपयोग कर रहा है - उदाहरण के लिए, add aहै 0x2Y, और 0xX8इसका मतलब है "रजिस्टर 0 प्रत्यक्ष" है, तो 0x28है add a, r0। सिलिकॉन पर बहुत बचत होती है :)

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

— Luaan
स्रोत

वास्तव में, NOPआम तौर पर करने के लिए एक उपनाम है MOV ax, ax, ADD ax, 0या इसी तरह के निर्देश। आप एक समर्पित निर्देश क्यों डिज़ाइन करेंगे, जब वहाँ बहुत कुछ नहीं है।

— दिमित्री ग्रिगोरीव

@DmitryGrigoryev यह वास्तव में स्वयं सीपीयू भाषा (अच्छी तरह से, सूक्ष्म वास्तुकला) के डिजाइन में चला जाता है। अधिकांश सीपीयू (और संकलक) MOV ax, axदूर का अनुकूलन करने की प्रवृत्ति रखते हैं ; NOPहमेशा निष्पादन के लिए निश्चित मात्रा में चक्र होंगे। लेकिन मैं यह नहीं देखता कि मैंने अपने उत्तर में जो भी लिखा है, वह कैसे प्रासंगिक है।

— लुआण

सीपीयू वास्तव में MOV ax, axदूर का अनुकूलन नहीं कर सकता , क्योंकि जब तक वे जानते हैं कि यह एक MOVनिर्देश है, पहले से ही पाइपलाइन में है।

— दिमित्री ग्रिगोरीव

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

— ओल्डस्कूल

1

+1 को नो-वन के लिए अनुकूलित करने के लिए! मुझे लगता है कि हम सभी सहयोग करना चाहिए और वर्तनी की इस शैली पर वापस जाना चाहिए! Z80 (और बदले में 8080) में 7 LD r, rनिर्देश हैं, जहां rआपके MOV ax, axनिर्देश के समान कोई एकल रजिस्टर है । कारण यह 7 है और 8 नहीं है क्योंकि निर्देशों में से एक बनने के लिए अतिभारित है HALT। तो 8080 और Z80 में कम से कम 7 अन्य निर्देश हैं जो समान हैं NOP! दिलचस्प रूप से पर्याप्त है, भले ही ये निर्देश तार्किक रूप से बिट पैटर्न से संबंधित नहीं हैं, लेकिन वे सभी 4 टी राज्यों को निष्पादित करने के लिए लेते हैं, इसलिए LDनिर्देशों का उपयोग करने का कोई कारण नहीं है !

— CJ डेनिस

5

70 के दशक के उत्तरार्ध में, हम (मैं तब एक युवा शोध छात्र था) में थोड़ी सी देव प्रणाली थी (8080 यदि मेमोरी काम करती है) जो 1024 बाइट्स कोड (यानी एक एकल UVEPROM) में चलती थी - इसमें लोड करने के लिए केवल चार कमांड थे (L ), सहेजें (एस), प्रिंट (पी), और कुछ और जो मुझे याद नहीं है। यह एक वास्तविक टेलेटाइप और पंच टेप के साथ संचालित किया गया था। यह कसकर कोडित था!

एनओओपी उपयोग का एक उदाहरण एक बाधा सेवा दिनचर्या (आईएसआर) में था, जो 8 बाइट अंतराल में फैला हुआ था। इस दिनचर्या को 9 बाइट्स के साथ समाप्त किया जा रहा है जो एक पते पर (लंबी) छलांग के साथ समाप्त होता है और पते की जगह को थोड़ा आगे बढ़ाता है। इसका मतलब है, थोड़ा एंडियन बाइट ऑर्डर, जिसे हाई एड्रेस बाइट 00h दिया गया था, और अगले ISR के पहले बाइट में स्लेट किया गया था, जिसका मतलब था कि यह (अगला ISR) NOOP के साथ शुरू हुआ था, बस इसलिए 'हम फिट हो सके सीमित स्थान में कोड!

इसलिए एनओओपी उपयोगी है। इसके अलावा, मुझे संदेह है कि इंटेल के लिए इसे इस तरह से कोड करना सबसे आसान था - उनके पास शायद निर्देशों की एक सूची थी जिसे वे लागू करना चाहते थे और यह '1' पर शुरू हुआ था, जैसे सभी सूचियां करते हैं (यह फोरट्रान के दिन थे), इसलिए शून्य एनओओपी कोड एक गिरावट बन गया। (मैंने एक लेख को यह तर्क देते हुए नहीं देखा है कि एक NOOP कम्प्यूटिंग विज्ञान सिद्धांत का एक अनिवार्य हिस्सा है (वही क्यू: क्या गणितज्ञों के पास शून्य सेशन है, जो समूह सिद्धांत के शून्य से अलग है?)

— फिलिप ओकले
स्रोत

सभी CPU में NOP 0x00 (हालांकि 8085, 8080 और CPU मैं सबसे अधिक परिचित है, Z80, सभी करते हैं) को एनकोड किया गया है। हालाँकि, अगर मैं एक प्रोसेसर डिजाइन कर रहा था, जहाँ मैं इसे रखूँगा! कुछ और बात यह है कि मेमोरी आमतौर पर सभी 0x00 के लिए इनिशियलाइज़ होती है, इसलिए इसे कोड के रूप में निष्पादित करना तब तक कुछ नहीं होगा जब तक सीपीयू नॉन-जीरो मेमोरी तक नहीं पहुँच जाता।

— CJ डेनिस

@CJDennis मैंने समझाया है कि मेरे जवाब में x86 सीपीयू का उपयोग क्यों नहीं 0x00किया nopजाता है। संक्षेप में, यह निर्देश डिकोडिंग पर बचाता है - xchg ax, axनिर्देश डिकोडिंग के काम करने के तरीके से स्वाभाविक रूप से बहता है, और यह कुछ "नॉपी" करता है, इसलिए क्यों नहीं इसका उपयोग करें और इसे कॉल करें nop, है ना? :) निर्देशन डिकोडिंग के लिए सिलिकॉन पर काफी कुछ बचाने के लिए इस्तेमाल किया ...

— लुआं

5

कुछ आर्किटेक्चर पर, NOPअप्रयुक्त देरी स्लॉट पर कब्जा करने के लिए उपयोग किया जाता है । उदाहरण के लिए, यदि शाखा निर्देश पाइपलाइन को साफ नहीं करता है, तो कई निर्देश वैसे भी निष्पादित होने के बाद:

 JMP     .label
 MOV     R2, 1    ; these instructions start execution before the jump
 MOV     R2, 2    ; takes place so they still get executed

लेकिन क्या होगा अगर आपके पास फिट होने के बाद कोई उपयोगी निर्देश न हो JMP? उस स्थिति में आपको NOPएस का उपयोग करना होगा ।

देरी स्लॉट केवल जंप तक सीमित नहीं हैं। कुछ आर्किटेक्चर पर, सीपीयू पाइपलाइन में डेटा खतरों को स्वचालित रूप से हल नहीं किया जाता है। इसका मतलब यह है कि प्रत्येक निर्देश के बाद जो एक रजिस्टर को संशोधित करता है, एक स्लॉट है जहां रजिस्टर का नया मूल्य अभी तक सुलभ नहीं है। यदि अगले निर्देश के लिए उस मूल्य की आवश्यकता है, तो स्लॉट को एक NOP:

 ADD     R1, R1
 NOP               ; The new value of R1 is not ready yet
 ADD     R1, R3

इसके अलावा, कुछ सशर्त निष्पादन निर्देश ( यदि-सत्य-गलत और समान) प्रत्येक स्थिति के लिए स्लॉट का उपयोग करते हैं, और जब किसी विशेष स्थिति में इससे जुड़ी कोई क्रिया नहीं होती है, तो इसके स्लॉट पर कब्जा होना चाहिए NOP:

CMP     R0, R1       ; Compare R0 and R1, setting flags
ITF     GT           ; If-True-False on GT flag 
MOV     R3, R2       ; If 'greater than', move R2 to R3
NOP                  ; Else, do nothing

— दिमित्री ग्रिगोरीव
स्रोत

+1। बेशक, वे केवल उन आर्किटेक्चर पर दिखाई देते हैं जो पीछे की संगतता के बारे में परवाह नहीं करते हैं - अगर x86 ने ऐसा कुछ करने की कोशिश की, जब निर्देश पाइपलाइनिंग शुरू करते समय, लगभग सभी लोग इसे गलत कहेंगे (आखिरकार, उन्होंने बस अपने सीपीयू को अपग्रेड किया, और उनका अनुप्रयोगों ने काम करना बंद कर दिया!)। तो 86 है सुनिश्चित करने के लिए आवेदन नहीं करता है नोटिस जब इस तरह के सुधार सीपीयू से जुड़ जाते हैं - जब तक हम वैसे भी बहु-कोर सीपीयू को मिला ...: डी

— Luaan

2

दो-बाइट NOP के लिए उपयोग का एक और उदाहरण : http://blogs.msdn.com/b/oldnewthing/archive/2011/09/21/10214405.aspx

एमओवी ईडीआई, ईडीआई निर्देश एक दो-बाइट एनओपी है, जो एक कूद निर्देश में पैच करने के लिए बस पर्याप्त स्थान है ताकि फ़ंक्शन को मक्खी पर अपडेट किया जा सके। आशय यह है कि MOV EDI, EDI निर्देश को दो बाइट JMP $ -5 निर्देश के साथ बदल दिया जाएगा, जो फ़ंक्शन के शुरू होने से तुरंत पहले आने वाले पांच बाइट्स पैच स्पेस को पुनः निर्देशित करता है। फुल जंप इंस्ट्रक्शन के लिए पांच बाइट्स पर्याप्त हैं, जो एड्रेस स्पेस में कहीं और स्थापित रिप्लेसमेंट फंक्शन को कंट्रोल भेज सकता है।

— pjc50
स्रोत