De Brent-Kung-adder werd in 1982 voorgesteld door Hsiang Te Kung en Richard Peirce Brent. Het is een parallelle prefix-opteller of boomopteller die vanwege zijn flexibiliteit veel wordt gebruikt in digitaal ontwerp. Parallelle Prefix Adders kunnen op verschillende manieren worden gebouwd, gebaseerd op het aantal logische niveaus, logische poorten betrokken, de fan-out van elke poort en de bedrading tussen de niveaus. Er zijn verschillende soorten boomadders beschikbaar, de fundamentele boomadders zijn Sklanskym KoggeStone & Brent-Kung. In vergelijking met de KSA (Kogge-Stone-adder) biedt deze adder een hoge regelmaat aan de structuur van de adder en heeft hij minder bedradingsblokkering wat leidt tot betere prestaties en minder vereist chipoppervlak. Dit artikel geeft korte informatie over a Brent Kung Adder .
Wat is Brent Kung Adder?
Een opteller die minimale schakelingen gebruikt om het resultaat te krijgen, staat bekend als Brent Kung Adder en staat ook bekend als een opteller met laag vermogen of parallelle opteller. Deze adder is bedoeld om de grootte van de chip te besparen, zodat het vervaardigen van deze adders eenvoudiger wordt. De symmetrie en gebruikelijke constructiestructuur van deze opteller zullen de productiekosten aanzienlijk verlagen en kunnen worden gebruikt in pijplijntopologieën. Het gebruik van complementaire doorlaattransistorlogica helpt bij het verbeteren van de ontwerpprestaties met de multiplexer aanpak in verschillende celontwerpen.
Brent Kung Adder-circuit
Hieronder wordt het brent-kung parallelle voorvoegsel-optellerdiagram weergegeven, dat fase 1 (voorverwerkingsfase) omvat, fasen 2 tot en met 7 zijn fasen voor het genereren van overdrachten en fase 8 is nabewerking. Het is een geavanceerde architectuur, zeer eenvoudig te construeren en zorgt voor minder bedradingsopstoppingen. Door minder bedrading te gebruiken, zal er dus minder ruimte nodig zijn om de architectuur uit te voeren. Bovendien wordt het routeren veel eenvoudiger doordat er minder draden elkaar kruisen (of overlappen). De straf zal echter toenemen bij vertraging vanwege het toegenomen aantal fasen. De fan-out voor deze opteller wordt vergroot, en vervolgens wordt de vertraging vergroot.
Hoe werkt Brent Kung Adder?
Brent Kung Adder werkt door de voorvoegsels voor twee bitgroepen te berekenen, wat handig is bij het vinden van de voorvoegsels van de 4 bitgroepen. Deze voorvoegsels worden gebruikt voor het berekenen van de voorvoegsels van de 8-bitsgroep, enz. Daarna zullen deze voorvoegsels worden gebruikt voor het berekenen van de uitvoering van de specifieke bitfase. Deze carry's worden gebruikt met de Group Propagate van de volgende fase om de Sum-bit van die fase te berekenen. Brent Kung Tree gebruikt 2log2N – 1 fase.
32-bit Brent Kung-adder
De 32-bits Brent Kung-opteller-indeling wordt hieronder weergegeven. Aan het begin van deze lay-out worden logische basispoorten ontworpen zoals NAND, inverter, XOR, NOR, enz. Daarna worden de noodzakelijke cellen zoals zwarte cellen, grijze cellen, buffers en PG-logica ontworpen met de logische poorten.
In de onderstaande 32-bits Brent Kung-opteller worden de inverterende poorten zoals AOI en OAI afwisselend gebruikt voor voornamelijk grijze en zwarte cellen. De zwarte en grijze cellen worden dus weergegeven met grijze en zwarte blokken, terwijl de buffers worden weergegeven met cirkels.
De ingangen zoals A en B worden geleverd aan PG-logica, zoals weergegeven in het blokdiagram. Voor een 32-bits opteller zijn 32 logische PG-blokken nodig en de signalen voor voortplanting (P) en genereren (G) zijn de uitgangen van dit blok. Deze signalen worden doorgegeven aan de Brent Kung-adderboomstructuur. De structuur van deze opteller omvat grijze cellen en zwarte cellen.
Een grijze cel bevat drie ingangen en één uitgang. Het voortplanten en genereren van signalen uit de huidige fase en het genereren van signalen uit de vorige fase zijn ingangen, terwijl de groep die signalen genereert de o/p is. In elke boomstructuur eindigt elke fase met een grijze cel en de o/p van deze cel is het signaal dat de groep genereert. Dit signaal wordt eenvoudigweg beschouwd als de overdracht van die fase. De zwarte cel bevat vier ingangen en twee uitgangen. De ingangen voor deze cel zijn de P & G-signalen van de huidige fase en de P-, G-signalen van de vorige fase.
Een PG-logica omvat EN- en XOR-poorten waarbij de EN-logische poort wordt gebruikt voor het genereren van het G-signaal en de XOR-logische poort het P-signaal levert. Om onnodige omvormers te elimineren, worden twee soorten grijze cellen en zwarte cellen gebruikt. De inverterende poorten die in de ene rij voor de grijze cel worden gebruikt, zijn AOI of AND-OR-Inverter en de inverterende poorten voor de zwarte cel in de volgende rij gebruiken OAI of OR-AND-Inverter. De AOI-cel gebruikt de normale ingangen om omgekeerde uitgangen te leveren, terwijl OAI omgekeerde ingangen gebruikt om normale uitgangen te leveren.
Brent Kung Adder-operatie
Brent Kung-opteller is een parallelle voorvoegsel-opteller die wordt gebruikt voor het uitvoeren van krachtige optellingen. Deze opteller ziet eruit als een boomstructuur die de rekenkundige bewerking uitvoert. Deze opteller bevat zwarte cellen en grijze cellen. Elke zwarte cel heeft twee EN-poorten en een enkele OF-poort en elke grijze cel heeft slechts één EN-poort.
De Brent-kung-adder omvat twee fasen; de voorverwerkingsfase en de generatiefase. In de eerste fase zal het genereren en propageren plaatsvinden vanuit elk paar inputs. Hier biedt de propagate een ‘XOR’-bewerking voor invoerbits, terwijl het genereren een ‘AND’-bewerking biedt voor invoerbits. De propageren en genereren zoals 'Pi' en 'Gi' worden hieronder gegeven.
Pi = Ai XOR Bi en Gi = Ai EN Bi.
In de tweede fase wordt de carry gegenereerd voor elk bit dat bekend staat als carry-genere ‘Cg’ en carry wordt doorgegeven voor elk bit dat bekend staat als carry-genereer ‘Cp’. Voor de verdere bewerking worden carry propagate en carry genereer gegenereerd. De laatste cel die beschikbaar is binnen elke bitbewerking zorgt voor carry. Dus de laatste bitoverdracht zal helpen om het volgende bit gelijktijdig op te tellen tot het laatste bit. De carry-genereer en propageer worden gegeven als;
Cp = P1 EN P0 en Cg=G1 OF (P1 EN G0)
Het wordt voornamelijk gebruikt voor de optelbewerking van tweeëndertig bits en elke bit doorloopt de voorverwerkings- en generatiefase en levert vervolgens de uiteindelijke som op.
De primaire invoerbits gaan onder de voorverwerkingsfase en produceren voortplanten en genereren. Dus deze propageren en genereren ondergaat de generatiefase, genereert carry, genereert & carry propageert en levert de uiteindelijke som op. Het stapsgewijze proces van de Brent-kung-adder wordt hieronder weergegeven.
De Brent-kung-opteller ziet eruit als een boomstructuur en is de snelle opteller die zich richt op logica op poortniveau. Deze opteller kan worden ontworpen met een afname van het aantal logische poorten. Het vermindert dus de vertraging en het geheugen dat binnen deze architectuur wordt gebruikt.
Brent Kung Adder Verilog-code
De Brent Kung adder verilog-code wordt hieronder weergegeven.
`define INPUTSIZE 64 //stel de invoergrootte n in
`define GROUPSIZE 8 //stel de groepsgrootte in op 1, 2, 4 of 8
module Brent_Kung_Adder(A, B, S);
ingang [`INPUTSIZE – 1:0] A;
ingang [`INPUTSIZE – 1:0] B;
uitgang [`INPUTSIZE:0] S;
draad [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r_temp;
draad [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r;
draad [`INPUTSIZE / `GROUPSIZE:0] cin;
draad [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] q;
wijs cin[0] = 1’b0 toe;
genereren
waar binnen;
voor (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) begin: parallel_FA_CLA_prefix
group_q_generation #(.Groupsize(`GROUPSIZE))
F(
.a(A[`GROEPSIZE * (i + 1) – 1:`GROEPSIZE * i]),
.b(B[`GROEPSIZE * (i + 1) – 1:`GROEPSIZE * i]),
.cin(cin[i]),
.s(S[`GROEPSIZE * (i + 1) – 1:`GROEPSIZE * i]),
.qg(q[i * 2 + 1:i * 2])
);
einde
parallel_prefix_tree_first_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t1(
.q(q[`INPUTSIZE / `GROEPSIZE * 2 – 1:0]),
.r(r_temp[`INPUTSIZE / `GROEPSIZE * 2 – 1:0])
);
parallel_prefix_tree_second_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t2(
.q(r_temp[`INPUTSIZE / `GROUPSIZE * 2 – 1:0]),
.r(r[`INPUTSIZE / `GROEPSIZE * 2 – 1:0])
);
voor (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) begin: cin_generation
cin_generation_logic f(
.r(r[2 * ik + 1:2 * ik]),
.c0(1’b0),
.cin(cin[i + 1])
);
einde
wijs S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE] toe;
eindgenereren
eindmodule
// Eerste helft van parallelle voorvoegselboom
module parallel_prefix_tree_first_half #(parameter Boomgrootte = `INPUTSIZE / `GROUPSIZE)(q, r);
invoer [Boomgrootte * 2 – 1:0] q;
uitvoer [Boomgrootte * 2 – 1:0] r;
genereren
waar binnen;
if (Boomgrootte == 2) begin: triviale_case
wijs r[1:0] = q[1:0] toe;
voorvoegsel_logica f(
.ql(q[1:0]),
.qh(q[3:2]),
.r(r[3:2])
);
einde anders begin: recursieve_case
draad [Boomgrootte * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Treesize(Boomgrootte / 2))
recursie_lsbh(
.q(q[Boomgrootte – 1:0]),
.r(r_temp[Boomgrootte – 1:0])
);
parallel_prefix_tree_first_half #(.Treesize(Boomgrootte / 2))
recursie_msbh(
.q(q[Boomgrootte * 2 – 1:Boomgrootte]),
.r(r_temp[Boomgrootte * 2 – 1:Boomgrootte])
);
voor (i = 0; i < Boomgrootte * 2; i = i + 2) begin: parallel_stitch_up
if (i != Treesize * 2 – 2) begin: parallel_stitch_up_pass
wijs r[i + 1:i] = r_temp[i + 1:i] toe;
einde anders begin: parallel_stitch_up_produce
voorvoegsel_logica f(
.ql(r_temp[Boomgrootte – 1:Boomgrootte – 2]),
.qh(r_temp[Boomgrootte * 2 – 1:Boomgrootte * 2 – 2]),
.r(r[Boomgrootte * 2 – 1:Boomgrootte * 2 – 2])
);
einde
einde
einde
eindgenereren
eindmodule
// Tweede helft van parallelle voorvoegselboom
module parallel_prefix_tree_second_half #(parameter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
invoer [Boomgrootte * 2 – 1:0] q;
uitvoer [Boomgrootte * 2 – 1:0] r;
draad [Boomgrootte * 2 * ($clog2(Boomgrootte) – 1) – 1:0] r_temp;
wijs r_temp[Boomgrootte * 2 – 1:0] = q[Boomgrootte * 2 – 1:0] toe;
genereren
genvar i, j;
voor (i = 0; i < $clog2(Treesize) – 2; i = i + 1) begin: second_half_level
wijs r_temp toe[Boomgrootte * 2 * (i + 1) + ((Boomgrootte / (2 ** i)) – 1 – 2 ** ($clog2(Boomgrootte / 4) – i)) * 2 – 1:Boomgrootte * 2 * (i + 1)] = r_temp[Boomgrootte * 2 * i + ((Boomgrootte / (2 ** i)) – 1 – 2 ** ($clog2(Boomgrootte / 4) – i)) * 2 – 1: Boomgrootte * 2 * i];
voor (j = (Boomgrootte / (2 ** i)) – 1 – 2 ** ($clog2(Boomgrootte / 4) – i); j < Boomgrootte; j = j + 2 ** ($clog2(Boomgrootte / 2 ) – i)) begin: second_half_level_logic
voorvoegsel_logica f(
.ql(r_temp[Boomgrootte * 2 * i + (j – 2 ** ($clog2(Boomgrootte / 4) – i)) * 2 + 1:Boomgrootte * 2 * i + (j – 2 ** ($clog2( Boomgrootte / 4) – i)) * 2]),
.qh(r_temp[Boomgrootte * 2 * i + j * 2 + 1:Boomgrootte * 2 * i + j * 2]),
.r(r_temp[Boomgrootte * 2 * (i + 1) + j * 2 + 1:Boomgrootte * 2 * (i + 1) + j * 2])
);
als (j != Boomgrootte – 1 – 2 ** ($clog2(Boomgrootte / 4) – i)) begin: second_half_level_direct_connect
wijs r_temp toe[Boomgrootte * 2 * (i + 1) + (j + 2 ** ($clog2(Boomgrootte / 2) – i)) * 2 – 1:Boomgrootte * 2 * (i + 1) + j * 2 + 2] = r_temp[Boomgrootte * 2 * i + (j + 2 ** ($clog2(Boomgrootte / 2) – i)) * 2 – 1:Boomgrootte * 2 * i + j * 2 + 2];
einde
einde
wijs r_temp toe[Boomgrootte * 2 * (i + 2) – 1:Boomgrootte * 2 * (i + 2) – (2 ** ($clog2(Boomgrootte / 4) – i)) * 2] = r_temp[Boomgrootte * 2 * (i + 1) – 1:Boomgrootte * 2 * (i + 1) – (2 ** ($clog2(Boomgrootte / 4) – i)) * 2];
einde
wijs r[1:0] = r_temp[Boomgrootte * 2 * ($clog2(Boomgrootte) – 2) + 1:Boomgrootte * 2 * ($clog2(Boomgrootte) – 2)] toe;
voor (i = 1; i < Boomgrootte; i = i + 2) begin: final_r_odd
wijs r[i * 2 + 1:i * 2] = r_temp[Boomgrootte * 2 * ($clog2(Boomgrootte) – 2) + i * 2 + 1:Boomgrootte * 2 * ($clog2(Boomgrootte) – 2) + ik * 2];
einde
voor (i = 2; i < Boomgrootte; i = i + 2) begin: final_r_even
voorvoegsel_logica f(
.ql(r_temp[Boomgrootte * 2 * ($clog2(Boomgrootte) – 2) + i * 2 – 1:Boomgrootte * 2 * ($clog2(Boomgrootte) – 2) + i * 2 – 2]),
.qh(r_temp[Boomgrootte * 2 * ($clog2(Boomgrootte) – 2) + i * 2 + 1:Boomgrootte * 2 * ($clog2(Boomgrootte) – 2) + i * 2]),
.r(r[i * 2 + 1:i * 2])
);
einde
eindgenereren
eindmodule
module group_q_generation #(parameter Groepsgrootte = `GROUPSIZE)(a, b, cin, s, qg);
invoer [Groepsgrootte – 1:0] a;
invoer [Groepsgrootte – 1:0] b;
invoer cin;
uitvoer [Groepsgrootte – 1:0] s;
uitvoer [1:0] qg;
draad [2 * Groepsgrootte – 1:0] q;
draad [Groepsgrootte – 1:0] c;
wijs c[0] = cin toe;
genereren
waar binnen;
voor (i = 0; i < Groepsgrootte; i = i + 1) begin: parallel_FA_CLA_prefix
FA_CLA_voorvoegsel f(
.a(a[i]),
.b(b[i]),
.cin(c[i]),
.s(s[i]),
.q(q[i * 2 + 1:i * 2])
);
if (i != Groepsgrootte – 1) begin: special_case
wijs c[i + 1] = q[i * 2 + 1] | toe (q[i * 2] & c[i]);
einde
einde
//group q-generatie op basis van de groepsgrootte
if (Groepsgrootte == 1) begin: case_gs1
wijs qg[1] = q[1] toe;
wijs qg[0] = q[0] toe;
end else if (Groepsgrootte == 2) begin: case_gs2
wijs qg[1] = q[3] | toe (q[1] & q[2]);
wijs qg[0] = q[2] & q[0] toe;
end else if (Groepsgrootte == 4) begin: case_gs4
wijs qg[1] = q[7] | toe (q[5] & q[6]) | (q[3] & q[6] & q[4]) | (q[1] & q[6] & q[4] & q[2]);
wijs qg[0] = q[6] & q[4] & q[2] & q[0] toe;
end else if (Groepsgrootte == 8) begin: case_gs8
wijs qg[1] = q[15] | toe (q[13] & q[14]) | (q[11] & q[14] & q[12]) | (q[9] & q[14] & q[12] & q[10]) | (q[7] & q[14] & q[12] & q[10] & q[8]) | (q[5] & q[14] & q[12] & q[10] & q[8] & q[6]) | (q[3] & q[14] & q[12] & q[10] & q[8] & q[6] & q[4]) | (q[1] & q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2]);
wijs qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0] toe;
einde
eindgenereren
eindmodule
// Cin-generatielogica
module cin_generation_logic(r, c0, cin);
ingang [1:0] r;
invoer c0;
uitvoer cin;
wijs cin = (r[0] & c0) | r[1];
eindmodule
// Basislogica voor prefixbewerkingen
modulevoorvoegsel_logic(ql, qh, r);
invoer [1:0] ql;
invoer [1:0] qh;
uitgang [1:0] r;
wijs r[0] = qh[0] & ql[0] toe;
wijs r[1] = (qh[0] & ql[1]) toe | qh[1];
eindmodule
// Full Adder-cel met carry-look-ahead
module FA_CLA_prefix(a, b, cin, s, q);
voer een in;
invoer b;
invoer cin;
uitgang s;
uitgang [1:0] q;
wijs q[0] = a ^ b toe;
wijs s = q[0] ^ cin toe;
wijs q[1] = a & b toe;
eindmodule
Voordelen
De voordelen van Brent Kung Adder zijn onder meer de volgende.
- Dit is een opteller met laag vermogen omdat deze een minimaal circuit gebruikt om het resultaat te krijgen.
- Het is een zeer populaire en veelgebruikte opteller.
- Dit soort opteller kan worden geïmplementeerd door minder modules te gebruiken in vergelijking met een Kogge-Stone-opteller.
- Het ontwerpen van Brent-Kung-adders is heel eenvoudig.
- Deze opteller heeft minder verbindingen met andere modules.
- Deze adders werden voornamelijk voorgesteld om de nadelen van Kogge-Stone-adders op te lossen.
Nadelen
De nadelen van Brent Kung Adde r omvat het volgende.
- Deze optellers hebben een grotere vertraging en hebben 2 log2 n − 2 logische niveaus nodig om alle carry-bits te berekenen.
- Het belangrijkste nadeel van deze opteller is fanout, waardoor de stroom door de opteller kan worden gesplitst en zwakker wordt.
Brent Kung Adder-toepassingen
De toepassingen van Brent Kung Adder omvatten het volgende.
- Een Brent-Kung-adder wordt op pijplijnwijze gebruikt om het stroomverbruik te verminderen door de combinatorische logische diepte en glitches-stabilisatie te verminderen.
- Brent-Kung-adder biedt een uitstekend aantal fasen van i/p tot alle o/ps, maar met asymmetrische tussentrappen.
- Deze opteller kan zowel binnen de vermenigvuldiger als bij andere gegevenspadelementen worden gebruikt.
Dit is dus het geval een overzicht van Brent kung-adder , de werking ervan, de voordelen, nadelen en de toepassingen ervan. Dit is een zeer efficiënte opteller en de structuur lijkt op een boomstructuur die voornamelijk wordt gebruikt voor krachtige rekenkundige bewerkingen. Dit type opteller is erg snel en richt zich voornamelijk op de logica op poortniveau. Deze opteller is ontworpen door minder logische poorten te gebruiken. Het vermindert dus het geheugen en de vertraging die binnen deze architectuur worden gebruikt. Hier is een vraag voor jou, Brent kung adder ook wel bekend als?
