32-बिट सिस्टम द्वारा 80-बिट फ़्लोटिंग पॉइंट का उपयोग कैसे किया जा सकता है? [डुप्लिकेट]

13

इस सवाल का पहले से ही यहाँ एक जवाब है:

यदि 32-बिट मशीनें केवल 2 ^ 32 तक की संख्या को संभाल सकती हैं, तो मैं अपनी मशीन के दुर्घटनाग्रस्त हुए बिना 1000000000000 (ट्रिलियन) क्यों लिख सकता हूं? 19 जवाब

चूंकि 32 बिट सिस्टम एक 2 ^ 33 नंबर (क्योंकि स्पष्ट 32-बिट सीमा) का प्रबंधन नहीं कर सकता है, 80-बिट फ्लोटिंग पॉइंट नंबर कैसे प्रबंधित कर सकता है ?

इसे "80-बिट" की आवश्यकता होनी चाहिए ...

memory 32-bit

— markzzz
स्रोत

8

उसी तरह यह 64-बिट फ्लोटिंग पॉइंट नंबर करता है। यह 3 या (2) 32-बिट रजिस्टरों का उपयोग करता है। चूंकि 80-बिट फ्लोटिंग पॉइंट नंबर एक मानक आकार भी नहीं है, यह वास्तव में एक 96-बिट नंबर होगा जिसमें केवल 80-बिट्स का उपयोग किया जाएगा।

— रामहाउंड

5

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

— फ्रैंक थॉमस

2

@ @Ceιᴇ007 उस एक का कोई ठिकाना नहीं । यह एक संख्या और इसके पाठ / ASCII प्रतिनिधित्व के बीच के अंतर के बारे में अधिक है, हालांकि इनमें से कुछ उत्तर इस पर भी ध्यान दे सकते हैं।

— बॉब

3

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

— डैनियल आर हिक्स

6

@ रामहाउंड: नहीं, 80 बिट्स 8087 की ख़ासियत है, और यह 1 एफपी रजिस्टर का उपयोग करता है। यह निश्चित रूप से एक 96 बिट संख्या नहीं है।

— MSalters

35

32 बिट CPU का एक अर्थ यह है कि इसके रजिस्टर 32 बिट्स चौड़े हैं। इसका मतलब यह नहीं है कि यह 64 बिट नंबरों के साथ सौदा नहीं कर सकता है, बस इसके लिए निचले 32 बिट आधे से निपटना होगा, फिर ऊपरी 32 बिट आधा सेकंड। (यह सीपीयू का कैरी फ़्लैग है ।) यदि सीपीयू केवल 64 बिट रजिस्टर में मूल्यों को लोड कर सकता है, लेकिन यह अभी भी संभव है तो यह धीमी है।

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

हालांकि, उदाहरण के लिए, इंटेल 32 बिट प्रोसेसर और फ्लोटिंग पॉइंट के साथ, इनमें से कोई भी मायने नहीं रखता, क्योंकि सीपीयू के फ्लोटिंग पॉइंट हिस्से के अपने रजिस्टर हैं और वे 80 बिट्स चौड़े हैं। (X86 के इतिहास के आरंभ में, फ्लोटिंग पॉइंट क्षमता एक अलग चिप थी, इसे सीपीयू में 80486TX के साथ एकीकृत किया गया था।)

@ निर्णायक के जवाब ने मुझे इसे जोड़ने के लिए प्रेरित किया।

फ़्लोटिंग पॉइंट वैल्यू, इनफ़ॉफ़र जैसे कि वे FPU रजिस्टरों में संग्रहीत होते हैं, बाइनरी पूर्णांक मानों की तुलना में बहुत अलग काम करते हैं।

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

यदि आपका घातांक बहुत बड़ा है, तो आपके पास एक फ़्लोटिंग-पॉइंट ओवरफ़्लो है, लेकिन आप इसे आसानी से किसी अन्य रजिस्टर में नहीं बढ़ा सकते हैं क्योंकि एक्सपोनेंट और मंटिसा एक साथ बंधे हैं।

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

यह ठीक है कि यह पूरी तरह से अलग तरह से काम करता है क्योंकि सीपीयू का पूरा "फ्लोटिंग-पॉइंट" हिस्सा अपनी ही दुनिया की तरह है - आप इसे और ऐसे एक्सेस करने के लिए विशेष सीपीयू निर्देशों का उपयोग करते हैं। इसके अलावा, प्रश्न के बिंदु की ओर, क्योंकि यह अलग है, एफपीयू की बिटनेस मूल सीपीयू की बिटनेस के साथ कसकर युग्मित नहीं है।

