Ang Brent–Kung adder ay iminungkahi noong 1982 nina Hsiang Te Kung at Richard Peirce Brent. Isa itong Parallel Prefix adder o tree adder na malawakang ginagamit sa Digital Design dahil sa flexibility nito. Ang mga Parallel Prefix Adders ay maaaring itayo sa maraming paraan batay sa bilang ng mga antas ng lohika, mga pintuan ng lohika kasangkot, ang fan-out mula sa bawat gate at ang mga kable sa pagitan ng mga antas. Mayroong iba't ibang uri ng tree adders na magagamit, ang pangunahing Tree adders ay Sklanskym KoggeStone & Brent-Kung, Kung ikukumpara sa KSA (Kogge–Stone adder), ang adder na ito ay nagbibigay ng mataas na regularity sa structure ng adder at ito ay may mas kaunting wiring blocking na humahantong sa mas mahusay na pagganap at hindi gaanong kinakailangang lugar ng chip. Ang artikulong ito ay nagbibigay ng maikling impormasyon sa a Brent Kung Adder .
Ano ang Brent Kung Adder?
Ang isang adder na gumagamit ng minimum na circuitry upang makuha ang resulta ay kilala bilang Brent Kung Adder at kilala rin ito bilang isang low-power adder o parallel adder. Ang adder na ito ay inilaan upang i-save ang laki ng chip upang maging mas madali ang paggawa ng mga adder na ito. Ang simetrya ng adder na ito at karaniwang istraktura ng konstruksiyon ay lubos na magpapababa sa mga gastos sa produksyon at pinapayagang gamitin sa mga pipeline na topologies. Ang paggamit ng pantulong na pass transistor logic ay nakakatulong sa pagpapahusay ng pagganap ng disenyo sa multiplexer diskarte sa iba't ibang disenyo ng cell.
Brent Kung Adder Circuit
Ang brent-kung parallel prefix adder diagram ay ipinapakita sa ibaba na kinabibilangan ng stage 1 (pre-processing stage), stage 2 hanggang 7 ay carry generation stages at stage 8 ay post-processing. Ito ay isang advanced na arkitektura at napakasimpleng gawin at nagbibigay ng mas kaunting pagsisikip ng mga kable. Kaya, ang mas kaunting mga kable nito ay magbabawas sa dami ng kinakailangang espasyo upang maisagawa ang arkitektura. Bilang karagdagan, ang pagruruta ay nagiging mas madali dahil sa pagtawid (o) pag-overlay ng mas kaunting mga wire. Gayunpaman, ang parusa ay tataas sa pagkaantala dahil sa tumaas na bilang ng mga yugto, Ang fan out para sa adder na ito ay tataas, at pagkatapos ay ang pagkaantala ay tataas.
Paano Gumagana ang Brent Kung Adder?
Gumagana ang Brent Kung Adder sa pamamagitan ng pagkalkula ng mga prefix para sa dalawang bit group na kapaki-pakinabang sa paghahanap ng 4 bit group prefix. Ang mga prefix na ito ay ginagamit para sa pag-compute ng mga prefix ng 8-bit na grupo, atbp. Pagkatapos nito, ang mga prefix na ito ay gagamitin para sa pag-compute ng carry-out ng partikular na yugto ng bit. Ang mga dala na ito ay ginagamit kasama ng Group Propagate ng susunod na yugto upang kalkulahin ang Sum bit ng yugtong iyon. Gumagamit ang Brent Kung Tree ng 2log2N – 1 stage.
32-bit na Brent Kung Adder
Ang 32-bit na Brent Kung adder layout ay ipinapakita sa ibaba. Sa simula ng layout na ito, ang mga pangunahing logic gate ay idinisenyo tulad ng NAND, inverter, XOR, NOR, atbp. Pagkatapos nito, ang mga kinakailangang cell tulad ng mga black cell, gray na mga cell, buffer, at PG logic ay idinisenyo gamit ang mga logic gate.
Sa ibabang 32-bit na Brent Kung adder, ang mga inverting gate tulad ng AOI at OAI ay alternatibong ginagamit para sa mga grey at black cell. Kaya ang mga itim at kulay abong mga cell ay kinakatawan ng kulay abo at itim na mga bloke samantalang ang mga buffer ay kinakatawan ng mga bilog.
Ang mga input tulad ng A & B ay ibinibigay sa PG logic na ipinapakita sa block diagram. Para sa isang 32-bit adder, 32 PG logic blocks ang kailangan at ang propagate (P) at generate (G) signal ay ang mga output ng block na ito. Ang mga signal na ito ay ibinibigay sa Brent Kung adder tree structure. Kasama sa istruktura ng adder na ito ang mga gray na selula at itim na selula.
Ang isang gray na cell ay may kasamang tatlong input at solong output. Ang nagpapalaganap at bumubuo ng mga signal mula sa kasalukuyang yugto at bumubuo ng mga signal mula sa nakaraang yugto ay mga input samantalang ang grupo ay bumubuo ng mga signal ay ang o/p. Sa anumang istraktura ng puno, ang bawat yugto ay magtatapos sa isang kulay-abo na cell at ang o/p ng cell na ito ay ang grupong bumubuo ng signal. Ang senyas na ito ay itinuturing na simpleng dala ng yugtong iyon. Kasama sa Black cell ang apat na input at dalawang output. Ang mga input para sa cell na ito ay ang kasalukuyang yugto ng P & G signal at P, G signal mula sa nakaraang yugto.
Kasama sa PG logic ang AND & XOR gate kung saan ginagamit ang AND logic gate para sa pagbuo ng G signal at ang XOR logic gate ay nagbibigay ng P signal. Upang alisin ang mga hindi kinakailangang inverter, dalawang uri ng gray na mga cell at itim na mga cell ang ginagamit. Ang inverting gate na ginagamit sa isang row para sa gray na cell ay AOI o AND-OR-Inverter at ang inverting gate para sa black cell sa loob ng susunod na row ay gumagamit ng OAI o OR-AND-Inverter. Ginagamit ng AOI cell ang mga normal na input upang magbigay ng mga inverted na output samantalang ang OAI ay gumagamit ng mga inverted input upang magbigay ng mga normal na output.
Brent Kung Adder Operation
Ang Brent Kung adder ay isang parallel prefix adder na ginagamit para sa pagpapatakbo ng high-performance na karagdagan. Ang adder na ito ay mukhang isang istraktura ng puno na nagsasagawa ng operasyon ng aritmetika. Kasama sa adder na ito ang mga black cell at gray na cell. Ang bawat black cell ay may dalawang AND gate at single OR gate at bawat gray na cell ay may iisang AND gate lang.
Kasama sa Brent-kung adder ang dalawang yugto; ang yugto ng pre-processing at yugto ng henerasyon. Sa unang yugto, ang pagbuo at pagpapalaganap ay magmumula sa bawat pares ng mga input. Dito ang propagate ay nagbibigay ng isang 'XOR' na operasyon para sa input bits samantalang ang bumubuo ay nagbibigay ng isang 'AT' na operasyon para sa input bits. Ang propagate at bumuo tulad ng 'Pi' at 'Gi' ay ibinigay sa ibaba.
Pi = Ai XOR Bi at Gi = Ai AT Bi.
Sa ikalawang yugto, ang carry ay bubuo para sa bawat bit na kilala bilang carry generate 'Cg' at carry ay nagpapalaganap para sa bawat bit ay kilala bilang carry generate 'Cp'. Para sa karagdagang operasyon, bubuo ng carry propagate at carry gene. Ang huling cell na magagamit sa loob ng bawat bit operate ay nagbibigay ng carry. Kaya't ang huling bit carry ay tutulong sa kabuuan ng susunod na bit nang sabay-sabay hanggang sa huling bit. Ang carry na bumubuo at nagpapalaganap ay ibinibigay bilang;
Cp = P1 AT P0 at Cg=G1 O (P1 AT G0)
Ito ay pangunahing ginagamit para sa pagdaragdag ng operasyon ng dalawang tatlumpu't dalawang bits at bawat bit ay nakakaranas ng preprocessing stage at generation stage pagkatapos ay nagbibigay ito ng huling kabuuan.
Ang mga pangunahing input bit ay nasa ibaba ng pre-processing stage at gumagawa sila ng propagate at generate. Kaya ang mga ito ay nagpapalaganap pati na rin ang bumubuo ay sumasailalim sa yugto ng henerasyon ay bumubuo ng mga carry na bumubuo at nagdadala ng mga nagpapalaganap at nagbibigay ng panghuling kabuuan. Ang hakbang-hakbang na proseso ng Brent-kung adder ay ipinapakita sa ibaba.
Ang pag-aayos ng Brent-kung adder ay mukhang isang istraktura ng puno at ito ang high-speed adder na nagta-target sa gate-level na logic. Ang adder na ito ay maaaring idisenyo na may pagbaba ng bilang ng mga logic gate. Kaya, binabawasan nito ang pagkaantala at memorya na ginamit sa loob ng arkitektura na ito.
Brent Kung Adder Verilog Code
Ang Brent Kung adder verilog code ay ipinapakita sa ibaba.
`define INPUTSIZE 64 //itakda ang laki ng input n
`define GROUPSIZE 8 //itakda ang laki ng grupo = 1, 2, 4 o 8
module Brent_Kung_Adder(A, B, S);
input [`INPUTSIZE – 1:0] A;
input [`INPUTSIZE – 1:0] B;
output [`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;
italaga ang cin[0] = 1’b0;
bumuo
saan sa;
para sa (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) magsisimula: 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])
);
wakas
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])
);
para sa (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) magsisimula: cin_generation
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1’b0),
.cin(cin[i + 1])
);
wakas
magtalaga ng S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
endgenerate
endmodule
// Unang kalahati ng parallel prefix tree
module parallel_prefix_tree_first_half #(parameter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
input [Treesize * 2 – 1:0] q;
output [Treesize * 2 – 1:0] r;
bumuo
saan sa;
kung (Treesize == 2) magsisimula: trivial_case
magtalaga ng r[1:0] = q[1:0];
prefix_logic f(
.ql(q[1:0]),
.qh(q[3:2]),
.r(r[3:2])
);
end else begin: recursive_case
wire [Treesize * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_lsbh(
.q(q[Laki ng Puno – 1:0]),
.r(r_temp[Laki ng Puno – 1:0])
);
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_msbh(
.q(q[Treesize * 2 – 1:Treesize]),
.r(r_temp[Treesize * 2 – 1:Treesize])
);
para sa (i = 0; i < Treesize * 2; i = i + 2) magsisimula: parallel_stitch_up
kung (i != Treesize * 2 – 2) magsisimula: parallel_stitch_up_pass
magtalaga ng r[i + 1:i] = r_temp[i + 1:i];
end else begin: parallel_stitch_up_produce
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])
);
wakas
wakas
wakas
endgenerate
endmodule
// Pangalawang kalahati ng parallel prefix tree
module parallel_prefix_tree_second_half #(parameter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
input [Treesize * 2 – 1:0] q;
output [Treesize * 2 – 1:0] r;
wire [Treesize * 2 * ($clog2(Treesize) – 1) – 1:0] r_temp;
magtalaga ng r_temp[Treesize * 2 – 1:0] = q[Treesize * 2 – 1:0];
bumuo
genvar i, j;
para sa (i = 0; i < $clog2(Treesize) – 2; i = i + 1) magsisimula: second_half_level
magtalaga ng 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: Laki ng puno * 2 * i];
para sa (j = (Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i);j < Treesize; j = j + 2 ** ($clog2(Treesize / 2 ) – i)) magsimula: second_half_level_logic
prefix_logic f(
.ql(r_temp[Treesize * 2 * i + (j – 2 ** ($clog2(Treesize / 4) – i)) * 2 + 1:Treesize * 2 * i + (j – 2 ** ($clog2( Laki ng puno / 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])
);
kung (j != Laki ng Puno – 1 – 2 ** ($clog2(Laki ng Puno / 4) – i)) ay magsisimula: second_half_level_direct_connect
magtalaga ng 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];
wakas
wakas
magtalaga ng 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];
wakas
magtalaga ng r[1:0] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + 1:Treesize * 2 * ($clog2(Treesize) – 2)];
para sa (i = 1; i < Treesize; i = i + 2) magsisimula: final_r_odd
magtalaga ng r[i * 2 + 1:i * 2] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesize) – 2) + i * 2];
wakas
para sa (i = 2; i < Treesize; i = i + 2) magsisimula: 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])
);
wakas
endgenerate
endmodule
module group_q_generation #(parameter Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
input [Groupsize – 1:0] a;
input [Groupsize – 1:0] b;
input cin;
output [Groupsize – 1:0] s;
output [1:0] qg;
wire [2 * Groupsize – 1:0] q;
wire [Groupsize – 1:0] c;
italaga ang c[0] = cin;
bumuo
saan sa;
para sa (i = 0; i < Groupsize; i = i + 1) magsisimula: parallel_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])
);
kung (i != Groupsize – 1) magsisimula: special_case
magtalaga ng c[i + 1] = q[i * 2 + 1] | (q[i * 2] at c[i]);
wakas
wakas
//group q generation batay sa Groupsize
kung (Groupsize == 1) magsisimula: case_gs1
italaga ang qg[1] = q[1];
italaga ang qg[0] = q[0];
end else if (Groupsize == 2) magsisimula: case_gs2
magtalaga ng qg[1] = q[3] | (q[1] at q[2]);
magtalaga ng qg[0] = q[2] & q[0];
end else if (Groupsize == 4) magsisimula: case_gs4
magtalaga ng qg[1] = q[7] | (q[5] at q[6]) | (q[3] at q[6] at q[4]) | (q[1] & q[6] & q[4] & q[2]);
magtalaga ng qg[0] = q[6] & q[4] & q[2] & q[0];
end else if (Groupsize == 8) magsisimula: case_gs8
magtalaga ng qg[1] = q[15] | (q[13] at q[14]) | (q[11] at q[14] at q[12]) | (q[9] at q[14] at q[12] at q[10]) | (q[7] at q[14] at q[12] at q[10] at 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] at q[4]) | (q[1] & q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2]);
magtalaga ng qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0];
wakas
endgenerate
endmodule
// Lohika ng henerasyon ng Cin
module cin_generation_logic(r, c0, cin);
input [1:0] r;
input c0;
output cin;
magtalaga ng cin = (r[0] & c0) | r[1];
endmodule
// Pangunahing lohika para sa mga pagpapatakbo ng prefix
module prefix_logic(ql, qh, r);
input [1:0] ql;
input [1:0] qh;
output [1:0] r;
magtalaga ng r[0] = qh[0] & ql[0];
magtalaga ng r[1] = (qh[0] at ql[1]) | qh[1];
endmodule
// Full Adder Cell na may Carry Look-Ahead
module FA_CLA_prefix(a, b, cin, s, q);
input a;
input b;
input cin;
output s;
output [1:0] q;
italaga ang q[0] = a ^ b;
magtalaga ng s = q[0] ^ cin;
magtalaga ng q[1] = a & b;
endmodule
Mga kalamangan
Ang mga pakinabang ng Brent Kung Adder ay kinabibilangan ng mga sumusunod.
- Isa itong low-power adder dahil gumagamit ito ng minimum na circuit para makuha ang resulta.
- Ito ay isang napaka-tanyag at malawakang ginagamit na adder.
- Ang ganitong uri ng adder ay maaaring ipatupad sa pamamagitan ng paggamit ng mas kaunting mga module kumpara sa isang Kogge-Stone adder.
- Ang pagdidisenyo ng Brent-Kung adder ay napakadali.
- Ang adder na ito ay may mas kaunting mga koneksyon sa iba pang mga module.
- Ang mga adder na ito ay iminungkahi pangunahin upang malutas ang mga kakulangan ng Kogge-Stone adders.
Mga disadvantages
Ang disadvantages ng Brent Kung Adde r isama ang mga sumusunod.
- Ang mga adder na ito ay may mas malaking pagkaantala at kailangan nito ng 2 log2 n − 2 na antas ng lohika para sa pag-compute ng lahat ng mga bitbit na bitbit.
- Ang pangunahing disbentaha ng adder na ito ay fanout na maaaring maging sanhi ng pagpapalaganap ng agos sa kabuuan ng adder upang mahati at maging mas mahina.
Brent Kung Adder Applications
Ang mga application ng Brent Kung Adder ay kinabibilangan ng mga sumusunod.
- Ang isang Brent–Kung adder ay ginagamit sa isang pipeline na paraan upang bawasan ang pagkonsumo ng kuryente sa pamamagitan ng pagpapababa ng combinatorial logic depth at glitches stabilization.
- Ang Brent-Kung adder ay nagbibigay ng natitirang bilang ng mga yugto mula i/p hanggang sa lahat ng o/ps ngunit may asymmetric Intermediate stages na naglo-load.
- Maaaring gamitin ang adder na ito sa loob ng multiplier pati na rin ang iba pang elemento ng path ng data.
Kaya, ito ay isang pangkalahatang-ideya ng Brent kung adder , ang paggana nito, mga pakinabang, disadvantages, at mga aplikasyon nito. Ito ay isang napakahusay na adder at ang istraktura nito ay mukhang isang istraktura ng puno na pangunahing ginagamit para sa mga pagpapatakbo ng aritmetika na may mataas na pagganap. Ang ganitong uri ng adder ay napakabilis at pangunahing nakatuon sa lohika sa antas ng gate. Ang adder na ito ay dinisenyo sa pamamagitan ng paggamit ng mas kaunting bilang ng mga logic gate. Kaya, binabawasan nito ang memorya at pagkaantala na ginamit sa loob ng arkitektura na ito. Narito ang isang tanong para sa iyo, Brent kung adder na kilala rin bilang?
