एक कुंजी दबाने से शुरुआत

आप कीबोर्ड पर ‘A’ अक्षर दबाते हैं।

1 मिलीसेकंड से भी कम समय में, वर्ण स्क्रीन पर प्रकट होता है।

सरल लगता है? वास्तव में, इस 1 मिलीसेकंड में, एक विद्युत संकेत कम से कम 6 परतों के अमूर्तन को पार करता है, दर्जनों हार्डवेयर घटकों से गुज़रता है, और इस “सरल” अंतःक्रिया को पूरा करने के लिए कई बसों को पार करता है।

कंप्यूटर का सार गणना नहीं, बल्कि अमूर्तन है।

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

आज, हम एक कुंजी दबाने के संकेत की पूरी यात्रा का अनुसरण करते हैं, यह देखते हुए कि कैसे कंप्यूटर, अमूर्तन की परत दर परत, एक भौतिक क्रिया को स्क्रीन पर एक वर्ण में बदलते हैं।

पहली परत: भौतिक संकेत से स्कैन कोड तक

आप जो दबाते हैं वह अक्षर नहीं, बल्कि एक स्विच है।

कीबोर्ड की प्रत्येक कुंजी के नीचे एक यांत्रिक स्विच होता है। जब आप ‘A’ कुंजी दबाते हैं, तो स्विच बंद हो जाता है और धारा प्रवाहित होती है। यह सबसे निचली भौतिक वास्तविकता है — केवल चालू और बंद, कोई ‘A’ नहीं।

कीबोर्ड नियंत्रक का काम इस भौतिक संकेत को उन संख्याओं में अनुवाद करना है जिन्हें कंप्यूटर समझ सके।

यह कैसे करता है?

मैट्रिक्स स्कैनिंग

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

एक शतरंज की बिसात की कल्पना करें, जिसमें पंक्ति रेखाएँ और स्तंभ रेखाएँ एक-दूसरे को काटती हैं। प्रत्येक कुंजी एक प्रतिच्छेदन बिंदु पर होती है। नियंत्रक तेज़ी से प्रत्येक पंक्ति को विद्युत प्रदान करता है और पता लगाता है कि प्रत्येक स्तंभ पर धारा है या नहीं। यदि पंक्ति 3 को विद्युत देने पर स्तंभ 5 धारा का पता लगाता है, तो इसका मतलब है कि पंक्ति 3, स्तंभ 5 वाली कुंजी दबाई गई है।

यहीं से स्कैन कोड आता है — एक संख्या जो कुंजी की स्थिति दर्शाती है।

‘A’ दबाने पर स्कैन कोड 0x1E आउटपुट हो सकता है। ‘A’ छोड़ने पर 0x9E आउटपुट होता है (“छोड़ना” दर्शाने वाला एक अतिरिक्त उच्च बिट)।

पहली परत पूर्ण: भौतिक क्रिया → डिजिटल एन्कोडिंग।

लेकिन यह अभी खत्म नहीं हुआ है। स्कैन कोड अभी भी कीबोर्ड के आंतरिक बफर में है, भेजे जाने की प्रतीक्षा कर रहा है।

दूसरी परत: I/O डिवाइस से मेमोरी तक

स्कैन कोड को CPU तक पहुँचने की आवश्यकता है, लेकिन CPU कीबोर्ड इनपुट की प्रतीक्षा में नहीं बैठ सकता।

CPU प्रति सेकंड अरबों संचालन की गति से चलता है; कीबोर्ड इनपुट प्रति सेकंड दर्जनों इनपुट की गति से आता है। यदि CPU प्रत्येक निर्देश से पहले “क्या कीबोर्ड इनपुट है?” जाँच करता, तो उसका 99.9999% समय बर्बाद हो जाता।

समाधान क्या है? इंटरप्ट तंत्र।

इंटरप्ट: “तैयार हो तो मुझे कॉल करें” का हार्डवेयर संस्करण

