कंप्यूटर आर्किटेक्चर क्या है?
कंप्यूटर आर्किटेक्चर कंप्यूटर का नक्शा है: इसमें कौन-से हिस्से हैं और वे आपस में कैसे बात करते हैं। कंप्यूटर को परतों में बाँट (decompose) सकते हैं:
- हार्डवेयर: CPU, मेमोरी, स्टोरेज, इनपुट/आउटपुट उपकरण।
- ऑपरेटिंग सिस्टम: हार्डवेयर को प्रोग्रामों में बाँटता है।
- एप्लिकेशन: तुम्हारे ऐप।
हर परत अपने नीचे की परत की बारीकियाँ छिपाती है। इसे अमूर्तन (abstraction) कहते हैं। इस पाठ में हम हार्डवेयर परत के अंदर देखेंगे।
वॉन न्यूमन मॉडल
1945 में जॉन वॉन न्यूमन ने एक डिज़ाइन बताया जिसे आज भी लगभग हर कंप्यूटर इस्तेमाल करता है। मुख्य विचार है संग्रहीत प्रोग्राम (stored program): प्रोग्राम के निर्देश और डेटा दोनों बाइनरी संख्याओं के रूप में एक ही मुख्य मेमोरी में रहते हैं।
मुख्य भाग
- CPU (सेंट्रल प्रोसेसिंग यूनिट): निर्देश चलाता है।
- मुख्य मेमोरी (RAM): नंबर वाले सेल; हर सेल का एक पता (address)।
- इनपुट और आउटपुट उपकरण।
बसें
- पता बस: किस सेल से काम है, उसका पता (सिर्फ़ CPU → मेमोरी)।
- डेटा बस: डेटा या निर्देश (दोनों दिशाओं में)।
- कंट्रोल बस: "पढ़ो", "लिखो" और घड़ी जैसे संकेत।
निर्देश और डेटा एक ही बस बाँटते हैं, इसलिए CPU एक समय में एक ही चीज़ ला सकता है। इस रुकावट को वॉन न्यूमन बॉटलनेक कहते हैं।
CPU के अंदर: CU, ALU और रजिस्टर
- कंट्रोल यूनिट (CU): हर निर्देश को डिकोड करती है और बाक़ी हिस्सों को संकेत भेजती है।
- अंकगणितीय तर्क इकाई (ALU): जोड़-घटाव और तर्क (AND, OR, तुलना) करती है।
- रजिस्टर: CPU के अंदर बहुत छोटे, बहुत तेज़ भंडार।
| रजिस्टर | काम |
|---|---|
| PC (प्रोग्राम काउंटर) | अगले निर्देश का पता |
| MAR (मेमोरी एड्रेस रजिस्टर) | मेमोरी में इस्तेमाल होने वाला पता |
| MDR (मेमोरी डेटा रजिस्टर) | मेमोरी से अभी पढ़ा या लिखा जाने वाला डेटा |
| CIR (करंट इंस्ट्रक्शन रजिस्टर) | डिकोड हो रहा निर्देश |
| ACC (एक्यूमुलेटर) | ALU की ताज़ा गणना का परिणाम |
फ़ेच-डिकोड-एक्ज़िक्यूट चक्र
- फ़ेच: PC को MAR में कॉपी करो। पता बस पर पता और "पढ़ो" संकेत भेजो। निर्देश डेटा बस से MDR में आता है, फिर CIR में। PC में 1 जोड़ो।
- डिकोड: CU निर्देश को ऑपकोड (क्या करना है, जैसे ADD) और ऑपरेंड (किस पर, जैसे पता 6) में बाँटती है।
- एक्ज़िक्यूट: काम करो। मान लाओ, ALU से गणना करो, परिणाम रखो, या PC बदलकर नए पते पर कूदो।
फिर चक्र दोबारा शुरू, जब तक HALT न आए।
हल किया हुआ ट्रेस
मेमोरी: 0: LOAD 5, 1: ADD 6, 2: STORE 7, 3: HALT, 5: 12, 6: 30। चक्र 1 के बाद ACC = 12। चक्र 2 के बाद ACC = 42। चक्र 3 के बाद सेल 7 = 42। चक्र 4 प्रोग्राम रोक देता है।
CPU तेज़ कैसे होता है?
- क्लॉक स्पीड: हर सेकंड कितने चक्र, हर्ट्ज़ में। 3 GHz = हर सेकंड 3 अरब टिक। तेज़ घड़ी = ज़्यादा निर्देश, पर ज़्यादा गर्मी।
- कोर की संख्या: हर कोर एक पूरा प्रोसेसर है। क्वाड-कोर 4 काम एक साथ कर सकता है, पर तभी जब सॉफ़्टवेयर काम बाँट सके। दो कोर हमेशा दोगुने तेज़ नहीं।
- कैश: CPU के अंदर छोटी, बहुत तेज़ मेमोरी जो हाल में इस्तेमाल हुआ डेटा और निर्देश रखती है। ज़्यादा कैश = RAM तक कम धीमे चक्कर। स्तर: L1 (सबसे छोटा, सबसे तेज़), L2, L3।
मशीन भाषा और अलग-अलग डिज़ाइन
मशीन कोड और असेंबली
CPU सिर्फ़ मशीन कोड समझता है: बाइनरी निर्देश, जैसे 0001 0101 (ऑपकोड 0001 = LOAD, ऑपरेंड 0101 = 5)। असेंबली भाषा यही निर्देश LOAD 5 लिखती है, और असेंबलर इसे बाइनरी में बदलता है। हर CPU परिवार का अपना निर्देश समूह (instruction set) होता है।
आर्किटेक्चर में विविधता
- हार्वर्ड आर्किटेक्चर: निर्देश और डेटा के लिए अलग मेमोरी और बसें, तो दोनों एक साथ आ सकते हैं। कई माइक्रोकंट्रोलर और CPU कैश में।
- CISC: बहुत सारे ताक़तवर निर्देश, कुछ कई चक्र लेते हैं (ज़्यादातर लैपटॉप-डेस्कटॉप चिप)।
- RISC: कम और सरल निर्देश, अक्सर एक चक्र में, कम बिजली (ज़्यादातर फ़ोन चिप)।
- मल्टी-कोर और GPU: बहुत सारे कोर समानांतर, ग्राफ़िक्स और AI के लिए अच्छे।
एम्बेडेड सिस्टम
एम्बेडेड सिस्टम किसी बड़े उपकरण के अंदर एक ही काम करने वाला छोटा कंप्यूटर है: वॉशिंग मशीन, माइक्रोवेव, कार के ब्रेक, फ़िटनेस बैंड। ये सस्ते, छोटे, कम बिजली वाले होते हैं और इन्हें दोबारा प्रोग्राम करना मुश्किल होता है।
खुद करके देखो
दोस्त के साथ "इंसानी CPU" खेलो। 8 नंबर वाले कार्ड बनाओ: 0: LOAD 5, 1: ADD 6, 2: STORE 7, 3: HALT, 5: 7, 6: 9, 7: ख़ाली। एक व्यक्ति PC है और कार्ड की ओर इशारा करता है; दूसरा कार्ड लाता है, बोलकर पढ़ता है (डिकोड) और कैलकुलेटर से करता है (एक्ज़िक्यूट)। कार्ड 7 पर क्या आया? फिर 3D में सेल 5 = 7 और सेल 6 = 9 रखकर जाँचो।
मुख्य सूत्र और परिभाषाएँ
- संग्रहीत प्रोग्राम: निर्देश और डेटा एक ही मेमोरी में (वॉन न्यूमन)
- फ़ेच → डिकोड → एक्ज़िक्यूट → दोहराओ
- फ़ेच: MAR ← PC; MDR ← memory[MAR]; CIR ← MDR; PC ← PC + 1
- निर्देश = ऑपकोड (क्या करना) + ऑपरेंड (किस पर)
- 1 GHz = हर सेकंड 1,000,000,000 चक्र
- पता बस: एक दिशा (CPU → मेमोरी); डेटा बस: दोनों दिशा
हल किए गए उदाहरण
1. प्रोग्राम 0: LOAD 5, 1: ADD 6, 2: STORE 7, 3: HALT को सेल 5 = 12 और सेल 6 = 30 के साथ ट्रेस करो। हर चक्र के बाद PC और ACC बताओ।
चक्र 1: PC = 1, ACC = 12। चक्र 2: PC = 2, ACC = 42। चक्र 3: PC = 3, ACC = 42 और सेल 7 = 42। चक्र 4: PC = 4, HALT, प्रोग्राम रुकता है।
2. CPU 2.5 GHz पर चलता है। एक सेकंड में कितने चक्र?
2.5 × 10⁹ = 2,50,00,00,000 चक्र प्रति सेकंड।
3. 4 GHz CPU को औसतन हर निर्देश के लिए 2 चक्र चाहिए। एक कोर लगभग कितने निर्देश प्रति सेकंड चलाएगा?
4 × 10⁹ ÷ 2 = 2 × 10⁹ निर्देश प्रति सेकंड।
4. किसी गेम के लिए 2 GHz क्वाड-कोर, 2 GHz डुअल-कोर से दोगुना तेज़ क्यों नहीं हो सकता?
अतिरिक्त कोर तभी मदद करते हैं जब गेम का काम समानांतर हिस्सों में बँट सके। अगर ज़्यादातर काम एक के बाद एक होना है, तो दो कोर ख़ाली बैठे रहेंगे।
5. निर्देश 8 बिट का है: पहले 4 बिट ऑपकोड, आख़िरी 4 ऑपरेंड। कितने ऑपकोड और कितने पते संभव हैं?
4 बिट से 2⁴ = 16 ऑपकोड और 2⁴ = 16 पते (0 से 15)।
6. समझाओ कि 1,000 बार चलने वाले लूप को कैश तेज़ क्यों करता है।
पहली बार के बाद लूप के निर्देश और डेटा कैश में रहते हैं। बाक़ी 999 बार वे धीमी RAM की जगह तेज़ कैश से आते हैं, तो हर फ़ेच में बहुत कम समय लगता है।
आम गलतियाँ
- MAR और MDR में गड़बड़: MAR में पता (ADDRESS) होता है, MDR में उस पते का डेटा (DATA)।
- यह सोचना कि PC में मौजूदा निर्देश है। PC में अगले निर्देश का पता होता है; मौजूदा निर्देश CIR में।
- यह कहना कि पता बस दोनों दिशाओं में चलती है। सिर्फ़ डेटा बस दो-तरफ़ा है।
- यह मानना कि दोगुने कोर हमेशा दोगुनी गति देते हैं। तभी, जब काम समानांतर बँट सके।