Hsiang Te Kung & Richard Peirce Brent ehdottivat Brent–Kung-lisäädintä vuonna 1982. Se on rinnakkaisetuliite- tai puusummain, jota käytetään laajasti digitaalisessa suunnittelussa sen joustavuuden vuoksi. Rinnakkaisetuliitteet voidaan rakentaa useilla tavoilla logiikkatasojen lukumäärän perusteella, logiikka portit mukana, tuuletin jokaisesta portista ja johdotus tasojen välillä. Saatavilla on erilaisia puusummaimia, peruspuusummaimet ovat Sklanskym KoggeStone & Brent-Kung. Verrattuna KSA:han (Kogge-Stone-summeriin), tämä summain tarjoaa suuren säännöllisyyden summaimen rakenteelle ja siinä on vähemmän johdotuksen esteitä. mikä johtaa parempaan suorituskykyyn ja pienempään hakealueeseen. Tämä artikkeli sisältää lyhyet tiedot a Brent Kung Adder .
Mikä on Brent Kung Adder?
Summain, joka käyttää minimipiirejä tuloksen saamiseksi, tunnetaan nimellä Brent Kung Adder ja se tunnetaan myös pienitehoisena summaimena tai rinnakkaissummaimena. Tämän summaimen tarkoituksena on säästää sirun kokoa, jotta näiden summaimien valmistus helpottuu. Tämän summaimen symmetria ja tavallinen rakennusrakenne alentaa tuotantokustannuksia huomattavasti ja niitä voidaan käyttää liukuhihnatopologioissa. Täydentävän pass-transistorilogiikan käyttö auttaa parantamaan suunnittelun suorituskykyä multiplekseri lähestymistapaa erilaisissa solumalleissa.
Brent Kung Adder -piiri
Alla on esitetty brent-kung rinnakkaisetuliitesummainkaavio, joka sisältää vaiheen 1 (esikäsittelyvaihe), vaiheet 2-7 ovat siirtovaiheita ja vaihe 8 on jälkikäsittely. Se on edistynyt arkkitehtuuri ja se on erittäin yksinkertainen rakentaa ja vähentää johdotuksen ruuhkautumista. Joten sen pienempi johdotus vähentää arkkitehtuurin suorittamiseen tarvittavan tilan määrää. Lisäksi reitityksestä tulee paljon helpompaa johtuen harvempien johtimien risteytymisestä (tai päällekkäisyydestä). Rangaistus kuitenkin kasvaa viiveestä johtuen lisääntyneestä portaiden määrästä. Tämän summaimen tuulettimen ulostuloa kasvatetaan ja sitten viivettä kasvatetaan.
Kuinka Brent Kung Adder toimii?
Brent Kung Adder toimii laskemalla etuliitteet kahdelle bittiryhmälle, jotka ovat hyödyllisiä 4-bittisten ryhmien etuliitteiden löytämisessä. Näitä etuliitteitä käytetään 8-bittisen ryhmän etuliitteiden jne. laskemiseen. Tämän jälkeen näitä etuliitteitä käytetään tietyn bittivaiheen suorituksen laskemiseen. Näitä siirtoja käytetään seuraavan vaiheen Group Propagaten kanssa laskemaan kyseisen vaiheen summabitti. Brent Kung Tree käyttää 2log2N - 1 vaihetta.
32-bittinen Brent Kung Adder
32-bittinen Brent Kung -lisäaineasettelu on esitetty alla. Tämän layoutin alussa suunnitellaan peruslogiikkaportit, kuten NAND, invertteri, XOR, NOR jne. Sen jälkeen tarvittavat solut, kuten mustat solut, harmaat solut, puskurit ja PG-logiikka, suunnitellaan logiikkaporteilla.
Alla olevassa 32-bittisessä Brent Kung -summaimessa kääntöportteja, kuten AOI ja OAI, käytetään vaihtoehtoisesti pääasiassa harmaille ja mustille soluille. Joten mustat ja harmaat solut on esitetty harmailla ja mustilla lohkoilla, kun taas puskurit on esitetty ympyröillä.
Tulot, kuten A & B, toimitetaan PG-logiikkaan, joka näkyy lohkokaaviossa. 32-bittiselle summaimelle tarvitaan 32 PG-logiikkalohkoa ja leviävät (P) ja generoivat (G) signaalit ovat tämän lohkon lähtöjä. Nämä signaalit toimitetaan Brent Kung -summainpuurakenteeseen. Tämän summaimen rakenne sisältää harmaita soluja ja mustia soluja.
Harmaa solu sisältää kolme tuloa ja yhden lähdön. Etenee ja generoi signaaleja nykyisestä vaiheesta ja generoi signaalit edellisestä vaiheesta ovat tuloja, kun taas ryhmä generoi signaaleja on o/p. Missä tahansa puurakenteessa jokainen vaihe päättyy harmaaseen soluun ja tämän solun o/p on ryhmägeneraattorisignaali. Tätä signaalia pidetään yksinkertaisesti kyseisen vaiheen kantajana. Musta solu sisältää neljä tuloa ja kaksi lähtöä. Tämän solun tulot ovat nykyisen vaiheen P&G-signaalit & P-, G-signaalit edellisestä vaiheesta.
PG-logiikka sisältää JA- & XOR-portit, joissa JA-logiikkaporttia käytetään G-signaalin generoimiseen ja XOR-logiikkaportti tarjoaa P-signaalin. Tarpeettomien invertterien poistamiseksi käytetään kahdenlaisia harmaita ja mustia kennoja. Harmaan solun yhdellä rivillä käytetyt kääntöportit ovat AOI tai AND-OR-Inverter ja seuraavan rivin mustan solun kääntöportit käyttävät OAI:ta tai OR-AND-Invertteriä. AOI-solu käyttää normaaleja tuloja käänteisten tulosten tuottamiseen, kun taas OAI käyttää käänteisiä tuloja normaalien tulosten tuottamiseen.
Brent Kung Adder -operaatio
Brent Kung -lisälaite on rinnakkaisetuliitesummain, jota käytetään tehokkaan lisäyksen toimintaan. Tämä summain näyttää puurakenteelta, joka suorittaa aritmeettisen toiminnon. Tämä summain sisältää mustia soluja ja harmaita soluja. Jokaisessa mustassa solussa on kaksi JA-porttia ja yksi TAI-portti ja jokaisessa harmaassa solussa on vain yksi JA-portti.
Brent-kung-summaimessa on kaksi vaihetta; esikäsittelyvaihe ja sukupolvivaihe. Ensimmäisessä vaiheessa generointi ja levitys tapahtuu jokaisesta tuloparista. Tässä leviäminen tarjoaa 'XOR'-operaation tulobiteille, kun taas geners tarjoaa 'AND'-operaation tulobiteille. Levitä ja luo kuten 'Pi' ja 'Gi' on annettu alla.
Pi = Ai XOR Bi ja Gi = Ai JA Bi.
Toisessa vaiheessa siirto luodaan jokaiselle bitille, joka tunnetaan nimellä siirtogenerointi 'Cg' ja siirto lähetetään jokaiselle bitille, joka tunnetaan nimellä siirtogenerointi 'Cp'. Jatkuvaa toimintaa varten luodaan siirto ja siirto. Viimeinen solu, joka on käytettävissä jokaisen bitin toiminnassa, tarjoaa siirron. Joten viimeinen bitin siirto auttaa seuraavan bitin summaamisessa samanaikaisesti viimeiseen bittiin asti. Siirrä generoi & propagate annetaan muodossa;
Cp = P1 JA P0 ja Cg = G1 TAI (P1 JA G0)
Sitä käytetään pääasiassa kahden 32 bitin lisäämiseen ja jokainen bitti kokee esikäsittelyvaiheen ja sukupolven vaiheen, minkä jälkeen se antaa lopullisen summan.
Ensisijaiset tulobitit menevät esikäsittelyvaiheen alapuolelle ja ne tuottavat leviämisen ja generoinnin. Joten nämä leviävät sekä generoivat käyvät läpi sukupolven vaiheen generoi siirto tuottaa & kuljettaa leviää ja antaa lopullisen summan. Brent-kung-lisälaitteen vaiheittainen prosessi on esitetty alla.
Brent-kung summainjärjestely näyttää puurakenteelta ja se on nopea summain, joka tähtää porttitason logiikkaan. Tämä summain voidaan suunnitella vähentämällä logiikkaporttien määrää. Siten se vähentää tässä arkkitehtuurissa käytettyä viivettä ja muistia.
Brent Kung Adder Verilog Code
Brent Kung -lisälaitteen verilog-koodi näkyy alla.
`define INPUTSIZE 64 //asettaa tulon koon n
`define GROUPSIZE 8 //asettaa ryhmän koko = 1, 2, 4 tai 8
moduuli Brent_Kung_Adder(A, B, S);
tulo [`INPUTSIZE – 1:0] A;
tulo [`INPUTSIZE – 1:0] B;
lähtö [`INPUTSIZE:0] S;
lanka [`INPUTSIZE /`GROUPSIZE * 2 – 1:0] r_temp;
lanka [`INPUTSIZE /`GROUPSIZE * 2 – 1:0] r;
lanka [`INPUTSIZE /`GROUPSIZE:0] cin;
lanka [`INPUTSIZE /`GROUPSIZE * 2 – 1:0] q;
määritä cin[0] = 1’b0;
Tuottaa
missä;
for (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) alkaa: rinnakkainen_FA_CLA_etuliite
group_q_generation #(.Groupsize(`GROUPSIZE))
f(
.a(A[`RYHMÄKOKO * (i + 1) – 1:`RYHMÄKOKO * i]),
.b(B[`RYHMÄKOKO * (i + 1) – 1:`RYHMÄKOKO * i]),
.cin(cin[i]),
.s(S[`RYHMÄKOKO * (i + 1) – 1:`RYHMÄKOKO * i]),
.qg(q[i * 2 + 1:i * 2])
);
loppu
parallel_prefix_tree_first_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t1(
.q(q[`SYÖTTÖKOKO /`RYHMÄKOKO * 2 – 1:0]),
.r(r_temp[`INPUTSIZE / `RYHMÄKOKO * 2 – 1:0])
);
parallel_prefix_tree_second_half #(.Treesize(`INPUTSIZE /`GROUPSIZE))
t2(
.q(r_temp[`INPUTSIZE / `RYHMÄKOKO * 2 – 1:0]),
.r(r[`SYÖTTÖKOKO /`RYHMÄKOKO * 2 – 1:0])
);
for (i = 0; i < `INPUTSIZE /`GROUPSIZE; i = i + 1) alkaa: cin_generation
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1'b0),
.cin(cin[i + 1])
);
loppu
assign S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
lopputuottaja
loppumoduuli
// Rinnakkaisetuliitepuun ensimmäinen puolisko
moduuli parallel_prefix_tree_first_half #(parametri Puun koko = `INPUTSIZE / `GROUPSIZE)(q, r);
tulo [Puun koko * 2 – 1:0] q;
lähtö [Puun koko * 2 – 1:0] r;
Tuottaa
missä;
if (Puun koko == 2) alkaa: trivial_case
määritä 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
lanka [Puun koko * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Puun koko(Puun koko / 2))
recursion_lsbh(
.q(q[puun koko – 1:0]),
.r(r_temp[Puun koko – 1:0])
);
parallel_prefix_tree_first_half #(.Puun koko(Puun koko / 2))
recursion_msbh(
.q(q[Puun koko * 2 – 1:Puun koko]),
.r(r_temp[Puun koko * 2 – 1:Puun koko])
);
for (i = 0; i < puun koko * 2; i = i + 2) alkaa: rinnakkainen_ommel_up
if (i != Puun koko * 2 – 2) alkaa: parallel_stitch_up_pass
määritä r[i + 1:i] = r_temp[i + 1:i];
loppu muu alkaa: parallel_stitch_up_produce
prefix_logic f(
.ql(r_temp[Puun koko – 1:Puun koko – 2]),
.qh(r_temp[Puun koko * 2 - 1:Puun koko * 2 - 2]),
.r(r[Puun koko * 2 - 1:Puun koko * 2 - 2])
);
loppu
loppu
loppu
lopputuottaja
loppumoduuli
// Rinnakkaisetuliitepuun toinen puolisko
moduuli parallel_prefix_tree_second_half #(parametri Puun koko = `INPUTSIZE /`GROUPSIZE)(q, r);
tulo [Puun koko * 2 – 1:0] q;
lähtö [Puun koko * 2 – 1:0] r;
lanka [Puun koko * 2 * ($clog2(Treesize) – 1) – 1:0] r_temp;
määritä r_lämpötila[Puun koko * 2 – 1:0] = q[Puun koko * 2 – 1:0];
Tuottaa
genvar i, j;
for (i = 0; i < $clog2(Puun koko) – 2; i = i + 1) alkaa: toinen_puolikas_taso
määritä r_temp[Puun koko * 2 * (i + 1) + ((Puun koko / (2 ** i)) - 1 - 2 ** ($clog2(Puun koko / 4) - i)) * 2 - 1:Puun koko * 2 * (i + 1)] = r_temp[Puun koko * 2 * i + ((Puun koko / (2 ** i)) - 1 - 2 ** ($tukos2(Puun koko / 4) - i)) * 2 - 1: puun koko * 2 * i];
for (j = (Puun koko / (2 ** i)) – 1 – 2 ** ($clog2(Puun koko / 4) – i); j < Puun koko; j = j + 2 ** ($clog2(Puun koko / 2) ) – i)) alkaa: second_half_level_logic
prefix_logic f(
[ Puun koko / 4) – i)) * 2]),
.qh(r_temp[Puun koko * 2 * i + j * 2 + 1:Puun koko * 2 * i + j * 2]),
.r(r_temp[Puun koko * 2 * (i + 1) + j * 2 + 1:Puun koko * 2 * (i + 1) + j * 2])
);
if (j != Puun koko – 1 – 2 ** ($clog2(Puun koko / 4) – i)) alkaa: second_half_level_direct_connect
määritä r_temp[Puun koko * 2 * (i + 1) + (j + 2 ** ($clog2(Puun koko / 2) – i)) * 2 - 1:Puun koko * 2 * (i + 1) + j * 2 + 2] = r_temp[Puun koko * 2 * i + (j + 2 ** ($tukos2(Puun koko / 2) – i)) * 2 - 1:Puun koko * 2 * i + j * 2 + 2];
loppu
loppu
määritä r_lämpötila[Puun koko * 2 * (i + 2) – 1:Puun koko * 2 * (i + 2) – (2 ** ($clog2(Puun koko / 4) – i)) * 2] = r_lämpö[Puun koko * 2 * (i + 1) – 1:Puun koko * 2 * (i + 1) – (2 ** ($tukos2(Puun koko / 4) – i)) * 2];
loppu
määritä r[1:0] = r_temp[Puun koko * 2 * ($clog2(Puun koko) – 2) + 1:Puun koko * 2 * ($clog2(Puun koko) – 2)];
for (i = 1; i < puun koko; i = i + 2) alkaa: lopullinen_r_pariton
määritä r[i * 2 + 1:i * 2] = r_temp[Puun koko * 2 * ($clog2(Puun koko) – 2) + i * 2 + 1:Puun koko * 2 * ($clog2(Puun koko) – 2) + i * 2];
loppu
for (i = 2; i < puun koko; i = i + 2) alkaa: lopullinen_r_parillinen
prefix_logic f(
.ql(r_temp[Puun koko * 2 * ($tuki2(Puun koko) – 2) + i * 2 – 1:Puun koko * 2 * ($tuki2(Puun koko) – 2) + i * 2 – 2]),
[
.r(r[i * 2 + 1:i * 2])
);
loppu
lopputuottaja
loppumoduuli
moduulin ryhmä_q_sukupolvi #(parametri Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
syöttö [Ryhmäkoko – 1:0] a;
input [Ryhmäkoko – 1:0] b;
tulo cin;
lähtö [Ryhmäkoko – 1:0] s;
lähtö [1:0] qg;
lanka [2 * Ryhmäkoko – 1:0] q;
lanka [Ryhmäkoko – 1:0] c;
määrittää c[0] = cin;
Tuottaa
missä;
for (i = 0; i < ryhmäkoko; i = i + 1) alkaa: rinnakkainen_FA_CLA_etuliite
FA_CLA_etuliite f(
.a(a[i]),
.b(b[i]),
.cin(c[i]),
.s(s[i]),
.q(q[i * 2 + 1:i * 2])
);
if (i != Ryhmäkoko – 1) begin: special_case
määritä c[i + 1] = q[i * 2 + 1] | (q[i*2] & c[i]);
loppu
loppu
//ryhmä q -sukupolvi ryhmän koon perusteella
if (Ryhmän koko == 1) begin: case_gs1
määritä qg[1] = q[1];
määritä qg[0] = q[0];
end else if (Ryhmän koko == 2) begin: case_gs2
määritä qg[1] = q[3] | (q[1] & q[2]);
määritä qg[0] = q[2] & q[0];
end else if (Ryhmän koko == 4) begin: case_gs4
määritä qg[1] = q[7] | (q[5] & q[6]) | (q[3] & q[6] & q[4]) | (q[1] & q[6] & q[4] & q[2]);
määritä qg[0] = q[6] & q[4] & q[2] & q[0];
end else if (Ryhmän koko == 8) begin: case_gs8
määritä 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]);
määritä qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0];
loppu
lopputuottaja
loppumoduuli
// Cinin luomisen logiikka
moduuli cin_generation_logic(r, c0, cin);
tulo [1:0] r;
tulo c0;
tuotanto cin;
määritä cin = (r[0] & c0) | r[1];
loppumoduuli
// Peruslogiikka etuliiteoperaatioille
moduulin prefix_logic(ql, qh, r);
tulo [1:0] ql;
tulo [1:0] qh;
lähtö [1:0] r;
määritä r[0] = qh[0] & ql[0];
määritä r[1] = (qh[0] & ql[1]) | qh[1];
loppumoduuli
// Täysi adder -solu Carry Look-Ahead -toiminnolla
moduuli FA_CLA_prefix(a, b, cin, s, q);
syöttö a;
tulo b;
tulo cin;
tuotos s;
lähtö [1:0] q;
määritä q[0] = a ^ b;
määrittää s = q[0]^cin;
määritä q[1] = a & b;
loppumoduuli
Edut
Brent Kung Adderin etuja ovat seuraavat.
- Tämä on pienitehoinen summain, koska se käyttää minimipiiriä tuloksen saamiseksi.
- Se on erittäin suosittu ja laajalti käytetty lisälaite.
- Tällainen summain voidaan toteuttaa käyttämällä vähemmän moduuleja kuin Kogge-Stone-summaimessa.
- Brent-Kung-lisälaitteen suunnittelu on erittäin helppoa.
- Tällä summaimella on vähemmän yhteyksiä muihin moduuleihin.
- Näitä summaimia ehdotettiin pääasiassa ratkaisemaan Kogge-Stone-summaimien haittoja.
Haitat
The Brent Kung Adden haitat r sisältää seuraavat.
- Näillä summaimilla on suurempi viive ja ne tarvitsevat 2 log2 n − 2 logiikkatasoa kaikkien siirtobittien laskemiseen.
- Tämän summaimen suurin haittapuoli on fanout, joka voi aiheuttaa virran etenemisen koko summaimessa jakaantumaan ja heikkenemään.
Brent Kung Adder -sovellukset
Brent Kung Adderin sovelluksia ovat seuraavat.
- Brent-Kung-summainta käytetään putkistolla vähentämään virrankulutusta vähentämällä kombinatorista logiikkaa ja vikojen stabilointia.
- Brent-Kung -summain tarjoaa erinomaisen määrän vaiheita i/p:stä kaikkiin o/ps:iin, mutta epäsymmetrisellä väliasteiden latauksella.
- Tätä summainta voidaan käyttää kertoimessa sekä muissa tietopolun elementeissä.
Näin ollen tämä on yleiskatsaus Brent kung adderista , sen toiminta, edut, haitat ja sovellukset. Tämä on erittäin tehokas summain ja sen rakenne näyttää puurakenteelta, jota käytetään pääasiassa korkean suorituskyvyn aritmeettisiin operaatioihin. Tämäntyyppinen summain on erittäin nopea ja keskittyy pääasiassa porttitason logiikkaan. Tämä summain on suunniteltu käyttämällä vähemmän logiikkaportteja. Siten se vähentää tässä arkkitehtuurissa käytettyä muistia ja viivettä. Tässä on kysymys sinulle, Brent kung -lisälaite, joka tunnetaan myös nimellä?
