HTG बताते हैं कि सीपीयू वास्तव में कैसे काम करता है?

कंप्यूटर में अधिकांश चीजें समझने में अपेक्षाकृत सरल होती हैं: रैम, स्टोरेज, पेरिफेरल्स, और सॉफ्टवेयर सभी एक साथ मिलकर कंप्यूटर का काम करते हैं। लेकिन आपके सिस्टम का दिल, सीपीयू, कई तकनीकी लोगों के लिए भी जादू जैसा लगता है। यहाँ, हम इसे नीचे तोड़ने की पूरी कोशिश करेंगे.

इस लेख के लिए अधिकांश शोध जे क्लार्क स्कॉट द्वारा "बट हाउ डू इट नो?" से आया है। यह एक शानदार रीड है, इस लेख की तुलना में बहुत अधिक गहराई में जाता है, और अमेज़ॅन पर युगल रुपये के लायक है.

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

छोटे से शुरू

कंप्यूटर बाइनरी में काम करते हैं। वे केवल दो राज्यों को समझते हैं: पर और बंद। बाइनरी में गणना करने के लिए, वे उपयोग करते हैं जिसे ट्रांजिस्टर कहा जाता है। ट्रांजिस्टर केवल स्रोत को प्रवाह के माध्यम से नाली में प्रवाहित करने की अनुमति देता है यदि गेट के पार वर्तमान है। अनिवार्य रूप से, यह एक बाइनरी स्विच बनाता है, जो दूसरे इनपुट सिग्नल के आधार पर वायर को काट देता है.

आधुनिक कंप्यूटर गणना करने के लिए अरबों ट्रांजिस्टर का उपयोग करते हैं, लेकिन सबसे निचले स्तरों पर, आपको केवल सबसे बुनियादी घटकों को बनाने के लिए एक मुट्ठी भर की आवश्यकता होती है, जिसे फाटकों के रूप में जाना जाता है।.

तर्क द्वार

कुछ ट्रांजिस्टर को ठीक से स्टैक करें, और आपको एक लॉजिक गेट के रूप में जाना जाता है। तर्क गेट्स दो बाइनरी इनपुट लेते हैं, उन पर एक ऑपरेशन करते हैं, और एक आउटपुट वापस करते हैं। उदाहरण के लिए, OR गेट सही है, यदि इनपुट में से कोई भी सत्य है। यदि दोनों इनपुट सत्य हैं, तो गेट का चेक, XOR चेक करता है कि क्या केवल एक इनपुट सत्य है, और N- वेरिएंट (NOR, NAND, और XNOR) उनके बेस गेट के उल्टे संस्करण हैं.

गेट्स के साथ गणित करना

सिर्फ दो द्वारों के साथ आप मूल द्विआधारी जोड़ कर सकते हैं। ऊपर दिए गए इस आरेख में एक आधा योजक दिखाया गया है, जो लॉजिकली गेट्स के लिए एक मुफ्त ऑनलाइन खेल का मैदान लॉजिकली का उपयोग करके बनाया गया है। यहाँ XOR गेट चालू होगा यदि इनपुट में से कोई एक चालू है, लेकिन दोनों नहीं। यदि दोनों इनपुट चालू हैं, तो AND गेट चालू हो जाएगा, लेकिन यदि कोई इनपुट नहीं है तो बंद रहें। इसलिए यदि दोनों चालू हैं, तो XOR रुक जाता है, और AND गेट चालू हो जाता है, दो का सही उत्तर आने पर:

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

पूर्ण योजक में तीन इनपुट होते हैं-जोड़ने के लिए दो नंबर, और एक "कैरी" होता है। कैरी का उपयोग तब किया जाता है जब अंतिम संख्या एक बिट में संग्रहीत की जा सकती है। पूर्ण योजक को एक श्रृंखला में जोड़ा जाएगा, और कैरी को एक योजक से दूसरे में पास किया जाएगा। कैरी को पहले हाफ योजक में XOR गेट के परिणाम में जोड़ा जाता है, और दोनों मामलों को संभालने के लिए एक अतिरिक्त OR गेट होता है, जिस पर चलने की आवश्यकता होती है.

जब दोनों इनपुट चालू होते हैं, तो कैरी चालू होता है, और इसे चेन में अगले पूर्ण योजक में भेजता है:

और यह लगभग उतना ही जटिल है जितना कि अतिरिक्त मिलता है। अनिवार्य रूप से अधिक बिट्स तक जाने का मतलब है एक लंबी श्रृंखला में अधिक पूर्ण योजक.

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

बस, और मेमोरी