इंटरप्ट का डिज़ाइन दर्शन रोज़मर्रा की ज़िंदगी को दर्शाता है: आप डिलीवरी ड्राइवर को हर 5 मिनट में कॉल करके नहीं पूछते “क्या मेरा पैकेज आ गया?” बजाय इसके, ड्राइवर के आने पर वह आपको कॉल करता है।

कीबोर्ड नियंत्रक द्वारा स्कैन कोड उत्पन्न करने के बाद, वह CPU को एक इंटरप्ट अनुरोध (IRQ) संकेत भेजता है।

यह संकेत इंटरप्ट नियंत्रक (8259A या इसके आधुनिक समतुल्य) से गुज़रता है और इसे एक इंटरप्ट नंबर आवंटित किया जाता है। कीबोर्ड सामान्यतः IRQ1, इंटरप्ट नंबर 0x21 होता है।

प्रत्येक निर्देश को निष्पादित करने के बाद, CPU इंटरप्ट संकेतों की जाँच करता है। यदि कोई है, तो वह अपना वर्तमान काम रोक देता है और इंटरप्ट को संभालता है।

इंटरप्ट वेक्टर तालिका

CPU कैसे जानता है कि कीबोर्ड इंटरप्ट को कैसे संभालना है?

मेमोरी में एक इंटरप्ट वेक्टर तालिका (Interrupt Vector Table) होती है जो प्रत्येक इंटरप्ट नंबर के लिए हैंडलर रूटीन का पता संग्रहीत करती है। यह एक फोनबुक की तरह है: इंटरप्ट नंबर 0x21 कीबोर्ड हैंडलर के पते से मेल खाता है।

जब CPU को कीबोर्ड इंटरप्ट प्राप्त होता है:

1. वर्तमान प्रोग्राम काउंटर (PC), स्थिति रजिस्टर आदि को स्टैक पर पुश करता है
2. इंटरप्ट नंबर का उपयोग करके तालिका में हैंडलर का पता ढूँढता है
3. हैंडलर पर जाकर उसे निष्पादित करता है

कीबोर्ड हैंडलर I/O पोर्ट (सामान्यतः 0x60) के माध्यम से स्कैन कोड पढ़ता है, फिर उसे मेमोरी में कीबोर्ड बफर में संग्रहीत करता है।

दूसरी परत पूर्ण: I/O घटना → मेमोरी में डेटा।

अब स्कैन कोड सुरक्षित रूप से मेमोरी में है। लेकिन यह अभी भी एक स्कैन कोड है, वर्ण ‘A’ नहीं।

तीसरी परत: स्कैन कोड से वर्ण तक

स्कैन कोड 0x1E “कीबोर्ड पर A कुंजी की स्थिति” दर्शाता है, वर्ण ‘A’ नहीं।

क्यों? क्योंकि एक ही कुंजी विभिन्न देशों के कीबोर्ड पर अलग-अलग वर्ण दर्शा सकती है। अमेरिकी इसे दबाते हैं और ‘A’ पाते हैं; फ्रांसीसी इसे दबाते हैं और ‘Q’ पाते हैं (उनका कीबोर्ड लेआउट अलग है)।

स्कैन कोड को वर्णों में बदलने की ज़िम्मेदारी ऑपरेटिंग सिस्टम की है।

इनपुट सबसिस्टम

आधुनिक ऑपरेटिंग सिस्टम में सभी के पास एक इनपुट सबसिस्टम (Input Subsystem) होता है, जो निम्नलिखित कार्य करता है:

1. कर्नेल बफर से स्कैन कोड पढ़ना
2. वर्तमान कीबोर्ड लेआउट के आधार पर उन्हें वर्णों में बदलना
3. संशोधक कुंजियों को संभालना (Shift+A = बड़ा ‘A’, Ctrl+C = कॉपी कमांड)
4. वर्तमान सक्रिय विंडो को वर्ण वितरित करना