— LawrenceC
स्रोत

4

मेरी प्रेरणा से आपने जो कुछ भी जोड़ा है वह सही है, इसलिए वहां कोई चिंता नहीं है :) बस एक बिंदु का उल्लेख करना चाहिए, हालांकि आप मूल सीपीयू निर्देशों का उपयोग कर सकते हैं जहां एक फ्लोटिंग-पॉइंट यूनिट मौजूद है, एक सॉफ्टवेयर में फ्लोटिंग पॉइंट ऑपरेशन भी कर सकता है (समतुल्य बिटवाइज़ के साथ) या पूर्णांक गणित संचालन)। उस बिंदु तक विस्तार करने के लिए, पर्याप्त मेमोरी दी गई, आपके पास मनमाने ढंग से सटीक संख्याएं भी हो सकती हैं (जैसा कि हमारे निर्धारित 64-बिट, या इस मामले में 80-बिट के विपरीत) सॉफ्टवेयर एल्गोरिदम / पुस्तकालयों का उपयोग करते हुए (आमतौर पर इस्तेमाल किया जाने वाला एक है GNU मल्टीपल प्रिसिजन) पुस्तकालय )।

— ब्रेकथ्रू

1

नाइटपिक: पहले इंटेल एकीकृत एफपीयू 80486DX में था, न कि 80386।

— थूक

2

@markzzz: यदि आवश्यक हो तो कुछ भी पागल नहीं है। अपने परमाणु भंडार का मूल्यांकन करने के लिए एक परमाणु बम का अनुकरण करने के लिए 16 बिट फ़्लोट्स का उपयोग करना पागल है क्योंकि यह आपके लिए परिणाम में आश्वस्त होने के लिए पर्याप्त सटीक नहीं है। जिस स्थिति में 32 बिट्स की आवश्यकता होती है (और हां, पुराने दिनों में ये गणना 16 बिट पीडीपी पर की गई थी)। इसी तरह जलवायु का अनुकरण करने के लिए 32 बिट फोलेट का उपयोग गणना की अराजक प्रकृति के कारण पर्याप्त सटीक नहीं है।

— स्लीवेटमैन

2

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

— स्लीपबेटमैन

2

@ X86 पर आप वास्तव में डेटा के लिए 7 प्रयोग करने योग्य GPRS हैं, EBP शामिल है। यह सिर्फ इतना है कि अधिकांश भाषाओं के कार्यान्वयन एबीआई स्टैक फ्रेम पॉइंटर के लिए इस रजिस्टर को सुरक्षित रखते हैं। लेकिन जीसीसी के साथ आप -fomit-frame-pointerउस रजिस्टर को वापस पाने के लिए उपयोग कर सकते हैं ।

— रुस्लान

13

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

एक निरंतर घड़ी की गति (साथ ही साथ वास्तुकला में सब कुछ स्थिर होने) को मानते हुए, और स्मृति को पढ़ना / लिखना एक ही गति है (हम यहां 1 घड़ी चक्र मानते हैं, लेकिन यह वास्तविक जीवन में मामले से बहुत दूर है), आप कर सकते हैं एक 64-बिट मशीन पर एक एकल घड़ी चक्र में दो 64-बिट संख्या जोड़ें (तीन यदि आप रैम से संख्याओं की गणना करते हैं):

ADDA [NUM1], [NUM2]
STAA [RESULT]

हम 32-बिट मशीन पर भी यही गणना कर सकते हैं ... हालाँकि, 32-बिट मशीन पर, हमें सॉफ्टवेयर में यह करने की आवश्यकता है, क्योंकि निचले 32-बिट्स को पहले जोड़ा जाना चाहिए, अतिप्रवाह के लिए क्षतिपूर्ति करना, फिर जोड़ना ऊपरी 64-बिट:

     ADDA [NUM1_LOWER], [NUM2_LOWER]
     STAA [RESULT_LOWER]
     CLRA          ; I'm assuming the condition flags are not modified by this.
     BRNO CMPS     ; Branch to CMPS if there was no overflow.
     ADDA #1       ; If there was overflow, compensate the value of A.
