🤟🏼 🎷 👩‍❤️‍💋‍👨 कंप्यूटर सिस्टम का आर्किटेक्चर 1 भाग। तर्क द्वार 🧗🏻 👩🏽‍🤝‍👩🏼 🎂

तार्किक तत्व

अच्छा दिन है, मैं गोलंग भाषा में एक आभासी मशीन लिखने पर लेखों की एक श्रृंखला शुरू कर रहा हूं। मैंने इस भाषा को चुना क्योंकि इसे पढ़ना आसान है और मानक पुस्तकालय में आवश्यक कार्य हैं जो भविष्य में काम आएंगे।

इस लेख में उन लोगों के लिए बिल्कुल कोई नई जानकारी नहीं है जो सरल लॉजिक गेट्स के लिए सत्य तालिकाओं का संकलन कर सकते हैं। यदि आप जानते हैं कि कैसे करना है, तो समय बर्बाद न करें और दूसरे भाग पर जाएं।

लॉजिक गेट एक उपकरण है जिसमें एक या अधिक इनपुट होते हैं और एक या अधिक आउटपुट होते हैं। इस भाग में हम उनमें से केवल सबसे सरल पर विचार करेंगे। मॉडलिंग गेट्स के लिए, हम वास्तविक गेट्स के इनपुट, आउटपुट विशेषताओं का उपयोग किए बिना केवल संकेतों 0 और 1 का उपयोग करेंगे।

चूंकि हम गोलंग के साथ काम करेंगे, प्रत्येक तत्व को एक फ़ंक्शन के रूप में दर्शाया जा सकता है।
Go में, फ़ंक्शन इस तरह दिखता है:

func (   )    {     //     return    }

बफर

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

एक	BUF ए
0	0
1	1

बफर के मामले में, हमारा कार्य इस तरह दिखेगा:

 func Buf(v bool) bool {    return v }

पलटनेवाला

एक ही बफर, केवल आउटपुट सिग्नल को निष्क्रिय करता है।

एक	नहीं है
0	1
1	0

पलटनेवाला के मामले में, फ़ंक्शन इस तरह दिखाई देगा:

 func Inv(v bool) bool {    return !v }

या

आउटपुट पर 1 प्राप्त करने के लिए इस तत्व को 1 के बराबर कम से कम एक सिग्नल की आवश्यकता होती है।

एक	ख	या एक बी
0	0	0
0	1	1
1	0	1
1	1	1

 func Or(v, s bool) bool {    return v || s }

और

यह हमेशा 1 रिटर्न देता है, जब 1 को इसके सभी इनपुट्स की आपूर्ति की जाती है, अन्य सभी मामलों में यह 0 देता है।

एक	ख	ए और बी
0	0	0
0	1	0
1	0	0
1	1	1

 func And(v, s bool) bool {    return v && s }

अनन्य या

आउटपुट पर 1 प्राप्त करने के लिए, यह आवश्यक है कि इनपुट पर विभिन्न संकेतों (0 और 1) या (1 और 0) को लागू किया जाए। यह ऑपरेशन उपयोगी है क्योंकि यह आपको अतिरिक्त मेमोरी का उपयोग किए बिना दो चर स्वैप करने की अनुमति देता है।

एक	ख	एक एक्सोर बी
0	0	0
0	1	1
1	0	1
1	1	0

 func Xor(v, s bool) bool { //  (v ^ s)    ,   bool     ,       return (v || s) && !(v && s) }

या नहीं

यह एक OR तत्व के रूप में काम करता है, केवल एक इन्वर्टर इसके आउटपुट से जुड़ा होता है, जहाँ से हमें सिग्नल मिलता है।

एक	ख	और न ही बी
0	0	1
0	1	0
1	0	0
1	1	0

 func Nor(v, s bool) bool {    return !(v || s) }

और नहीं

एलिमेंट एंड एलिमेंट की तरह ही काम करता है, केवल आउटपुट पर सिग्नल उलटा होता है।

एक	ख	एक नंद बी
0	0	1
0	1	1
1	0	1
1	1	0

 func Nand(v, s bool) bool {    return !(v && s) }

विशेष या उलटा के साथ

तत्व OR तत्व की तरह ही कार्य करता है, केवल संकेत आउटपुट पर उलटा होता है।

एक	ख	एक XNOR b
0	0	1
0	1	0
1	0	0
1	1	1

 func Xnor(v, s bool) bool { //       return !((v || s) && !(v && s)) }

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

कंप्यूटर सिस्टम का आर्किटेक्चर 1 भाग। तर्क द्वार