Brent-Kung sumatorių 1982 m. pasiūlė Hsiang Te Kung ir Richardas Peirce'as Brentas. Tai lygiagrečiojo prefikso priedas arba medžio papildiklis, kuris dėl savo lankstumo plačiai naudojamas skaitmeniniame projekte. Lygiagrečių prefiksų priedai gali būti sukurti keliais būdais, atsižvelgiant į loginių lygių skaičių, logikos vartai įtrauktas, ventiliatorius iš visų vartų ir laidai tarp lygių. Galimi įvairių tipų medžių sumatoriai, pagrindiniai medžių sumatoriai yra Sklanskym KoggeStone & Brent-Kung. Palyginti su KSA (Kogge-Stone sumatorius), šis sumatorius užtikrina aukštą sumatoriaus struktūros taisyklingumą ir mažiau blokuoja laidus. o tai užtikrina geresnį našumą ir mažiau reikalingo lusto ploto. Šiame straipsnyje pateikiama trumpa informacija apie a Brentas Kung Adderis .
Kas yra Brent Kung Adder?
Sumatorius, kuris naudoja minimalią schemą rezultatui gauti, yra žinomas kaip Brent Kung Adder ir jis taip pat žinomas kaip mažos galios sumatorius arba lygiagretusis sumatorius. Šis sumatorius skirtas sutaupyti lusto dydį, kad būtų lengviau gaminti šiuos priedus. Dėl šios sumatoriaus simetrijos ir įprastos konstrukcijos struktūros labai sumažės gamybos sąnaudos ir ją galima naudoti konvejerinėse topologijose. Papildomos tranzistoriaus logikos panaudojimas padeda pagerinti projektavimo našumą multiplekseris požiūris į įvairius ląstelių dizainus.
Brent Kung Adder grandinė
Žemiau parodyta brent-kung lygiagretaus priešdėlio papildymo schema, apimanti 1 etapą (išankstinio apdorojimo etapą), 2–7 etapai yra perdavimo generavimo etapai, o 8 etapas yra tolesnis apdorojimas. Tai pažangi architektūra, kurią labai paprasta konstruoti, todėl laidų perkrova mažesnė. Taigi, dėl mažiau laidų sumažės architektūrai įgyvendinti reikalingos vietos. Be to, maršruto parinkimas tampa daug lengvesnis, nes susikerta (arba) sutampa mažiau laidų. Tačiau bauda už vėlavimą padidės dėl padidėjusio etapų skaičiaus. Padidėja ventiliatoriaus išėjimas šiam sumikliui, o tada vėlavimas bus padidintas.
Kaip veikia Brent Kung Adder?
Brent Kung Adder veikia apskaičiuodamas dviejų bitų grupių priešdėlius, kurie yra naudingi ieškant 4 bitų grupių priešdėlių. Šie priešdėliai naudojami skaičiuojant 8 bitų grupės prefiksus ir pan. Po to šie priešdėliai bus naudojami konkretaus bitų etapo vykdymui apskaičiuoti. Šie nešikliai naudojami su kito etapo grupės sklaida, norint apskaičiuoti to etapo sumos bitą. Brent Kung Tree naudoja 2log2N – 1 pakopa.
32 bitų Brent Kung Adder
32 bitų Brent Kung papildiklio išdėstymas parodytas žemiau. Šio išdėstymo pradžioje yra suprojektuoti pagrindiniai loginiai vartai, pvz., NAND, keitiklis, XOR, NOR ir tt. Po to reikalingi langeliai, tokie kaip juodieji langeliai, pilki langeliai, buferiai ir PG logika, yra suprojektuoti su loginiais vartais.
Žemiau esančiame 32 bitų Brent Kung sumatoriuje apverčiamieji vartai, tokie kaip AOI ir OAI, alternatyviai naudojami daugiausia pilkoms ir juodoms ląstelėms. Taigi juodos ir pilkos ląstelės pavaizduotos pilkais ir juodais blokais, o buferiai vaizduojami apskritimais.
Tokie įėjimai kaip A ir B yra pateikiami PG logikai, kuri parodyta blokinėje diagramoje. 32 bitų sumatoriui reikalingi 32 PG loginiai blokai, o sklindantys (P) ir generuojami (G) signalai yra šio bloko išėjimai. Šie signalai pateikiami Brent Kung sumatoriaus medžio struktūrai. Šio papildiklio struktūroje yra pilkų ir juodų langelių.
Pilka langelis turi tris įėjimus ir vieną išvestį. Skleisti ir generuoti signalus iš dabartinės pakopos ir generuoti signalus iš ankstesnio etapo yra įvestis, o grupės generuoti signalai yra o/p. Bet kurioje medžio struktūroje kiekvienas etapas baigsis pilku langeliu, o šios ląstelės o/p yra grupės generavimo signalas. Šis signalas laikomas tiesiog to etapo pernešimu. Juodasis elementas turi keturis įėjimus ir du išėjimus. Šios ląstelės įvestys yra dabartinio etapo P & G signalai ir P, G signalai iš ankstesnio etapo.
PG logika apima AND & XOR vartus, kur IR loginiai vartai naudojami G signalui generuoti, o XOR loginiai vartai suteikia P signalą. Norint pašalinti nereikalingus keitiklius, naudojami dviejų tipų pilki ir juodi elementai. Apverčiamieji vartai, naudojami vienoje pilkos spalvos langelio eilutėje, yra AOI arba AND-OR-Inverter, o kitos eilutės juodos spalvos langelio apverčiamieji vartai naudoja OAI arba OR-AND-Inverter. AOI ląstelė naudoja įprastas įvestis, kad teiktų apverstas išvestis, o OAI naudoja apverstas įvestis normalioms išvestims teikti.
„Brent Kung Adder“ operacija
Brent Kung sumatorius yra lygiagretusis priešdėlių sumatorius, naudojamas didelio našumo papildymui. Šis sumatorius atrodo kaip medžio struktūra, kuri atlieka aritmetinę operaciją. Šis papildiklis apima juodus ir pilkus langelius. Kiekviena juoda ląstelė turi du IR vartus ir vieną ARBA vartus, o kiekvienas pilkas langelis turi tik vieną AND vartus.
Brent-kung sumatorius apima du etapus; išankstinio apdorojimo ir generavimo etapas. Pirmajame etape generavimas ir platinimas bus iš kiekvienos įvesties poros. Čia propagavimas suteikia įvesties bitams operaciją „XOR“, o generavimas – „AND“ operaciją įvesties bitams. Toliau pateikiami tokie kaip „Pi“ ir „Gi“ platinimas ir generavimas.
Pi = Ai XOR Bi ir Gi = Ai IR Bi.
Antrame etape bus sugeneruotas pernešimas kiekvienam bitui, kuris yra žinomas kaip perdavimo generavimas „Cg“, o pernešimas yra perduodamas kiekvienam bitui, žinomas kaip perdavimo generavimas „Cp“. Tolimesnei operacijai bus sugeneruotas pernešimas ir generavimas. Galutinis kiekvieno bito veikimo langelis suteikia pernešimą. Taigi paskutinis bitų perkėlimas padės susumuoti kitą bitą vienu metu iki paskutinio bito. Perkelti generuoti ir skleisti yra pateikiami kaip;
Cp = P1 IR P0 ir Cg = G1 ARBA (P1 IR G0)
Jis daugiausia naudojamas dviejų trisdešimt dviejų bitų pridėjimui, o kiekvienas bitas patiria išankstinio apdorojimo ir generavimo etapą, tada pateikia galutinę sumą.
Pirminiai įvesties bitai pereina žemiau išankstinio apdorojimo etapo, jie perduoda ir generuoja. Taigi šie sklinda ir generuoja, pereina generavimo etapą, generuoja, generuoja ir neša, ir pateikia galutinę sumą. Žemiau parodytas žingsnis po žingsnio Brent-kung papildiklio procesas.
„Brent-kung“ sumatoriaus išdėstymas atrodo kaip medžio struktūra, ir tai yra didelės spartos sumatorius, skirtas vartų lygio logikai. Šis sumatorius gali būti suprojektuotas sumažinus loginių vartų skaičių. Taigi tai sumažina vėlavimą ir atmintį, naudojamą šioje architektūroje.
Brent Kung Adder Verilog kodas
Brent Kung papildiklio verilog kodas parodytas žemiau.
`define INPUTSIZE 64 //nustatykite įvesties dydį n
`nustatyti GROUPSIZE 8 //nustatyti grupės dydį = 1, 2, 4 arba 8
modulis Brent_Kung_Adder(A, B, S);
įvestis [`INPUTSIZE – 1:0] A;
įvestis [`INPUTSIZE – 1:0] B;
išvestis [`INPUTSIZE:0] S;
laidas [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r_temp;
laidas [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r;
laidas [`INPUTSIZE / `GROUPSIZE:0] cin;
laidas [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] q;
priskirti cin[0] = 1’b0;
generuoti
kur;
už (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) prasideda: lygiagretus_FA_CLA_prefix
group_q_generation #(.Grupės dydis(`GROUPSIZE))
f(
.a(A[`GRUPĖS DYDIS * (i + 1) – 1:`GRUPĖS DYDIS * i]),
.b(B[„GRUPĖS DYDIS * (i + 1) – 1:„GRUPĖS DYDIS * i]),
.cin(cin[i]),
.s(S[„GRUPĖS DYDIS * (i + 1) – 1:„GROUPSIZE * i]),
.qg(q[i * 2 + 1:i * 2])
);
galas
parallel_prefix_tree_first_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t1(
.q(q[`INPUTSIZE / `GRUPĖS DYDIS * 2 – 1:0]),
.r(r_temp[`INPUTSIZE / `GRUPĖS DYDIS * 2 – 1:0])
);
parallel_prefix_tree_second_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t2(
.q(r_temp[`INPUTSIZE / `GRUPĖS DYDIS * 2 – 1:0]),
.r(r[Įvesties dydis / GRUPĖS DYDIS * 2 – 1:0])
);
už (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) pradėti: cin_generation
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1'b0),
.cin(cin[i + 1])
);
galas
priskirti S[`INPUTSIZE] = cin[`INPUTSIZE/`GROUPSIZE];
galutinis generatorius
pabaigos modulis
// Pirmoji lygiagrečiojo priešdėlio medžio pusė
modulis parallel_prefix_tree_first_half #(parametras Medžio dydis = `INPUTSIZE / `GROUPSIZE)(q, r);
įvestis [Medžio dydis * 2 – 1:0] q;
išvestis [Medžio dydis * 2 – 1:0] r;
generuoti
kur;
if (Medžio dydis == 2) begin: trivial_case
priskirti r[1:0] = q[1:0];
prefix_logic f(
.ql(q[1:0]),
.qh(q[3:2]),
.r(r[3:2])
);
pabaiga kita pradžia: recursive_case
viela [Medžio dydis * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Treesize(Medžio dydis / 2))
recursion_lsbh(
.q(q [medžio dydis – 1:0]),
.r(r_temp[medžio dydis – 1:0])
);
parallel_prefix_tree_first_half #(.Treesize(Medžio dydis / 2))
recursion_msbh(
.q(q [medžio dydis * 2 – 1: medžio dydis]),
.r(r_temp[medžio dydis * 2 – 1:medžio dydis])
);
už (i = 0; i < Medžio dydis * 2; i = i + 2) pradžia: lygiagretus_dygsnis_up
if (i != Medžio dydis * 2 – 2) pradeda: lygiagretus_dygsnis_up_pass
priskirti r[i + 1:i] = r_temp[i + 1:i];
pabaiga kita pradžia: parallel_stitch_up_produce
prefix_logic f(
.ql(r_temp[medžio dydis – 1: medžio dydis – 2]),
.qh(r_temp[medžio dydis * 2 – 1: medžio dydis * 2 – 2]),
.r(r[medžio dydis * 2 - 1: medžio dydis * 2 - 2])
);
galas
galas
galas
galutinis generatorius
pabaigos modulis
// Antroji lygiagretaus priešdėlio medžio pusė
modulis parallel_prefix_tree_second_half #(parametras Medžio dydis = `INPUTSIZE / `GROUPSIZE)(q, r);
įvestis [Medžio dydis * 2 – 1:0] q;
išvestis [Medžio dydis * 2 – 1:0] r;
viela [Treesize * 2 * ($clog2(Treesize) – 1) – 1:0] r_temp;
priskirti r_temp[Medžio dydis * 2 – 1:0] = q[Medžio dydis * 2 – 1:0];
generuoti
genvar i, j;
for (i = 0; i < $ užkimštas2(medžio dydis) – 2; i = i + 1) pradėti: antras_pusės_lygis
priskirti r_temp[medžio dydis * 2 * (i + 1) + ((medžio dydis / (2 ** i)) – 1 – 2 ** ($ užkimšti2 (medžio dydis / 4) – i)) * 2 - 1: medžio dydis * 2 * (i + 1)] = r_temp[medžio dydis * 2 * i + ((medžio dydis / (2 ** i)) – 1 – 2 ** ($ užkimštas2(medžio dydis / 4) – i)) * 2 – 1: Medžių dydis * 2 * i];
for (j = (medžio dydis / (2 ** i)) – 1 – 2 ** ($ užkimšti2(medžio dydis / 4) – i); j < medžio dydis; j = j + 2 ** ($ užkimšti2(medžio dydis / 2) ) – i)) pradžia: antrosios_pusės_lygio_logika
prefix_logic f(
.ql(r_temp[medžio dydis * 2 * i + (j - 2 ** ($ užkimštis2(medžio dydis / 4) - i)) * 2 + 1: medžio dydis * 2 * i + (j - 2 ** ($ užkimštis2 Medžių dydis / 4) – i)) * 2]),
.qh(r_temp[medžio dydis * 2 * i + j * 2 + 1: medžio dydis * 2 * i + j * 2]),
.r(r_temp[medžio dydis * 2 * (i + 1) + j * 2 + 1: medžio dydis * 2 * (i + 1) + j * 2])
);
if (j != Medžio dydis – 1 – 2 ** ($clog2(Treesize / 4) – i)) begin: second_half_level_direct_connect
priskirti r_temp[medžio dydis * 2 * (i + 1) + (j + 2 ** ($ užkimštis2 (medžio dydis / 2) – i)) * 2 - 1: medžio dydis * 2 * (i + 1) + j * 2 + 2] = r_temp[medžio dydis * 2 * i + (j + 2 ** ($ užkimštis2(medžio dydis / 2) – i)) * 2 - 1: medžio dydis * 2 * i + j * 2 + 2];
galas
galas
priskirti r_temp[medžio dydis * 2 * (i + 2) – 1: medžio dydis * 2 * (i + 2) – (2 ** ($ užkimštas2(medžio dydis / 4) – i)) * 2] = r_temp[medžio dydis * 2 * (i + 1) – 1:Medžio dydis * 2 * (i + 1) – (2 ** ($ užkimštas2(Medžio dydis / 4) – i)) * 2];
galas
priskirti r[1:0] = r_temp[Medžio dydis * 2 * ($ užkimštis2(medžio dydis) – 2) + 1:medžio dydis * 2 * ($ užkimštas2(medžio dydis) – 2)];
už (i = 1; i < medžio dydis; i = i + 2) prasideda: final_r_dd
priskirti r[i * 2 + 1:i * 2] = r_temp[medžio dydis * 2 * ($ užkimštas2 (medžio dydis) – 2) + i * 2 + 1: medžio dydis * 2 * ($ užkimštas2 (medžio dydis) – 2) + i * 2];
galas
už (i = 2; i < medžio dydis; i = i + 2) prasideda: final_r_even
prefix_logic f(
.ql(r_temp[medžio dydis * 2 * ($ užkimštis2 (medžio dydis) – 2) + i * 2 – 1: medžio dydis * 2 * ($ užkimštis2 (medžio dydis) – 2) + i * 2 – 2]),
.qh(r_temp[medžio dydis * 2 * ($ užkimštis2 (medžio dydis) – 2) + i * 2 + 1: medžio dydis * 2 * ($ užkimštis2 (medžio dydis) – 2) + i * 2]),
.r(r[i * 2 + 1:i * 2])
);
galas
galutinis generatorius
pabaigos modulis
modulis group_q_generation #(parametras Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
įvestis [Grupės dydis – 1:0] a;
įvestis [Grupės dydis – 1:0] b;
įvesties cin;
išėjimas [Grupės dydis – 1:0] s;
išvestis [1:0] qg;
viela [2 * Grupės dydis – 1:0] q;
viela [Grupės dydis – 1:0] c;
priskirti c[0] = cin;
generuoti
kur;
už (i = 0; i < grupės dydis; i = i + 1) pradėti: lygiagretus_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) begin: special_case
priskirti c[i + 1] = q[i * 2 + 1] | (q[i * 2] ir c[i]);
galas
galas
//Grupės q generavimas pagal grupės dydį
if (Grupės dydis == 1) begin: case_gs1
priskirti qg[1] = q[1];
priskirti qg[0] = q[0];
end else if (Grupės dydis == 2) pradžia: case_gs2
priskirti qg[1] = q[3] | (q[1] ir q[2]);
priskirti qg[0] = q[2] & q[0];
end else if (Grupės dydis == 4) pradžia: case_gs4
priskirti qg[1] = q[7] | (q[5] ir q[6]) | (q[3] ir q[6] ir q[4]) | (q[1] ir q[6] ir q[4] ir q[2]);
priskirti qg[0] = q[6] & q[4] & q[2] & q[0];
end else if (Grupės dydis == 8) pradžia: case_gs8
priskirti qg[1] = q[15] | (q[13] ir q[14]) | (q[11] ir q[14] ir q[12]) | (q[9] ir q[14] ir q[12] ir q[10]) | (q[7] ir q[14] ir q[12] ir q[10] ir q[8]) | (q[5] ir q[14] ir q[12] ir q[10] ir q[8] ir q[6]) | (q[3] ir q[14], q[12] ir q[10], q[8] ir q[6] ir q[4]) | (q[1] ir q[14], q[12] ir q[10], q[8] ir q[6], q[4] ir q[2]);
priskirti qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0];
galas
galutinis generatorius
pabaigos modulis
// Cin generavimo logika
modulis cin_generation_logic(r, c0, cin);
įvestis [1:0] r;
įvestis c0;
išvesties cin;
priskirti cin = (r[0] & c0) | r[1];
pabaigos modulis
// Pagrindinė priešdėlio operacijų logika
modulio prefix_logic(ql, qh, r);
įvestis [1:0] ql;
įvestis [1:0] qh;
išvestis [1:0] r;
priskirti r[0] = qh[0] & ql[0];
priskirti r[1] = (qh[0] & ql[1]) | qh[1];
pabaigos modulis
// Pilna priedų ląstelė su „Carry Look-Ahead“.
modulis FA_CLA_prefix(a, b, cin, s, q);
įvestis a;
įvestis b;
įvesties cin;
išvestis s;
išėjimas [1:0] q;
priskirti q[0] = a ^ b;
priskirti s = q[0] ^ cin;
priskirti q[1] = a & b;
pabaigos modulis
Privalumai
„Brent Kung Adder“ pranašumai yra šie.
- Tai mažos galios sumatorius, nes rezultatui gauti naudoja minimalią grandinę.
- Tai labai populiarus ir plačiai naudojamas papildiklis.
- Tokio tipo sumatorių galima įdiegti naudojant mažiau modulių, palyginti su Kogge-Stone sumatoriumi.
- Brent-Kung sumatorių projektavimas yra labai paprastas.
- Šis papildiklis turi mažiau jungčių su kitais moduliais.
- Šie sumatoriai buvo pasiūlyti daugiausia siekiant išspręsti Kogge-Stone sumatorių trūkumus.
Trūkumai
The Brent Kung Adde trūkumai r įtraukti šiuos dalykus.
- Šie sumatoriai turi didesnį delsą ir jiems reikia 2 log2 n − 2 loginių lygių, kad būtų galima apskaičiuoti visus perdavimo bitus.
- Pagrindinis šio sumatoriaus trūkumas yra išpūtimas, dėl kurio srovės sklidimas visame sumatoriuje gali suskaidyti ir susilpnėti.
„Brent Kung Adder“ programos
„Brent Kung Adder“ programos apima šias programas.
- Brent-Kung sumatorius naudojamas konvejeriniu būdu, siekiant sumažinti energijos suvartojimą, sumažinant kombinatorinį loginį gylį ir trikdžių stabilizavimą.
- Brent-Kung sumatorius suteikia išskirtinį etapų skaičių nuo i/p iki visų o/ps, bet su asimetrine tarpinių pakopų įkėlimu.
- Šis sumatorius gali būti naudojamas daugiklyje ir kituose duomenų kelio elementuose.
Taigi, tai yra Brent kung adder apžvalga , jo veikimas, privalumai, trūkumai ir pritaikymas. Tai labai efektyvus sumatorius ir jo struktūra atrodo kaip medžio struktūra, daugiausia naudojama didelio našumo aritmetinėms operacijoms. Šio tipo sumatorius yra labai greitas ir daugiausia dėmesio skiria vartų lygio logikai. Šis sumatorius sukurtas naudojant mažiau loginių vartų. Taigi tai sumažina šioje architektūroje naudojamą atmintį ir delsą. Štai klausimas jums, Brent kung adder taip pat žinomas kaip?