CMPS ADDA [NUM1_UPPER], [NUM2_UPPER]
     STAA [RESULT_UPPER]

मेरे बनाये हुए असेंबली सिंटैक्स के माध्यम से जा रहे हैं, आप आसानी से देख सकते हैं कि उच्च-सटीक ऑपरेशन कम शब्द लंबाई की मशीन पर कितना लंबा समय ले सकते हैं। यह 64-बिट और 128-बिट प्रोसेसर के लिए वास्तविक कुंजी है: वे हमें एक ही ऑपरेशन में बड़ी संख्या में बिट्स को संभालने की अनुमति देते हैं। कुछ मशीनों में कैरी (जैसे ADCx86) के साथ अन्य मात्राओं को जोड़ने के निर्देश शामिल हैं , लेकिन ऊपर दिए गए उदाहरण में मनमाने ढंग से सटीक मान हैं।

अब, इस सवाल का विस्तार करने के लिए, यह देखना आसान है कि हम हमारे द्वारा उपलब्ध कराए गए रजिस्टरों की तुलना में बड़ी संख्याओं को कैसे जोड़ सकते हैं - हम समस्या को केवल रजिस्टर के आकार को तोड़ते हैं, और वहां से काम करते हैं। हालाँकि @MatteoItalia द्वारा उल्लेख किया गया है , x87 FPU स्टैक में 80-बिट मात्रा के लिए मूल समर्थन है, सिस्टम में इस समर्थन की कमी है (या प्रोसेसर में एक फ्लोटिंग पॉइंट यूनिट की कमी है!), समकक्ष संगणना / संचालन सॉफ्टवेयर में किया जाना चाहिए ।

इसलिए प्रत्येक 32-बिट सेगमेंट को जोड़ने के बाद 80-बिट संख्या के लिए, 81-बिट बिट में अतिप्रवाह के लिए भी जाँच करेगा, और वैकल्पिक रूप से उच्च क्रम बिट्स को शून्य कर देगा। ये चेक / शून्य स्वचालित रूप से कुछ x86 और x86-64 निर्देशों के लिए किए जाते हैं, जहां स्रोत और गंतव्य ऑपरेंड आकार निर्दिष्ट हैं (हालांकि ये केवल 1 बाइट वाइड से शुरू होने वाली 2 की शक्तियों में निर्दिष्ट हैं)।

बेशक, फ्लोटिंग पॉइंट नंबरों के साथ, कोई भी बाइनरी जोड़ नहीं कर सकता है क्योंकि मंटिसा और महत्वपूर्ण अंक ऑफसेट फॉर्म में एक साथ पैक किए गए हैं। AL86 में एक x86 प्रोसेसर पर, IEEE 32-बिट और 64-बिट फ़्लोट्स के लिए यह प्रदर्शन करने के लिए एक हार्डवेयर सर्किट है; हालाँकि , फ़्लोटिंग-पॉइंट यूनिट (FPU) की अनुपस्थिति में, समान संगणना सॉफ्टवेयर में भी की जा सकती है (जैसे GNU साइंटिफिक लाइब्रेरी के उपयोग के माध्यम से , जो आर्किटेक्चर पर संकलित होने पर FPU का उपयोग करती है , सॉफ़्टवेयर के बैकफ़ॉर्म में वापस आती है। अगर कोई फ्लोटिंग-पॉइंट हार्डवेयर उपलब्ध नहीं है [उदाहरण के लिए एम्बेडेड माइक्रोकंट्रोलर के लिए एफपीयू की कमी है])।

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

— दरार
स्रोत

2

आप सबसे महत्वपूर्ण विवरण का उल्लेख करने में विफल रहे हैं: x86 प्लेटफ़ॉर्म पर x87 FPU में 80-बिट फ़्लोटिंग पॉइंट रजिस्टर हैं, इसलिए इसकी मूल गणना वास्तव में 80 बिट फ़्लोट पर की जाती है, सॉफ़्टवेयर में कुछ भी अनुकरण करने की आवश्यकता नहीं है।

— मटेओ इटालिया

@MatteoItalia मैं अब देख रहा हूँ, धन्यवाद। मुझे लगा कि मूल प्रश्न अधिक सामान्य अवलोकन के लिए पूछ रहा था कि प्रोसेसर शब्द आकार से बड़ी संख्या में संचालन कैसे कर सकता है, और x86 में विस्तारित 80-बिट फ़्लोट्स के विशिष्ट कार्यान्वयन नहीं है (यह भी कि मेरे उदाहरण के बजाय 90 बिट्स क्यों थे? 80 ...)। मैंने इस उत्तर को बेहतर ढंग से प्रतिबिंबित करने के लिए अद्यतन किया है, सिर ऊपर करने के लिए धन्यवाद।

