Brent–Kung zbrajalo predložili su 1982. Hsiang Te Kung i Richard Peirce Brent. To je zbrajalo paralelnog prefiksa ili zbrajalo stabla koje se široko koristi u digitalnom dizajnu zbog svoje fleksibilnosti. Paralelni zbrajači prefiksa mogu se izgraditi na nekoliko načina na temelju broja logičkih razina, logička vrata uključeni, izlaz iz svake kapije i ožičenje između razina. Dostupni su različiti tipovi zbrajalica stabla, temeljni zbrajači stabla su Sklanskym KoggeStone & Brent-Kung, U usporedbi s KSA (Kogge–Stone zbrajačem), ovaj zbrajalac pruža visoku pravilnost strukture zbrajala i ima manje blokiranja ožičenja što dovodi do boljih performansi i manje potrebne površine čipa. Ovaj članak pruža kratke informacije o a Brent Kung Adder .
Što je Brent Kung Adder?
Zbrajalo koje koristi minimalni sklop za dobivanje rezultata poznato je kao Brent Kung zbrajalo, a poznato je i kao zbrajalo male snage ili paralelno zbrajalo. Ovo zbrajalo je namijenjeno za uštedu veličine čipa tako da će proizvodnja ovih zbrajala postati lakša. Simetrija i uobičajena konstrukcijska struktura ovog zbrajala uvelike će smanjiti troškove proizvodnje i dopušteno je koristiti u cjevovodnim topologijama. Korištenje logike komplementarnog prolaznog tranzistora pomaže u poboljšanju izvedbe dizajna s multiplekser pristup u različitim dizajnom ćelija.
Brent Kung Adder Circuit
Dolje je prikazan dijagram brent-kung paralelnog zbrajala prefiksa koji uključuje fazu 1 (fazu pretprocesiranja), faze 2 do 7 su faze generiranja prijenosa, a faza 8 je naknadna obrada. To je napredna arhitektura i vrlo je jednostavna za konstruirati te omogućuje manje zagušenja ožičenja. Dakle, manje ožičenja će smanjiti količinu potrebnog prostora za izvođenje arhitekture. Osim toga, usmjeravanje postaje mnogo lakše zbog križanja (ili) preklapanja manjeg broja žica. Međutim, kazna će se povećati u kašnjenju zbog povećanog broja stupnjeva. Izlaz za ovaj zbrajalo je povećan, a zatim će se kašnjenje povećati.
Kako radi Brent Kung Adder?
Brent Kung Adder radi tako što izračunava prefikse za dvije grupe bitova koji su korisni u pronalaženju prefiksa grupe od 4 bita. Ovi se prefiksi koriste za izračunavanje prefiksa 8-bitne grupe, itd. Nakon toga, ti će se prefiksi koristiti za izračunavanje provedbe specifične bitne faze. Ti se prijenosi koriste s grupnim širenjem sljedećeg stupnja za izračunavanje bita zbroja tog stupnja. Brent Kung Tree koristi 2log2N – 1 stupanj.
32-bitni Brent Kung Adder
Dolje je prikazan raspored 32-bitnog zbrajala Brent Kung. Na početku ovog rasporeda dizajnirana su osnovna logička vrata kao što su NAND, inverter, XOR, NOR, itd. Nakon toga, potrebne ćelije kao što su crne ćelije, sive ćelije, međuspremnici i PG logika dizajnirane su s logičkim vratima.
U donjem 32-bitnom Brent Kung zbrajaču, invertirajuća vrata poput AOI i OAI alternativno se koriste uglavnom za sive i crne ćelije. Tako su crne i sive ćelije predstavljene sivim i crnim blokovima, dok su međuspremnici predstavljeni kružićima.
Ulazi kao što su A & B dani su PG logici koja je prikazana na blok dijagramu. Za 32-bitno zbrajalo potrebna su 32 PG logička bloka, a signali širenja (P) i generiranja (G) su izlazi ovog bloka. Ovi signali se dostavljaju strukturi stabla zbrajalice Brent Kung. Struktura ovog zbrajala uključuje sive i crne ćelije.
Siva ćelija uključuje tri ulaza i jedan izlaz. Širenje i generiranje signala iz sadašnje faze i generiranje signala iz prethodne faze su ulazi, dok je grupno generiranje signala o/p. U bilo kojoj strukturi stabla, svaka će faza završiti sivom ćelijom, a o/p ove ćelije je grupno generiranje signala. Ovaj signal se jednostavno smatra prijenosom te faze. Crna ćelija uključuje četiri ulaza i dva izlaza. Ulazi za ovu ćeliju su P & G signali sadašnjeg stupnja i P, G signali iz prethodnog stupnja.
PG logika uključuje AND & XOR vrata gdje se AND logička vrata koriste za generiranje G signala, a XOR logička vrata osiguravaju P signal. Kako bi se uklonili nepotrebni pretvarači, koriste se dvije vrste sivih i crnih ćelija. Invertirajuća vrata koja se koriste u jednom redu za sivu ćeliju su AOI ili I-ILI-inverter, a invertirajuća vrata za crnu ćeliju unutar sljedećeg retka koriste OAI ili ILI-I-inverter. AOI ćelija koristi normalne ulaze za pružanje invertiranih izlaza, dok OAI koristi invertirane ulaze za pružanje normalnih izlaza.
Operacija Brent Kung Adder
Brent Kung zbrajalo je paralelno zbrajalo prefiksa koje se koristi za operaciju zbrajanja visokih performansi. Ovo zbrajalo izgleda kao struktura stabla koja izvodi aritmetičku operaciju. Ovo zbrajalo uključuje crne i sive ćelije. Svaka crna ćelija ima dva I vrata i jedno ILI vrata, a svaka siva ćelija ima samo jedno I vrata.
Brent-kung guja uključuje dva stupnja; faza predobrade i faza generiranja. U prvoj fazi generiranje i širenje bit će iz svakog para ulaza. Ovdje propagate pruža operaciju 'XOR' za ulazne bitove, dok generira daje operaciju 'AND' za ulazne bitove. Širenje i generiranje poput 'Pi' i 'Gi' dani su u nastavku.
Pi = Ai XOR Bi i Gi = Ai I Bi.
U drugoj fazi, prijenos će se generirati za svaki bit koji je poznat kao generiranje prijenosa 'Cg', a prijenos koji se širi za svaki bit je poznat kao generiranje prijenosa 'Cp'. Za daljnji rad, generirati će se prijenos propagiranja i prijenosa generiranja. Posljednja ćelija dostupna unutar operacije svaki bit osigurava prijenos. Tako će posljednji prijenos bita pomoći u zbroju sljedećeg bita istovremeno do posljednjeg bita. Generiranje prijenosa i širenje dani su kao;
Cp = P1 I P0 i Cg=G1 ILI (P1 I G0)
Uglavnom se koristi za operaciju zbrajanja dva trideset i dva bita i svaki bit prolazi fazu pretprocesiranja i fazu generiranja, a zatim daje konačni zbroj.
Primarni ulazni bitovi idu ispod faze pretprocesiranja i proizvode, šire i generiraju. Dakle, ovi propagiraju kao i generiraju prolazi kroz fazu generiranja generira prijenos generira & nosi propagira i daje konačni zbroj. Dolje je prikazan korak po korak postupak zbrajanja Brent-kung.
Brent-kung raspored zbrajalica izgleda kao struktura stabla i to je zbrajalo velike brzine koje cilja na logiku na razini vrata. Ovaj zbrajalo može biti dizajniran sa smanjenjem broja logičkih vrata. Stoga se smanjuje kašnjenje i memorija koja se koristi unutar ove arhitekture.
Brent Kung Adder Verilog kod
Verilog kod zbrajalice Brent Kung prikazan je u nastavku.
`define INPUTSIZE 64 //postavite veličinu unosa n
`definiraj GROUPSIZE 8 //postavi veličinu grupe = 1, 2, 4 ili 8
modul Brent_Kung_Adder(A, B, S);
unos [`INPUTSIZE – 1:0] A;
unos [`INPUTSIZE – 1:0] B;
izlaz [`INPUTSIZE:0] S;
žica [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r_temp;
žica [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r;
žica [`INPUTSIZE / `GROUPSIZE:0] cin;
žica [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] q;
dodijeliti cin[0] = 1’b0;
generirati
gdje u;
za (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) početak: paralelni_FA_CLA_prefiks
group_q_generation #(.Groupsize(`GROUPSIZE))
f(
.a(A[`VELIČINA GRUPE * (i + 1) – 1:`VELIČINA GRUPE * i]),
.b(B[`VELIČINA GRUPE * (i + 1) – 1:`VELIČINA GRUPE * i]),
.cin(cin[i]),
.s(S[`VELIČINA GRUPE * (i + 1) – 1:`VELIČINA GRUPE * i]),
.qg(q[i * 2 + 1:i * 2])
);
kraj
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) početak: cin_generacija
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1'b0),
.cin(cin[i + 1])
);
kraj
dodijeli S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
endgenerirati
krajnji modul
// Prva polovica stabla paralelnog prefiksa
modul parallel_prefix_tree_first_half #(parametar Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
ulaz [Veličina stabla * 2 – 1:0] q;
izlaz [veličina stabla * 2 – 1:0] r;
generirati
gdje u;
if (Treesize == 2) početak: trivijalni_slučaj
dodijeli r[1:0] = q[1:0];
prefiks_logika f(
.ql(q[1:0]),
.qh(q[3:2]),
.r(r[3:2])
);
end else begin: recursive_case
žica [veličina stabla * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
rekurzija_lsbh(
.q(q[veličina stabla – 1:0]),
.r(r_temp[veličina stabla – 1:0])
);
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_msbh(
.q(q[veličina stabla * 2 – 1:veličina stabla]),
.r(r_temp[veličina stabla * 2 – 1:veličina stabla])
);
for (i = 0; i < Treesize * 2; i = i + 2) početak: parallel_stitch_up
if (i != Veličina stabla * 2 – 2) početak: parallel_stitch_up_pass
dodijeliti r[i + 1:i] = r_temp[i + 1:i];
kraj inače početak: paralelno_šivanje_up_proizvodnja
prefiks_logika f(
.ql(r_temp[veličina stabla – 1:veličina stabla – 2]),
.qh(r_temp[veličina stabla * 2 – 1:veličina stabla * 2 – 2]),
.r(r[Veličina stabla * 2 – 1:Veličina stabla * 2 – 2])
);
kraj
kraj
kraj
endgenerirati
krajnji modul
// Druga polovica stabla paralelnog prefiksa
modul parallel_prefix_tree_second_half #(parametar Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
ulaz [Veličina stabla * 2 – 1:0] q;
izlaz [veličina stabla * 2 – 1:0] r;
žica [veličina stabla * 2 * ($clog2(veličina stabla) – 1) – 1:0] r_temp;
dodijeli r_temp[veličina stabla * 2 – 1:0] = q[veličina stabla * 2 – 1:0];
generirati
genvar i, j;
za (i = 0; i < $clog2(Treesize) – 2; i = i + 1) početak: druga_polovina_razine
dodijeli r_temp[veličina stabla * 2 * (i + 1) + ((veličina stabla / (2 ** i)) – 1 – 2 ** ($clog2(veličina stabla / 4) – i)) * 2 – 1:veličina stabla * 2 * (i + 1)] = r_temp[veličina stabla * 2 * i + ((veličina stabla / (2 ** i)) – 1 – 2 ** ($clog2(veličina stabla / 4) – i)) * 2 – 1: Veličina stabla * 2 * i];
za (j = (veličina stabla / (2 ** i)) – 1 – 2 ** ($clog2(veličina stabla / 4) – i); j < veličina stabla; j = j + 2 ** ($clog2(veličina stabla / 2 ) – i)) početak: druga_polovina_logike_razine
prefiks_logika f(
.ql(r_temp[Veličina stabla * 2 * i + (j – 2 ** ($clog2(Veličina stabla / 4) – i)) * 2 + 1:Veličina stabla * 2 * i + (j – 2 ** ($clog2( Veličina stabla / 4) – i)) * 2]),
.qh(r_temp[Veličina stabla * 2 * i + j * 2 + 1:Veličina stabla * 2 * i + j * 2]),
.r(r_temp[veličina stabla * 2 * (i + 1) + j * 2 + 1:veličina stabla * 2 * (i + 1) + j * 2])
);
if (j != Treesize – 1 – 2 ** ($clog2(Treesize / 4) – i)) početak: second_half_level_direct_connect
dodijeli r_temp[veličina stabla * 2 * (i + 1) + (j + 2 ** ($clog2(veličina stabla / 2) – i)) * 2 – 1:veličina stabla * 2 * (i + 1) + j * 2 + 2] = r_temp[veličina stabla * 2 * i + (j + 2 ** ($clog2(veličina stabla / 2) – i)) * 2 – 1:veličina stabla * 2 * i + j * 2 + 2];
kraj
kraj
dodijeli r_temp[veličina stabla * 2 * (i + 2) – 1:veličina stabla * 2 * (i + 2) – (2 ** ($clog2(veličina stabla / 4) – i)) * 2] = r_temp[veličina stabla * 2 * (i + 1) – 1:Veličina stabla * 2 * (i + 1) – (2 ** ($clog2(Veličina stabla / 4) – i)) * 2];
kraj
dodijeli r[1:0] = r_temp[veličina stabla * 2 * ($clog2(veličina stabla) – 2) + 1:veličina stabla * 2 * ($clog2(veličina stabla) – 2)];
za (i = 1; i < veličina stabla; i = i + 2) početak: final_r_odd
dodijeli r[i * 2 + 1:i * 2] = r_temp[veličina stabla * 2 * ($clog2(veličina stabla) – 2) + i * 2 + 1:veličina stabla * 2 * ($clog2(veličina stabla) – 2) + i * 2];
kraj
for (i = 2; i < Veličina stabla; i = i + 2) početak: final_r_even
prefiks_logika f(
.ql(r_temp[veličina stabla * 2 * ($clog2(veličina stabla) – 2) + i * 2 – 1:veličina stabla * 2 * ($clog2(veličina stabla) – 2) + i * 2 – 2]),
.qh(r_temp[veličina stabla * 2 * ($clog2(veličina stabla) – 2) + i * 2 + 1:veličina stabla * 2 * ($clog2(veličina stabla) – 2) + i * 2]),
.r(r[i * 2 + 1:i * 2])
);
kraj
endgenerirati
krajnji modul
modul group_q_generation #(parametar Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
unos [veličina grupe – 1:0] a;
unos [veličina grupe – 1:0] b;
unos cin;
izlaz [veličina grupe – 1:0] s;
izlaz [1:0] qg;
žica [2 * Veličina grupe – 1:0] q;
žica [veličina grupe – 1:0] c;
dodijeli c[0] = cin;
generirati
gdje u;
za (i = 0; i < veličina grupe; i = i + 1) početak: paralelni_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 != Groupsize – 1) početak: poseban_slučaj
dodijeli c[i + 1] = q[i * 2 + 1] | (q[i * 2] & c[i]);
kraj
kraj
//generacija grupe q na temelju veličine grupe
if (veličina grupe == 1) početak: case_gs1
dodijeli qg[1] = q[1];
dodijeli qg[0] = q[0];
end else if (Groupsize == 2) begin: case_gs2
dodijeli qg[1] = q[3] | (q[1] & q[2]);
dodijeli qg[0] = q[2] & q[0];
end else if (Groupsize == 4) begin: case_gs4
dodijeli qg[1] = q[7] | (q[5] & q[6]) | (q[3] & q[6] & q[4]) | (q[1] & q[6] & q[4] & q[2]);
dodijeli qg[0] = q[6] & q[4] & q[2] & q[0];
end else if (Groupsize == 8) begin: case_gs8
dodijeli 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]);
dodijeli qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0];
kraj
endgenerirati
krajnji modul
// Cin generacijska logika
modul cin_generacijska_logika(r, c0, cin);
ulaz [1:0] r;
ulaz c0;
izlaz cin;
dodijeli cin = (r[0] & c0) | r[1];
krajnji modul
// Osnovna logika za prefiksne operacije
modul prefix_logic(ql, qh, r);
unos [1:0] ql;
ulaz [1:0] qh;
izlaz [1:0] r;
dodijeli r[0] = qh[0] & ql[0];
dodijeli r[1] = (qh[0] & ql[1]) | qh[1];
krajnji modul
// Full Adder Cell s Carry Look-Ahead
modul FA_CLA_prefiks(a, b, cin, s, q);
unos a;
ulaz b;
unos cin;
izlaz s;
izlaz [1:0] q;
dodijeli q[0] = a ^ b;
dodijeli s = q[0] ^ cin;
dodijeli q[1] = a & b;
krajnji modul
Prednosti
Prednosti Brent Kung Addera uključuju sljedeće.
- Ovo je zbrajalo male snage jer koristi minimalni krug za dobivanje rezultata.
- To je vrlo popularan i naširoko korišten zbrajalo.
- Ova vrsta zbrajala može se implementirati korištenjem manje modula u usporedbi s Kogge-Stone zbrajačem.
- Projektiranje Brent-Kung zbrajalice je vrlo jednostavno.
- Ovaj zbrajač ima manje veza s drugim modulima.
- Ove su zbrajalice predložene uglavnom za rješavanje nedostataka Kogge-Stoneovih zbrajalica.
Nedostaci
The nedostaci Brenta Kung Addea r uključuju sljedeće.
- Ovi zbrajači imaju veće kašnjenje i trebaju 2 log2 n − 2 logičke razine za izračunavanje svih prijenosnih bitova.
- Glavni nedostatak ovog zbrajala je odvod koji može uzrokovati da se struja kroz zbrajalo razdvoji i postane slabija.
Brent Kung Adder aplikacije
Prijave Brenta Kung Addera uključuju sljedeće.
- Brent–Kung zbrajalo koristi se na cjevovodni način za smanjenje potrošnje energije smanjenjem dubine kombinatorne logike i stabilizacijom kvarova.
- Brent-Kung zbrajalo pruža izvanredan broj stupnjeva od i/p do svih o/ps ali s asimetričnim opterećenjem međustupnjeva.
- Ovo zbrajalo može se koristiti unutar množitelja kao i drugi elementi puta podataka.
Dakle, ovo je pregled Brent kung guja , njegov rad, prednosti, nedostaci i njegove primjene. Ovo je vrlo učinkovito zbrajalo i njegova struktura izgleda kao struktura stabla koja se uglavnom koristi za aritmetičke operacije visokih performansi. Ova vrsta zbrajala je vrlo brza i fokusira se uglavnom na logiku na razini vrata. Ovo zbrajalo je dizajnirano korištenjem manjeg broja logičkih vrata. Stoga smanjuje memoriju i odgodu korištenu unutar ove arhitekture. Evo pitanja za vas, Brent kung guja poznata i kao?