इस रूपांतरण में कीबोर्ड लेआउट मैपिंग तालिका शामिल है। Windows रजिस्ट्री में HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layouts है, जो विभिन्न भाषाओं के लिए मैपिंग संग्रहीत करता है।

रूपांतरण के बाद, वर्ण ‘A’ को एक संदेश कतार में रखा जाता है, जो एप्लिकेशन द्वारा पढ़े जाने की प्रतीक्षा करता है।

तीसरी परत पूर्ण: हार्डवेयर-निर्भर एन्कोडिंग → एकीकृत वर्ण एन्कोडिंग।

चौथी परत: वर्ण से पिक्सेल तक

एप्लिकेशन को वर्ण ‘A’ प्राप्त होता है और उसे इसे स्क्रीन पर प्रदर्शित करने की आवश्यकता होती है।

लेकिन आप जो देखते हैं वह वर्ण नहीं — बल्कि पिक्सेल हैं।

एक मॉनिटर केवल पिक्सेल समझता है — प्रत्येक बिंदु किस रंग का है। वर्ण ‘A’ पिक्सेल के एक सेट से बना एक पैटर्न है, जो एक फ़ॉन्ट फ़ाइल में संग्रहीत है।

फ़ॉन्ट रेंडरिंग

जब आप ‘A’ टाइप करते हैं, तो एप्लिकेशन:

1. फ़ॉन्ट फ़ाइल ढूँढ़ेगा (जैसे Microsoft YaHei, SimSun)
2. ‘A’ के लिए ग्लिफ़ विवरण (वेक्टर कर्व या बिटमैप) प्राप्त करेगा
3. फ़ॉन्ट आकार के अनुसार ग्लिफ़ को स्केल करेगा
4. रैस्टराइज़ करेगा: वेक्टर कर्व को पिक्सेल ग्रिड में बदलेगा
5. किनारों को चिकना बनाने के लिए एंटी-अलियासिंग लागू करेगा

ये पिक्सेल डेटा वीडियो मेमोरी (VRAM) — ग्राफ़िक्स कार्ड पर मेमोरी — में लिखे जाते हैं।

VRAM से स्क्रीन तक

ग्राफ़िक्स कार्ड पर डिस्प्ले नियंत्रक प्रति सेकंड 60 बार (60Hz) की दर से VRAM से डेटा पढ़ता है, उसे वीडियो सिग्नल में बदलता है, और मॉनिटर को भेजता है।

मॉनिटर सिग्नल प्राप्त करता है, प्रत्येक पिक्सेल के रंग को नियंत्रित करता है, और आप वर्ण ‘A’ देखते हैं।

चौथी परत पूर्ण: वर्ण एन्कोडिंग → पिक्सेल मैट्रिक्स।

पाँचवीं परत: CPU इन निर्देशों को कैसे निष्पादित करता है

ऊपर उल्लिखित सभी संचालन — स्कैनिंग, इंटरप्ट, रूपांतरण, रेंडरिंग — अंततः CPU द्वारा निष्पादित किए जाने चाहिए।

CPU निर्देशों को कैसे निष्पादित करता है?

निर्देश चक्र: फ़ेच-डिकोड-एक्ज़ीक्यूट

एक निर्देश को निष्पादित करने में तीन चरण होते हैं:

1. फ़ेच (Fetch)

   • प्रोग्राम काउंटर (PC) अगले निर्देश का पता संग्रहीत करता है
   • पता मेमोरी को भेजता है, निर्देश प्राप्त करता है
   • निर्देश को निर्देश रजिस्टर (IR) में संग्रहीत करता है

2. डिकोड (Decode)

   • नियंत्रण इकाई निर्देश के ऑपकोड का विश्लेषण करती है
   • निर्धारित करती है कि कौन सा संचालन करना है (जोड़? लोड? जंप?)
   • निर्धारित करती है कि ऑपरेंड कहाँ हैं

