Brenta–Kung papildinātāju 1982. gadā ierosināja Hsiangs Te Kungs un Ričards Pīrss Brents. Tas ir paralēlais prefiksu papildinātājs vai koku papildinātājs, ko tā elastības dēļ plaši izmanto digitālajā dizainā. Paralēlos prefiksu papildinātājus var izveidot vairākos veidos, pamatojoties uz loģikas līmeņu skaitu, loģikas vārti iesaistīts, ventilators no katriem vārtiem un vadi starp līmeņiem. Ir pieejami dažāda veida koku summatori, galvenie koku summētāji ir Sklanskym KoggeStone & Brent-Kung. Salīdzinot ar KSA (Kogge–Stone summatori), šis summētājs nodrošina augstu summatora struktūras regularitāti un mazāk bloķē vadu. kas nodrošina labāku veiktspēju un mazāk nepieciešamo mikroshēmas laukumu. Šajā rakstā ir sniegta īsa informācija par a Brents Kungs Adders .
Kas ir Brents Kungs Adders?
Sumators, kas rezultāta iegūšanai izmanto minimālo shēmu, ir pazīstams kā Brent Kung papildinātājs, un tas ir pazīstams arī kā mazjaudas sumators vai paralēlais sumators. Šis papildinātājs ir paredzēts, lai saglabātu mikroshēmas izmēru, lai šo papildinātāju izgatavošana kļūtu vienkāršāka. Šī summētāja simetrija un parastā konstrukcijas struktūra ievērojami samazinās ražošanas izmaksas un ir pieļaujama izmantošana konveijera topoloģijās. Papildu caurlaides tranzistora loģikas izmantošana palīdz uzlabot dizaina veiktspēju ar multipleksors pieeja dažādos šūnu dizainos.
Brenta Kunga aidera ķēde
Tālāk ir parādīta brent-kung paralēlā prefiksa pievienotāja diagramma, kas ietver 1. posmu (pirmsapstrādes stadiju), 2. līdz 7. posmi ir pārneses ģenerēšanas posmi, bet 8. posms ir pēcapstrāde. Tā ir uzlabota arhitektūra, un to ir ļoti vienkārši uzbūvēt, un tā nodrošina mazāku vadu pārslodzi. Tādējādi mazāks vadu skaits samazinās arhitektūras izpildei nepieciešamās vietas daudzumu. Turklāt maršrutēšana kļūst daudz vienkāršāka, jo mazāk vadu krustojas (vai pārklājas). Tomēr sods palielināsies par kavēšanos, jo palielinās posmu skaits. Šim summētājam tiek palielināts ventilators, un pēc tam tiks palielināta kavēšanās.
Kā darbojas Brent Kung Adder?
Brent Kung Adder darbojas, aprēķinot divu bitu grupu prefiksus, kas ir noderīgi, lai atrastu 4 bitu grupu prefiksus. Šie prefiksi tiek izmantoti, lai aprēķinātu 8 bitu grupas prefiksus utt. Pēc tam šie prefiksi tiks izmantoti, lai aprēķinātu konkrētā bitu posma izpildi. Šie pārnesumi tiek izmantoti kopā ar nākamā posma grupas izplatīšanu, lai aprēķinātu šī posma summas bitu. Brent Kung Tree izmanto 2log2N – 1 posmu.
32 bitu Brent Kung papildinātājs
Tālāk ir parādīts 32 bitu Brent Kung papildinātāja izkārtojums. Šī izkārtojuma sākumā ir izstrādāti pamata loģikas vārti, piemēram, NAND, invertors, XOR, NOR utt. Pēc tam nepieciešamās šūnas, piemēram, melnās šūnas, pelēkās šūnas, buferi un PG loģika, tiek izstrādātas ar loģikas vārtiem.
Zemāk esošajā 32 bitu Brent Kung papildinātājā invertējošie vārti, piemēram, AOI un OAI, tiek izmantoti galvenokārt pelēkajām un melnajām šūnām. Tātad melnās un pelēkās šūnas tiek attēlotas ar pelēkiem un melniem blokiem, bet buferi ir attēloti ar apļiem.
Tādas ieejas kā A un B tiek nodrošinātas PG loģikai, kas ir parādīta blokshēmā. 32 bitu summatoram ir nepieciešami 32 PG loģiskie bloki, un šī bloka izejas ir izplatīšanās (P) un ģenerēšanas (G) signāli. Šie signāli tiek nodrošināti Brent Kung papildinātāja koka struktūrā. Šī papildinātāja struktūra ietver pelēkās un melnās šūnas.
Pelēkā šūnā ir trīs ieejas un viena izeja. Signālu izplatīšana un ģenerēšana no pašreizējās pakāpes un signālu ģenerēšana no iepriekšējās pakāpes ir ieejas, savukārt grupas ģenerēšanas signāli ir o/p. Jebkurā koka struktūrā katrs posms beigsies ar pelēku šūnu, un šīs šūnas o/p ir grupas ģenerēšanas signāls. Šis signāls tiek uzskatīts vienkārši par šī posma pārnēsāšanu. Melnajā šūnā ir četras ieejas un divas izejas. Šīs šūnas ievades ir pašreizējā posma P & G signāli un P, G signāli no iepriekšējā posma.
PG loģika ietver UN un XOR vārtus, kur UN loģikas vārti tiek izmantoti G signāla ģenerēšanai, un XOR loģiskie vārti nodrošina P signālu. Lai novērstu nevajadzīgus invertorus, tiek izmantotas divu veidu pelēkās un melnās šūnas. Apgriežamie vārti, kas tiek izmantoti vienā rindā pelēkajai šūnai, ir AOI vai AND-OR-Inverter, un apgriežamie vārti melnā šūnai nākamajā rindā izmanto OAI vai OR-AND-Inverter. AOI šūna izmanto parastās ievades, lai nodrošinātu apgrieztas izejas, savukārt OAI izmanto apgrieztās ievades, lai nodrošinātu normālus izvadus.
Brenta Kunga Addera operācija
Brent Kung papildinātājs ir paralēlais prefiksu papildinātājs, ko izmanto augstas veiktspējas pievienošanas darbībai. Šis summētājs izskatās kā koka struktūra, kas veic aritmētisko darbību. Šajā papildinātājā ir iekļautas melnās un pelēkās šūnas. Katrā melnajā šūnā ir divi UN vārti un viens VAI vārti, un katrā pelēkajā šūnā ir tikai viens UN vārti.
Brent-kung papildinātājs ietver divus posmus; pirmapstrādes un ģenerēšanas posms. Pirmajā posmā ģenerēšana un izplatīšana tiks veikta no katra ievades pāra. Šeit izplatīšana nodrošina ievades bitiem operāciju “XOR”, savukārt ģenerēšana ievades bitiem nodrošina operāciju “UN”. Tālāk ir norādītas tādas kā “Pi” un “Gi” izplatīšana un ģenerēšana.
Pi = Ai XOR Bi un Gi = Ai UN Bi.
Otrajā posmā pārnēsāšana tiks ģenerēta katram bitam, kas ir pazīstams kā pārneses ģenerēšana “Cg”, un pārnēsāšana tiek izplatīta katram bitam, ko sauc par pārneses ģenerēšanu “Cp”. Turpmākai darbībai tiks ģenerēta pārnēsāšana un ģenerēšana. Pēdējā šūna, kas pieejama katrā bitā, nodrošina pārnešanu. Tātad pēdējais bitu pārnesums palīdzēs summēt nākamo bitu vienlaikus līdz pēdējam bitam. Pārnēsāšanas ģenerēšana un izplatīšana tiek dota kā;
Cp = P1 UN P0 un Cg = G1 VAI (P1 UN G0)
To galvenokārt izmanto divu trīsdesmit divu bitu pievienošanas darbībai, un katrs bits tiek pakļauts pirmapstrādes un ģenerēšanas stadijai, pēc tam tas nodrošina galīgo summu.
Primārās ievades biti atrodas zem priekšapstrādes stadijas, un tie veic izplatīšanu un ģenerēšanu. Tātad tie izplatās, kā arī ģenerē iziet ģenerēšanas stadiju, ģenerē pārnesumu ģenerē un pārnēsā izplatās un nodrošina galīgo summu. Brent-kung papildinātāja soli pa solim process ir parādīts zemāk.
Brent-kung summatora izkārtojums izskatās pēc koka struktūras, un tas ir ātrgaitas summators, kura mērķis ir vārtu līmeņa loģika. Šo summētāju var konstruēt ar loģisko vārtu skaita samazinājumu. Tādējādi tas samazina aizkavi un atmiņu, kas tiek izmantota šajā arhitektūrā.
Brent Kung Adder Verilog kods
Tālāk ir parādīts Brent Kung papildinātāja verilog kods.
`define INPUTSIZE 64 //iestatiet ievades izmēru n
`definēt GROUPSIZE 8 //iestatīt grupas lielumu = 1, 2, 4 vai 8
modulis Brent_Kung_Adder(A, B, S);
ievade [`INPUTSIZE – 1:0] A;
ievade [`INPUTSIZE – 1:0] B;
izeja [`INPUTSIZE:0] S;
vads [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r_temp;
vads [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r;
vads [`INPUTSIZE / `GROUPSIZE:0] cin;
vads [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] q;
piešķirt cin[0] = 1’b0;
ģenerēt
kur atrodas;
priekš (i = 0; i < `INPUTSIZE/`GROUPSIZE; i = i + 1) sākas: paralēls_FA_CLA_prefikss
group_q_generation #(.Groupsize(`GROUPSIZE))
f(
.a(A[`GROUPSIZE* (i+1)-1:`GROUPSIZE*i]),
.b(B[`GRUPAS IZMĒRS* (i + 1) - 1:`GROUPSIZE * i]),
.cin(cin[i]),
.s(S[`GROUPSIZE* (i+1)-1:`GROUPSIZE*i]),
.qg(q[i * 2 + 1:i * 2])
);
beigas
parallel_prefix_tree_first_half #(.Treesize(`INPUTSIZE/`GROUPSIZE))
t1(
.q(q [IEVADES IZMĒRS / GRUPAS IZMĒRS * 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/`GRUPAS IZMĒRS * 2–1:0])
);
priekš (i = 0; i < `INPUTSIZE/`GROUPSIZE; i = i + 1) sākas: cin_generation
cin_generation_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1'b0),
.cin(cin[i + 1])
);
beigas
piešķirt S[`INPUTSIZE] = cin[`INPUTSIZE/`GROUPSIZE];
gala radītājs
gala modulis
// Paralēlā prefiksa koka pirmā puse
modulis parallel_prefix_tree_first_half #(parametrs Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
ievade [Treesize * 2 – 1:0] q;
izvade [Treesize * 2 – 1:0] r;
ģenerēt
kur atrodas;
if (Treesize == 2) begin: trivial_case
piešķirt r[1:0] = q[1:0];
prefix_logic f(
.ql(q[1:0]),
.qh(q[3:2]),
.r(r[3:2])
);
beigas cits sākums: recursive_case
vads [Treesize * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_lsbh(
.q(q[koka izmērs — 1:0]),
.r(r_temp[koka izmērs — 1:0])
);
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
recursion_msbh(
.q(q [koka izmērs * 2–1: koka izmērs]),
.r(r_temp[koka izmērs * 2–1: koka izmērs])
);
for (i = 0; i < Koka izmērs * 2; i = i + 2) sākas: paralēlais dūriens
if (i != Treesize * 2 – 2) begin: parallel_stitch_up_pass
piešķirt r[i + 1:i] = r_temp[i + 1:i];
beigas cits sākums: parallel_stitch_up_produce
prefix_logic f(
.ql(r_temp[koka izmērs — 1: koka izmērs — 2]),
.qh(r_temp[koka izmērs * 2–1: koka izmērs * 2–2]),
.r(r[koka izmērs * 2 - 1: koka izmērs * 2 - 2])
);
beigas
beigas
beigas
gala radītājs
gala modulis
// Paralēlā prefiksa koka otrā puse
modulis parallel_prefix_tree_second_half #(parametrs Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
ievade [Treesize * 2 – 1:0] q;
izvade [Treesize * 2 – 1:0] r;
vads [Treesize * 2 * ($clog2(Treesize) – 1) – 1:0] r_temp;
piešķirt r_temp[Koka izmērs * 2 – 1:0] = q[Koka izmērs * 2 – 1:0];
ģenerēt
genvar i, j;
for (i = 0; i < $clog2(Treesize) – 2; i = i + 1) sākas: otrais_puses_līmenis
piešķirt r_temp[Koka izmērs * 2 * (i + 1) + ((Koka izmērs / (2 ** i)) - 1 - 2 ** ($clog2(Treesize / 4) - i)) * 2 - 1:Koka izmērs * 2 * (i + 1)] = r_temp[Koka izmērs * 2 * i + ((Koka izmērs / (2 ** i)) - 1 - 2 ** ($clog2(Treesize / 4) - i)) * 2 - 1: Koka izmērs * 2 * i];
for (j = (Koka izmērs / (2 ** i)) - 1 - 2 ** ($clog2(Treesize / 4) - i); j < Koka izmērs; j = j + 2 ** ($clog2(Treesize / 2) ) – i)) begin: second_half_level_logic
prefix_logic f(
.ql(r_temp[Koka izmērs * 2 * i + (j - 2 ** ($clog2(Treesize / 4) - i)) * 2 + 1:Treesize * 2 * i + (j - 2 ** ($clog2( Koka izmērs / 4) – i)) * 2]),
.qh(r_temp[koka izmērs * 2 * i + j * 2 + 1: koka izmērs * 2 * i + j * 2]),
.r(r_temp[koka izmērs * 2 * (i + 1) + j * 2 + 1: koka izmērs * 2 * (i + 1) + j * 2])
);
if (j != Koka izmērs – 1 – 2 ** ($clog2(Treesize / 4) – i)) sākas: second_half_level_direct_connect
piešķirt r_temp[Treesize * 2 * (i + 1) + (j + 2 ** ($clog2(Treesize / 2) - i)) * 2 - 1:Treesize * 2 * (i + 1) + j * 2 + 2] = r_temp[Koka izmērs * 2 * i + (j + 2 ** ($clog2(Treesize / 2) - i)) * 2 - 1:Koka izmērs * 2 * i + j * 2 + 2];
beigas
beigas
piešķirt r_temp[Koka lielums * 2 * (i + 2) - 1: koka izmērs * 2 * (i + 2) - (2 ** ($clog2(Treesize / 4) - i)) * 2] = r_temp[Koka izmērs * 2 * (i + 1) - 1:Treesize * 2 * (i + 1) - (2 ** ($clog2(Treesize / 4) - i)) * 2];
beigas
piešķirt r[1:0] = r_temp[Koka izmērs * 2 * ($clog2(Treesize) – 2) + 1:Treesize * 2 * ($clog2(Treesize) – 2)];
for (i = 1; i < Koka izmērs; i = i + 2) sākas: final_r_odd
piešķirt r[i * 2 + 1:i * 2] = r_temp[Koka izmērs * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesize) - 2) + i * 2];
beigas
for (i = 2; i < Koka izmērs; i = i + 2) sākas: final_r_even
prefix_logic f(
.ql(r_temp[Koka izmērs * 2 * ($clog2(Treesize) - 2) + i * 2 - 1:Treesize * 2 * ($clog2(Treesize) - 2) + i * 2 - 2]),
.qh(r_temp[Koka izmērs * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesize) – 2) + i * 2]),
.r(r[i * 2 + 1:i * 2])
);
beigas
gala radītājs
gala modulis
modulis group_q_generation #(parametrs Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
ievade [Grupas izmērs – 1:0] a;
ievade [Grupas izmērs – 1:0] b;
ievade cin;
izvade [Grupas izmērs – 1:0] s;
izvade [1:0] qg;
vads [2 * Grupas izmērs – 1:0] q;
vads [Grupas izmērs – 1:0] c;
piešķirt c[0] = cin;
ģenerēt
kur atrodas;
priekš (i = 0; i < grupas lielums; i = i + 1) sākas: paralēls_FA_CLA_prefikss
FA_CLA_prefikss 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
piešķirt c[i + 1] = q[i * 2 + 1] | (q[i * 2] & c[i]);
beigas
beigas
//grupas q paaudze, pamatojoties uz grupas lielumu
if (Grupas izmērs == 1) begin: case_gs1
piešķirt qg[1] = q[1];
piešķirt qg[0] = q[0];
beigas else if (Grupas izmērs == 2) begin: case_gs2
piešķirt qg[1] = q[3] | (q[1] un q[2]);
piešķirt qg[0] = q[2] & q[0];
beigas else if (Grupas izmērs == 4) begin: case_gs4
piešķirt qg[1] = q[7] | (q[5] un q[6]) | (q[3] & q[6] un q[4]) | (q[1] & q[6] un q[4] un q[2]);
piešķirt qg[0] = q[6] & q[4] & q[2] & q[0];
beigas else if (Grupas izmērs == 8) begin: case_gs8
piešķirt qg[1] = q[15] | (q[13] un q[14]) | (q[11] & q[14] un q[12]) | (q[9] un q[14] un q[12] un q[10]) | (q[7] un q[14] un q[12] un q[10] un q[8]) | (q[5] un q[14] un q[12] un q[10] un q[8] un q[6]) | (q[3] un q[14] un q[12] un q[10] un q[8] un q[6] un q[4]) | (q[1] & q[14] & q[12] & q[10] & q[8] un q[6] un q[4] un q[2]);
piešķirt qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0];
beigas
gala radītājs
gala modulis
// Cin ģenerēšanas loģika
modulis cin_generation_logic(r, c0, cin);
ievade [1:0] r;
ievade c0;
izejas cin;
piešķirt cin = (r[0] & c0) | r[1];
gala modulis
// Pamata loģika prefiksu operācijām
moduļa prefix_logic(ql, qh, r);
ievade [1:0] ql;
ievade [1:0] qh;
izeja [1:0] r;
piešķirt r[0] = qh[0] & ql[0];
piešķirt r[1] = (qh[0] & ql[1]) | qh[1];
gala modulis
// Pilna papildinātāja šūna ar Carry Look-Ahead
modulis FA_CLA_prefix(a, b, cin, s, q);
ievade a;
ievade b;
ievade cin;
izvade s;
izvade [1:0] q;
piešķirt q[0] = a ^ b;
piešķirt s = q[0] ^ cin;
piešķirt q[1] = a & b;
gala modulis
Priekšrocības
Brent Kung Adder priekšrocības ir šādas.
- Šis ir mazjaudas papildinātājs, jo rezultāta iegūšanai tas izmanto minimālo ķēdi.
- Tas ir ļoti populārs un plaši izmantots papildinātājs.
- Šāda veida summētāju var ieviest, izmantojot mazāk moduļu, salīdzinot ar Kogge-Stone summatoru.
- Brent-Kung papildinātāja projektēšana ir ļoti vienkārša.
- Šim papildinātājam ir mazāk savienojumu ar citiem moduļiem.
- Šie papildinātāji tika piedāvāti galvenokārt, lai atrisinātu Kogge-Stone summatoru trūkumus.
Trūkumi
The Brenta Kunga Adde trūkumi r iekļaujiet tālāk norādīto.
- Šiem summētājiem ir lielāka aizkave, un tiem ir nepieciešami 2 log2 n − 2 loģiskie līmeņi, lai aprēķinātu visus pārnēsāšanas bitus.
- Galvenais šī summatora trūkums ir izplūde, kas var izraisīt strāvas izplatīšanos visā summatorā, lai sadalītos un kļūtu vājāka.
Brenta Kunga papildinātāja lietojumprogrammas
Brent Kung Adder lietojumprogrammas ir šādas.
- Brent-Kung summators tiek izmantots cauruļvada veidā, lai samazinātu enerģijas patēriņu, samazinot kombinatorisko loģikas dziļumu un traucējumu stabilizāciju.
- Brent-Kung papildinātājs nodrošina izcilu pakāpju skaitu no i/p līdz visiem o/ps, bet ar asimetrisku starpposmu ielādi.
- Šo summatoru var izmantot reizinātājā, kā arī citos datu ceļa elementos.
Tādējādi tas ir pārskats par Brent kung adder , tā darbība, priekšrocības, trūkumi un pielietojums. Šis ir ļoti efektīvs summētājs, un tā struktūra izskatās kā koka struktūra, ko galvenokārt izmanto augstas veiktspējas aritmētiskām darbībām. Šāda veida summators ir ļoti ātrs un koncentrējas galvenokārt uz vārtu līmeņa loģiku. Šis papildinātājs ir izstrādāts, izmantojot mazāku loģisko vārtu skaitu. Tādējādi tas samazina šajā arhitektūrā izmantoto atmiņu un aizkavi. Šeit ir jautājums jums, Brent kung papildinātājs, kas pazīstams arī kā?
