A Brent–Kung összeadót 1982-ben Hsiang Te Kung és Richard Peirce Brent javasolta. Ez egy párhuzamos előtag-összeadó vagy fa-összeadó, amelyet rugalmassága miatt széles körben használnak a digitális tervezésben. A párhuzamos előtag-összeadók a logikai szintek száma alapján többféleképpen is felépíthetők, logikai kapuk érintett, a ventilátor kivezetés minden kapuból és a vezetékek a szintek között. Különféle faösszeadók állnak rendelkezésre, az alapvető faösszeadók a Sklanskym KoggeStone & Brent-Kung. A KSA-hoz (Kogge–Stone összeadó) képest ez az összeadó nagy szabályosságot biztosít az összeadó szerkezetében, és kevesebb vezetékblokkolással rendelkezik. ami jobb teljesítményt és kevesebb forgácsterületet eredményez. Ez a cikk rövid tájékoztatást nyújt a Brent Kung Adder .
Mi az a Brent Kung Adder?
Az eredmény eléréséhez minimális áramkört használó összeadó Brent Kung Adder néven ismert, és alacsony fogyasztású vagy párhuzamos összeadóként is ismert. Ennek az összeadónak a célja a chip méretének megtakarítása, így az összeadók gyártása könnyebbé válik. Ennek az összeadónak a szimmetriája és a szokásos konstrukciós felépítése nagymértékben csökkenti a gyártási költségeket, és használható csővezetékes topológiákban. A komplementer áteresztő tranzisztor logika alkalmazása segít a tervezési teljesítmény fokozásában multiplexer megközelítést a különböző sejtkialakításokban.
Brent Kung Adder áramkör
Az alábbiakban látható a brent-kung párhuzamos előtag-összeadó diagram, amely tartalmazza az 1. szakaszt (előfeldolgozási szakasz), a 2-7. Ez egy fejlett architektúra, és nagyon egyszerű a felépítése, és kevesebb vezetékes torlódást biztosít. Így a kevesebb vezetékezés csökkenti az architektúra végrehajtásához szükséges helyet. Ezenkívül az útválasztás sokkal könnyebbé válik a kevesebb vezeték keresztezése (vagy átfedése) miatt. Azonban a büntetés a késleltetés miatt nő a fokozatok megnövekedett száma miatt. Ennek az összeadónak a ventilátor kimenete megnő, majd a késleltetés megnő.
Hogyan működik a Brent Kung Adder?
A Brent Kung Adder úgy működik, hogy kiszámítja az előtagokat két bitcsoporthoz, amelyek hasznosak a 4 bites csoport előtagjainak megtalálásához. Ezek az előtagok a 8 bites csoport előtagjainak kiszámítására szolgálnak, stb. Ezt követően ezek az előtagok az adott bitszakasz végrehajtásának kiszámítására szolgálnak. Ezeket a hordozókat a következő szakasz Group Propagate-jével együtt használják az adott szakasz Összeg bitjének kiszámításához. A Brent Kung Tree 2log2N-t használ – 1 fokozat.
32 bites Brent Kung Adder
A 32 bites Brent Kung összeadó elrendezése lent látható. Ennek az elrendezésnek az elején az alapvető logikai kapukat tervezték, mint például a NAND, az inverter, az XOR, a NOR stb. Ezt követően a szükséges cellák, mint a fekete cellák, szürke cellák, pufferek és a PG logika a logikai kapukkal vannak kialakítva.
Az alábbi 32 bites Brent Kung összeadóban az invertáló kapukat, például az AOI-t és az OAI-t főként szürke és fekete cellákhoz használják. Tehát a fekete és szürke cellák szürke és fekete blokkokkal, míg a pufferek körökkel vannak ábrázolva.
Az olyan bemenetek, mint az A és B, a PG logikához vannak biztosítva, amely a blokkdiagramon látható. Egy 32 bites összeadóhoz 32 PG logikai blokk szükséges, és ennek a blokknak a kimenetei a propagate (P) és a generált (G) jelek. Ezeket a jeleket a Brent Kung összeadó fastruktúra biztosítja. Az összeadó szerkezete szürke és fekete cellákat tartalmaz.
Egy szürke cella három bemenetet és egyetlen kimenetet tartalmaz. A jelen szakaszból származó jelek terjedése és generálása, valamint az előző szakaszból származó jelek generálása bemenet, míg a jeleket generáló csoport az o/p. Bármely fastruktúrában minden szakasz egy szürke cellával végződik, és ennek a cellának az o/p-je a csoportgeneráló jel. Ezt a jelet egyszerűen az adott szakasz átvitelének tekintik. A fekete cella négy bemenetet és két kimenetet tartalmaz. Ennek a cellának a bemenetei a jelenlegi fokozat P & G jelei, valamint az előző szakasz P, G jelei.
A PG logika ÉS & XOR kapukat tartalmaz, ahol az ÉS logikai kapu a G jel generálására szolgál, és az XOR logikai kapu biztosítja a P jelet. A felesleges inverterek kiküszöbölésére kétféle szürke és fekete cellát használnak. Az egyik sorban a szürke cellához használt invertáló kapuk AOI vagy AND-OR-Inverter, a következő soron belüli fekete cella invertáló kapui pedig OAI-t vagy OR-AND-Invertert használnak. Az AOI cella a normál bemeneteket használja az invertált kimenetek biztosítására, míg az OAI invertált bemeneteket használ a normál kimenetek biztosítására.
Brent Kung Adder művelet
A Brent Kung összeadó egy párhuzamos előtag-összeadó, amelyet a nagy teljesítményű összeadás műveletéhez használnak. Ez az összeadó úgy néz ki, mint egy fastruktúra, amely végrehajtja az aritmetikai műveletet. Ez az összeadó fekete és szürke cellákat tartalmaz. Minden fekete cellának két ÉS kapuja és egyetlen VAGY kapuja van, és minden szürke cellának csak egyetlen ÉS kapuja van.
A Brent-kung összeadó két szakaszból áll; az előfeldolgozási és generálási szakasz. Az első szakaszban a generálás és terjesztés minden bemenetpárból történik. Itt a propagate „XOR” műveletet biztosít a bemeneti bitekhez, míg a generálás „ÉS” műveletet biztosít a bemeneti bitekhez. A „Pi” és a „Gi” terjesztését és generálását az alábbiakban adjuk meg.
Pi = Ai XOR Bi és Gi = Ai ÉS Bi.
A második szakaszban a átvitelt minden bithez generálják, amelyet 'Cg'-nek neveznek, és a átvitelt minden bithez 'Cp'-nek nevezik. A további művelethez a carry propagate & carry generálást generálják. A minden biten belül elérhető utolsó cella átvitelt biztosít. Tehát az utolsó bitátvitel segíti a következő bit összegzését egyidejűleg az utolsó bitig. A hordozás generálás és propagálás a következőképpen adható meg;
Cp = P1 ÉS P0 és Cg = G1 VAGY (P1 ÉS G0)
Főleg két harminckét bit összeadási műveletére használják, és minden bit átéli az előfeldolgozási és generálási szakaszt, majd adja a végső összeget.
Az elsődleges bemeneti bitek az előfeldolgozási szakasz alá kerülnek, és továbbítják és generálják. Tehát ezek a terjedés és a generálás generálási szakaszon megy keresztül, generál átvitel generál és átvitel terjed, és végső összeget biztosít. A Brent-kung összeadó lépésről lépésre történő folyamata az alábbiakban látható.
A Brent-kung összeadó elrendezése úgy néz ki, mint egy fastruktúra, és ez a nagy sebességű összeadó, amely a kapuszintű logikát célozza meg. Ez az összeadó a logikai kapuk számának csökkentésével tervezhető. Így csökkenti az architektúrán belül felhasznált késleltetést és memóriát.
Brent Kung Adder Verilog kód
A Brent Kung adder verilog kódja lent látható.
`define INPUTSIZE 64 //az n bemeneti méret beállítása
`define GROUPSIZE 8 //állítsa be a csoport méretét = 1, 2, 4 vagy 8
modul Brent_Kung_Adder(A, B, S);
bemenet [`INPUTSIZE – 1:0] A;
bemenet [`INPUTSIZE – 1:0] B;
kimenet [`INPUTSIZE:0] S;
vezeték [`INPUTSIZE / `CSOPORTMÉRET * 2 – 1:0] r_temp;
vezeték [`BEMENETI MÉRET / `CSOPORTMÉRET * 2 – 1:0] r;
vezeték [`INPUTSIZE / `GROUPSIZE:0] cin;
vezeték [`INPUTSIZE / `CSOPORTMÉRET * 2 – 1:0] q;
hozzárendelni cin[0] = 1’b0;
generál
hol van;
for (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) kezdődik: párhuzamos_FA_CLA_prefix
group_q_generation #(.Groupsize(`GROUPSIZE))
f(
.a(A[`CSOPORTMÉRET * (i + 1) – 1:`CSOPORTMÉRET * i]),
.b(B[`CSOPORTMÉRET * (i + 1) – 1:`CSOPORTMÉRET * i]),
.cin(cin[i]),
.s(S[`CSOPORTMÉRET * (i + 1) - 1:`CSOPORTMÉRET * i]),
.qg(q[i * 2 + 1:i * 2])
);
vége
parallel_prefix_tree_first_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t1(
.q(q[`BEMENETI MÉRET / `CSOPORTMÉRET * 2 – 1:0]),
.r(r_temp[`BEMENETI MÉRET / `CSOPORTMÉRET * 2 – 1:0])
);
parallel_prefix_tree_second_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t2(
.q(r_temp[`INPUTSIZE / `CSOPORTMÉRET * 2 – 1:0]),
.r(r[`BEMENETI MÉRET / `CSOPORTMÉRET * 2 – 1:0])
);
for (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) kezdődik: cin_generation
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1'b0),
.cin(cin[i + 1])
);
vége
hozzárendelés S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
végtermék
végmodul
// A párhuzamos előtag fa első fele
modul parallel_prefix_tree_first_half #(paraméter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
bemenet [Treesize * 2 – 1:0] q;
kimenet [Fa méret * 2 – 1:0] r;
generál
hol van;
if (Treesize == 2) begin: trivial_case
hozzárendelni 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
vezeték [Treesize * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_lsbh(
.q(q[faméret – 1:0]),
.r(r_temp[faméret – 1:0])
);
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_msbh(
.q(q[faméret * 2 – 1:faméret]),
.r(r_temp[fa mérete * 2 – 1:fa mérete])
);
for (i = 0; i < fa mérete * 2; i = i + 2) kezdődik: párhuzamos_öltés_fel
if (i != Fa mérete * 2 – 2) kezdődik: parallel_stitch_up_pass
hozzárendelni r[i + 1:i] = r_temp[i + 1:i];
end else begin: parallel_stitch_up_produce
prefix_logic f(
.ql(r_temp[faméret – 1:faméret – 2]),
.qh(r_temp[Faméret * 2 – 1:Faméret * 2 – 2]),
.r(r[fa mérete * 2 - 1: fa mérete * 2 - 2])
);
vége
vége
vége
végtermék
végmodul
// A párhuzamos előtag fa második fele
modul parallel_prefix_tree_second_half #(paraméter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
bemenet [Treesize * 2 – 1:0] q;
kimenet [Fa méret * 2 – 1:0] r;
vezeték [Treesize * 2 * ($clog2(Treesize) – 1) – 1:0] r_temp;
r_temp hozzárendelése[Faméret * 2 – 1:0] = q[Faméret * 2 – 1:0];
generál
genvar i, j;
for (i = 0; i < $clog2(Treesize) – 2; i = i + 1) kezdődik: második_félszint
r_temp hozzárendelése[Faméret * 2 * (i + 1) + ((Faméret / (2 ** i)) – 1 – 2 ** ($clog2(Faméret / 4) – i)) * 2 – 1:Faméret * 2 * (i + 1)] = r_hőmérséklet[Faméret * 2 * i + ((Faméret / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i)) * 2 – 1: Faméret * 2 * i];
for (j = (Faméret / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i); j < Faméret; j = j + 2 ** ($clog2(Faméret / 2) ) – i)) begin: second_half_level_logic
prefix_logic f(
[ Faméret / 4) – i)) * 2]),
.qh(r_temp[fa mérete * 2 * i + j * 2 + 1: fa mérete * 2 * i + j * 2]),
.r(r_temp[faméret * 2 * (i + 1) + j * 2 + 1:fa méret * 2 * (i + 1) + j * 2])
);
if (j != Faméret – 1 – 2 ** ($clog2(Treesize / 4) – i)) kezdődik: második_félszint_közvetlen_csatlakozás
r_temp hozzárendelése [Faméret * 2 * (i + 1) + (j + 2 ** ($clog2(Faméret / 2) – i)) * 2 - 1: Faméret * 2 * (i + 1) + j * 2 + 2] = r_hőmérséklet[Faméret * 2 * i + (j + 2 ** ($clog2(Faméret / 2) – i)) * 2 – 1:Faméret * 2 * i + j * 2 + 2];
vége
vége
r_temp hozzárendelése[Faméret * 2 * (i + 2) – 1:Faméret * 2 * (i + 2) – (2 ** ($clog2(Faméret / 4) – i)) * 2] = r_hőmérséklet[Faméret * 2 * (i + 1) – 1:Faméret * 2 * (i + 1) – (2 ** ($clog2(Treesize / 4) – i)) * 2];
vége
hozzárendelni r[1:0] = r_temp[Faméret * 2 * ($clog2(Faméret) – 2) + 1:Faméret * 2 * ($clog2(Faméret) – 2)];
mert (i = 1; i < fa mérete; i = i + 2) kezdődik: végső_r_páratlan
hozzárendelni r[i * 2 + 1:i * 2] = r_temp[faméret * 2 * ($clog2(faméret) – 2) + i * 2 + 1:fa mérete * 2 * ($clog2(faméret) – 2) + i * 2];
vége
mert (i = 2; i < fa mérete; i = i + 2) kezdődik: végső_r_páros
prefix_logic f(
.ql(r_temp[faméret * 2 * ($clog2(faméret) – 2) + i * 2 – 1:fa mérete * 2 * ($clog2(faméret) – 2) + i * 2 – 2]),
.qh(r_temp[faméret * 2 * ($clog2(faméret) – 2) + i * 2 + 1:faméret * 2 * ($clog2(faméret) – 2) + i * 2]),
.r(r[i * 2 + 1:i * 2])
);
vége
végtermék
végmodul
modul_q_generation #(paraméter Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
bemenet [Csoportméret – 1:0] a;
bemenet [Csoportméret – 1:0] b;
bemeneti cin;
kimenet [Csoportméret – 1:0] s;
kimenet [1:0] qg;
vezeték [2 * Csoportméret – 1:0] q;
vezeték [Csoportméret – 1:0] c;
hozzárendelni c[0] = cin;
generál
hol van;
for (i = 0; i < csoportméret; i = i + 1) kezdődik: párhuzamos_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 != Csoportméret – 1) kezdődik: speciális_eset
hozzárendelni c[i + 1] = q[i * 2 + 1] | (q[i*2] & c[i]);
vége
vége
//group q generáció a Groupsize alapján
if (Csoportméret == 1) kezdődik: case_gs1
hozzárendelni qg[1] = q[1];
hozzárendelni qg[0] = q[0];
end else if (Csoportméret == 2) begin: case_gs2
hozzárendelni qg[1] = q[3] | (q[1] és q[2]);
qg[0] = q[2] & q[0] hozzárendelése;
end else if (Csoportméret == 4) begin: case_gs4
hozzárendelni qg[1] = q[7] | (q[5] és q[6]) | (q[3] és q[6] és q[4]) | (q[1] & q[6] & q[4] és q[2]);
qg[0] = q[6] & q[4] & q[2] & q[0] hozzárendelése;
end else if (Csoportméret == 8) begin: case_gs8
hozzárendelni qg[1] = q[15] | (q[13] és q[14]) | (q[11] & q[14] és q[12]) | (q[9] és q[14] és q[12] és q[10]) | (q[7] és q[14] és q[12] és q[10] és q[8]) | (q[5] és q[14] és q[12] és q[10] és q[8] és q[6]) | (q[3] és q[14] és q[12] és q[10] és q[8] és q[6] és q[4]) | (q[1] & q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2]);
qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0] hozzárendelése;
vége
végtermék
végmodul
// Cin generálási logika
modul cin_generation_logic(r, c0, cin);
bemenet [1:0] r;
bemenet c0;
kimeneti cin;
hozzárendelni cin = (r[0] & c0) | r[1];
végmodul
// Alapvető logika az előtag műveletekhez
modul prefix_logic(ql, qh, r);
bemenet [1:0] ql;
bemenet [1:0] qh;
kimenet [1:0] r;
hozzárendelni r[0] = qh[0] & ql[0];
r[1] = (qh[0] & ql[1]) hozzárendelése | qh[1];
végmodul
// Full Adder Cell Carry Look-Ahead funkcióval
modul FA_CLA_prefix(a, b, cin, s, q);
bemenet a;
b bemenet;
bemeneti cin;
kimenet s;
kimenet [1:0] q;
hozzárendelni q[0] = a ^ b;
hozzárendelni s = q[0] ^ cin;
hozzárendelni q[1] = a & b;
végmodul
Előnyök
A Brent Kung Adder előnyei a következők.
- Ez egy kis teljesítményű összeadó, mert minimális áramkört használ az eredmény eléréséhez.
- Ez egy nagyon népszerű és széles körben használt összeadó.
- Ez a fajta összeadó kevesebb modul használatával valósítható meg, mint egy Kogge-Stone összeadó.
- A Brent-Kung összeadó tervezése nagyon egyszerű.
- Ennek az összeadónak kevesebb kapcsolata van más modulokkal.
- Ezeket az összeadókat főként a Kogge-Stone összeadók hátrányainak megoldására javasolták.
Hátrányok
A Brent Kung Adde hátrányai r tartalmazza a következőket.
- Ezeknek az összeadóknak nagyobb a késleltetésük, és 2 log2 n − 2 logikai szintre van szükségük az összes átviteli bit kiszámításához.
- Ennek az összeadónak a fő hátránya a fanout, amely az áram terjedését az összeadóban feloszthatja és gyengülheti.
Brent Kung Adder alkalmazások
A Brent Kung Adder alkalmazásai a következők.
- A Brent–Kung összeadót csővezetékes módon használják az energiafogyasztás csökkentésére a kombinatorikus logikai mélység és a hibák stabilizálásának csökkentésével.
- A Brent-Kung összeadó kiemelkedő számú fokozatot biztosít az i/p-től az összes o/ps-ig, de aszimmetrikus köztes fokozatok betöltésével.
- Ez az összeadó a szorzón belül, valamint más adatútelemeken belül is használható.
Ez tehát az a Brent kung adder áttekintése , működése, előnyei, hátrányai és alkalmazásai. Ez egy nagyon hatékony összeadó, és szerkezete úgy néz ki, mint egy fastruktúra, amelyet főként nagy teljesítményű aritmetikai műveletekhez használnak. Ez a típusú összeadó nagyon gyors, és főleg a kapuszintű logikára összpontosít. Ezt az összeadót kevesebb logikai kapu használatával tervezték. Így csökkenti az architektúrán belül felhasznált memóriát és késleltetést. Íme egy kérdés, a Brent kung adder más néven?
