Brent-Kung huggorm föreslogs 1982 av Hsiang Te Kung & Richard Peirce Brent. Det är en parallellprefixadderare eller trädadderare som används flitigt inom digital design på grund av sin flexibilitet. Parallella prefix adders kan byggas på flera sätt baserat på antalet logiska nivåer, logiska grindar inblandade, fan-out från varje grind & kablarna mellan nivåerna. Det finns olika typer av trädaddare tillgängliga, de grundläggande trädaddare är Sklanskym KoggeStone & Brent-Kung. Jämfört med KSA (Kogge–Stone adder) ger denna adder hög regelbundenhet till strukturen av adderaren och den har mindre ledningsblockering vilket leder till bättre prestanda & mindre erforderlig chiparea. Den här artikeln ger kort information om a Brent Kung Adder .
Vad är Brent Kung Adder?
En adderare som använder minimala kretsar för att få resultatet är känd som Brent Kung Adder och den är också känd som en lågeffektadderare eller parallelladderare. Denna adderare är avsedd att spara storleken på chippet så att tillverkningen av dessa adderare blir enklare. Denna huggorms symmetri och vanliga konstruktionsstruktur kommer att minska produktionskostnaderna avsevärt och är tillåtna att använda i pipelinetopologier. Användningen av komplementär passtransistorlogik hjälper till att förbättra designprestandan med multiplexor tillvägagångssätt i olika celldesigner.
Brent Kung Adder Circuit
Brent-kungs parallella prefix adderdiagram visas nedan som inkluderar steg 1 (förbehandlingssteg), steg 2 till 7 är överföringsgenereringssteg och steg 8 är efterbearbetning. Det är en avancerad arkitektur och är mycket enkel att konstruera och ger mindre ledningsstockning. Så de mindre ledningarna kommer att minska mängden utrymme som krävs för att utföra arkitekturen. Dessutom blir routing mycket lättare på grund av korsning (eller) överlappning av färre ledningar. Straffet kommer dock att öka i fördröjning på grund av det ökade antalet steg. Fläkten ut för denna adderare ökar, och sedan kommer fördröjningen att öka.
Hur fungerar Brent Kung Adder?
Brent Kung Adder fungerar genom att beräkna prefixen för två bitgrupper som är användbara för att hitta 4 bitars gruppprefix. Dessa prefix används för att beräkna 8-bitarsgruppens prefix etc. Därefter kommer dessa prefix att användas för att beräkna utförandet av det specifika bitsteget. Dessa bärare används med nästa stegs Group Propagate för att beräkna det stegets Sum-bit. Brent Kung Tree använder 2log2N – 1 steg.
32-bitars Brent Kung Adder
32-bitars Brent Kung adderlayout visas nedan. I början av denna layout är grundläggande logiska grindar utformade som NAND, inverter, XOR, NOR, etc. Därefter designas de nödvändiga cellerna som svarta celler, grå celler, buffertar och PG-logik med de logiska grindarna.
I nedanstående 32-bitars Brent Kung-adderare används de inverterande grindarna som AOI och OAI alternativt för huvudsakligen grå och svarta celler. Så de svarta och grå cellerna representeras med gråa och svarta block medan buffertarna representeras med cirklar.
Ingångar som A & B tillhandahålls till PG-logik som visas i blockschemat. För en 32-bitars adderare krävs 32 PG-logikblock och signalerna för utbredning (P) och generering (G) är utgångarna från detta block. Dessa signaler tillhandahålls till Brent Kung-adderarträdstrukturen. Strukturen för denna adderare inkluderar grå celler och svarta celler.
En grå cell innehåller tre ingångar och en enda utgång. Spridnings- och genereringssignalerna från det aktuella steget och genereringssignalerna från det föregående steget är ingångar medan gruppen som genererar signaler är o/p. I vilken trädstruktur som helst kommer varje steg att sluta med en grå cell och o/p för denna cell är gruppgenereringssignalen. Denna signal betraktas helt enkelt som överföringen av det steget. Den svarta cellen innehåller fyra ingångar och två utgångar. Ingångarna för denna cell är nuvarande stegs P & G-signaler & P, G-signaler från föregående steg.
En PG-logik inkluderar AND & XOR-grindar där AND-logikgrinden används för att generera G-signalen & XOR-logikgrinden tillhandahåller P-signalen. För att eliminera onödiga växelriktare används två typer av grå celler och svarta celler. De inverterande grindarna som används i en rad för den grå cellen är AOI eller AND-OR-Inverter och de inverterande grindarna för den svarta cellen inom nästa rad använder OAI eller OR-AND-Inverter. AOI-cellen använder de normala ingångarna för att ge inverterade utgångar medan OAI använder inverterade ingångar för att tillhandahålla normala utgångar.
Brent Kung Adder Operation
Brent Kung adderare är en parallell prefixadderare som används för drift av högpresterande addering. Denna adderare ser ut som en trädstruktur som utför den aritmetiska operationen. Denna adderare inkluderar svarta celler och grå celler. Varje svart cell har två AND-grindar och en ELLER-grind och varje grå cell har bara en OCH-grind.
Brent-kung huggorm inkluderar två steg; förbearbetningsstadiet & generationsstadiet. I det första steget kommer generera och spridas från varje par av ingångar. Här tillhandahåller propagatet en 'XOR'-operation för inmatningsbitar medan genererar tillhandahåller en 'AND'-operation för inmatningsbitar. Spridning och generering av 'Pi' och 'Gi' ges nedan.
Pi = Ai XOR Bi och Gi = Ai OCH Bi.
I det andra steget kommer överföringen att genereras för varje bit som är känd som bär generera 'Cg' och bär generera för varje bit är känd som bär generera 'Cp'. För vidare operation kommer carry propagate & carry generera att genereras. Den sista cellen tillgänglig inom varje bit fungerar ger bära. Så den sista bitöverföringen hjälper till att summera nästa bit samtidigt till den sista biten. Bär generera & propagate ges som;
Cp = P1 OCH P0 och Cg=G1 ELLER (P1 OCH G0)
Den används huvudsakligen för additionsoperationen av två trettiotvå bitar och varje bit upplever förbearbetningssteget och genereringssteget och ger sedan den slutliga summan.
De primära inmatningsbitarna går under förbehandlingssteget och de producerar fortplantning och genererar. Så dessa sprider sig såväl som genererar genomgår generationsstadiet genererar bär genererar & bär sprider och ger slutsumma. Brent-kung-adderaren steg-för-steg-processen visas nedan.
Brent-kung-adderarrangemanget ser ut som en trädstruktur och det är höghastighetsadderaren som riktar sig mot logik på grindnivå. Denna adderare kan utformas med en minskning av antalet logiska grindar. Således minskar det fördröjningen och minnet som används inom denna arkitektur.
Brent Kung Adder Verilog-kod
Verilogkoden för Brent Kung adder visas nedan.
`definiera INPUTSIZE 64 //ställ in ingångsstorleken n
`definiera GROUPSIZE 8 //ställ in gruppstorleken = 1, 2, 4 eller 8
modul Brent_Kung_Adder(A, B, S);
in [`INPUTSIZE – 1:0] A;
in [`INPUTSIZE – 1:0] B;
utgång [`INPUTSIZE:0] S;
tråd [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r_temp;
tråd [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r;
tråd [`INPUTSIZE / `GROUPSIZE:0] cin;
tråd [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] q;
tilldela cin[0] = 1'b0;
generera
genvar i;
för (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) börjar: parallell_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])
);
slutet
parallel_prefix_tree_first_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t1(
.q(q[`INPUTSIZE / `GROUPSIZE * 2 – 1:0]),
.r(r_temp[`INPUTSIZE / `GROUPSIZE * 2 – 1:0])
);
parallell_prefix_träd_andra_halvan #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t2(
.q(r_temp[`INPUTSIZE / `GROUPSIZE * 2 – 1:0]),
.r(r[`INPUTSIZE / `GROUPSIZE * 2 – 1:0])
);
för (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) börjar: cin_generation
cin_generation_logic f(
.r(r[2 *i + 1:2 *i]),
.c0(1'b0),
.cin(cin[i + 1])
);
slutet
tilldela S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
slutgenerera
slutmodul
// Första halvan av parallellt prefixträd
modul parallell_prefix_träd_första_halvan #(parameter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
input [Trästorlek * 2 – 1:0] q;
utgång [Trästorlek * 2 – 1:0] r;
generera
genvar i;
if (Trästorlek == 2) börjar: trivial_case
tilldela r[1:0] = q[1:0];
prefix_logic f(
.ql(q[1:0]),
.qh(q[3:2]),
.r(r[3:2])
);
slut annat börja: rekursivt_fall
tråd [Trästorlek * 2 – 1:0] r_temp;
parallell_prefix_träd_första_halvan #(.Treesize(Treesize / 2))
rekursion_lsbh(
.q(q[Trädstorlek – 1:0]),
.r(r_temp[Treesize – 1:0])
);
parallell_prefix_träd_första_halvan #(.Treesize(Treesize / 2))
rekursion_msbh(
.q(q[Treesize * 2 – 1:Treesize]),
.r(r_temp[Treesize * 2 – 1:Treesize])
);
för (i = 0; i < Trädstorlek * 2; i = i + 2) börjar: parallellstygn_upp
om (i != Trädstorlek * 2 – 2) börjar: parallell_stitch_up_pass
tilldela r[i + 1:i] = r_temp[i + 1:i];
end else start: parallell_söm_upp_producera
prefix_logic 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])
);
slutet
slutet
slutet
slutgenerera
slutmodul
// Andra halvan av parallellt prefixträd
modulen parallell_prefix_träd_andra_halvan #(parameter Trädstorlek = `INPUTSIZE / `GROUPSIZE)(q, r);
input [Trästorlek * 2 – 1:0] q;
utgång [Trästorlek * 2 – 1:0] r;
tråd [Treesize * 2 * ($clog2(Treesize) – 1) – 1:0] r_temp;
tilldela r_temp[Treesize * 2 – 1:0] = q[Treesize * 2 – 1:0];
generera
genvar i, j;
för (i = 0; i < $clog2(Treesize) – 2; i = i + 1) start: second_half_level
tilldela 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: Trädstorlek * 2 * i];
för (j = (Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i); j < Treesize; j = j + 2 ** ($clog2(Treesize / 2) ) – i)) börjar: andra_halvan_nivå_logik
prefix_logic f(
.ql(r_temp[Treesize * 2 * i + (j – 2 ** ($clog2(Treesize / 4) – i)) * 2 + 1:Treesize * 2 * i + (j – 2 ** ($clog2( Trädstorlek / 4) – i)) * 2]),
.qh(r_temp[Trädstorlek * 2 * i + j * 2 + 1:Trädstorlek * 2 * i + j * 2]),
.r(r_temp[Trädstorlek * 2 * (i + 1) + j * 2 + 1:Trädstorlek * 2 * (i + 1) + j * 2])
);
if (j != Treesize – 1 – 2 ** ($clog2(Treesize / 4) – i)) börjar: second_half_level_direct_connect
tilldela 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];
slutet
slutet
tilldela 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];
slutet
tilldela r[1:0] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + 1:Treesize * 2 * ($clog2(Treesize) – 2)];
för (i = 1; i < Trädstorlek; i = i + 2) börjar: final_r_odd
tilldela r[i * 2 + 1:i * 2] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesize) – 2) + i * 2];
slutet
för (i = 2; i < Trädstorlek; i = i + 2) börjar: final_r_even
prefix_logic 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])
);
slutet
slutgenerera
slutmodul
module group_q_generation #(parameter Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
input [Gruppstorlek – 1:0] a;
input [Gruppstorlek – 1:0] b;
ingång cin;
output [Gruppstorlek – 1:0] s;
output [1:0] qg;
tråd [2 * Gruppstorlek – 1:0] q;
tråd [Gruppstorlek – 1:0] c;
tilldela c[0] = cin;
generera
genvar i;
för (i = 0; i < Gruppstorlek; i = i + 1) börjar: parallell_FA_CLA_prefix
FA_CLA_prefix f(
.a(a[i]),
.b(b[i]),
.cin(c[i]),
.s(s[i]),
.q(q[i * 2 + 1:i * 2])
);
if (i != Gruppstorlek – 1) börjar: special_case
tilldela c[i + 1] = q[i * 2 + 1] | (q[i*2] & c[i]);
slutet
slutet
//grupp q generation baserad på gruppstorleken
if (Gruppstorlek == 1) börjar: case_gs1
tilldela qg[1] = q[1];
tilldela qg[0] = q[0];
end else if (Gruppstorlek == 2) börjar: case_gs2
tilldela qg[1] = q[3] | (q[1] & q[2]);
tilldela qg[0] = q[2] & q[0];
end else if (Gruppstorlek == 4) börjar: case_gs4
tilldela qg[1] = q[7] | (q[5] & q[6]) | (q[3] & q[6] & q[4]) | (q[1] & q[6] & q[4] & q[2]);
tilldela qg[0] = q[6] & q[4] & q[2] & q[0];
end else if (Gruppstorlek == 8) börjar: case_gs8
tilldela 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]);
tilldela qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0];
slutet
slutgenerera
slutmodul
// Cin generation logik
modul cin_generation_logic(r, c0, cin);
ingång [1:0] r;
ingång c0;
utgång cin;
tilldela cin = (r[0] & c0) | r[1];
slutmodul
// Grundläggande logik för prefixoperationer
modulprefix_logic(ql, qh, r);
input [1:0] ql;
inmatning [1:0] qh;
utsignal [1:0] r;
tilldela r[0] = qh[0] & ql[0];
tilldela r[1] = (qh[0] & ql[1]) | qh[1];
slutmodul
// Full Adder Cell med Carry Look-Ahead
modul FA_CLA_prefix(a, b, cin, s, q);
mata in a;
ingång b;
ingång cin;
utgång s;
utsignal [1:0] q;
tilldela q[0] = a ^ b;
tilldela s = q[0] ^ cin;
tilldela q[1] = a & b;
slutmodul
Fördelar
Fördelarna med Brent Kung Adder inkluderar följande.
- Detta är en lågeffekt adderare eftersom den använder en minimal krets för att få resultatet.
- Det är en mycket populär och flitigt använd huggorm.
- Denna typ av adderare kan implementeras genom att använda färre moduler jämfört med en Kogge-Stone adderare.
- Brent-Kung huggormdesign är mycket lätt.
- Denna adderare har färre anslutningar till andra moduler.
- Dessa huggormar föreslogs främst för att lösa nackdelarna med Kogge-Stone huggormar.
Nackdelar
De nackdelar med Brent Kung Adde r inkludera följande.
- Dessa adderare har större fördröjning och de behöver 2 log2 n − 2 logiska nivåer för att beräkna alla bärbitar.
- Den största nackdelen med denna adderare är fanout som kan orsaka att strömmen sprids genom adderaren att delas upp och blir svagare.
Brent Kung Adder-applikationer
Tillämpningarna av Brent Kung Adder inkluderar följande.
- En Brent-Kung-adderare används på ett pipeline-sätt för att minska energiförbrukningen genom att minska det kombinatoriska logiska djupet och stabilisering av fel.
- Brent-Kung adder ger ett enastående antal steg från i/p till alla o/ps men med asymmetrisk mellanstadsbelastning.
- Denna adderare kan användas inom multiplikatorn såväl som andra datavägelement.
Detta är alltså en översikt över Brent kung huggorm , dess funktion, fördelar, nackdelar och dess tillämpningar. Detta är en mycket effektiv adderare och dess struktur ser ut som en trädstruktur som huvudsakligen används för högpresterande aritmetiska operationer. Denna typ av adderare är mycket snabb och fokuserar främst på gate-nivå logiken. Denna adderare är designad genom att använda mindre antal logiska grindar. Således minskar det minnet och fördröjningen som används inom denna arkitektur. Här är en fråga till dig, Brent kung huggorm även känd som?
