कंप्यूटर में अधिकांश चीजें समझने में अपेक्षाकृत सरल होती हैं: रैम, स्टोरेज, पेरिफेरल्स, और सॉफ्टवेयर सभी एक साथ मिलकर कंप्यूटर का काम करते हैं। लेकिन आपके सिस्टम का दिल, सीपीयू, कई तकनीकी लोगों के लिए भी जादू जैसा लगता है। यहां, हम इसे तोड़ने के लिए अपनी पूरी कोशिश करेंगे।
इस लेख के लिए अधिकांश शोध से आता है "लेकिन यह कैसे पता है?" जे। क्लार्क स्कॉट द्वारा। यह एक शानदार रीड है, इस लेख की तुलना में बहुत अधिक गहराई में जाता है, और अमेज़ॅन पर युगल रुपये के लायक है।
हमारे शुरू होने से पहले एक नोट: आधुनिक सीपीयू जितना हम यहां रेखांकित कर रहे हैं, उससे कहीं अधिक परिमाण के आदेश हैं। एक व्यक्ति के लिए एक बिलियन ट्रांजिस्टर के साथ चिप की प्रत्येक बारीकियों को समझना लगभग असंभव है। हालांकि, यह कैसे फिट बैठता है इसके मूल सिद्धांत समान रहते हैं, और मूल बातें समझने से आपको आधुनिक प्रणालियों की बेहतर समझ मिलेगी।
छोटे से शुरू
कंप्यूटर में काम करते हैं बाइनरी । वे केवल दो राज्यों को समझते हैं: चालू और बंद। बाइनरी में गणना करने के लिए, वे एक ट्रांजिस्टर कहते हैं। ट्रांजिस्टर केवल स्रोत के प्रवाह के माध्यम से इसे नाली में प्रवाह करने की अनुमति देता है अगर गेट के पार वर्तमान है। अनिवार्य रूप से, यह एक बाइनरी स्विच बनाता है, जो दूसरे इनपुट सिग्नल के आधार पर वायर को काट देता है।
सम्बंधित: बाइनरी क्या है, और क्यों कंप्यूटर इसका उपयोग करते हैं?
आधुनिक कंप्यूटर गणना करने के लिए अरबों ट्रांजिस्टर का उपयोग करते हैं, लेकिन सबसे निचले स्तरों पर, आपको केवल सबसे बुनियादी घटकों को बनाने के लिए मुट्ठी भर की आवश्यकता होती है, जिन्हें फाटकों के रूप में जाना जाता है।
तर्क द्वार
कुछ ट्रांजिस्टर को ठीक से स्टैक करें, और आपके पास लॉजिक गेट के रूप में जाना जाता है। तर्क गेट्स दो बाइनरी इनपुट लेते हैं, उन पर एक ऑपरेशन करते हैं, और एक आउटपुट वापस करते हैं। उदाहरण के लिए, OR गेट सत्य है, यदि इनपुट में से कोई भी सत्य है। AND गेट की जाँच करता है कि दोनों इनपुट सही हैं, XOR जाँचता है कि क्या केवल एक इनपुट सही है, और N- वेरिएंट (NOR, NAND, और XNOR) उनके बेस गेट के उल्टे संस्करण हैं।
गेट्स के साथ गणित करना
सिर्फ दो द्वारों के साथ आप मूल द्विआधारी जोड़ कर सकते हैं। ऊपर दिया गया यह आरेख एक आधे योजक को दिखाता है, जिसका उपयोग करके बनाया गया है Logicly , तर्क फाटकों के लिए एक मुफ्त ऑनलाइन खेल का मैदान। यहाँ XOR गेट चालू होगा यदि इनपुट में से कोई एक चालू है, लेकिन दोनों नहीं। दोनों इनपुट चालू होने पर AND गेट चालू हो जाएगा, लेकिन इनपुट न होने पर बंद रहें। इसलिए यदि दोनों चालू हैं, तो XOR रुक जाता है, और AND गेट चालू हो जाता है, दो का सही उत्तर आने पर:
यह हमें तीन अलग-अलग आउटपुट के साथ एक सरल सेटअप देता है: शून्य, एक और दो। लेकिन एक बिट 1 से अधिक कुछ भी स्टोर नहीं कर सकता है, और यह मशीन बहुत उपयोगी नहीं है क्योंकि यह केवल सबसे सरल गणित समस्याओं में से एक को हल करता है। लेकिन यह केवल एक आधा योजक है, और यदि आप उनमें से दो को दूसरे इनपुट से जोड़ते हैं, तो आपको पूर्ण योजक मिलता है:
पूर्ण योजक में तीन इनपुट होते हैं- जोड़ने के लिए दो नंबर, और एक "कैरी"। कैरी का उपयोग तब किया जाता है जब अंतिम संख्या एक बिट में संग्रहीत की जा सकती है। पूर्ण योजक को एक श्रृंखला में जोड़ा जाएगा, और कैरी को एक योजक से दूसरे में पास किया जाएगा। कैरी को पहले हाफ योजक में XOR गेट के परिणाम में जोड़ा जाता है, और दोनों मामलों को संभालने के लिए एक अतिरिक्त OR गेट है, ताकि उस पर चलने की आवश्यकता हो।
जब दोनों इनपुट चालू होते हैं, तो कैरी चालू हो जाता है, और इसे चेन में अगले पूर्ण योजक में भेज देता है:
और यह लगभग उतना ही जटिल है जितना कि इसके अलावा। अनिवार्य रूप से अधिक बिट्स तक जाने का मतलब है एक लंबी श्रृंखला में अधिक पूर्ण योजक।
अधिकांश अन्य गणित संचालन अतिरिक्त के साथ किए जा सकते हैं; गुणन सिर्फ दोहराया इसके अलावा, घटाव कुछ फैंसी बिट उलटा के साथ किया जा सकता है, और विभाजन सिर्फ दोहराया घटाव है। और जब सभी आधुनिक कंप्यूटरों में हार्डवेयर-आधारित समाधान होते हैं, तो अधिक जटिल संचालन को गति देने के लिए, आप तकनीकी रूप से इसे पूर्ण योजक के साथ कर सकते हैं।
बस, और मेमोरी
अभी, हमारा कंप्यूटर एक खराब कैलकुलेटर से ज्यादा कुछ नहीं है। ऐसा इसलिए है क्योंकि यह कुछ भी याद नहीं रख सकता है, और इसके आउटपुट के साथ कुछ भी नहीं करता है। ऊपर दिखाया गया एक मेमोरी सेल है, जो वह सब कर सकता है। हुड के तहत, यह बहुत सारे नंद फाटकों का उपयोग करता है, और वास्तविक जीवन में भंडारण तकनीक के आधार पर काफी भिन्न हो सकता है, लेकिन इसका कार्य समान है। आप इसे कुछ इनपुट देते हैं, it राइट ’बिट चालू करते हैं, और यह सेल के अंदर इनपुट को स्टोर करेगा। यह सिर्फ एक मेमोरी सेल नहीं है, क्योंकि हमें इससे जानकारी पढ़ने का एक तरीका भी चाहिए। यह एक एनबलर के साथ किया जाता है, जो कि मेमोरी में प्रत्येक बिट के लिए AND गेट्स का एक संग्रह है, जो सभी दूसरे इनपुट से बंधा हुआ है, "रीड" बिट। लिखने और पढ़ने वाले बिट्स को अक्सर "सेट" और "सक्षम" भी कहा जाता है।
इस पूरे पैकेज को एक रजिस्टर के रूप में जाना जाता है। ये रजिस्टर बस से जुड़े होते हैं, जो पूरे सिस्टम के चारों ओर चलने वाले तारों का एक बंडल है, जो हर घटक से जुड़ा होता है। यहां तक कि आधुनिक कंप्यूटरों में एक बस है, हालांकि मल्टीटास्किंग प्रदर्शन को बेहतर बनाने के लिए उनके पास कई बसें हो सकती हैं।
प्रत्येक रजिस्टर में अभी भी एक राइट और रीड बिट है, लेकिन इस सेटअप में, इनपुट और आउटपुट एक ही बात है। यह वास्तव में अच्छा है। उदाहरण के लिए। यदि आप R1 की सामग्री को R2 में कॉपी करना चाहते हैं, तो आप R1 के लिए रीड बिट को चालू करेंगे, जो R1 की सामग्री को बस में धकेल देगा। जबकि रीड बिट चालू है, आप R2 के लिए राइट बिट चालू करते हैं, जो बस सामग्री को R2 में कॉपी कर देगा।
रजिस्टरों का उपयोग रैम बनाने के लिए भी किया जाता है। रैम को अक्सर एक ग्रिड में रखा जाता है, जिसमें दो दिशाओं में तार होते हैं:
डिकोडर्स एक बाइनरी इनपुट लेते हैं और संबंधित गिने तार को चालू करते हैं। उदाहरण के लिए, "11" बाइनरी में 3 है, उच्चतम 2-बिट संख्या है, इसलिए विकोडक उच्चतम तार चालू करेगा। प्रत्येक चौराहे पर, एक रजिस्टर है। ये सभी केंद्रीय बस से जुड़े हैं, और एक केंद्रीय लिखने और पढ़ने के इनपुट के लिए। रीड और राइट दोनों इनपुट केवल तभी चालू होंगे जब रजिस्टर पर दो तार पार होंगे, प्रभावी रूप से आपको उस रजिस्टर का चयन करने की अनुमति देगा जिससे लिखना और पढ़ना है। फिर से, आधुनिक रैम कहीं अधिक जटिल है, लेकिन यह सेटअप अभी भी काम करता है।
द क्लॉक, स्टेपर और डिकोडर
रजिस्टरों को हर जगह उपयोग किया जाता है और सीपीयू में सूचनाओं को संग्रहीत करने और उन्हें संग्रहीत करने के लिए मूल उपकरण होते हैं। तो उन्हें चीजों को स्थानांतरित करने के लिए क्या कहता है?
सीपीयू के मूल में घड़ी पहला घटक है और एक सेट अंतराल पर, हर्ट्ज या प्रति सेकंड चक्र में मापा जाता है। यह वह गति है जो आप सीपीयू के साथ विज्ञापित देखते हैं; एक 5 गीगाहर्ट्ज चिप प्रति सेकंड 5 बिलियन चक्र का प्रदर्शन कर सकता है। सीपीयू कितना तेज़ है, इसके लिए क्लॉक स्पीड अक्सर बहुत अच्छी मीट्रिक है।
घड़ी की तीन अलग-अलग अवस्थाएँ होती हैं: आधार घड़ी, सक्षम घड़ी और सेट घड़ी। आधार घड़ी आधे चक्र पर और दूसरी छमाही के लिए बंद रहेगी। रजिस्टरों को चालू करने के लिए सक्षम घड़ी का उपयोग किया जाता है और यह सुनिश्चित करने के लिए अधिक समय तक रहना होगा कि डेटा सक्षम है। सेट क्लॉक को हमेशा सक्षम घड़ी के रूप में उसी समय पर होना चाहिए, अन्यथा गलत डेटा लिखा जा सकता है।
घड़ी स्टेपर से जुड़ी होती है, जो एक से अधिकतम चरण तक गिना जाएगा, और जब यह किया जाता है, तब तक खुद को वापस रीसेट कर देता है। सीपीयू के लिए लिखी गई प्रत्येक रजिस्टर के लिए घड़ी और गेट्स से भी जुड़ा है:
ये और द्वार एक अन्य घटक के उत्पादन से भी जुड़े हुए हैं, निर्देश डिकोडर। निर्देश डिकोडर “SET R2 TO R1” जैसे निर्देश को लेता है और इसे कुछ इस तरह से डिकोड करता है जिसे CPU समझ सकता है। इसका अपना आंतरिक रजिस्टर है, जिसे "इंस्ट्रक्शन रजिस्टर" कहा जाता है, जो कि वर्तमान ऑपरेशन को संग्रहीत किया जाता है। आपके द्वारा चलाए जा रहे सिस्टम पर यह कितना सही है, लेकिन एक बार यह डिकोड हो जाने के बाद, यह सही सेट पर चालू हो जाएगा और सही रजिस्टरों के लिए बिट्स को सक्षम करेगा, जो घड़ी के अनुसार बंद हो जाएगा।
कार्यक्रम के निर्देश रैम में संग्रहीत हैं (या आधुनिक प्रणालियों पर एल 1 कैश, सीपीयू के करीब)। चूंकि प्रोग्राम डेटा को रजिस्टरों में संग्रहीत किया जाता है, हर दूसरे वेरिएबल की तरह, इसे प्रोग्राम के चारों ओर कूदने के लिए फ्लाई पर हेरफेर किया जा सकता है। यह है कि कार्यक्रमों को उनकी संरचना कैसे मिलती है, लूप के साथ और यदि कथन हैं। एक जम्प इंस्ट्रक्शन मेमोरी में करंट लोकेशन को सेट करता है जो इंस्ट्रक्शन डिकोडर अलग लोकेशन से पढ़ रहा होता है।
कैसे यह सब एक साथ आता है
अब, सीपीयू कैसे काम करता है, इसके बारे में हमारी स्थूल निगरानी है। मुख्य बस पूरी प्रणाली को फैलाती है और सभी रजिस्टरों से जुड़ती है। पूर्ण योजक, अन्य परिचालनों के एक समूह के साथ, अरिथमेटिक लॉजिक यूनिट या ALU में पैक किए जाते हैं। इस ALU में बस के कनेक्शन होंगे, और दूसरा नंबर जिस पर यह काम कर रहा है उसे संग्रहीत करने के लिए अपने स्वयं के रजिस्टर भी होंगे।
गणना करने के लिए, प्रोग्राम डेटा को सिस्टम रैम से कंट्रोल सेक्शन में लोड किया जाता है। नियंत्रण अनुभाग रैम से दो नंबर पढ़ता है, पहले एक को ALU के निर्देश रजिस्टर में लोड करता है, और फिर दूसरे को बस में लोड करता है। इस बीच, यह ALU को एक निर्देश कोड भेजता है जो बताता है कि क्या करना है। ALU तब सभी गणना करता है और परिणाम को एक अलग रजिस्टर में संग्रहीत करता है, जिसे सीपीयू पढ़ सकता है और फिर प्रक्रिया जारी रख सकता है।
छवि क्रेडिट: Rost9 / Shutterstock