3. एक्ज़ीक्यूट (Execute)

   • अंकगणित तर्क इकाई (ALU) गणना करती है
   • या डेटा पढ़ने/लिखने के लिए मेमोरी तक पहुँचती है
   • प्रोग्राम काउंटर को अपडेट करती है

फिर दोहराता है।

एक उदाहरण

मान लीजिए CPU को ADD R1, R2, R3 निष्पादित करने की आवश्यकता है (R2 और R3 के मान जोड़ें, R1 में संग्रहीत करें):

1. फ़ेच: मेमोरी से इस निर्देश का मशीन कोड पढ़ें
2. डिकोड: इसे जोड़ निर्देश के रूप में पहचानें, ऑपरेंड R2 और R3 में हैं
3. एक्ज़ीक्यूट: ALU R2 और R3 के मानों को योजक को भेजता है, परिणाम R1 में लिखता है

प्रत्येक निर्देश नैनोसेकंड में पूरा होता है।

पाँचवीं परत पूर्ण: उच्च-स्तरीय भाषा → मशीन निर्देश → विद्युत संकेत।

अमूर्तन की कीमत

अमूर्तन मुफ्त नहीं है।

अमूर्तन की प्रत्येक परत प्रदर्शन ओवरहेड के साथ आती है:

• कीबोर्ड स्कैनिंग: कुछ माइक्रोसेकंड
• इंटरप्ट हैंडलिंग: दर्जनों माइक्रोसेकंड
• OS रूपांतरण: सैकड़ों माइक्रोसेकंड
• फ़ॉन्ट रेंडरिंग: कुछ मिलीसेकंड
• VRAM लेखन: कुछ माइक्रोसेकंड

ये सब मिलकर “इनपुट लैग” (input lag) बनाते हैं जिसे आप अनुभव करते हैं, आमतौर पर 10 से 50 मिलीसेकंड के बीच।

एक सामान्य व्यक्ति के लिए, यह विलंब नगण्य है। लेकिन eSports खिलाड़ियों के लिए, यह जीवन और मृत्यु का अंतर है। यही कारण है कि वे यांत्रिक कीबोर्ड (तेज़ एक्ट्यूएशन), उच्च रिफ़्रेश दर वाले मॉनिटर (144Hz+), और वायर्ड कनेक्शन (वायरलेस अतिरिक्त विलंब जोड़ता है) का उपयोग करते हैं।

एक बात याद रखें

कंप्यूटर का सार अमूर्तन है: जटिलता को एन्कैप्सुलेट करें, केवल एक सरल इंटरफ़ेस प्रकट करें।

एक कुंजी दबाने के संकेत की यात्रा:

भौतिक स्विच → स्कैन कोड → इंटरप्ट → मेमोरी बफर → वर्ण एन्कोडिंग → संदेश कतार → फ़ॉन्ट रेंडरिंग → VRAM → पिक्सेल

प्रत्येक परत केवल एक काम करती है: नीचे की परत से सरलीकृत आउटपुट प्राप्त करना, उसे संसाधित करना, और ऊपर की परत को एक सरलीकृत इंटरफ़ेस प्रदान करना।

यह स्तरित अमूर्तन ही है जो मनुष्यों को अविश्वसनीय रूप से जटिल कंप्यूटर सिस्टम में महारत हासिल करने में सक्षम बनाता है।

प्रोग्रामर को यह जानने की आवश्यकता नहीं है कि कीबोर्ड स्कैनिंग कैसे काम करती है — उन्हें केवल getchar() का रिटर्न मान पढ़ने की आवश्यकता है।

प्रोग्रामर को यह जानने की आवश्यकता नहीं है कि ग्राफ़िक्स कार्ड कैसे रेंडर करता है — उन्हें केवल DrawText() फ़ंक्शन को कॉल करने की आवश्यकता है।

अमूर्तन की शक्ति जटिलता को प्रबंधनीय बनाना है।