El sumador Brent-Kung va ser proposat el 1982 per Hsiang Te Kung i Richard Peirce Brent. És un sumador de prefixos paral·lels o sumador d'arbres que s'utilitza àmpliament en el disseny digital per la seva flexibilitat. Els sumadors de prefixos paral·lels es poden construir de diverses maneres en funció del nombre de nivells lògics, portes lògiques implicats, el ventall de cada porta i el cablejat entre els nivells. Hi ha diferents tipus de sumadors d'arbres disponibles, els sumadors d'arbre fonamentals són Sklanskym KoggeStone i Brent-Kung, en comparació amb el KSA (Kogge–Stone adder), aquest sumador proporciona una gran regularitat a l'estructura del sumador i té menys bloqueig de cablejat. que condueix a un millor rendiment i menys àrea de xip necessària. Aquest article proporciona informació breu sobre a Brent Kung Adder .
Què és Brent Kung Adder?
Un sumador que utilitza un circuit mínim per obtenir el resultat es coneix com Brent Kung Adder i també es coneix com a sumador de baixa potència o sumador paral·lel. Aquest sumador està pensat per estalviar la mida del xip perquè la fabricació d'aquests sumadors sigui més fàcil. La simetria d'aquest sumador i l'estructura de construcció habitual reduiran molt els costos de producció i es permetran utilitzar-los en topologies canalitzades. La utilització de la lògica de transistors de passada complementària ajuda a millorar el rendiment del disseny amb el multiplexor enfocament en diferents dissenys cel·lulars.
Circuit Brent Kung Adder
A continuació es mostra el diagrama de sumador de prefixos paral·lels brent-kung que inclou l'etapa 1 (etapa de preprocessament), les etapes 2 a 7 són etapes de generació de transport i l'etapa 8 és el postprocessament. És una arquitectura avançada i és molt senzill de construir i proporciona menys congestió de cablejat. Per tant, el seu menys cablejat disminuirà la quantitat d'espai necessari per executar l'arquitectura. A més, l'encaminament es fa molt més fàcil a causa de l'encreuament (o) superposició de menys cables. No obstant això, la penalització augmentarà en retard a causa de l'augment del nombre d'etapes, s'augmenta la sortida de ventilació d'aquest sumador i, a continuació, augmentarà el retard.
Com funciona Brent Kung Adder?
Brent Kung Adder funciona calculant els prefixos per a grups de dos bits que són útils per trobar els prefixos de grups de 4 bits. Aquests prefixos s'utilitzen per calcular els prefixos del grup de 8 bits, etc. Després d'això, aquests prefixos s'utilitzaran per calcular la realització de l'etapa de bits específica. Aquests transports s'utilitzen amb la propagació del grup de l'etapa següent per calcular el bit Sum d'aquesta etapa. Brent Kung Tree utilitza 2log2N - 1 etapa.
Brent Kung Adder de 32 bits
A continuació es mostra el disseny del sumador Brent Kung de 32 bits. Al començament d'aquest disseny, es dissenyen portes lògiques bàsiques com NAND, inversor, XOR, NOR, etc. Després d'això, les cel·les necessàries com les cel·les negres, les cel·les grises, els buffers i la lògica PG es dissenyen amb les portes lògiques.
Al sumador Brent Kung de 32 bits a continuació, les portes inversores com AOI i OAI s'utilitzen alternativament principalment per a cèl·lules grises i negres. Així, les cel·les negres i grises es representen amb blocs grisos i negres, mentre que els buffers es representen amb cercles.
Les entrades com A i B es proporcionen a la lògica PG que es mostra al diagrama de blocs. Per a un sumador de 32 bits, són necessaris 32 blocs lògics PG i els senyals de propagació (P) i generació (G) són les sortides d'aquest bloc. Aquests senyals es proporcionen a l'estructura d'arbre del sumador de Brent Kung. L'estructura d'aquest sumador inclou cèl·lules grises i cèl·lules negres.
Una cel·la grisa inclou tres entrades i una única sortida. Els senyals de propagació i generació de l'etapa actual i els senyals de generació de l'etapa anterior són entrades, mentre que el grup de senyals de generació és l'o/p. En qualsevol estructura d'arbre, cada etapa acabarà amb una cel·la grisa i l'o/p d'aquesta cel·la és el senyal que genera el grup. Aquest senyal es considera simplement com el transport d'aquesta etapa. La pila negra inclou quatre entrades i dues sortides. Les entrades d'aquesta cel·la són els senyals P & G de l'etapa actual i els senyals P, G de l'etapa anterior.
Una lògica PG inclou portes AND & XOR on la porta lògica AND s'utilitza per generar el senyal G i la porta lògica XOR proporciona el senyal P. Per eliminar inversors innecessaris, s'utilitzen dos tipus de cèl·lules grises i cèl·lules negres. Les portes inversores utilitzades en una fila per a la cel·la grisa són AOI o AND-OR-inverter i les portes inversores per a la cel·la negra de la fila següent utilitzen OAI o OR-AND-inverter. La cel·la AOI utilitza les entrades normals per proporcionar sortides invertides, mentre que OAI utilitza entrades invertides per proporcionar sortides normals.
Operació Brent Kung Adder
El sumador Brent Kung és un sumador de prefix paral·lel utilitzat per a l'operació d'addició d'alt rendiment. Aquest sumador sembla una estructura d'arbre que realitza l'operació aritmètica. Aquest sumador inclou cèl·lules negres i cel·les grises. Cada cel·la negra té dues portes AND i una única porta OR i cada cel·la grisa només té una única porta AND.
El sumador Brent-kung inclou dues etapes; fase de preprocessament i fase de generació. En la primera etapa, generar i propagar serà de cada parell d'entrades. Aquí, la propagació proporciona una operació 'XOR' per als bits d'entrada, mentre que genera proporciona una operació 'I' per als bits d'entrada. La propagació i generació com 'Pi' i 'Gi' es donen a continuació.
Pi = Ai XOR Bi i Gi = Ai AND Bi.
En la segona etapa, el transport es generarà per a cada bit que es coneix com a carry genera 'Cg' i el carry es propaga per a cada bit es coneix com a carry generate 'Cp'. Per a l'operació posterior, es generarà carry propagate i carry generate. La cel·la final disponible dins de l'operació de cada bit proporciona transport. Així, el transport de bits final ajudarà a la suma del bit següent simultàniament fins a l'últim bit. Els carry generate & propagate es donen com;
Cp = P1 I P0 i Cg=G1 O (P1 I G0)
S'utilitza principalment per a l'operació d'addició de dos trenta-dos bits i cada bit experimenta l'etapa de preprocessament i l'etapa de generació, després proporciona la suma final.
Els bits d'entrada primaris van per sota de l'etapa de preprocessament i produeixen propagació i generació. Per tant, aquests es propaguen, així com generar, es sotmeten a l'etapa de generació, genera transport, genera i transport, es propaga i proporciona la suma final. A continuació es mostra el procés pas a pas del sumador Brent-kung.
La disposició del sumador Brent-kung sembla una estructura d'arbre i és el sumador d'alta velocitat que s'orienta a la lògica de nivell de porta. Aquest sumador es pot dissenyar amb una disminució del nombre de portes lògiques. Així, redueix el retard i la memòria utilitzada dins d'aquesta arquitectura.
Brent Kung Adder Codi Verilog
A continuació es mostra el codi de verilog del sumador Brent Kung.
`definir INPUTSIZE 64 //establir la mida d'entrada n
`definir GROUPSIZE 8 //establir la mida del grup = 1, 2, 4 o 8
mòdul Brent_Kung_Adder(A, B, S);
entrada [`INPUTSIZE – 1:0] A;
entrada [`INPUTSIZE – 1:0] B;
sortida [`INPUTSIZE:0] S;
cable [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r_temp;
cable [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r;
cable [`INPUTSIZE / `GROUPSIZE:0] cin;
cable [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] q;
assignar cin[0] = 1’b0;
generar
on dins;
per (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) comença: parallel_FA_CLA_prefix
group_q_generation #(.Groupize(`GROUPSIZE))
f(
.a(A[`GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.b(B[`MITADA DEL GRUP * (i + 1) – 1:`TAM DEL GRUP * i]),
.cin(cin[i]),
.s(S[`GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.qg(q[i * 2 + 1:i * 2])
);
final
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])
);
per (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) comença: cin_generation
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1’b0),
.cin(cin[i + 1])
);
final
assignar S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
generar final
mòdul final
// Primera meitat de l'arbre de prefixos paral·lels
module parallel_prefix_tree_first_half #(parametre Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
entrada [Mida de l'arbre * 2 – 1:0] q;
sortida [Treesize * 2 – 1:0] r;
generar
on dins;
if (Treesize == 2) begin: trivial_case
assignar 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
cable [Treesize * 2 – 1:0] r_temp;
paral·lel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_lsbh(
.q(q[Mida de l'arbre – 1:0]),
.r(r_temp[Mida de l'arbre – 1:0])
);
paral·lel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_msbh(
.q(q[Mida de l'arbre * 2 – 1:Mida de l'arbre]),
.r(r_temp[Treesize * 2 – 1:Treesize])
);
per a (i = 0; i < Mida de l'arbre * 2; i = i + 2) comença: punt_paral·lel_amunt
if (i != Treesize * 2 – 2) comença: parallel_stitch_up_pass
assignar 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[Mida de l'arbre * 2 – 1:Mida de l'arbre * 2 – 2])
);
final
final
final
generar final
mòdul final
// Segona meitat de l'arbre de prefixos paral·lels
module parallel_prefix_tree_second_half #(paràmetre Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
entrada [Mida de l'arbre * 2 – 1:0] q;
sortida [Treesize * 2 – 1:0] r;
filferro [Treesize * 2 * ($clog2(Treesize) – 1) – 1:0] r_temp;
assignar r_temp[Treesize * 2 – 1:0] = q[Treesize * 2 – 1:0];
generar
genvar i, j;
per (i = 0; i < $clog2(Treesize) – 2; i = i + 1) comença: segon_meitat_nivell
assignar 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: Mida de l'arbre * 2 * i];
per a (j = (Treesize / (2 ** i)) – 1 – 2 ** ($clog2 (Treesize / 4) – i); j < Treesize; j = j + 2 ** ($clog2 (Treesize / 2) ) – i)) comença: lògica_de_segon_nivell
prefix_logic f(
.ql(r_temp[Treesize * 2 * i + (j – 2 ** ($clog2(Treesize / 4) – i)) * 2 + 1:Treesize * 2 * i + (j – 2 ** ($clog2( Mida de l'arbre / 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)) comença: segon_nivell_meitat_connectar_directament
assignar 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];
final
final
assignar 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];
final
assignar r[1:0] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + 1:Treesize * 2 * ($clog2(Treesize) – 2)];
per (i = 1; i < Treesize; i = i + 2) comença: final_r_odd
assignar r[i * 2 + 1:i * 2] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesize) – 2) + i * 2];
final
per (i = 2; i < Mida de l'arbre; i = i + 2) comença: 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])
);
final
generar final
mòdul final
mòdul group_q_generation #(paràmetre Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
entrada [Mida del grup – 1:0] a;
entrada [Mida del grup – 1:0] b;
entrada cin;
sortida [Mida del grup – 1:0] s;
sortida [1:0] qg;
cable [2 * Mida del grup - 1:0] q;
filferro [Mida del grup – 1:0] c;
assignar c[0] = cin;
generar
on dins;
per (i = 0; i < Mida del grup; i = i + 1) comença: 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])
);
if (i != Groupsize – 1) comença: cas_especial
assignar c[i + 1] = q[i * 2 + 1] | (q[i * 2] i c[i]);
final
final
//generació del grup q basada en la mida del grup
si (mida del grup == 1) comença: case_gs1
assignar qg[1] = q[1];
assignar qg[0] = q[0];
end else if (mida del grup == 2) begin: case_gs2
assignar qg[1] = q[3] | (q[1] i q[2]);
assignar qg[0] = q[2] & q[0];
end else if (Mida del grup == 4) begin: case_gs4
assignar qg[1] = q[7] | (q[5] i q[6]) | (q[3] i q[6] i q[4]) | (q[1] i q[6] i q[4] i q[2]);
assignar qg[0] = q[6] & q[4] & q[2] & q[0];
end else if (mida del grup == 8) begin: case_gs8
assignar qg[1] = q[15] | (q[13] i q[14]) | (q[11] i q[14] i q[12]) | (q[9] i q[14] i q[12] i q[10]) | (q[7] i q[14] i q[12] i q[10] i q[8]) | (q[5] i q[14] i q[12] i q[10] i q[8] i q[6]) | (q[3] i q[14] i q[12] i q[10] i q[8] i q[6] i q[4]) | (q[1] i q[14] i q[12] i q[10] i q[8] i q[6] i q[4] i q[2]);
assignar qg[0] = q[14] i q[12] i q[10] i q[8] i q[6] i q[4] i q[2] i q[0];
final
generar final
mòdul final
// Lògica de generació Cin
mòdul cin_generation_logic(r, c0, cin);
entrada [1:0] r;
entrada c0;
sortida cin;
assignar cin = (r[0] i c0) | r[1];
mòdul final
// Lògica bàsica per a les operacions de prefix
mòdul prefix_logic(ql, qh, r);
entrada [1:0] ql;
entrada [1:0] qh;
sortida [1:0] r;
assignar r[0] = qh[0] & ql[0];
assignar r[1] = (qh[0] i ql[1]) | qh[1];
mòdul final
// Cèl·lula de sumador completa amb Carry Look-Ahead
mòdul FA_CLA_prefix(a, b, cin, s, q);
entrada a;
entrada b;
entrada cin;
sortida s;
sortida [1:0] q;
assignar q[0] = a ^ b;
assignar s = q[0] ^ cin;
assignar q[1] = a & b;
mòdul final
Avantatges
Els avantatges de Brent Kung Adder inclouen els següents.
- Es tracta d'un sumador de baixa potència perquè utilitza un circuit mínim per obtenir el resultat.
- És un sumador molt popular i àmpliament utilitzat.
- Aquest tipus de sumador es pot implementar utilitzant menys mòduls en comparació amb un sumador Kogge-Stone.
- El disseny del sumador Brent-Kung és molt fàcil.
- Aquest sumador té menys connexions amb altres mòduls.
- Aquests sumadors es van proposar principalment per resoldre els inconvenients dels sumadors de Kogge-Stone.
Desavantatges
El desavantatges de Brent Kung Adde r incloure el següent.
- Aquests sumadors tenen un retard més gran i necessiten 2 log2 n - 2 nivells lògics per calcular tots els bits de transport.
- El principal inconvenient d'aquest sumador és el fanout que pot provocar que la propagació del corrent per tot el sumador es divideixi i es debiliti.
Aplicacions de Brent Kung Adder
Les aplicacions de Brent Kung Adder inclouen les següents.
- Un sumador Brent-Kung s'utilitza de manera canalitzada per reduir el consum d'energia disminuint la profunditat de la lògica combinatòria i l'estabilització de fallades.
- El sumador Brent-Kung proporciona un nombre excepcional d'etapes des d'i/p fins a tots els o/ps, però amb una càrrega asimètrica d'etapes intermèdies.
- Aquest sumador es pot utilitzar dins del multiplicador així com d'altres elements del camí de dades.
Així, això és una visió general de Brent kung adder , el seu funcionament, avantatges, inconvenients i les seves aplicacions. Aquest és un sumador molt eficient i la seva estructura sembla una estructura d'arbre utilitzada principalment per a operacions aritmètiques d'alt rendiment. Aquest tipus de sumador és molt ràpid i se centra principalment en la lògica de nivell de porta. Aquest sumador està dissenyat utilitzant un nombre menor de portes lògiques. Així, redueix la memòria i el retard utilitzats en aquesta arquitectura. Aquí teniu una pregunta per a vosaltres, Brent kung adder també conegut com?