— ब्रेकथ्रू

5

सिस्टम की मेमोरी आर्किटेक्चर आपको केवल एक बार में 32 बिट्स को स्थानांतरित करने की अनुमति दे सकता है - लेकिन यह बड़ी संख्या का उपयोग करने से नहीं रोकता है।

गुणा के बारे में सोचो। आप 10 गुणा तक अपनी गुणन सारणी जान सकते हैं, फिर भी आपको शायद कागज के एक टुकड़े पर 123x321 प्रदर्शन करने में कोई समस्या नहीं है: आप इसे कई छोटी समस्याओं में तोड़ते हैं, व्यक्तिगत अंकों को गुणा करते हैं और कैरी का ध्यान रखते हैं आदि।

प्रोसेसर वही काम कर सकते हैं। "पुराने दिनों" में आपके पास 8 बिट प्रोसेसर थे जो फ्लोटिंग पॉइंट गणित कर सकते थे। लेकिन वे नारेबाजी कर रहे थे।

— फ्लोरिस
स्रोत

1

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

— रामहाउंड

3

"32-बिट" वास्तव में प्रोसेसर को वर्गीकृत करने का एक तरीका है, न कि एक सेट-इन-स्टोन सत्तारूढ़। "32-बिट" प्रोसेसर में आमतौर पर काम करने के लिए 32 बिट सामान्य प्रयोजन रजिस्टर होते हैं।

हालांकि, पत्थर की आवश्यकता में कोई सेट नहीं है कि प्रोसेसर में सब कुछ 32-बिट में किया जाए। उदाहरण के लिए, "32-बिट" कंप्यूटर के लिए 28-बिट एड्रेस बस होना अनसुना नहीं था, क्योंकि यह हार्डवेयर बनाने के लिए सस्ता था। 64-बिट कंप्यूटर में अक्सर एक ही कारण के लिए केवल 40-बिट या 48-बिट मेमोरी बस होती है।

फ्लोटिंग पॉइंट अंकगणित एक और जगह है जहाँ आकार भिन्न होते हैं। कई 32-बिट प्रोसेसर ने 64-बिट फ्लोटिंग पॉइंट नंबर का समर्थन किया। उन्होंने विशेष रजिस्टरों में फ्लोटिंग पॉइंट वैल्यू को स्टोर करके ऐसा किया जो सामान्य उद्देश्य रजिस्टरों की तुलना में व्यापक था। विशेष रजिस्टरों में इन बड़े फ्लोटिंग पॉइंट नंबरों में से एक को स्टोर करने के लिए, पहले नंबर को दो सामान्य प्रयोजन रजिस्टरों में विभाजित किया जाएगा, फिर उन्हें विशेष रजिस्टरों में फ्लोट में संयोजित करने के लिए एक निर्देश जारी किया जाएगा। एक बार उन फ़्लोटिंग पॉइंट रजिस्टरों में, मानों को 32-बिट हाफ़ की एक जोड़ी के बजाय 64-बिट फ़्लोट्स के रूप में हेरफेर किया जाएगा।

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

इंटेल समाधान यह है कि फ्लोटिंग पॉइंट रजिस्टर सभी 80 बिट्स हैं, लेकिन उन रजिस्टरों से मानों को स्थानांतरित करने के निर्देश प्राइमरीली 64-बिट संख्याओं के साथ काम करते हैं। जब तक आप इंटेल के x87 फ़्लोटिंग पॉइंट स्टैक के भीतर पूरी तरह से काम करते हैं, तब तक आपके सभी ऑपरेशन 80 बिट्स सटीक के साथ किए जाते हैं। यदि आपके कोड को फ्लोटिंग पॉइंट रजिस्टरों में से किसी एक मान को खींचने और उसे कहीं स्टोर करने की आवश्यकता है, तो यह इसे 64-बिट्स तक काट देता है।

कहानी का नैतिक: "32-बिट" जैसे वर्गीकरण हमेशा खतरनाक होते हैं जब आप चीजों में गहराई से उतरते हैं!

— Cort Ammon
स्रोत

