Seštevalnik Brent–Kung sta leta 1982 predlagala Hsiang Te Kung in Richard Peirce Brent. Je seštevalnik vzporedne predpone ali drevesni seštevalnik, ki se zaradi svoje prilagodljivosti pogosto uporablja v digitalnem oblikovanju. Vzporedne seštevalnike predpone je mogoče zgraditi na več načinov glede na število logičnih nivojev, logična vrata vpleteni, pahljača iz vsakih vrat in ožičenje med nivoji. Na voljo so različne vrste drevesnih seštevalnikov, temeljna drevesna seštevalnika sta Sklanskym KoggeStone & Brent-Kung. V primerjavi s KSA (Kogge–Stone seštevalnik) ta seštevalnik zagotavlja visoko pravilnost strukture seštevalnika in ima manj blokiranja ožičenja. kar vodi do boljše zmogljivosti in manj potrebne površine čipov. Ta članek vsebuje kratke informacije o a Brent Kung Adder .
Kaj je Brent Kung Adder?
Seštevalnik, ki za pridobitev rezultata uporablja minimalno vezje, je znan kot seštevalnik Brent Kung, znan pa je tudi kot seštevalnik nizke moči ali vzporedni seštevalnik. Ta seštevalnik je namenjen prihranku velikosti čipa, tako da bo izdelava teh seštevalnikov lažja. Simetrija in običajna konstrukcijska struktura tega seštevalnika bosta močno zmanjšala proizvodne stroške in ju je dovoljeno uporabljati v cevovodnih topologijah. Uporaba komplementarne tranzistorske logike pomaga pri izboljšanju konstrukcijske zmogljivosti z multiplekser pristop v različnih modelih celic.
Brent Kung Adder Circuit
Spodaj je prikazan diagram vzporednega seštevalnika predpon brent-kung, ki vključuje stopnjo 1 (stopnja predprocesiranja), stopnje 2 do 7 so stopnje generiranja prenosa in stopnja 8 je naknadna obdelava. Je napredna arhitektura in je zelo enostavna za izdelavo ter zagotavlja manj zastojev pri napeljavi. Torej bo njegovo manjše ožičenje zmanjšalo količino potrebnega prostora za izvedbo arhitekture. Poleg tega postane usmerjanje veliko lažje zaradi križanja (ali) prekrivanja manjšega števila žic. Vendar pa se bo kazen povečala za zakasnitev zaradi povečanega števila stopenj. Razpršenost za ta seštevalnik se poveča, nato pa se zakasnitev poveča.
Kako deluje Brent Kung Adder?
Brent Kung Adder deluje tako, da izračuna predpone za dve bitni skupini, ki sta uporabni pri iskanju 4-bitnih predpon skupin. Te predpone se uporabljajo za izračun predpon 8-bitne skupine itd. Po tem bodo te predpone uporabljene za izračun izvedbe določene bitne stopnje. Ti prenosi se uporabljajo z naslednjo stopnjo Group Propagate za izračun vsote bita te stopnje. Brent Kung Tree uporablja 2log2N – 1 stopnja.
32-bitni Brent Kung Adder
Spodaj je prikazana postavitev 32-bitnega seštevalnika Brent Kung. Na začetku te postavitve so zasnovana osnovna logična vrata, kot so NAND, pretvornik, XOR, NOR itd. Po tem so potrebne celice, kot so črne celice, sive celice, medpomnilniki in logika PG, zasnovane z logičnimi vrati.
V spodnjem 32-bitnem seštevalniku Brent Kung se obračajoča vrata, kot sta AOI in OAI, alternativno uporabljajo predvsem za sive in črne celice. Tako so črne in sive celice predstavljene s sivimi in črnimi bloki, medpomnilniki pa s krogi.
Vhodi, kot sta A in B, so na voljo logiki PG, ki je prikazana v blokovnem diagramu. Za 32-bitni seštevalnik je potrebnih 32 logičnih blokov PG in signala za širjenje (P) in generiranje (G) sta izhoda tega bloka. Ti signali so posredovani drevesni strukturi seštevalnika Brent Kung. Struktura tega seštevalnika vključuje sive in črne celice.
Siva celica vključuje tri vhode in en izhod. Razširjanje in generiranje signalov iz trenutne stopnje in generiranje signalov iz prejšnje stopnje sta vhoda, medtem ko je skupinsko generiranje signalov o/p. V kateri koli drevesni strukturi se bo vsaka stopnja končala s sivo celico in o/p te celice je skupinsko generiranje signala. Ta signal se obravnava preprosto kot prenos te stopnje. Črna celica vključuje štiri vhode in dva izhoda. Vhodi za to celico so signali P & G trenutne stopnje in signali P, G iz prejšnje stopnje.
Logika PG vključuje vrata IN in XOR, kjer se logična vrata IN uporabljajo za generiranje signala G, logična vrata XOR pa zagotavljajo signal P. Za odpravo nepotrebnih pretvornikov se uporabljata dve vrsti sivih in črnih celic. Invertirajoča vrata, ki se uporabljajo v eni vrstici za sivo celico, so AOI ali IN-ALI-inverter, invertirajoča vrata za črno celico v naslednji vrstici pa uporabljajo OAI ali ALI-IN-inverter. Celica AOI uporablja običajne vhode za zagotavljanje obrnjenih izhodov, medtem ko OAI uporablja obrnjene vhode za zagotavljanje običajnih izhodov.
Operacija Brent Kung Adder
Seštevalnik Brent Kung je vzporedni seštevalnik predpon, ki se uporablja za delovanje visokozmogljivega seštevanja. Ta seštevalnik je videti kot drevesna struktura, ki izvaja aritmetično operacijo. Ta seštevalnik vključuje črne in sive celice. Vsaka črna celica ima dve vrati IN in ena vrata ALI, vsaka siva celica pa ima samo ena vrata IN.
Seštevalnik Brent-kung vključuje dve stopnji; stopnja predhodne obdelave in stopnja generiranja. V prvi fazi bo generiranje in širjenje iz vsakega para vhodov. Tukaj propagate zagotavlja operacijo 'XOR' za vhodne bite, medtem ko generira operacijo 'AND' za vhodne bite. Razmnoževanje in ustvarjanje kot 'Pi' in 'Gi' sta podana spodaj.
Pi = Ai XOR Bi in Gi = Ai IN Bi.
V drugi fazi bo prenos ustvarjen za vsak bit, kar je znano kot generiranje prenosa 'Cg' in prenos, ki se širi za vsak bit, je znan kot generiranje prenosa 'Cp'. Za nadaljnje delovanje bo ustvarjen prenos prenosa in prenosa. Končna celica, ki je na voljo v operaciji vsak bit, zagotavlja prenos. Tako bo končni prenos bita pomagal pri vsoti naslednjega bita sočasno do zadnjega bita. Generiranje in širjenje prenosa sta podana kot;
Cp = P1 IN P0 in Cg=G1 ALI (P1 IN G0)
Uporablja se predvsem za seštevanje dveh dvaintridesetih bitov in vsak bit doživi stopnjo predprocesiranja in fazo generiranja, nato pa zagotovi končno vsoto.
Primarni vhodni biti gredo pod stopnjo predprocesiranja in proizvajajo, širijo in ustvarjajo. Tako se ti širijo in ustvarjajo, je podvržen fazi generiranja, generira prenos, generira in prenaša, se razmnožuje in zagotavlja končno vsoto. Spodaj je prikazan postopek seštevalnika Brent-kung po korakih.
Ureditev seštevalnika Brent-kung je videti kot drevesna struktura in to je seštevalnik visoke hitrosti, ki cilja na logiko na ravni vrat. Ta seštevalnik je mogoče oblikovati z zmanjšanjem števila logičnih vrat. Tako zmanjša zakasnitev in pomnilnik, uporabljen v tej arhitekturi.
Brent Kung Adder Verilog koda
Koda verilog seštevalnika Brent Kung je prikazana spodaj.
`define INPUTSIZE 64 //nastavi velikost vnosa n
`define GROUPSIZE 8 //nastavite velikost skupine = 1, 2, 4 ali 8
modul Brent_Kung_Adder(A, B, S);
vnos [`INPUTSIZE – 1:0] A;
vnos [`INPUTSIZE – 1:0] B;
izhod [`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;
dodeli cin[0] = 1’b0;
ustvariti
kje v;
za (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) začetek: parallel_FA_CLA_prefix
group_q_generation #(.Groupsize(`GROUPSIZE))
f(
.a(A['GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.b(B[`SKUPINA VELIKOST * (i + 1) – 1:`SKUPINA VELIKOST * i]),
.cin(cin[i]),
.s(S[`GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.qg(q[i * 2 + 1:i * 2])
);
konec
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) začetek: cin_generacija
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1'b0),
.cin(cin[i + 1])
);
konec
dodeli S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
endgenerate
končni modul
// Prva polovica drevesa vzporednih predpon
modul parallel_prefix_tree_first_half #(parameter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
vnos [Velikost drevesa * 2 – 1:0] q;
izhod [Velikost drevesa * 2 – 1:0] r;
ustvariti
kje v;
if (Velikost drevesa == 2) začetek: trivialni_primer
dodeli 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
žica [Velikost drevesa * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_lsbh(
.q(q[Velikost drevesa – 1:0]),
.r(r_temp[velikost drevesa – 1:0])
);
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_msbh(
.q(q[Velikost drevesa * 2 – 1:Velikost drevesa]),
.r(r_temp[Velikost drevesa * 2 – 1:Velikost drevesa])
);
for (i = 0; i < Treesize * 2; i = i + 2) začetek: parallel_stitch_up
if (i != Treesize * 2 – 2) začetek: parallel_stitch_up_pass
dodeli r[i + 1:i] = r_temp[i + 1:i];
end else begin: parallel_stitch_up_produce
prefix_logic f(
.ql(r_temp[Velikost drevesa – 1:Velikost drevesa – 2]),
.qh(r_temp[Velikost drevesa * 2 – 1:Velikost drevesa * 2 – 2]),
.r(r[Velikost drevesa * 2 – 1:Velikost drevesa * 2 – 2])
);
konec
konec
konec
endgenerate
končni modul
// Druga polovica drevesa vzporednih predpon
modul parallel_prefix_tree_second_half #(parameter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
vnos [Velikost drevesa * 2 – 1:0] q;
izhod [Velikost drevesa * 2 – 1:0] r;
žica [Velikost drevesa * 2 * ($clog2(Velikost drevesa) – 1) – 1:0] r_temp;
dodeli r_temp[Velikost drevesa * 2 – 1:0] = q[Velikost drevesa * 2 – 1:0];
ustvariti
genvar i, j;
for (i = 0; i < $clog2(Treesize) – 2; i = i + 1) začetek: druga_polovična_nivo
dodeli r_temp[Velikost drevesa * 2 * (i + 1) + ((Velikost drevesa / (2 ** i)) – 1 – 2 ** ($clog2(Velikost drevesa / 4) – i)) * 2 – 1:Velikost drevesa * 2 * (i + 1)] = r_temp[Velikost drevesa * 2 * i + ((Velikost drevesa / (2 ** i)) – 1 – 2 ** ($clog2(Velikost drevesa / 4) – i)) * 2 – 1: Velikost drevesa * 2 * i];
za (j = (Velikost drevesa / (2 ** i)) – 1 – 2 ** ($clog2(Velikost drevesa / 4) – i); j < Velikost drevesa; j = j + 2 ** ($clog2(Velikost drevesa / 2) ) – i)) začetek: logika_druge_polovične_stopnje
prefix_logic f(
.ql(r_temp[Velikost drevesa * 2 * i + (j – 2 ** ($clog2(Velikost drevesa / 4) – i)) * 2 + 1:Velikost drevesa * 2 * i + (j – 2 ** ($clog2( Velikost drevesa / 4) – i)) * 2]),
.qh(r_temp[Velikost drevesa * 2 * i + j * 2 + 1:Velikost drevesa * 2 * i + j * 2]),
.r(r_temp[Velikost drevesa * 2 * (i + 1) + j * 2 + 1:Velikost drevesa * 2 * (i + 1) + j * 2])
);
if (j != Treesize – 1 – 2 ** ($clog2(Treesize / 4) – i)) začetek: second_half_level_direct_connect
dodeli r_temp[Velikost drevesa * 2 * (i + 1) + (j + 2 ** ($clog2(Velikost drevesa / 2) – i)) * 2 – 1:Velikost drevesa * 2 * (i + 1) + j * 2 + 2] = r_temp[Velikost drevesa * 2 * i + (j + 2 ** ($clog2(Velikost drevesa / 2) – i)) * 2 – 1:Velikost drevesa * 2 * i + j * 2 + 2];
konec
konec
dodeli r_temp[Velikost drevesa * 2 * (i + 2) – 1:Velikost drevesa * 2 * (i + 2) – (2 ** ($clog2(Velikost drevesa / 4) – i)) * 2] = r_temp[Velikost drevesa * 2 * (i + 1) – 1:Velikost drevesa * 2 * (i + 1) – (2 ** ($clog2(Velikost drevesa / 4) – i)) * 2];
konec
dodeli r[1:0] = r_temp[Velikost drevesa * 2 * ($clog2(Velikost drevesa) – 2) + 1:Velikost drevesa * 2 * ($clog2(Velikost drevesa) – 2)];
za (i = 1; i < Velikost drevesa; i = i + 2) začetek: final_r_odd
dodeli r[i * 2 + 1:i * 2] = r_temp[Velikost drevesa * 2 * ($clog2(Velikost drevesa) – 2) + i * 2 + 1:Velikost drevesa * 2 * ($clog2(Velikost drevesa) – 2) + i * 2];
konec
for (i = 2; i < Treesize; i = i + 2) začetek: final_r_even
prefix_logic f(
.ql(r_temp[Velikost drevesa * 2 * ($clog2(Velikost drevesa) – 2) + i * 2 – 1:Velikost drevesa * 2 * ($clog2(Velikost drevesa) – 2) + i * 2 – 2]),
.qh(r_temp[Velikost drevesa * 2 * ($clog2(Velikost drevesa) – 2) + i * 2 + 1:Velikost drevesa * 2 * ($clog2(Velikost drevesa) – 2) + i * 2]),
.r(r[i * 2 + 1:i * 2])
);
konec
endgenerate
končni modul
modul group_q_generation #(parameter Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
vnos [velikost skupine – 1:0] a;
vnos [velikost skupine – 1:0] b;
vnos cin;
izhod [velikost skupine – 1:0] s;
izhod [1:0] qg;
žica [2 * velikost skupine – 1:0] q;
žica [Velikost skupine – 1:0] c;
dodeli c[0] = cin;
ustvariti
kje v;
za (i = 0; i < velikost skupine; i = i + 1) začetek: parallel_FA_CLA_prefix
FA_CLA_predpona f(
.a(a[i]),
.b(b[i]),
.cin(c[i]),
.s(s[i]),
.q(q[i * 2 + 1:i * 2])
);
if (i != Groupsize – 1) začetek: poseben_primer
priredi c[i + 1] = q[i * 2 + 1] | (q[i * 2] & c[i]);
konec
konec
//generacija skupine q na podlagi velikosti skupine
if (velikost skupine == 1) začetek: case_gs1
dodeli qg[1] = q[1];
dodeli qg[0] = q[0];
end else if (Groupsize == 2) begin: case_gs2
dodeli qg[1] = q[3] | (q[1] & q[2]);
dodeli qg[0] = q[2] & q[0];
end else if (Groupsize == 4) begin: case_gs4
dodeli qg[1] = q[7] | (q[5] & q[6]) | (q[3] & q[6] & q[4]) | (q[1] & q[6] & q[4] & q[2]);
dodeli qg[0] = q[6] & q[4] & q[2] & q[0];
end else if (Groupsize == 8) begin: case_gs8
dodeli 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]);
dodeli qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0];
konec
endgenerate
končni modul
// Logika generiranja Cin
modul cin_generation_logic(r, c0, cin);
vnos [1:0] r;
vnos c0;
izhod cin;
dodeli cin = (r[0] & c0) | r[1];
končni modul
// Osnovna logika za operacije predpon
modul prefix_logic(ql, qh, r);
vnos [1:0] ql;
vnos [1:0] qh;
izhod [1:0] r;
dodeli r[0] = qh[0] & ql[0];
dodeli r[1] = (qh[0] & ql[1]) | qh[1];
končni modul
// Polna celica seštevalnika s Carry Look-Ahead
modul FA_CLA_prefix(a, b, cin, s, q);
vnos a;
vnos b;
vnos cin;
izhod s;
izhod [1:0] q;
dodeli q[0] = a ^ b;
dodeli s = q[0] ^ cin;
dodeli q[1] = a & b;
končni modul
Prednosti
Prednosti Brent Kung Adder vključujejo naslednje.
- To je seštevalnik z nizko porabo energije, ker za pridobitev rezultata uporablja minimalno vezje.
- Je zelo priljubljen in pogosto uporabljen seštevalnik.
- To vrsto seštevalnika je mogoče implementirati z uporabo manj modulov v primerjavi s seštevalnikom Kogge-Stone.
- Načrtovanje seštevalnika Brent-Kung je zelo enostavno.
- Ta seštevalnik ima manj povezav z drugimi moduli.
- Ti seštevalniki so bili predlagani predvsem za odpravo pomanjkljivosti seštevalnikov Kogge-Stone.
Slabosti
The slabosti Brenta Kung Addeja r vključujejo naslednje.
- Ti seštevalniki imajo večjo zakasnitev in potrebujejo 2 log2 n − 2 logični ravni za izračun vseh prenosnih bitov.
- Glavna pomanjkljivost tega seštevalnika je razcep, ki lahko povzroči, da se širjenje toka po seštevalniku razcepi in postane šibkejše.
Aplikacije Brent Kung Adder
Aplikacije Brenta Kung Adderja vključujejo naslednje.
- Seštevalnik Brent–Kung se uporablja na cevovodni način za zmanjšanje porabe energije z zmanjšanjem kombinatorične logične globine in stabilizacije motenj.
- Seštevalnik Brent-Kung zagotavlja izjemno število stopenj od i/p do vseh o/ps, vendar z asimetričnim nalaganjem vmesnih stopenj.
- Ta seštevalnik se lahko uporablja znotraj množitelja kot tudi drugih elementov podatkovne poti.
Torej, to je pregled Brent kung adderja , njegovo delovanje, prednosti, slabosti in aplikacije. To je zelo učinkovit seštevalnik in njegova struktura je videti kot drevesna struktura, ki se uporablja predvsem za visoko zmogljive aritmetične operacije. Ta vrsta seštevalnika je zelo hitra in se osredotoča predvsem na logiko na ravni vrat. Ta seštevalnik je zasnovan z uporabo manjšega števila logičnih vrat. Tako zmanjša pomnilnik in zakasnitev, uporabljena v tej arhitekturi. Tukaj je vprašanje za vas, Brent kung adder znan tudi kot?
