Hsiang Te Kung ja Richard Peirce Brent pakkusid välja 1982. aastal Brenti-Kungi liitja. See on Parallel Prefix liitja või puu liitja, mida selle paindlikkuse tõttu kasutatakse digitaalses disainis laialdaselt. Paralleelseid eesliidete lisajaid saab loogikatasemete arvu põhjal ehitada mitmel viisil, loogika väravad kaasatud, ventilaator igast väravast ja juhtmestik tasandite vahel. Saadaval on erinevat tüüpi puulisajaid, põhilised puulisajad on Sklanskym KoggeStone & Brent-Kung. Võrreldes KSA-ga (Kogge-Stone liitja) tagab see liitja suure regulaarsuse liitja struktuurile ja sellel on vähem juhtmestiku blokeeringuid. mis toob kaasa parema jõudluse ja vähem nõutava kiibi pindala. See artikkel sisaldab lühikest teavet a Brent Kung Adder .
Mis on Brent Kung Adder?
Summer, mis kasutab tulemuse saamiseks minimaalset vooluringi, on tuntud kui Brent Kung Adder ja see on tuntud ka kui väikese võimsusega liitja või paralleelsumma. See summaar on mõeldud kiibi suuruse salvestamiseks, et nende lisajate valmistamine muutuks lihtsamaks. Selle liitja sümmeetria ja tavaline ehitusstruktuur vähendab oluliselt tootmiskulusid ja on lubatud kasutada konveier topoloogiates. Täiendava läbipääsutransistori loogika kasutamine aitab parandada konstruktsiooni jõudlust multiplekser lähenemisviisi erinevates rakukujundustes.
Brent Kung Adderi ringrada
Allpool on näidatud brent-kungi paralleelse eesliidete liitmise diagramm, mis sisaldab 1. etappi (eeltöötlusetapp), etapid 2 kuni 7 on ülekande genereerimise etapid ja 8. etapp on järeltöötlus. See on täiustatud arhitektuur ja seda on väga lihtne ehitada ning see vähendab juhtmestiku ülekoormust. Seega vähendab selle väiksem juhtmestik arhitektuuri teostamiseks vajaliku ruumi hulka. Lisaks muutub marsruutimine palju lihtsamaks tänu vähemate juhtmete ristumisele (või kattumisele). Siiski suureneb trahv viivituse tõttu suurenenud etappide arvu tõttu. Selle summari ventilaatori väljalaskevõimet suurendatakse ja seejärel viivitust.
Kuidas Brent Kung Adder töötab?
Brent Kung Adder arvutab kahe bitirühma eesliited, mis on kasulikud 4-bitise rühma eesliidete leidmisel. Neid eesliiteid kasutatakse 8-bitise rühma eesliidete jne arvutamiseks. Pärast seda kasutatakse neid eesliiteid konkreetse bitietapi teostamise arvutamiseks. Neid kandjaid kasutatakse koos järgmise etapi rühma levikuga, et arvutada selle etapi summa bitti. Brent Kung Tree kasutab 2log2N – 1 etapp.
32-bitine Brent Kung Adder
32-bitise Brent Kungi lisaja paigutus on näidatud allpool. Selle paigutuse alguses kujundatakse põhilised loogikaväravad nagu NAND, inverter, XOR, NOR jne. Pärast seda koostatakse loogikaväravatega vajalikud lahtrid, nagu mustad lahtrid, hallid lahtrid, puhvrid ja PG-loogika.
Allolevas 32-bitises Brent Kungi liiteris kasutatakse inverteerivaid väravaid, nagu AOI ja OAI, alternatiivselt peamiselt hallide ja mustade rakkude jaoks. Nii et mustad ja hallid lahtrid on esindatud hallide ja mustade plokkidega, puhvrid aga ringidega.
Sellised sisendid nagu A ja B antakse PG-loogikale, mis on näidatud plokkskeemil. 32-bitise summari jaoks on vaja 32 PG loogikaplokki ning levivad (P) ja genereerivad (G) signaalid on selle ploki väljundid. Need signaalid edastatakse Brent Kungi liitepuu struktuurile. Selle lisaja struktuur sisaldab halle ja musti lahtreid.
Hall lahter sisaldab kolme sisendit ja ühte väljundit. Praeguse etapi signaalide levitamine ja genereerimine ning eelmise etapi signaalide genereerimine on sisendid, samas kui signaalide rühma genereerimine on o/p. Igas puustruktuuris lõpeb iga etapp halli lahtriga ja selle lahtri o/p on rühma genereeriv signaal. Seda signaali peetakse lihtsalt selle etapi edasikandjaks. Must element sisaldab nelja sisendit ja kahte väljundit. Selle lahtri sisenditeks on praeguse etapi P & G signaalid ning eelmise etapi P, G signaalid.
PG-loogika sisaldab AND- ja XOR-väravaid, kus JA-loogikaväravat kasutatakse G-signaali genereerimiseks ja XOR-loogikavärav annab P-signaali. Tarbetute inverterite kõrvaldamiseks kasutatakse kahte tüüpi halle ja musti rakke. Ühes reas halli lahtri jaoks kasutatavad pöördväravad on AOI või AND-OR-Inverter ja järgmise rea musta lahtri pöördväravad kasutavad OAI-d või OR-AND-Inverterit. AOI lahter kasutab pöördväljundite pakkumiseks tavalisi sisendeid, samas kui OAI kasutab tavaliste väljundite saamiseks inverteeritud sisendeid.
Brent Kung Adderi operatsioon
Brent Kung liitja on paralleelne eesliite liitja, mida kasutatakse suure jõudlusega lisamise toimimiseks. See summaar näeb välja nagu puustruktuur, mis teostab aritmeetilise toimingu. See lisaja sisaldab musti ja halle lahtreid. Igal mustal lahtril on kaks JA-väravat ja üks VÕI värav ning igal hallil lahtril on ainult üks JA-värav.
Brent-kungi liiter sisaldab kahte etappi; eeltöötlusetapp ja genereerimisetapp. Esimeses etapis toimub genereerimine ja levitamine igast sisendipaarist. Siin pakub levitamine sisendbittide jaoks operatsiooni XOR, genereerimine aga sisendbittide jaoks AND-operatsiooni. Sellised levitamine ja genereerimine nagu 'Pi' ja 'Gi' on toodud allpool.
Pi = Ai XOR Bi ja Gi = Ai JA Bi.
Teises etapis genereeritakse edastus iga biti jaoks, mida nimetatakse ülekande genereerimiseks 'Cg' ja ülekandeks iga biti jaoks, mida tuntakse kande genereerimise 'Cp'na. Edasiseks toimimiseks luuakse edastus- ja ülekandegenereerimine. Iga biti toimimise ajal saadaolev viimane lahter tagab edasikandmise. Seega aitab viimane bitikandmine järgmise biti summeerida samaaegselt kuni viimase bitini. Transpordi genereerimine ja levitamine on antud kui;
Cp = P1 JA P0 ning Cg = G1 VÕI (P1 JA G0)
Seda kasutatakse peamiselt kahe kolmekümne kahe biti liitmiseks ja iga bitt läbib eeltöötluse ja genereerimise etapi, seejärel annab see lõppsumma.
Esmased sisendbitid lähevad eeltöötlusetapi alla ja toodavad levitamist ja genereerimist. Nii need levivad kui ka genereerivad läbivad genereerimisetapi, genereerib ülekande genereerib ja edastab ning annab lõppsumma. Brent-kungi liitja samm-sammuline protsess on näidatud allpool.
Brent-kungi liiteseade näeb välja nagu puustruktuur ja see on kiire liitja, mis sihib väravataseme loogikat. Seda summarit saab konstrueerida loogiliste väravate arvu vähendamisega. Seega vähendab see selles arhitektuuris kasutatavat viivitust ja mälu.
Brent Kung Adder Verilogi kood
Brent Kungi lisaja verilogi kood on näidatud allpool.
`define INPUTSIZE 64 //seadke sisendi suurus n
`define GROUPSIZE 8 //määrake rühma suurus = 1, 2, 4 või 8
moodul Brent_Kung_Adder(A, B, S);
sisend [`INPUTSIZE – 1:0] A;
sisend [`INPUTSIZE – 1:0] B;
väljund [`INPUTSIZE:0] S;
traat [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r_temp;
traat [`SISEND SUURUS / `GRUPPSUURUS * 2 – 1:0] r;
traat [`INPUTSIZE / `GROUPSIZE:0] cin;
traat [`SISEND SUURUS / `GRUPPSUURUS * 2 – 1:0] q;
määrata cin[0] = 1’b0;
genereerida
kus sees;
jaoks (i = 0; i < `SISEND SUURUS / `GRUPISUURUS; i = i + 1) algab: parallel_FA_CLA_prefix
group_q_generation #(.Groupsize(`GROUPSIZE))
f(
.a(A[`GRUPPSUURUS* (i + 1) – 1:`GRUPPSUURUS * i]),
.b(B[`GRUPPSUURUS* (i + 1) – 1:`GRUPPSUURUS * i]),
.cin(cin[i]),
.s(S[GRUPPSUURUS * (i + 1) – 1: GROUPSIZE * i]),
.qg(q[i * 2 + 1:i * 2])
);
lõpp
parallel_prefix_tree_first_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t1(
.q(q[`SISESTUSSUURUS / `RÜHMASUURUS * 2 – 1:0]),
.r(r_temp[`SISEND SUURUS / `GRUPISUURUS * 2–1:0])
);
parallel_prefix_tree_second_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t2(
.q(r_temp[`INPUTSIZE / `GROUPSIZE * 2 – 1:0]),
.r(r[`SISESTUSSUURUS / `RÜHMASUURUS * 2–1:0])
);
jaoks (i = 0; i < `SISEND SUURUS / `GRUPISUURUS; i = i + 1) algab: cin_generation
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1'b0),
.cin(cin[i + 1])
);
lõpp
määra S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
lõppgenereerima
lõppmoodul
// Paralleelsete eesliidete puu esimene pool
moodul parallel_prefix_tree_first_half #(parameeter Puu suurus = `INPUTSIZE / `GROUPSIZE)(q, r);
sisend [Puu suurus * 2 – 1:0] q;
väljund [Puu suurus * 2 – 1:0] r;
genereerida
kus sees;
if (Puu suurus == 2) begin: trivial_case
määrata 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
traat [Puu suurus * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Puu suurus(Puu suurus / 2))
recursion_lsbh(
.q(q[puu suurus – 1:0]),
.r(r_temp[Puu suurus – 1:0])
);
parallel_prefix_tree_first_half #(.Puu suurus(Puu suurus / 2))
recursion_msbh(
.q(q[Puu suurus * 2 – 1:Puu suurus]),
.r(r_temp[Puu suurus * 2–1:Puu suurus])
);
jaoks (i = 0; i < puu suurus * 2; i = i + 2) algab: paralleelõmblus_üles
if (i != Puu suurus * 2 – 2) begin: parallel_stitch_up_pass
määrata r[i + 1:i] = r_temp[i + 1:i];
end else begin: parallel_stitch_up_produce
prefix_logic f(
.ql(r_temp[Puu suurus – 1:Puu suurus – 2]),
.qh(r_temp[Puu suurus * 2–1:Puu suurus * 2–2]),
.r(r[Puu suurus * 2–1:Puu suurus * 2–2])
);
lõpp
lõpp
lõpp
lõppgenereerima
lõppmoodul
// Paralleelsete eesliidete puu teine pool
moodul parallel_prefix_tree_second_half #(parameeter Puu suurus = `INPUTSIZE / `GROUPSIZE)(q, r);
sisend [Puu suurus * 2 – 1:0] q;
väljund [Puu suurus * 2 – 1:0] r;
traat [Puu suurus * 2 * ($clog2(Treesize) – 1) – 1:0] r_temp;
määra r_temp[Puu suurus * 2 – 1:0] = q[Puu suurus * 2 – 1:0];
genereerida
genvar i, j;
for (i = 0; i < $clog2(Treesize) – 2; i = i + 1) algab: teine_pooltase
määra r_temp[Puu suurus * 2 * (i + 1) + ((Puu suurus / (2 ** i)) - 1 - 2 ** ($clog2(Treesize / 4) - i)) * 2 - 1:Puu suurus * 2 * (i + 1)] = r_temp[Puu suurus * 2 * i + ((Puu suurus / (2 ** i)) - 1 - 2 ** ($ ummistus2(Puu suurus / 4) - i)) * 2 - 1: Puu suurus * 2 * i];
for (j = (Puu suurus / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i); j < Puu suurus; j = j + 2 ** ($clog2(Treesize / 2) ) – i)) begin: second_half_level_logic
prefix_logic f(
[ Puu suurus / 4) – i)) * 2]),
.qh(r_temp[puu suurus * 2 * i + j * 2 + 1: puu suurus * 2 * i + j * 2]),
.r(r_temp[puu suurus * 2 * (i + 1) + j * 2 + 1: puu suurus * 2 * (i + 1) + j * 2])
);
if (j != Puu suurus – 1 – 2 ** ($clog2(Treesize / 4) – i)) begin: second_half_level_direct_connect
määra r_temp[Puu suurus * 2 * (i + 1) + (j + 2 ** ($clog2(Puu suurus / 2) – i)) * 2 - 1:Puu suurus * 2 * (i + 1) + j * 2 + 2] = r_temp[Puu suurus * 2 * i + (j + 2 ** ($ ummistus2(Puu suurus / 2) – i)) * 2 - 1:Puu suurus * 2 * i + j * 2 + 2];
lõpp
lõpp
määra r_temp[Puu suurus * 2 * (i + 2) – 1:Puu suurus * 2 * (i + 2) – (2 ** ($clog2(Treesize / 4) – i)) * 2] = r_temp[Puu suurus * 2 * (i + 1) – 1:Puu suurus * 2 * (i + 1) – (2 ** ($clog2(Treesize / 4) – i)) * 2];
lõpp
määra r[1:0] = r_temp[Puu suurus * 2 * ($ummistus2(Puu suurus) – 2) + 1:Puu suurus * 2 * ($clog2(Treesize) – 2)];
jaoks (i = 1; i < puu suurus; i = i + 2) algab: lõplik_r_paar
määra r[i * 2 + 1:i * 2] = r_temp[Puu suurus * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesise) – 2) + i * 2];
lõpp
jaoks (i = 2; i < puu suurus; i = i + 2) algab: lõplik_r_paaris
prefix_logic f(
.ql(r_temp[Puu suurus * 2 * ($ ummistus2(Puu suurus) – 2) + i * 2 – 1:Puu suurus * 2 * ($clog2(Treesize) – 2) + i * 2 – 2]),
.qh(r_temp[Puu suurus * 2 * ($ ummistus2(Puu suurus) – 2) + i * 2 + 1:Puu suurus * 2 * ($clog2(Treesize) – 2) + i * 2]),
.r(r[i * 2 + 1:i * 2])
);
lõpp
lõppgenereerima
lõppmoodul
moodul group_q_generation #(parameeter Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
sisend [Grupi suurus – 1:0] a;
sisend [Grupi suurus – 1:0] b;
sisend cin;
väljund [Grupi suurus – 1:0] s;
väljund [1:0] qg;
traat [2 * Grupi suurus – 1:0] q;
traat [Rühmasuurus – 1:0] c;
määrata c[0] = cin;
genereerida
kus sees;
jaoks (i = 0; i < rühma suurus; i = i + 1) algab: parallel_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: erijuhtum
määra c[i + 1] = q[i * 2 + 1] | (q[i * 2] & c[i]);
lõpp
lõpp
//grupi q genereerimine rühma suuruse alusel
if (Grupi suurus == 1) begin: case_gs1
määra qg[1] = q[1];
määra qg[0] = q[0];
end else if (Grupi suurus == 2) algus: case_gs2
määra qg[1] = q[3] | (q[1] ja q[2]);
määra qg[0] = q[2] & q[0];
end else if (Grupi suurus == 4) algus: case_gs4
määra qg[1] = q[7] | (q[5] ja q[6]) | (q[3] & q[6] ja q[4]) | (q[1] & q[6] & q[4] ja q[2]);
määra qg[0] = q[6] & q[4] & q[2] & q[0];
end else if (Grupi suurus == 8) algus: case_gs8
määra qg[1] = q[15] | (q[13] ja q[14]) | (q[11] & q[14] ja q[12]) | (q[9] ja q[14] ja q[12] ja q[10]) | (q[7] & q[14] ja q[12] ja q[10] ja q[8]) | (q[5] & q[14] & q[12] ja q[10] ja q[8] ja q[6]) | (q[3] & q[14] & q[12] ja q[10] ja q[8] ja q[6] ja q[4]) | (q[1] & q[14] & q[12] & q[10] & q[8] & q[6] & q[4] ja q[2]);
määra qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0];
lõpp
lõppgenereerima
lõppmoodul
// Tsiini genereerimise loogika
moodul cin_generation_logic(r, c0, cin);
sisend [1:0] r;
sisend c0;
väljund cin;
määrata cin = (r[0] & c0) | r[1];
lõppmoodul
// Eesliidete operatsioonide põhiloogika
mooduli prefiks_loogika(ql, qh, r);
sisend [1:0] ql;
sisend [1:0] qh;
väljund [1:0] r;
määra r[0] = qh[0] & ql[0];
määra r[1] = (qh[0] & ql[1]) | qh[1];
lõppmoodul
// Full Adder Cell koos Carry Look-Ahead
moodul FA_CLA_prefix(a, b, cin, s, q);
sisend a;
sisend b;
sisend cin;
väljund s;
väljund [1:0] q;
määrata q[0] = a ^ b;
määrata s = q[0] ^ cin;
määra q[1] = a & b;
lõppmoodul
Eelised
Brent Kung Adderi eelised hõlmavad järgmist.
- See on väikese võimsusega liiter, kuna see kasutab tulemuse saamiseks minimaalset vooluringi.
- See on väga populaarne ja laialdaselt kasutatav lisaja.
- Sellist liitjat saab realiseerida, kasutades Kogge-Stone'i liitjaga võrreldes vähem mooduleid.
- Brent-Kung lisajate kujundamine on väga lihtne.
- Sellel lisajal on teiste moodulitega vähem ühendusi.
- Need liitjad pakuti välja peamiselt Kogge-Stone'i liiterite puuduste lahendamiseks.
Puudused
The Brent Kung Adde'i puudused r sisaldab järgmist.
- Nendel summaritel on suurem viivitus ja see vajab kõigi ülekandebittide arvutamiseks 2 log2 n − 2 loogikataset.
- Selle summari peamiseks puuduseks on fanout, mis võib põhjustada voolu levimise kogu summaris lõhenemist ja nõrgenemist.
Brent Kung Adderi rakendused
Brent Kung Adderi rakendused hõlmavad järgmist.
- Brent-Kung liitjat kasutatakse torujuhtmena, et vähendada energiatarbimist, vähendades kombinatoorse loogika sügavust ja tõrgete stabiliseerimist.
- Brent-Kung summaar pakub silmapaistvat arvu etappe i/p-st kõigi o/ps-ni, kuid asümmeetrilise vaheastmete laadimisega.
- Seda summarit saab kasutada nii kordajas kui ka muudes andmetee elementides.
Seega on see ülevaade Brent kung adderist , selle töö, eelised, puudused ja rakendused. See on väga tõhus liitja ja selle struktuur näeb välja nagu puustruktuur, mida kasutatakse peamiselt suure jõudlusega aritmeetiliste toimingute jaoks. Seda tüüpi summaar on väga kiire ja keskendub peamiselt väravataseme loogikale. See summaar on loodud väiksema arvu loogiliste väravate kasutamisel. Seega vähendab see selles arhitektuuris kasutatavat mälu ja viivitust. Siin on teile küsimus, Brent kung lisaja, tuntud ka kui?
![IC 4060 kinnitusprobleem [lahendatud]](https://electronics.jf-parede.pt/img/timer-delay-relay/35/ic-4060-latching-problem.jpg)
