Penambah Brent – Kung diusulkan pada tahun 1982 oleh Hsiang Te Kung & Richard Peirce Brent. Ini adalah penambah Awalan Paralel atau penambah pohon yang digunakan secara luas dalam Desain Digital karena fleksibilitasnya. Parallel Prefix Adders dapat dibangun dengan beberapa cara berdasarkan jumlah level logika, gerbang logika terlibat, penyebaran dari setiap gerbang & kabel di antara level. Ada berbagai jenis penambah pohon yang tersedia, Penambah pohon yang mendasar adalah Sklanskym KoggeStone & Brent-Kung, Dibandingkan dengan KSA (Kogge–Stone adder), penambah ini memberikan keteraturan yang tinggi pada struktur penambah dan memiliki lebih sedikit pemblokiran kabel yang menghasilkan kinerja lebih baik & lebih sedikit area chip yang dibutuhkan. Artikel ini memberikan informasi singkat tentang a Brent Kung Adder .
Apa itu Brent Kung Adder?
Penambah yang menggunakan sirkuit minimum untuk mendapatkan hasilnya dikenal sebagai Brent Kung Adder dan juga dikenal sebagai penambah daya rendah atau penambah paralel. Adder ini dimaksudkan untuk menghemat ukuran chip sehingga pembuatan adder tersebut akan menjadi lebih mudah. Simetri & struktur konstruksi biasa penambah ini akan sangat mengurangi biaya produksi dan memungkinkan untuk digunakan dalam topologi perpipaan. Pemanfaatan logika transistor pass pelengkap membantu dalam meningkatkan kinerja desain dengan multiplekser pendekatan dalam berbagai desain sel.
Sirkuit Brent Kung Adder
Diagram penambah prefiks paralel brent-kung ditunjukkan di bawah ini yang meliputi tahap 1 (tahap pra-pemrosesan), tahap 2 hingga 7 adalah tahap pembangkitan carry & tahap 8 adalah pasca-pemrosesan. Ini adalah arsitektur canggih dan sangat sederhana untuk dibangun & mengurangi kemacetan kabel. Jadi, lebih sedikit kabel akan mengurangi jumlah ruang yang dibutuhkan untuk menjalankan arsitektur. Selain itu, perutean menjadi lebih mudah karena lebih sedikit kabel yang bersilangan (atau) tumpang tindih. Namun, penalti penundaan akan bertambah karena bertambahnya jumlah tahapan, Fan out untuk penambah ini ditingkatkan, dan kemudian penundaan akan ditingkatkan.
Bagaimana Cara Kerja Brent Kung Adder?
Brent Kung Adder bekerja dengan menghitung prefiks untuk dua grup bit yang berguna dalam mencari prefiks grup 4 bit. Awalan ini digunakan untuk menghitung awalan grup 8-bit, dll. Setelah itu, awalan ini akan digunakan untuk menghitung pelaksanaan tahap bit tertentu. Carry ini digunakan dengan Group Propagate tahap berikutnya untuk menghitung Sum bit tahap tersebut. Brent Kung Tree menggunakan 2log2N – 1 tahap.
Brent Kung Adder 32-bit
Tata letak penambah Brent Kung 32-bit ditunjukkan di bawah ini. Pada awal tata letak ini, gerbang logika dasar dirancang seperti NAND, inverter, XOR, NOR, dll. Setelah itu, sel-sel yang diperlukan seperti sel hitam, sel abu-abu, buffer, dan logika PG dirancang dengan gerbang logika.
Dalam penambah Brent Kung 32-bit di bawah ini, gerbang pembalik seperti AOI & OAI digunakan sebagai alternatif terutama untuk sel abu-abu & hitam. Jadi sel hitam & abu-abu direpresentasikan dengan blok abu-abu & hitam sedangkan buffer direpresentasikan dengan lingkaran.
Input seperti A & B diberikan ke logika PG yang ditunjukkan dalam diagram blok. Untuk penambah 32-bit, diperlukan 32 blok logika PG dan sinyal propagasi (P) & pembangkit (G) adalah keluaran dari blok ini. Sinyal-sinyal ini diberikan ke struktur pohon penambah Brent Kung. Struktur penambah ini meliputi sel abu-abu & sel hitam.
Sel abu-abu mencakup tiga masukan & keluaran tunggal. Sinyal yang merambat dan menghasilkan dari tahap sekarang & menghasilkan sinyal dari tahap sebelumnya adalah input sedangkan kelompok sinyal yang menghasilkan adalah output. Dalam struktur pohon mana pun, setiap tahapan akan diakhiri dengan sel abu-abu & output dari sel ini adalah sinyal yang menghasilkan grup. Sinyal ini dianggap hanya sebagai pembawa tahap itu. Sel Hitam mencakup empat input & dua output. Masukan untuk sel ini adalah sinyal P&G tahap sekarang & sinyal P, G dari tahap sebelumnya.
Logika PG mencakup gerbang AND & XOR dimana gerbang logika AND digunakan untuk menghasilkan sinyal G & gerbang logika XOR menyediakan sinyal P. Untuk menghilangkan inverter yang tidak diperlukan, dua jenis sel abu-abu dan sel hitam digunakan. Gerbang pembalik yang digunakan pada satu baris untuk sel abu-abu adalah AOI atau AND-OR-Inverter & gerbang pembalik untuk sel hitam pada baris berikutnya menggunakan OAI atau OR-AND-Inverter. Sel AOI menggunakan masukan normal untuk menghasilkan keluaran terbalik sedangkan OAI menggunakan masukan terbalik untuk menghasilkan keluaran normal.
Operasi Brent Kung Adder
Penambah Brent Kung adalah penambah awalan paralel yang digunakan untuk pengoperasian penambahan kinerja tinggi. Penjumlah ini terlihat seperti struktur pohon yang melakukan operasi aritmatika. Penambah ini mencakup sel hitam & sel abu-abu. Setiap sel hitam mempunyai dua gerbang AND dan satu gerbang OR, dan setiap sel abu-abu hanya mempunyai satu gerbang AND.
Penambah Brent-kung mencakup dua tahap; tahap pra-pemrosesan & tahap generasi. Pada tahap pertama, pembangkitan & propagasi akan dilakukan dari setiap pasangan masukan. Di sini propagasi menyediakan operasi 'XOR' untuk bit masukan sedangkan pembangkit menyediakan operasi 'DAN' untuk bit masukan. Propagasi & hasilkan seperti 'Pi' dan 'Gi' diberikan di bawah ini.
Pi = Ai XOR Bi dan Gi = Ai DAN Bi.
Pada tahap kedua, carry akan dihasilkan untuk setiap bit yang disebut carry generate 'Cg' & carry yang disebarkan untuk setiap bit dikenal sebagai carry generate 'Cp'. Untuk operasi selanjutnya, carry propagate & carry generate akan dihasilkan. Sel terakhir yang tersedia dalam setiap fungsi bit menyediakan carry. Jadi bit terakhir yang dibawa akan membantu menjumlahkan bit berikutnya secara bersamaan hingga bit terakhir. Hasil carry & propagasi diberikan sebagai;
Cp = P1 DAN P0 dan Cg=G1 ATAU (P1 DAN G0)
Ini digunakan terutama untuk operasi penambahan dua tiga puluh dua bit & setiap bit mengalami tahap pra-pemrosesan & tahap pembuatan kemudian memberikan jumlah akhir.
Bit masukan utama berada di bawah tahap pra-pemrosesan & menghasilkan propagasi & menghasilkan. Jadi propagasi dan pembangkitan ini mengalami tahap pembangkitan carry, generate & carry, propagasi dan memberikan jumlah akhir. Proses langkah demi langkah penambah Brent-kung ditunjukkan di bawah ini.
Susunan penambah Brent-kung terlihat seperti struktur pohon dan merupakan penambah berkecepatan tinggi yang menargetkan logika tingkat gerbang. Penambah ini dapat dirancang dengan pengurangan jumlah gerbang logika. Dengan demikian, ini mengurangi penundaan & memori yang digunakan dalam arsitektur ini.
Kode Verilog Brent Kung Adder
Kode verilog penambah Brent Kung ditunjukkan di bawah ini.
`define INPUTSIZE 64 //atur ukuran input n
`define GROUPSIZE 8 //atur ukuran grup = 1, 2, 4 atau 8
modul Brent_Kung_Adder(A,B,S);
masukan [`INPUTSIZE – 1:0] A;
masukan [`INPUTSIZE – 1:0] B;
keluaran [`UKURAN INPUT:0] S;
kawat [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r_temp;
kawat [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r;
kawat [`INPUTSIZE / `GROUPSIZE:0] cin;
kawat [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] q;
tetapkan cin[0] = 1'b0;
menghasilkan
di mana;
untuk (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) mulai: parallel_FA_CLA_prefix
group_q_generasi #(.Groupsize(`GROUPSIZE))
F(
.a(A[`UKURAN GRUP * (i + 1) – 1:`UKURAN GRUP * i]),
.b(B[`UKURAN KELOMPOK * (i + 1) – 1:`UKURAN KELOMPOK * i]),
.cin(cin[i]),
.s(S[`UKURAN KELOMPOK * (i + 1) – 1:`UKURAN KELOMPOK * i]),
.qg(q[i * 2 + 1:i * 2])
);
akhir
parallel_prefix_tree_first_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t1(
.q(q[`INPUTSIZE / `GROUPSIZE * 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 / `GROUPSIZE * 2 – 1:0])
);
untuk (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) mulai: cin_generasi
cin_generasi_logika f(
.r(r[2 * saya + 1:2 * saya]),
.c0(1'b0),
.cin(cin[i + 1])
);
akhir
tetapkan S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
menghasilkan akhir
modul akhir
// Paruh pertama pohon prefiks paralel
modul parallel_prefix_tree_first_half #(parameter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
masukan [Ukuran Pohon * 2 – 1:0] q;
keluaran [Ukuran Pohon * 2 – 1:0] r;
menghasilkan
di mana;
if (Treesize == 2) mulai: sepele_case
tetapkan r[1:0] = q[1:0];
awalan_logika f(
.ql(q[1:0]),
.qh(q[3:2]),
.r(r[3:2])
);
akhiri yang lain mulai: recursive_case
kawat [Ukuran Pohon * 2 – 1:0] r_temp;
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
rekursi_lsbh(
.q(q[Ukuran Pohon – 1:0]),
.r(r_temp[Ukuran Pohon – 1:0])
);
parallel_prefix_tree_first_half #(.Treesize(Treesize / 2))
rekursi_msbh(
.q(q[Ukuran Pohon * 2 – 1:Ukuran Pohon]),
.r(r_temp[Ukuran Pohon * 2 – 1:Ukuran Pohon])
);
untuk (i = 0; i < Ukuran Pohon * 2; i = i + 2) mulai: parallel_stitch_up
if (i != Ukuran pohon * 2 – 2) mulai: parallel_stitch_up_pass
tetapkan r[i + 1:i] = r_temp[i + 1:i];
akhiri yang lain mulai: parallel_stitch_up_produce
awalan_logika f(
.ql(r_temp[Ukuran Pohon – 1:Ukuran Pohon – 2]),
.qh(r_temp[Ukuran Pohon * 2 – 1:Ukuran Pohon * 2 – 2]),
.r(r[Ukuran Pohon * 2 – 1:Ukuran Pohon * 2 – 2])
);
akhir
akhir
akhir
menghasilkan akhir
modul akhir
// Bagian kedua dari pohon awalan paralel
modul parallel_prefix_tree_second_half #(parameter Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
masukan [Ukuran Pohon * 2 – 1:0] q;
keluaran [Ukuran Pohon * 2 – 1:0] r;
kawat [Ukuran Pohon * 2 * ($clog2(Ukuran Pohon) – 1) – 1:0] r_temp;
tetapkan r_temp[Ukuran Pohon * 2 – 1:0] = q[Ukuran Pohon * 2 – 1:0];
menghasilkan
genvar saya, j;
untuk (i = 0; i < $clog2(Treesize) – 2; i = i + 1) mulai: second_half_level
tetapkan r_temp[Ukuran Pohon * 2 * (i + 1) + ((Ukuran Pohon / (2 ** i)) – 1 – 2 ** ($clog2(Ukuran Pohon / 4) – i)) * 2 – 1:Ukuran Pohon * 2 * (i + 1)] = r_temp[Ukuran Pohon * 2 * i + ((Ukuran Pohon / (2 ** i)) – 1 – 2 ** ($clog2(Ukuran Pohon / 4) – i)) * 2 – 1: Ukuran pohon * 2 * i];
untuk (j = (Ukuran Pohon / (2 ** i)) – 1 – 2 ** ($clog2(Ukuran Pohon / 4) – i); j < Ukuran Pohon; j = j + 2 ** ($clog2(Ukuran Pohon / 2 ) – i)) mulai: logika_tingkat_setengah_kedua
awalan_logika f(
.ql(r_temp[Ukuran Pohon * 2 * i + (j – 2 ** ($clog2(Ukuran Pohon / 4) – i)) * 2 + 1:Ukuran Pohon * 2 * i + (j – 2 ** ($clog2( Ukuran Pohon / 4) – i)) * 2]),
.qh(r_temp[Ukuran Pohon * 2 * i + j * 2 + 1:Ukuran Pohon * 2 * i + j * 2]),
.r(r_temp[Ukuran Pohon * 2 * (i + 1) + j * 2 + 1:Ukuran Pohon * 2 * (i + 1) + j * 2])
);
if (j != Ukuran Pohon – 1 – 2 ** ($clog2(Ukuran Pohon / 4) – i)) mulai: second_half_level_direct_connect
tetapkan r_temp[Ukuran Pohon * 2 * (i + 1) + (j + 2 ** ($clog2(Ukuran Pohon / 2) – i)) * 2 – 1:Ukuran Pohon * 2 * (i + 1) + j * 2 + 2] = r_temp[Ukuran Pohon * 2 * i + (j + 2 ** ($clog2(Ukuran Pohon / 2) – i)) * 2 – 1:Ukuran Pohon * 2 * i + j * 2 + 2];
akhir
akhir
tetapkan r_temp[Ukuran Pohon * 2 * (i + 2) – 1:Ukuran Pohon * 2 * (i + 2) – (2 ** ($clog2(Ukuran Pohon / 4) – i)) * 2] = r_temp[Ukuran Pohon * 2 * (i + 1) – 1:Ukuran Pohon * 2 * (i + 1) – (2 ** ($clog2(Ukuran Pohon / 4) – i)) * 2];
akhir
tetapkan r[1:0] = r_temp[Ukuran Pohon * 2 * ($clog2(Ukuran Pohon) – 2) + 1:Ukuran Pohon * 2 * ($clog2(Ukuran Pohon) – 2)];
untuk (i = 1; i < Ukuran pohon; i = i + 2) mulai: final_r_odd
tetapkan r[i * 2 + 1:i * 2] = r_temp[Ukuran Pohon * 2 * ($clog2(Ukuran Pohon) – 2) + i * 2 + 1:Ukuran Pohon * 2 * ($clog2(Ukuran Pohon) – 2) + saya * 2];
akhir
untuk (i = 2; i < Ukuran pohon; i = i + 2) mulai: final_r_even
awalan_logika f(
.ql(r_temp[Ukuran Pohon * 2 * ($clog2(Ukuran Pohon) – 2) + i * 2 – 1:Ukuran Pohon * 2 * ($clog2(Ukuran Pohon) – 2) + i * 2 – 2]),
.qh(r_temp[Ukuran Pohon * 2 * ($clog2(Ukuran Pohon) – 2) + i * 2 + 1:Ukuran Pohon * 2 * ($clog2(Ukuran Pohon) – 2) + i * 2]),
.r(r[i * 2 + 1:i * 2])
);
akhir
menghasilkan akhir
modul akhir
modul group_q_generasi #(parameter Ukuran Grup = `UKURAN GROUP)(a, b, cin, s, qg);
masukan [Ukuran Grup – 1:0] a;
masukan [Ukuran Grup – 1:0] b;
masukan cin;
keluaran [Ukuran Grup – 1:0] s;
keluaran [1:0]qg;
kawat [2 * Ukuran grup – 1:0] q;
wire [Ukuran Grup – 1:0] c;
tetapkan c[0] = cin;
menghasilkan
di mana;
untuk (i = 0; i < Ukuran grup; i = i + 1) mulai: parallel_FA_CLA_prefix
FA_CLA_awalan f(
.a(sebuah[i]),
.b(b[i]),
.cin(c[i]),
.s(s[i]),
.q(q[i * 2 + 1:i * 2])
);
if (i != Ukuran grup – 1) mulai: kasus_khusus
tetapkan c[i + 1] = q[i * 2 + 1] | (q[i * 2] & c[i]);
akhir
akhir
//pembuatan grup q berdasarkan Groupsize
if (Ukuran Grup == 1) mulai: case_gs1
tetapkan qg[1] = q[1];
tetapkan qg[0] = q[0];
akhiri yang lain jika (Ukuran Grup == 2) mulai: case_gs2
tetapkan qg[1] = q[3] | (q[1] & q[2]);
tetapkan qg[0] = q[2] & q[0];
akhiri yang lain jika (Ukuran Grup == 4) mulai: case_gs4
tetapkan qg[1] = q[7] | (q[5] & q[6]) | (q[3] & q[6] & q[4]) | (q[1] & q[6] & q[4] & q[2]);
tetapkan qg[0] = q[6] & q[4] & q[2] & q[0];
akhiri yang lain jika (Ukuran Grup == 8) mulai: case_gs8
tetapkan 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]);
tetapkan qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0];
akhir
menghasilkan akhir
modul akhir
// Logika generasi Cin
modul cin_generasi_logic(r, c0, cin);
masukan [1:0] r;
masukan c0;
keluaran cin;
tetapkan cin = (r[0] & c0) | r[1];
modul akhir
// Logika dasar untuk operasi awalan
modul prefix_logic(ql, qh, r);
masukan [1:0] ql;
masukan [1:0] qh;
keluaran [1:0] r;
tetapkan r[0] = qh[0] & ql[0];
tetapkan r[1] = (qh[0] & ql[1]) | qh[1];
modul akhir
// Sel Adder Penuh dengan Carry Look-Ahead
modul FA_CLA_prefix(a, b, cin, s, q);
masukan a;
masukan b;
masukan cin;
keluaran;
keluaran [1:0] q;
tetapkan q[0] = a ^ b;
tetapkan s = q[0] ^ cin;
tetapkan q[1] = a & b;
modul akhir
Keuntungan
Keunggulan Brent Kung Adder antara lain sebagai berikut.
- Ini adalah penambah daya rendah karena menggunakan rangkaian minimum untuk mendapatkan hasilnya.
- Ini adalah penambah yang sangat populer & banyak digunakan.
- Penambah semacam ini dapat diimplementasikan dengan menggunakan lebih sedikit modul dibandingkan dengan penambah Kogge-Stone.
- Perancangan penambah Brent-Kung sangat mudah.
- Penambah ini memiliki lebih sedikit koneksi dengan modul lain.
- Penambah ini diusulkan terutama untuk mengatasi kelemahan penambah Kogge-Stone.
Kekurangan
Itu kelemahan Brent Kung Adde r sertakan yang berikut ini.
- Adder ini mempunyai penundaan yang lebih besar dan memerlukan 2 log2 n − 2 level logika untuk menghitung semua bit carry.
- Kelemahan utama dari penambah ini adalah fanout yang dapat menyebabkan perambatan arus ke seluruh penambah terpecah & menjadi lemah.
Aplikasi Brent Kung Adder
Penerapan Brent Kung Adder antara lain sebagai berikut.
- Penambah Brent – Kung digunakan secara pipeline untuk mengurangi konsumsi daya dengan mengurangi kedalaman logika kombinatorial & stabilisasi gangguan.
- Penambah Brent-Kung memberikan jumlah tahapan yang luar biasa dari i/p hingga semua o/ps tetapi dengan pemuatan tahapan Menengah yang asimetris.
- Penambah ini dapat digunakan dalam pengganda serta elemen jalur data lainnya.
Jadi, ini adalah gambaran umum tentang Brent kung adder , cara kerja, kelebihan, kekurangan, dan penerapannya. Ini adalah penjumlah yang sangat efisien dan strukturnya tampak seperti struktur pohon yang digunakan terutama untuk operasi aritmatika berkinerja tinggi. Jenis penambah ini sangat cepat dan berfokus terutama pada logika tingkat gerbang. Adder ini dirancang dengan jumlah gerbang logika yang lebih sedikit. Dengan demikian, ini mengurangi memori & penundaan yang digunakan dalam arsitektur ini. Ini pertanyaan untuk Anda, Brent kung adder juga dikenal sebagai?