अभी, हमारा कंप्यूटर एक खराब कैलकुलेटर से ज्यादा कुछ नहीं है। ऐसा इसलिए है क्योंकि यह कुछ भी याद नहीं कर सकता है, और इसके आउटपुट के साथ कुछ भी नहीं करता है। ऊपर दिखाया गया एक मेमोरी सेल है, जो वह सब कर सकता है। हुड के तहत, यह बहुत सारे नंद फाटकों का उपयोग करता है, और वास्तविक जीवन में भंडारण तकनीक के आधार पर काफी भिन्न हो सकता है, लेकिन इसका कार्य समान है। आप इसे कुछ इनपुट देते हैं, 'राइट' बिट चालू करें, और यह सेल के अंदर इनपुट को स्टोर करेगा। यह सिर्फ एक मेमोरी सेल नहीं है, क्योंकि हमें इससे जानकारी पढ़ने का एक तरीका भी चाहिए। यह एक एनबलर के साथ किया जाता है, जो कि मेमोरी में प्रत्येक बिट के लिए AND गेट्स का एक संग्रह है, जो सभी दूसरे इनपुट से बंधा हुआ है, "रीड" बिट। लिखने और पढ़ने वाले बिट्स को अक्सर "सेट" और "सक्षम" भी कहा जाता है.

इस पूरे पैकेज को एक रजिस्टर के रूप में जाना जाता है। ये रजिस्टर बस से जुड़े होते हैं, जो पूरे सिस्टम के चारों ओर चलने वाले तारों का एक बंडल है, जो हर घटक से जुड़ा होता है। यहां तक ​​कि आधुनिक कंप्यूटरों में एक बस है, हालांकि मल्टीटास्किंग प्रदर्शन को बेहतर बनाने के लिए उनके पास कई बसें हो सकती हैं.

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

रजिस्टरों का उपयोग रैम बनाने के लिए भी किया जाता है। रैम को अक्सर एक ग्रिड में रखा जाता है, जिसमें दो दिशाओं में तार होते हैं:

डिकोडर्स एक बाइनरी इनपुट लेते हैं और संबंधित गिने तार को चालू करते हैं। उदाहरण के लिए, "11" बाइनरी में 3 है, उच्चतम 2-बिट संख्या है, इसलिए डिकोडर उच्चतम तार चालू करेगा। प्रत्येक चौराहे पर, एक रजिस्टर है। ये सभी केंद्रीय बस से जुड़े हुए हैं, और एक केंद्रीय लिखने और पढ़ने के इनपुट के लिए। रीड और राइट दोनों इनपुट केवल तभी चालू होंगे जब रजिस्टर पर दो तार पार होंगे, प्रभावी रूप से आपको उस रजिस्टर का चयन करने की अनुमति देगा जिसमें से लिखना और पढ़ना है। फिर से, आधुनिक रैम कहीं अधिक जटिल है, लेकिन यह सेटअप अभी भी काम करता है.

द क्लॉक, स्टेपर और डिकोडर

रजिस्टरों का उपयोग हर जगह किया जाता है और सीपीयू में सूचनाओं को संग्रहीत करने और उन्हें संग्रहीत करने के लिए बुनियादी उपकरण होते हैं। तो उन्हें चीजों को स्थानांतरित करने के लिए क्या कहता है?

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

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

घड़ी स्टेपर से जुड़ी होती है, जो एक से अधिकतम चरण तक गिना जाएगा, और जब यह पूरा हो जाता है, तो खुद को वापस रीसेट कर देता है। सीपीयू के लिए लिखी गई प्रत्येक रजिस्टर के लिए घड़ी और गेट से भी जुड़ा हुआ है:

ये और द्वार एक अन्य घटक के उत्पादन से भी जुड़े हैं, निर्देश डिकोडर। निर्देश डिकोडर "SET R2 TO R1" जैसे एक निर्देश लेता है और इसे कुछ इस तरह से डिकोड करता है जिसे CPU समझ सकता है। इसका अपना आंतरिक रजिस्टर है, जिसे "इंस्ट्रक्शन रजिस्टर" कहा जाता है, जो कि वर्तमान ऑपरेशन को संग्रहीत किया जाता है। आपके द्वारा चलाए जा रहे सिस्टम पर यह कितना सही है, लेकिन एक बार यह डिकोड हो जाने के बाद, यह सही सेट पर चालू हो जाएगा और सही रजिस्टरों के लिए बिट्स को सक्षम करेगा, जो घड़ी के अनुसार बंद हो जाएगा.

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

कैसे यह सब एक साथ आता है

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

गणना करने के लिए, प्रोग्राम डेटा को सिस्टम रैम से कंट्रोल सेक्शन में लोड किया जाता है। नियंत्रण खंड रैम से दो नंबर पढ़ता है, पहले एक को ALU के निर्देश रजिस्टर में लोड करता है, और फिर बस पर दूसरा लोड करता है। इस बीच, यह ALU को एक निर्देश कोड भेजता है जो बताता है कि क्या करना है। ALU तब सभी गणना करता है और परिणाम को एक अलग रजिस्टर में संग्रहीत करता है, जिसे सीपीयू पढ़ सकता है और फिर प्रक्रिया जारी रख सकता है.

छवि क्रेडिट: रोस्ट 9 / शटरस्टॉक