लेकिन अगर मैं 32 बिट फ़्लोटिंग पॉइंट वैल्यूज़ को 16 बिट सिस्टम (या 64 बिट फ़्लोटिंग पॉइंट वैल्यूज़ इन ए 32 बिट सिस्टम) का उपयोग करता हूँ तो इसके लिए केवल अधिक मेमोरी (क्योंकि इसे दो बार रजिस्टर करना होगा) की आवश्यकता होती है? या सूचना को संसाधित करने से ओवरहेड जुड़ जाएगा, इसलिए अधिक समय लगेगा?

— मार्कजज़

@markzzz: कई रजिस्टरों के साथ काम करने में लगभग हमेशा अधिक समय लगता है

— Mooing Duck

विशेष उद्देश्य रजिस्टरों में 32 बिट फ्लोटिंग पॉइंट वैल्यू लोड होने में अधिक समय लगेगा। हालाँकि, एक बार जब वे विशेष प्रयोजन फ़्लोटिंग पॉइंट रजिस्टरों में 32-बिट फ़्लोट्स के रूप में संग्रहीत होते हैं, तो हार्डवेयर पूरी गति से उन फ़्लोटिंग पॉइंट मानों पर काम करेगा। याद रखें, "16-बिट" केवल सामान्य प्रयोजन रजिस्टरों के आकार को संदर्भित करता है। फ्लोटिंग पॉइंट रजिस्टर अपने कार्य के लिए विशेष आकार के होते हैं, और व्यापक हो सकते हैं (आपके मामले में 32 बिट्स चौड़े)

— Cort Ammon

2

एक "32-बिट" सीपीयू वह है जहां अधिकांश डेटा रजिस्टर 32-बिट रजिस्टर होते हैं, और अधिकांश निर्देश उन 32-बिट रजिस्टरों में डेटा पर काम करते हैं। एक 32-बिट सीपीयू भी एक बार में 32-बिट से मेमोरी को डेटा स्थानांतरित करने की संभावना है। अधिकांश रजिस्टर 32-बिट होने का मतलब यह नहीं है कि सभी रजिस्टर 32-बिट हैं। संक्षिप्त उत्तर यह है कि एक 32-बिट सीपीयू में कुछ विशेषताएं हो सकती हैं जो अन्य बिटकॉन्स का उपयोग करती हैं, जैसे कि 80-बिट फ्लोटिंग पॉइंट रजिस्टर और संबंधित निर्देश।

जैसा कि @spudone ने @ ultrasawblade के उत्तर पर एक टिप्पणी में कहा, एकीकृत फ्लोटिंग-पॉइंट संचालन के लिए पहला x86 CPU इंटेल i486 था (विशेषकर 80486DX लेकिन 80486SX नहीं), जो कि i486 माइक्रोप्रोसेसर प्रोग्रामर के पेज 15-1 के अनुसार था संदर्भ मैनुअल , इसके संख्यात्मक रजिस्टरों में "आठ व्यक्तिगत रूप से-पता लगाने योग्य 80-बिट संख्यात्मक रजिस्टर" शामिल हैं। I486 में 32-बिट मेमोरी बस है, इसलिए 80-बिट मान ट्रांसफर करने पर 3 मेमोरी ऑपरेशन होंगे।

486 पीढ़ी के पूर्ववर्ती, i386 के पास कोई एकीकृत फ्लोटिंग-पॉइंट ऑपरेशन नहीं था। इसके बजाय, इसे बाहरी फ़्लोटिंग पॉइंट "कोप्रोसेसर", 80387 का उपयोग करने के लिए समर्थन था। इस कोप्रोसेसर में लगभग समान कार्यक्षमता थी जिसे i486 में एकीकृत किया गया था, जैसा कि आप 80387 प्रोग्रामर के संदर्भ मैनुअल के पेज 2-1 से देख सकते हैं ।

80-बिट फ़्लोटिंग पॉइंट प्रारूप 8087, 8086 और 8088 के गणित गणक के साथ उत्पन्न हुआ है। 8086 और 8088 16-बिट सीपीयू (16-बिट और 8-बिट मेमोरी बसों के साथ) थे, और अभी भी सक्षम थे 80-बिट फ़्लोटिंग बिंदु प्रारूप का उपयोग करने के लिए, कोपरोसेसर में 80-बिट रजिस्टरों का लाभ उठाकर।

— ShadSterling
स्रोत