Brent – Kung huggorm ble foreslått i 1982 av Hsiang Te Kung og Richard Peirce Brent. Det er en Parallell Prefix adder eller tre adder som brukes mye i digital design på grunn av sin fleksibilitet. Parallelle prefiksaddere kan bygges på flere måter basert på antall logiske nivåer, logiske porter involvert, viften fra hver port og ledningene mellom nivåene. Det finnes forskjellige typer trehoggormer tilgjengelig, de grunnleggende trehoggorme er Sklanskym KoggeStone & Brent-Kung. Sammenlignet med KSA (Kogge–Stone adder), gir denne hoggormen høy regularitet til strukturen til hoggormen og den har mindre ledningsblokkering som fører til bedre ytelse og mindre nødvendig brikkeområde. Denne artikkelen gir kort informasjon om en Brent Kung Adder .
Hva er Brent Kung Adder?
En adder som bruker minimumskretser for å få resultatet er kjent som Brent Kung Adder og den er også kjent som en laveffekt adder eller parallell adder. Denne addereren er ment å spare størrelsen på brikken slik at produksjonen av disse addererne blir enklere. Denne huggormens symmetri og vanlige konstruksjonsstruktur vil redusere produksjonskostnadene betraktelig og er tillatt å bruke i pipelinede topologier. Bruken av komplementær passtransistorlogikk hjelper til med å forbedre designytelsen med multiplekser tilnærming i ulike celledesign.
Brent Kung Adder Circuit
Brent-kung parallellprefiksadderdiagrammet er vist nedenfor som inkluderer trinn 1 (forbehandlingstrinn), trinn 2 til 7 er bæregenereringstrinn og trinn 8 er etterbehandling. Det er en avansert arkitektur og er veldig enkel å konstruere og gir mindre overbelastning av ledninger. Så mindre ledninger vil redusere mengden nødvendig plass for å utføre arkitekturen. I tillegg blir ruting mye enklere på grunn av kryssing (eller) overlapping av færre ledninger. Imidlertid vil straffen øke i forsinkelse på grunn av det økte antallet trinn. Viften ut for denne addereren økes, og deretter vil forsinkelsen økes.
Hvordan fungerer Brent Kung Adder?
Brent Kung Adder fungerer ved å beregne prefiksene for to bitgrupper som er nyttige for å finne 4 bits gruppeprefiksene. Disse prefiksene brukes til å beregne 8-bitgruppens prefikser osv. Etter det vil disse prefiksene bli brukt til å beregne utføringen av det spesifikke bittrinnet. Disse bærene brukes sammen med neste trinns Group Propagate for å beregne sum-biten til den fasen. Brent Kung Tree bruker 2log2N – 1 trinn.
32-bit Brent Kung Adder
32-bits Brent Kung adder layout er vist nedenfor. Ved starten av denne layouten er grunnleggende logiske porter utformet som NAND, inverter, XOR, NOR, etc. Deretter blir de nødvendige cellene som svarte celler, grå celler, buffere og PG-logikk designet med de logiske portene.
I 32-bits Brent Kung-adderen nedenfor, brukes de inverterende portene som AOI og OAI alternativt for hovedsakelig grå og svarte celler. Så de svarte og grå cellene er representert med grå og svarte blokker, mens bufferne er representert med sirkler.
Inngangene som A & B leveres til PG-logikk som er vist i blokkskjemaet. For en 32-bits adderer er det nødvendig med 32 PG logiske blokker, og forplantnings- (P) og generere (G)-signaler er utgangene til denne blokken. Disse signalene leveres til Brent Kung-hoggortrestrukturen. Strukturen til denne hoggormen inkluderer grå celler og svarte celler.
En grå celle inkluderer tre innganger og enkelt utgang. Forplantnings- og genereringssignalene fra det nåværende trinnet og genereringssignalene fra forrige trinn er innganger, mens gruppen som genererer signaler er o/p. I en hvilken som helst trestruktur vil hvert trinn ende med en grå celle, og o/p til denne cellen er det gruppegenererende signalet. Dette signalet betraktes ganske enkelt som bæreren av det stadiet. Den svarte cellen inkluderer fire innganger og to utganger. Inngangene for denne cellen er nåværende trinns P & G-signaler & P, G-signaler fra forrige trinn.
En PG-logikk inkluderer OG & XOR-porter hvor OG-logikkporten brukes for å generere G-signalet og XOR-logikkport gir P-signalet. For å eliminere unødvendige invertere, brukes to typer grå celler og svarte celler. De inverterende portene som brukes i en rad for den grå cellen er AOI eller OG-ELLER-inverter, og de inverterende portene for den svarte cellen i neste rad bruker OAI eller OR-AND-Inverter. AOI-cellen bruker de normale inngangene for å gi inverterte utganger, mens OAI bruker inverterte innganger for å gi normale utganger.
Brent Kung huggormoperasjon
Brent Kung adder er en parallell prefiks adder som brukes til drift av høyytelses addering. Denne addereren ser ut som en trestruktur som utfører den aritmetiske operasjonen. Denne adderen inkluderer svarte celler og grå celler. Hver svart celle har to OG-porter og enkel ELLER-port, og hver grå celle har bare én OG-port.
Brent-kung huggorm inkluderer to trinn; forbehandlingsstadiet og generasjonsstadiet. I det første trinnet vil generere og forplante seg fra hvert par av innganger. Her gir forplantningen en 'XOR'-operasjon for inngangsbiter, mens generering gir en 'AND'-operasjon for inngangsbiter. Forplante og generere like 'Pi' og 'Gi' er gitt nedenfor.
Pi = Ai XOR Bi og Gi = Ai OG Bi.
I det andre trinnet vil overføringen bli generert for hver bit som er kjent som bære generer 'Cg' og bære er forplante for hver bit er kjent som bære generere 'Cp'. For den videre operasjonen vil carry propagate & carry generer bli generert. Den siste cellen tilgjengelig innenfor hver bit operere gir bære. Så den siste bitbæringen vil hjelpe til med summen av den neste biten samtidig til den siste biten. Bæren generere og forplante er gitt som;
Cp = P1 OG P0 og Cg=G1 ELLER (P1 OG G0)
Den brukes hovedsakelig for addisjonsoperasjonen av to trettito biter og hver bit opplever forbehandlingsstadiet og generasjonsstadiet, så gir det den endelige summen.
De primære inngangsbitene går under forbehandlingsstadiet og de produserer forplanter og genererer. Så disse forplanter seg så vel som genererer gjennomgår generasjonsstadiet genererer bære genererer og bære forplanter seg og gir endelig sum. Brent-kung huggorm trinn-for-trinn-prosessen er vist nedenfor.
Brent-kung huggorm-arrangementet ser ut som en trestruktur, og det er høyhastighets-hoggormen som sikter mot logikk på portnivå. Denne addereren kan utformes med en reduksjon av antall logiske porter. Dermed reduserer det forsinkelsen og minnet som brukes i denne arkitekturen.
Brent Kung Adder Verilog-kode
Brent Kung adder verilog-koden er vist nedenfor.
`definer INPUTSIZE 64 //sett inngangsstørrelsen n
`definer GROUPSIZE 8 //sett gruppestørrelsen = 1, 2, 4 eller 8
modul Brent_Kung_Adder(A, B, S);
input [`INPUTSIZE – 1:0] A;
input [`INPUTSIZE – 1:0] B;
utgang [`INPUTSIZE:0] S;
wire [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r_temp;
wire [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r;
wire [`INPUTSIZE / `GROUPSIZE:0] cin;
wire [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] q;
tilordne cin[0] = 1'b0;
generere
hvor i;
for (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) start: parallel_FA_CLA_prefix
group_q_generation #(.Groupsize(`GROUPSIZE))
f(
.a(A[`GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.b(B[`GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.cin(cin[i]),
.s(S[`GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.qg(q[i * 2 + 1:i * 2])
);
slutt
parallel_prefix_tree_first_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t1(
.q(q[`INPUTSIZE / `GROUPSIZE * 2 – 1:0]),
.r(r_temp[`INPUTSIZE / `GROUPSIZE * 2 – 1:0])
);
parallel_prefix_tree_second_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t2(
.q(r_temp[`INPUTSIZE / `GROUPSIZE * 2 – 1:0]),
.r(r[`INPUTSIZE / `GROUPSIZE * 2 – 1:0])
);
for (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) begynner: cin_generation
cin_generation_logic f(
.r(r[2 *i + 1:2 *i]),
.c0(1'b0),
.cin(cin[i + 1])
);
slutt
tilordne S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
sluttgenerere
endemodul
// Første halvdel av parallellprefiksetre
module parallel_prefix_tree_first_half #(parameter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
input [Treesize * 2 – 1:0] q;
utgang [Treesize * 2 – 1:0] r;
generere
hvor i;
if (Treesize == 2) begynner: trivial_case
tilordne r[1:0] = q[1:0];
prefiks_logikk f(
.ql(q[1:0]),
.qh(q[3:2]),
.r(r[3:2])
);
end else start: rekursiv_case
wire [Treesize * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
rekursjon_lsbh(
.q(q[Treesize – 1:0]),
.r(r_temp[Treesize – 1:0])
);
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
rekursjon_msbh(
.q(q[Treesize * 2 – 1:Treesize]),
.r(r_temp[Treesize * 2 – 1:Treesize])
);
for (i = 0; i < Treesize * 2; i = i + 2) start: parallel_stitch_up
hvis (i != Treesize * 2 – 2) begynner: parallel_stitch_up_pass
tilordne r[i + 1:i] = r_temp[i + 1:i];
end else start: parallel_stitch_up_produce
prefiks_logikk f(
.ql(r_temp[Treesize – 1:Treesize – 2]),
.qh(r_temp[Treesize * 2 – 1:Treesize * 2 – 2]),
.r(r[Treesize * 2 – 1:Treesize * 2 – 2])
);
slutt
slutt
slutt
sluttgenerere
endemodul
// Andre halvdel av parallellprefiksetre
module parallel_prefix_tree_second_half #(parameter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
input [Treesize * 2 – 1:0] q;
utgang [Treesize * 2 – 1:0] r;
ledning [Treesize * 2 * ($clog2(Treesize) – 1) – 1:0] r_temp;
tilordne r_temp[Treesize * 2 – 1:0] = q[Treesize * 2 – 1:0];
generere
genvar i, j;
for (i = 0; i < $clog2(Treesize) – 2; i = i + 1) start: second_half_level
tilordne r_temp[Treesize * 2 * (i + 1) + ((Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i)) * 2 – 1:Treesize * 2 * (i + 1)] = r_temp[Treesize * 2 * i + ((Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i)) * 2 – 1: Treesize * 2 * i];
for (j = (Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i); j < Treesize; j = j + 2 ** ($clog2(Treesize / 2) ) – i)) begynne: andre_halvdel_nivå_logikk
prefiks_logikk f(
.ql(r_temp[Treesize * 2 * i + (j – 2 ** ($clog2(Treesize / 4) – i)) * 2 + 1:Treesize * 2 * i + (j – 2 ** ($clog2( Treesize / 4) – i)) * 2]),
.qh(r_temp[Treesize * 2 * i + j * 2 + 1:Treesize * 2 * i + j * 2]),
.r(r_temp[Treesize * 2 * (i + 1) + j * 2 + 1:Treesize * 2 * (i + 1) + j * 2])
);
if (j != Treesize – 1 – 2 ** ($clog2(Treesize / 4) – i)) begynner: second_half_level_direct_connect
tilordne r_temp[Treesize * 2 * (i + 1) + (j + 2 ** ($clog2(Treesize / 2) – i)) * 2 – 1:Treesize * 2 * (i + 1) + j * 2 + 2] = r_temp[Treesize * 2 * i + (j + 2 ** ($clog2(Treesize / 2) – i)) * 2 – 1:Treesize * 2 * i + j * 2 + 2];
slutt
slutt
tilordne r_temp[Treesize * 2 * (i + 2) – 1:Treesize * 2 * (i + 2) – (2 ** ($clog2(Treesize / 4) – i)) * 2] = r_temp[Treesize * 2 * (i + 1) – 1:Treesize * 2 * (i + 1) – (2 ** ($clog2(Treesize / 4) – i)) * 2];
slutt
tilordne r[1:0] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + 1:Treesize * 2 * ($clog2(Treesize) – 2)];
for (i = 1; i < Treesize; i = i + 2) begynner: final_r_odd
tilordne r[i * 2 + 1:i * 2] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesize) – 2) + i * 2];
slutt
for (i = 2; i < Treesize; i = i + 2) begynner: final_r_even
prefiks_logikk 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])
);
slutt
sluttgenerere
endemodul
module group_q_generation #(parameter Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
input [Gruppestørrelse – 1:0] a;
input [Gruppestørrelse – 1:0] b;
input cin;
utgang [Gruppestørrelse – 1:0] s;
utgang [1:0] qg;
ledning [2 * Gruppestørrelse – 1:0] q;
tråd [Gruppestørrelse – 1:0] c;
tilordne c[0] = cin;
generere
hvor i;
for (i = 0; i < gruppestørrelse; i = i + 1) begynner: parallell_FA_CLA_prefiks
FA_CLA_prefiks f(
.a(a[i]),
.b(b[i]),
.cin(c[i]),
.s(s[i]),
.q(q[i * 2 + 1:i * 2])
);
if (i != Gruppestørrelse – 1) begynner: special_case
tilordne c[i + 1] = q[i * 2 + 1] | (q[i * 2] & c[i]);
slutt
slutt
//gruppe q generasjon basert på gruppestørrelsen
if (Gruppestørrelse == 1) begynner: case_gs1
tilordne qg[1] = q[1];
tilordne qg[0] = q[0];
end else if (Gruppestørrelse == 2) begynner: case_gs2
tilordne qg[1] = q[3] | (q[1] & q[2]);
tilordne qg[0] = q[2] & q[0];
end else if (Gruppestørrelse == 4) begynner: case_gs4
tilordne qg[1] = q[7] | (q[5] & q[6]) | (q[3] & q[6] & q[4]) | (q[1] & q[6] & q[4] & q[2]);
tilordne qg[0] = q[6] & q[4] & q[2] & q[0];
end else if (Gruppestørrelse == 8) begynner: case_gs8
tilordne qg[1] = q[15] | (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]);
tilordne qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0];
slutt
sluttgenerere
endemodul
// Cin generasjonslogikk
modul cin_generation_logic(r, c0, cin);
input [1:0] r;
inngang c0;
utgang cin;
tilordne cin = (r[0] & c0) | r[1];
endemodul
// Grunnleggende logikk for prefiksoperasjoner
modulprefiks_logikk(ql, qh, r);
input [1:0] ql;
input [1:0] qh;
utgang [1:0] r;
tilordne r[0] = qh[0] & ql[0];
tilordne r[1] = (qh[0] & ql[1]) | qh[1];
endemodul
// Full Adder Cell med Carry Look-Ahead
modul FA_CLA_prefiks(a, b, cin, s, q);
skriv inn a;
inngang b;
input cin;
utgang s;
utgang [1:0] q;
tilordne q[0] = a ^ b;
tilordne s = q[0] ^ cin;
tilordne q[1] = a & b;
endemodul
Fordeler
Fordelene med Brent Kung Adder inkluderer følgende.
- Dette er en laveffekt adder fordi den bruker en minimumskrets for å få resultatet.
- Det er en veldig populær og mye brukt huggorm.
- Denne typen adderer kan implementeres ved å bruke færre moduler sammenlignet med en Kogge-Stone huggorm.
- Brent-Kung huggormdesign er veldig enkelt.
- Denne addereren har færre forbindelser med andre moduler.
- Disse hoggormene ble foreslått hovedsakelig for å løse ulempene med Kogge-Stone huggorm.
Ulemper
De ulemper med Brent Kung Adde r inkluderer følgende.
- Disse addererne har større forsinkelse og trenger 2 log2 n − 2 logiske nivåer for å beregne alle bærebitene.
- Den største ulempen med denne adderen er fanout som kan føre til at strømmen forplanter seg gjennom adderen til å dele seg opp og bli svakere.
Brent Kung Adder-applikasjoner
Applikasjonene til Brent Kung Adder inkluderer følgende.
- En Brent-Kung adder brukes på en rørledningsmåte for å redusere strømforbruket ved å redusere den kombinatoriske logiske dybden og stabilisering av feil.
- Brent-Kung adder gir et enestående antall trinn fra i/p til alle o/ps, men med asymmetrisk mellomtrinnsbelastning.
- Denne addereren kan brukes i multiplikatoren så vel som andre databaneelementer.
Dermed er dette en oversikt over Brent kung huggorm , dets virkemåte, fordeler, ulemper og bruksområder. Dette er en veldig effektiv huggorm, og strukturen ser ut som en trestruktur som hovedsakelig brukes til aritmetiske operasjoner med høy ytelse. Denne typen adderer er veldig rask og fokuserer hovedsakelig på gatenivålogikken. Denne addereren er designet ved å bruke mindre antall logiske porter. Dermed reduserer det minnet og forsinkelsen som brukes i denne arkitekturen. Her er et spørsmål til deg, Brent kung huggorm også kjent som?