ब्रेंट-कुंग योजक 1982 में ह्सियांग ते कुंग और रिचर्ड पीयर्स ब्रेंट द्वारा प्रस्तावित किया गया था। यह एक पैरेलल प्रीफ़िक्स एडर या ट्री एडर है जो अपने लचीलेपन के कारण डिजिटल डिज़ाइन में व्यापक रूप से उपयोग किया जाता है। तर्क स्तरों की संख्या के आधार पर समानांतर उपसर्ग योजक कई तरीकों से बनाए जा सकते हैं, तर्क द्वार इसमें प्रत्येक गेट से पंखे की निकासी और स्तरों के बीच में वायरिंग शामिल है। विभिन्न प्रकार के ट्री एडर उपलब्ध हैं, मूल ट्री एडर स्क्लान्स्कीम कोगेस्टोन और ब्रेंट-कुंग हैं, केएसए (कोगगे-स्टोन एडर) की तुलना में, यह एडर एडर की संरचना को उच्च नियमितता प्रदान करता है और इसमें कम वायरिंग अवरोधन होता है। जिससे बेहतर प्रदर्शन और कम आवश्यक चिप क्षेत्र प्राप्त होता है। यह आलेख एक पर संक्षिप्त जानकारी प्रदान करता है ब्रेंट कुंग अडर .
ब्रेंट कुंग अडर क्या है?
एक योजक जो परिणाम प्राप्त करने के लिए न्यूनतम सर्किटरी का उपयोग करता है उसे ब्रेंट कुंग योजक के रूप में जाना जाता है और इसे कम-शक्ति योजक या समानांतर योजक के रूप में भी जाना जाता है। इस योजक का उद्देश्य चिप के आकार को बचाना है ताकि इन योजकों का निर्माण आसान हो जाए। इस योजक की समरूपता और सामान्य निर्माण संरचना से उत्पादन लागत में काफी कमी आएगी और पाइपलाइन टोपोलॉजी में उपयोग करने की अनुमति है। पूरक पास ट्रांजिस्टर लॉजिक का उपयोग डिज़ाइन प्रदर्शन को बढ़ाने में मदद करता है बहुसंकेतक विभिन्न सेल डिज़ाइन में दृष्टिकोण।
ब्रेंट कुंग एडर सर्किट
ब्रेंट-कुंग समानांतर उपसर्ग योजक आरेख नीचे दिखाया गया है जिसमें चरण 1 (पूर्व-प्रसंस्करण चरण), चरण 2 से 7 कैरी जनरेशन चरण हैं और चरण 8 पोस्ट-प्रोसेसिंग शामिल है। यह एक उन्नत वास्तुकला है और इसे बनाना बहुत आसान है और यह तारों की कम भीड़भाड़ प्रदान करता है। इसलिए, इसकी कम वायरिंग से आर्किटेक्चर को निष्पादित करने के लिए आवश्यक स्थान की मात्रा कम हो जाएगी। इसके अलावा, कम तारों के क्रॉसिंग (या) ओवरलैपिंग के कारण रूटिंग बहुत आसान हो जाती है। हालाँकि, चरणों की संख्या बढ़ने के कारण देरी पर जुर्माना बढ़ जाएगा, इस योजक के लिए फैन आउट बढ़ जाएगा, और फिर देरी बढ़ जाएगी।
ब्रेंट कुंग एडर कैसे काम करता है?
ब्रेंट कुंग एडर दो बिट समूहों के लिए उपसर्गों की गणना करके काम करता है जो 4 बिट समूह उपसर्गों को खोजने में उपयोगी होते हैं। इन उपसर्गों का उपयोग 8-बिट समूह के उपसर्गों आदि की गणना के लिए किया जाता है। उसके बाद, इन उपसर्गों का उपयोग विशिष्ट बिट चरण के कैरी-आउट की गणना के लिए किया जाएगा। इन कैरीज़ का उपयोग अगले चरण के ग्रुप प्रोपेगेट के साथ उस चरण के सम बिट की गणना करने के लिए किया जाता है। ब्रेंट कुंग ट्री 2log2N - 1 चरण का उपयोग करता है।
32-बिट ब्रेंट कुंग एडर
32-बिट ब्रेंट कुंग योजक लेआउट नीचे दिखाया गया है। इस लेआउट की शुरुआत में, बुनियादी लॉजिक गेट्स को NAND, इन्वर्टर, XOR, NOR, आदि जैसे डिज़ाइन किया गया है। उसके बाद, ब्लैक सेल, ग्रे सेल, बफ़र्स और PG लॉजिक जैसे आवश्यक सेल को लॉजिक गेट्स के साथ डिज़ाइन किया गया है।
नीचे दिए गए 32-बिट ब्रेंट कुंग योजक में, एओआई और ओएआई जैसे इनवर्टिंग गेट्स का उपयोग वैकल्पिक रूप से मुख्य रूप से ग्रे और ब्लैक सेल के लिए किया जाता है। तो काले और भूरे कोशिकाओं को भूरे और काले ब्लॉकों के साथ दर्शाया जाता है जबकि बफ़र्स को हलकों के साथ दर्शाया जाता है।
ए और बी जैसे इनपुट पीजी लॉजिक को प्रदान किए जाते हैं जो ब्लॉक आरेख में दिखाया गया है। 32-बिट योजक के लिए, 32 पीजी लॉजिक ब्लॉक आवश्यक हैं और प्रोपेगेट (पी) और जेनरेट (जी) सिग्नल इस ब्लॉक के आउटपुट हैं। ये सिग्नल ब्रेंट कुंग योजक वृक्ष संरचना को प्रदान किए जाते हैं। इस योजक की संरचना में ग्रे कोशिकाएँ और काली कोशिकाएँ शामिल हैं।
एक ग्रे सेल में तीन इनपुट और एकल आउटपुट शामिल होते हैं। वर्तमान चरण से सिग्नल प्रसारित करना और उत्पन्न करना और पिछले चरण से सिग्नल उत्पन्न करना इनपुट है जबकि समूह द्वारा सिग्नल उत्पन्न करना ओ/पी है। किसी भी वृक्ष संरचना में, प्रत्येक चरण एक ग्रे सेल के साथ समाप्त होगा और इस सेल का संचालन समूह द्वारा उत्पन्न सिग्नल है। इस सिग्नल को बस उस चरण का वाहक माना जाता है। ब्लैक सेल में चार इनपुट और दो आउटपुट शामिल हैं। इस सेल के लिए इनपुट वर्तमान चरण के पी एंड जी सिग्नल और पिछले चरण के पी, जी सिग्नल हैं।
पीजी लॉजिक में AND और XOR गेट शामिल होते हैं जहां AND लॉजिक गेट का उपयोग G सिग्नल उत्पन्न करने के लिए किया जाता है और XOR लॉजिक गेट P सिग्नल प्रदान करता है। अनावश्यक इनवर्टर को ख़त्म करने के लिए दो प्रकार की ग्रे सेल और ब्लैक सेल का उपयोग किया जाता है। ग्रे सेल के लिए एक पंक्ति में उपयोग किए जाने वाले इनवर्टिंग गेट AOI या AND-OR-इन्वर्टर हैं और अगली पंक्ति के भीतर ब्लैक सेल के लिए इनवर्टिंग गेट OAI या OR-AND-इन्वर्टर का उपयोग करते हैं। AOI सेल उल्टे आउटपुट प्रदान करने के लिए सामान्य इनपुट का उपयोग करता है जबकि OAI सामान्य आउटपुट प्रदान करने के लिए उल्टे इनपुट का उपयोग करता है।
ब्रेंट कुंग एडर ऑपरेशन
ब्रेंट कुंग योजक एक समानांतर उपसर्ग योजक है जिसका उपयोग उच्च-प्रदर्शन जोड़ के संचालन के लिए किया जाता है। यह योजक एक वृक्ष संरचना की तरह दिखता है जो अंकगणितीय ऑपरेशन करता है। इस योजक में काली कोशिकाएँ और धूसर कोशिकाएँ शामिल हैं। प्रत्येक ब्लैक सेल में दो AND गेट और सिंगल OR गेट होते हैं और प्रत्येक ग्रे सेल में केवल एक AND गेट होता है।
ब्रेंट-कुंग योजक में दो चरण शामिल हैं; पूर्व-प्रसंस्करण चरण और उत्पादन चरण। पहले चरण में, प्रत्येक जोड़ी इनपुट से उत्पन्न और प्रचारित किया जाएगा। यहां प्रोपेगेट इनपुट बिट्स के लिए 'XOR' ऑपरेशन प्रदान करता है जबकि जनरेट इनपुट बिट्स के लिए 'AND' ऑपरेशन प्रदान करता है। 'Pi' और 'Gi' जैसे प्रचार और उत्पादन नीचे दिए गए हैं।
पाई = ऐ XOR Bi और Gi = ऐ और Bi।
दूसरे चरण में, प्रत्येक बिट के लिए कैरी उत्पन्न की जाएगी जिसे कैरी जनरेट 'सीजी' के रूप में जाना जाता है और प्रत्येक बिट के लिए कैरी को प्रसारित किया जाता है जिसे कैरी जेनरेट 'सीपी' के रूप में जाना जाता है। आगे के संचालन के लिए, कैरी प्रोपेगेट और कैरी जनरेट उत्पन्न किया जाएगा। प्रत्येक बिट फ़ंक्शन के भीतर उपलब्ध अंतिम सेल कैरी प्रदान करता है। तो अंतिम बिट कैरी अगले बिट को अंतिम बिट तक समवर्ती रूप से जोड़ने में सहायता करेगा। कैरी जनरेट और प्रोपेगेंडा इस प्रकार दिया गया है;
सीपी = पी1 और पी0 और सीजी=जी1 या (पी1 और जी0)
इसका उपयोग मुख्य रूप से दो बत्तीस बिट्स के अतिरिक्त संचालन के लिए किया जाता है और प्रत्येक बिट प्रीप्रोसेसिंग चरण और पीढ़ी चरण का अनुभव करता है फिर यह अंतिम योग प्रदान करता है।
प्राथमिक इनपुट बिट्स प्री-प्रोसेसिंग चरण से नीचे जाते हैं और वे प्रचारित और उत्पन्न करते हैं। तो ये प्रचार के साथ-साथ जनरेशन चरण से गुजरते हैं, कैरी जनरेट करते हैं और कैरी प्रचार करते हैं और अंतिम राशि प्रदान करते हैं। ब्रेंट-कुंग योजक चरण-दर-चरण प्रक्रिया नीचे दिखाई गई है।
ब्रेंट-कुंग योजक व्यवस्था एक वृक्ष संरचना की तरह दिखती है और यह उच्च गति योजक है जो गेट-स्तरीय तर्क पर लक्ष्य करती है। इस योजक को लॉजिक गेट्स की संख्या में कमी के साथ डिज़ाइन किया जा सकता है। इस प्रकार, यह इस आर्किटेक्चर में उपयोग की जाने वाली देरी और मेमोरी को कम करता है।
ब्रेंट कुंग एडर वेरिलॉग कोड
ब्रेंट कुंग एडर वेरिलॉग कोड नीचे दिखाया गया है।
`इनपुट आकार 64 को परिभाषित करें // इनपुट आकार एन सेट करें
`समूह आकार 8 को परिभाषित करें // समूह का आकार निर्धारित करें = 1, 2, 4 या 8
मॉड्यूल ब्रेंट_कुंग_एडर (ए, बी, एस);
इनपुट [`इनपुट आकार - 1:0] ए;
इनपुट [`इनपुट आकार - 1:0] बी;
आउटपुट [`इनपुट आकार:0] एस;
तार [`इनपुट आकार /` समूह आकार * 2 - 1:0] r_temp;
तार [`इनपुट आकार /` समूह आकार * 2 - 1:0] आर;
तार [`इनपुट आकार/`समूह आकार:0] सिन;
तार [`इनपुट आकार /` समूह आकार * 2 - 1:0] क्यू;
cin[0] = 1'b0 असाइन करें;
उत्पन्न
कहाँ पर;
(i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) के लिए प्रारंभ करें: समानांतर_FA_CLA_prefix
समूह_क्यू_पीढ़ी #(.समूह आकार(`समूह आकार))
एफ(
.a(ए[`समूह आकार * (i + 1) - 1:`समूह आकार * i]),
.बी(बी[`ग्रुपसाइज * (आई + 1) - 1:`ग्रुपसाइज * आई]),
.cin(cin[i]),
.s(एस[`समूह आकार * (i + 1) - 1:`समूह आकार * i]),
.qg(q[i * 2 + 1:i * 2])
);
अंत
समानांतर_उपसर्ग_वृक्ष_पहला_आधा #(.वृक्ष आकार(`इनपुट आकार /` समूह आकार))
टी1(
.q(q[`इनपुटसाइज /`ग्रुपसाइज * 2 - 1:0]),
.r(r_temp[`इनपुटसाइज /`ग्रुपसाइज * 2 - 1:0])
);
समानांतर_उपसर्ग_वृक्ष_दूसरा_आधा #(.वृक्ष आकार(`इनपुट आकार /` समूह आकार))
टी2(
.q(r_temp[`इनपुटसाइज /`ग्रुपसाइज * 2 - 1:0]),
.r(r[`इनपुटसाइज /`ग्रुपसाइज * 2 - 1:0])
);
(i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) के लिए प्रारंभ करें: cin_generation
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1'b0),
.cin(cin[i + 1])
);
अंत
एस[`इनपुटसाइज] = सीन[`इनपुटसाइज / `ग्रुपसाइज] असाइन करें;
अंतउत्पन्न
एंडमॉड्यूल
// समानांतर उपसर्ग वृक्ष का पहला भाग
मॉड्यूल पैरेलल_प्रीफिक्स_ट्री_फर्स्ट_हाफ #(पैरामीटर ट्रीसाइज = `इनपुटसाइज /`ग्रुपसाइज)(क्यू, आर);
इनपुट [वृक्ष आकार * 2 - 1:0] क्यू;
आउटपुट [ट्रीसाइज़ * 2 - 1:0] आर;
उत्पन्न
कहाँ पर;
यदि (वृक्ष आकार == 2) प्रारंभ: trivial_case
r[1:0] = q[1:0] असाइन करें;
उपसर्ग_तर्क f(
.ql(q[1:0]),
.qh(q[3:2]),
.r(r[3:2])
);
अंत अन्यथा प्रारंभ: recursive_case
तार [पेड़ का आकार * 2 - 1:0] r_temp;
समानांतर_उपसर्ग_वृक्ष_पहला_आधा #(.वृक्ष आकार(वृक्ष आकार / 2))
प्रत्यावर्तन_lsbh(
.q(q[पेड़ का आकार - 1:0]),
.r(r_temp[पेड़ का आकार - 1:0])
);
समानांतर_उपसर्ग_वृक्ष_पहला_आधा #(.वृक्ष आकार(वृक्ष आकार / 2))
रिकर्सन_एमएसबीएच(
.q(q[वृक्ष आकार * 2 - 1: वृक्ष आकार]),
.r(r_temp[वृक्ष आकार * 2 - 1: वृक्ष आकार])
);
(i = 0; i < वृक्ष आकार * 2; i = i + 2) के लिए प्रारंभ करें: समानांतर_स्टिच_अप
यदि (i != ट्रीसाइज़ * 2 - 2) प्रारंभ करें: समानांतर_स्टिच_अप_पास
r[i + 1:i] = r_temp[i + 1:i] असाइन करें;
अंत अन्यथा प्रारंभ: समानांतर_सिलाई_अप_उत्पादन
उपसर्ग_तर्क f(
.ql(r_temp[पेड़ का आकार - 1: पेड़ का आकार - 2]),
.qh(r_temp[वृक्ष आकार * 2 - 1: वृक्ष आकार * 2 - 2]),
.r(r[पेड़ का आकार * 2 - 1: पेड़ का आकार * 2 - 2])
);
अंत
अंत
अंत
अंतउत्पन्न
एंडमॉड्यूल
// समानांतर उपसर्ग वृक्ष का दूसरा भाग
मॉड्यूल पैरेलल_प्रीफिक्स_ट्री_सेकेंड_हाफ #(पैरामीटर ट्रीसाइज = `इनपुटसाइज /`ग्रुपसाइज)(क्यू, आर);
इनपुट [वृक्ष आकार * 2 - 1:0] क्यू;
आउटपुट [ट्रीसाइज़ * 2 - 1:0] आर;
तार [पेड़ का आकार * 2 * ($clog2(पेड़ का आकार) - 1) - 1:0] r_temp;
r_temp[वृक्ष आकार * 2 – 1:0] = q[वृक्ष आकार * 2 – 1:0] असाइन करें;
उत्पन्न
जेनवर आई, जे;
(i = 0; i < $clog2(Treesize) - 2; i = i + 1) के लिए प्रारंभ: दूसरा_आधा_स्तर
r_temp असाइन करें[ट्रीसाइज * 2 * (आई + 1) + ((ट्रीसाइज / (2 ** आई)) - 1 - 2 ** ($क्लॉग2(ट्रीसाइज / 4) - आई)) * 2 - 1:ट्रीसाइज * 2 * (i + 1)] = r_temp[पेड़ का आकार * 2 * i + ((पेड़ का आकार / (2 ** i)) - 1 - 2 ** ($clog2(पेड़ का आकार / 4) - i)) * 2 - 1: वृक्षआकार * 2 * i];
के लिए (j = (वृक्ष आकार / (2 ** i)) – 1 – 2 ** ($clog2(वृक्ष आकार / 4) – i); j < वृक्ष आकार; j = j + 2 ** ($clog2(वृक्ष आकार / 2) ) - i)) प्रारंभ: सेकंड_हाफ_लेवल_लॉजिक
उपसर्ग_तर्क f(
.ql(r_temp[Treesize * 2 * i + (j – 2 ** ($clog2(Treesize / 4) – i)) * 2 + 1:Treesize * 2 * i + (j – 2 ** ($clog2( वृक्षआकार / 4) – i)) * 2]),
.qh(r_temp[वृक्ष आकार * 2 * i + j * 2 + 1: वृक्ष आकार * 2 * i + j * 2]),
.r(r_temp[पेड़ का आकार * 2 * (i + 1) + j * 2 + 1: पेड़ का आकार * 2 * (i + 1) + j * 2])
);
यदि (j != वृक्ष आकार - 1 - 2 ** ($clog2(वृक्ष आकार / 4) - i)) प्रारंभ: सेकंड_हाफ_लेवल_डायरेक्ट_कनेक्ट
r_temp असाइन करें[ट्रीसाइज़ * 2 * (i + 1) + (j + 2 ** ($clog2(ट्रीसाइज़ / 2) - i)) * 2 - 1: ट्रीसाइज़ * 2 * (i + 1) + j * 2 + 2] = r_temp[वृक्ष आकार * 2 * i + (j + 2 ** ($clog2(वृक्ष आकार / 2) – i)) * 2 – 1: वृक्ष आकार * 2 * i + j * 2 + 2];
अंत
अंत
r_temp असाइन करें[Treesize * 2 * (i + 2) – 1:Treesize * 2 * (i + 2) – (2 ** ($clog2(Treesize / 4) – i)) * 2] = r_temp[Treesize * 2 * (i + 1) – 1: वृक्ष आकार * 2 * (i + 1) – (2 ** ($clog2( वृक्ष आकार / 4) – i)) * 2];
अंत
r[1:0] = r_temp[ट्रीसाइज * 2 * ($clog2(ट्रीसाइज) – 2) + 1:ट्रीसाइज * 2 * ($clog2(ट्रीसाइज) – 2)] असाइन करें;
(i = 1; i < वृक्ष आकार; i = i + 2) के लिए प्रारंभ करें: अंतिम_r_odd
r[i * 2 + 1:i * 2] = r_temp[वृक्ष आकार * 2 * ($clog2(वृक्ष आकार) – 2) + i * 2 + 1: वृक्ष आकार * 2 * ($clog2(वृक्ष आकार) – 2) + असाइन करें मैं*2];
अंत
(i = 2; i < वृक्ष आकार; i = i + 2) के लिए प्रारंभ करें: अंतिम_r_सम
उपसर्ग_तर्क f(
.ql(r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 – 1:Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 – 2]),
.qh(r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesize) – 2) + i * 2]),
.r(r[i * 2 + 1:i * 2])
);
अंत
अंतउत्पन्न
एंडमॉड्यूल
मॉड्यूल ग्रुप_क्यू_जेनरेशन #(पैरामीटर ग्रुपसाइज = `ग्रुपसाइज)(ए, बी, सीन, एस, क्यूजी);
इनपुट [समूह आकार - 1:0] ए;
इनपुट [समूह आकार - 1:0] बी;
इनपुट सीन;
आउटपुट [समूह आकार - 1:0] एस;
आउटपुट [1:0] क्यूजी;
तार [2 * समूह आकार - 1:0] क्यू;
तार [समूह आकार - 1:0] सी;
असाइन करें c[0] = cin;
उत्पन्न
कहाँ पर;
(i = 0; i < समूह आकार; i = i + 1) के लिए प्रारंभ करें: समानांतर_FA_CLA_prefix
FA_CLA_उपसर्ग f(
.a(a[i]),
.बी(बी[आई]),
.cin(c[i]),
.s(s[i]),
.q(q[i * 2 + 1:i * 2])
);
यदि (i != समूह आकार - 1) प्रारंभ करें: विशेष_केस
c[i + 1] = q[i * 2 + 1] | असाइन करें (क्यू[आई * 2] और सी[आई]);
अंत
अंत
//समूह आकार के आधार पर समूह क्यू पीढ़ी
यदि (समूह आकार == 1) प्रारंभ करें: केस_जीएस1
qg[1] = q[1] असाइन करें;
qg[0] = q[0] असाइन करें;
समाप्त करें अन्यथा यदि (समूह आकार == 2) प्रारंभ करें: केस_जीएस2
qg[1] = q[3] | असाइन करें (क्यू[1] और क्यू[2]);
qg[0] = q[2] और q[0] असाइन करें;
समाप्त करें अन्यथा यदि (समूह आकार == 4) प्रारंभ करें: केस_जीएस4
qg[1] = q[7] | असाइन करें (क्यू[5] और क्यू[6]) | (क्यू[3] और क्यू[6] और क्यू[4]) | (क्यू[1] और क्यू[6] और क्यू[4] और क्यू[2]);
qg[0] = q[6] और q[4] और q[2] और q[0] असाइन करें;
समाप्त करें अन्यथा यदि (समूह आकार == 8) प्रारंभ करें: केस_जीएस8
qg[1] = q[15] | असाइन करें (क्यू[13] और क्यू[14]) | (क्यू[11] और क्यू[14] और क्यू[12]) | (क्यू[9] और क्यू[14] और क्यू[12] और क्यू[10]) | (क्यू[7] और क्यू[14] और क्यू[12] और क्यू[10] और क्यू[8]) | (क्यू[5] और क्यू[14] और क्यू[12] और क्यू[10] और क्यू[8] और क्यू[6]) | (क्यू[3] और क्यू[14] और क्यू[12] और क्यू[10] और क्यू[8] और क्यू[6] और क्यू[4]) | (क्यू[1] और क्यू[14] और क्यू[12] और क्यू[10] और क्यू[8] और क्यू[6] और क्यू[4] और क्यू[2]);
qg[0] = q[14] और q[12] और q[10] और q[8] और q[6] और q[4] और q[2] और q[0] असाइन करें;
अंत
अंतउत्पन्न
एंडमॉड्यूल
// सिने पीढ़ी तर्क
मॉड्यूल cin_generation_logic(r, c0, cin);
इनपुट [1:0] आर;
इनपुट c0;
आउटपुट सिने;
cin = (r[0] और c0) | असाइन करें आर[1];
एंडमॉड्यूल
// उपसर्ग संचालन के लिए बुनियादी तर्क
मॉड्यूल prefix_logic(ql, qh, r);
इनपुट [1:0] क्यूएल;
इनपुट [1:0] क्यूएच;
आउटपुट [1:0] आर;
r[0] = qh[0] और ql[0] असाइन करें;
r[1] = (qh[0] और ql[1]) | असाइन करें क्यूएच[1];
एंडमॉड्यूल
// कैरी लुक-अहेड के साथ पूर्ण एडर सेल
मॉड्यूल FA_CLA_prefix(a, b, cin, s, q);
इनपुट ए;
इनपुट बी;
इनपुट सीन;
आउटपुट एस;
आउटपुट [1:0] क्यू;
q[0] = a ^ b असाइन करें;
असाइन करें s = q[0] ^ cin;
q[1] = ए और बी असाइन करें;
एंडमॉड्यूल
लाभ
ब्रेंट कुंग एडर के फायदों में निम्नलिखित शामिल हैं।
- यह एक कम-शक्ति योजक है क्योंकि यह परिणाम प्राप्त करने के लिए न्यूनतम सर्किट का उपयोग करता है।
- यह एक बहुत लोकप्रिय और व्यापक रूप से उपयोग किया जाने वाला ऐडर है।
- इस प्रकार के योजक को कोग्गे-स्टोन योजक की तुलना में कम मॉड्यूल का उपयोग करके कार्यान्वित किया जा सकता है।
- ब्रेंट-कुंग योजक डिजाइनिंग बहुत आसान है।
- इस योजक का अन्य मॉड्यूल के साथ कम कनेक्शन है।
- ये योजक मुख्य रूप से कोग्गे-स्टोन योजकों की कमियों को हल करने के लिए प्रस्तावित किए गए थे।
नुकसान
ब्रेंट कुंग Adde के नुकसान आर में निम्नलिखित शामिल हैं.
- इन योजकों में अधिक विलंब होता है और सभी कैरी बिट्स की गणना के लिए 2 लॉग2 एन - 2 तर्क स्तरों की आवश्यकता होती है।
- इस योजक का मुख्य दोष फैनआउट है जिसके कारण पूरे योजक में करंट फैलकर विभाजित हो सकता है और कमजोर हो सकता है।
ब्रेंट कुंग एडर एप्लीकेशन
ब्रेंट कुंग अडर के अनुप्रयोगों में निम्नलिखित शामिल हैं।
- ब्रेंट-कुंग योजक का उपयोग कॉम्बिनेटरियल लॉजिक डेप्थ और ग्लिच स्थिरीकरण को कम करके बिजली की खपत को कम करने के लिए पाइपलाइन तरीके से किया जाता है।
- ब्रेंट-कुंग योजक आई/पी से सभी ओ/पीएस तक चरणों की एक उत्कृष्ट संख्या प्रदान करता है लेकिन असममित मध्यवर्ती चरणों की लोडिंग के साथ।
- इस योजक का उपयोग गुणक के साथ-साथ अन्य डेटा पथ तत्वों के भीतर भी किया जा सकता है।
इस प्रकार, यह है ब्रेंट कुंग योजक का एक सिंहावलोकन , इसकी कार्यप्रणाली, फायदे, नुकसान और इसके अनुप्रयोग। यह एक बहुत ही कुशल योजक है और इसकी संरचना एक वृक्ष संरचना की तरह दिखती है जिसका उपयोग मुख्य रूप से उच्च-प्रदर्शन अंकगणितीय संचालन के लिए किया जाता है। इस प्रकार का योजक बहुत तेज़ है और मुख्य रूप से गेट-स्तरीय तर्क पर केंद्रित है। यह ऐडर कम संख्या में लॉजिक गेट्स का उपयोग करके डिज़ाइन किया गया है। इस प्रकार, यह इस आर्किटेक्चर में उपयोग की जाने वाली मेमोरी और देरी को कम करता है। यहां आपके लिए एक प्रश्न है, ब्रेंट कुंग एडर को किस नाम से भी जाना जाता है?
