Bộ cộng Brent–Kung được Hsiang Te Kung & Richard Peirce Brent đề xuất vào năm 1982. Nó là một bộ cộng Tiền tố song song hoặc bộ cộng cây được sử dụng rộng rãi trong Thiết kế Kỹ thuật số do tính linh hoạt của nó. Bộ bổ sung tiền tố song song có thể được xây dựng theo nhiều cách dựa trên số mức logic, cổng logic liên quan, quạt ra từ mọi cổng và hệ thống dây điện giữa các tầng. Có sẵn nhiều loại bộ cộng cây khác nhau, bộ cộng cây cơ bản là Sklanskym KoggeStone & Brent-Kung. So với KSA (bộ cộng Kogge–Stone), bộ cộng này cung cấp tính đều đặn cao cho cấu trúc của bộ cộng và nó ít bị chặn dây hơn dẫn đến hiệu suất tốt hơn và diện tích chip ít hơn. Bài viết này cung cấp thông tin ngắn gọn về một Bộ cộng Brent Kung .
Brent Kung Adder là gì?
Một bộ cộng sử dụng mạch điện tối thiểu để có được kết quả được gọi là Bộ cộng Brent Kung và nó còn được gọi là bộ cộng công suất thấp hoặc bộ cộng song song. Bộ cộng này nhằm mục đích tiết kiệm kích thước của chip để việc sản xuất các bộ cộng này sẽ trở nên dễ dàng hơn. Cấu trúc đối xứng và cấu trúc thông thường của bộ cộng này sẽ giảm đáng kể chi phí sản xuất và được phép sử dụng trong các cấu trúc liên kết đường ống. Việc sử dụng logic bóng bán dẫn bổ sung giúp nâng cao hiệu suất thiết kế với bộ ghép kênh cách tiếp cận trong các thiết kế tế bào khác nhau.
Mạch cộng Brent Kung
Sơ đồ bộ cộng tiền tố song song brent-kung được hiển thị bên dưới, bao gồm giai đoạn 1 (giai đoạn tiền xử lý), giai đoạn 2 đến 7 là giai đoạn tạo mang & giai đoạn 8 là xử lý hậu kỳ. Đây là một kiến trúc tiên tiến và rất đơn giản để xây dựng cũng như ít gây tắc nghẽn hệ thống dây điện hơn. Vì vậy, việc ít đi dây hơn sẽ làm giảm lượng không gian cần thiết để thực hiện kiến trúc. Ngoài ra, việc định tuyến trở nên dễ dàng hơn nhiều do có ít dây đi qua (hoặc) chồng chéo hơn. Tuy nhiên, hình phạt sẽ tăng lên do độ trễ do số lượng giai đoạn tăng lên, Quạt ra cho bộ cộng này tăng lên và sau đó độ trễ sẽ tăng lên.
Brent Kung Adder hoạt động như thế nào?
Brent Kung Adder hoạt động bằng cách tính toán các tiền tố cho hai nhóm bit, rất hữu ích trong việc tìm kiếm các tiền tố nhóm 4 bit. Các tiền tố này được sử dụng để tính toán các tiền tố của nhóm 8 bit, v.v. Sau đó, các tiền tố này sẽ được sử dụng để tính toán việc thực hiện giai đoạn bit cụ thể. Các giá trị mang này được sử dụng với Tuyên truyền nhóm của giai đoạn tiếp theo để tính bit Tổng của giai đoạn đó. Brent Kung Tree sử dụng 2log2N – 1 giai đoạn.
Bộ cộng Brent Kung 32-bit
Bố cục bộ cộng Brent Kung 32-bit được hiển thị bên dưới. Khi bắt đầu bố cục này, các cổng logic cơ bản được thiết kế như NAND, biến tần, XOR, NOR, v.v. Sau đó, các ô cần thiết như ô đen, ô xám, bộ đệm và logic PG được thiết kế với các cổng logic.
Trong bộ cộng Brent Kung 32 bit bên dưới, các cổng đảo ngược như AOI & OAI được sử dụng thay thế cho các ô chủ yếu là màu xám và đen. Vì vậy, các ô màu đen và xám được biểu thị bằng các khối màu xám và đen trong khi vùng đệm được biểu thị bằng các vòng tròn.
Các đầu vào như A & B được cung cấp cho logic PG được hiển thị trong sơ đồ khối. Đối với bộ cộng 32 bit, cần có 32 khối logic PG và tín hiệu truyền (P) & tạo (G) là đầu ra của khối này. Các tín hiệu này được cung cấp cho cấu trúc cây cộng Brent Kung. Cấu trúc của bộ cộng này bao gồm các ô màu xám và các ô màu đen.
Một ô màu xám bao gồm ba đầu vào và một đầu ra. Việc truyền và tạo tín hiệu từ giai đoạn hiện tại và tạo tín hiệu từ giai đoạn trước là đầu vào trong khi tín hiệu tạo nhóm là o/p. Trong bất kỳ cấu trúc cây nào, mọi giai đoạn sẽ kết thúc bằng một ô màu xám và o/p của ô này là tín hiệu tạo nhóm. Tín hiệu này được coi đơn giản là tín hiệu của giai đoạn đó. Ô Đen bao gồm bốn đầu vào và hai đầu ra. Đầu vào của ô này là tín hiệu P & G của giai đoạn hiện tại và tín hiệu P, G từ giai đoạn trước.
Logic PG bao gồm các cổng AND & XOR trong đó cổng logic AND được sử dụng để tạo tín hiệu G và cổng logic XOR cung cấp tín hiệu P. Để loại bỏ các bộ biến tần không cần thiết, hai loại ô màu xám và ô màu đen được sử dụng. Các cổng đảo ngược được sử dụng trong một hàng cho ô màu xám là AOI hoặc AND-OR-Inverter và các cổng đảo ngược cho ô đen ở hàng tiếp theo sử dụng OAI hoặc OR-AND-Inverter. Ô AOI sử dụng đầu vào bình thường để cung cấp đầu ra đảo ngược trong khi OAI sử dụng đầu vào đảo ngược để cung cấp đầu ra bình thường.
Hoạt động của bộ cộng Brent Kung
Bộ cộng Brent Kung là bộ cộng tiền tố song song được sử dụng để thực hiện phép cộng hiệu suất cao. Bộ cộng này trông giống như một cấu trúc cây thực hiện phép tính số học. Bộ cộng này bao gồm các ô đen và các ô màu xám. Mỗi ô màu đen có hai cổng AND & một cổng OR và mỗi ô màu xám chỉ có một cổng AND duy nhất.
Bộ cộng Brent-kung bao gồm hai giai đoạn; giai đoạn tiền xử lý và giai đoạn tạo. Trong giai đoạn đầu tiên, việc tạo và truyền bá sẽ được thực hiện từ mọi cặp đầu vào. Ở đây, quá trình truyền cung cấp thao tác 'XOR' cho các bit đầu vào trong khi việc tạo cung cấp thao tác 'AND' cho các bit đầu vào. Việc truyền bá và tạo ra như ‘Pi’ và ‘Gi’ được đưa ra dưới đây.
Pi = Ai XOR Bi và Gi = Ai VÀ Bi.
Trong giai đoạn thứ hai, phần mang sẽ được tạo cho mỗi bit được gọi là phần mang tạo ra 'Cg' và phần mang được truyền cho mọi bit được gọi là phần mang tạo ra 'Cp'. Đối với hoạt động tiếp theo, việc truyền tải và tạo mang sẽ được tạo ra. Ô cuối cùng có sẵn trong mỗi hoạt động bit cung cấp khả năng mang theo. Vì vậy, việc mang bit cuối cùng sẽ hỗ trợ tổng hợp đồng thời bit tiếp theo cho đến bit cuối cùng. Việc tạo và truyền bá được thực hiện như sau;
Cp = P1 VÀ P0 và Cg=G1 HOẶC (P1 VÀ G0)
Nó được sử dụng chủ yếu cho hoạt động cộng của hai ba mươi hai bit và mỗi bit trải qua giai đoạn tiền xử lý & giai đoạn tạo sau đó nó cung cấp tổng cuối cùng.
Các bit đầu vào chính nằm dưới giai đoạn tiền xử lý và chúng tạo ra sự lan truyền và tạo ra. Vì vậy, sự lan truyền cũng như tạo ra này trải qua giai đoạn tạo ra tạo ra sự lan truyền mang theo và mang theo và cung cấp số tiền cuối cùng. Quy trình từng bước của bộ cộng Brent-kung được hiển thị bên dưới.
Sự sắp xếp bộ cộng Brent-kung trông giống như một cấu trúc cây và nó là bộ cộng tốc độ cao nhắm vào logic cấp cổng. Bộ cộng này có thể được thiết kế với việc giảm số lượng cổng logic. Do đó, nó làm giảm độ trễ và bộ nhớ được sử dụng trong kiến trúc này.
Mã Verilog của Brent Kung Adder
Mã Verilog của bộ cộng Brent Kung được hiển thị bên dưới.
`xác định INPUTSIZE 64 //đặt kích thước đầu vào n
`xác định GROUPSIZE 8 // đặt kích thước nhóm = 1, 2, 4 hoặc 8
mô-đun Brent_Kung_Adder(A, B, S);
đầu vào [`INPUTSIZE – 1:0] A;
đầu vào [`INPUTSIZE – 1:0] B;
đầu ra [`INPUTSIZE:0] S;
wire [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r_temp;
wire [`INPUTSIZE / `GROUPSIZE * 2 – 1:0] r;
dây [`INPUTSIZE / `GROUPSIZE:0] cin;
wire [`INPUTTSIZE / `GROUPSIZE * 2 – 1:0] q;
gán cin[0] = 1’b0;
phát ra
ở đâu;
for (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) bắt đầu: Parallel_FA_CLA_prefix
group_q_Generation #(.Groupsize(`GROUPSIZE))
f(
.a(A[`GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.b(B[`GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.cin(cin[i]),
.s(S[`GROUPSIZE * (i + 1) – 1:`GROUPSIZE * i]),
.qg(q[i * 2 + 1:i * 2])
);
kết thúc
song song_prefix_tree_first_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t1(
.q(q[`INPUTSIZE / `GROUPSIZE * 2 – 1:0]),
.r(r_temp[`INPUTSIZE / `GROUPSIZE * 2 – 1:0])
);
song song_prefix_tree_second_half #(.Treesize(`INPUTSIZE / `GROUPSIZE))
t2(
.q(r_temp[`INPUTSIZE / `GROUPSIZE * 2 – 1:0]),
.r(r[`INPUTSIZE / `GROUPSIZE * 2 – 1:0])
);
for (i = 0; i < `INPUTSIZE / `GROUPSIZE; i = i + 1) bắt đầu: cin_Generation
cin_thế hệ_logic f(
.r(r[2 * i + 1:2 * i]),
.c0(1’b0),
.cin(cin[i + 1])
);
kết thúc
gán S[`INPUTSIZE] = cin[`INPUTSIZE / `GROUPSIZE];
sinh ra
mô-đun cuối
// Nửa đầu của cây tiền tố song song
mô-đun song song_prefix_tree_first_half #(tham số Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
đầu vào [Cỡ cây * 2 – 1:0] q;
đầu ra [Cỡ cây * 2 – 1:0] r;
phát ra
ở đâu;
if (Treesize == 2) bắt đầu: tầm thường_case
gán r[1:0] = q[1:0];
tiền tố_logic f(
.ql(q[1:0]),
.qh(q[3:2]),
.r(r[3:2])
);
kết thúc khác bắt đầu: recursive_case
wire [Cỡ cây * 2 – 1:0] r_temp;
song song_prefix_tree_first_half #(.Treesize(Treesize / 2))
đệ quy_lsbh(
.q(q[Cây kích thước – 1:0]),
.r(r_temp[Treesize – 1:0])
);
song song_prefix_tree_first_half #(.Treesize(Treesize / 2))
đệ quy_msbh(
.q(q[Cây kích thước * 2 – 1:Cây kích thước]),
.r(r_temp[Cây kích thước * 2 – 1:Cây kích thước])
);
for (i = 0; i < Treesize * 2; i = i + 2) bắt đầu: Parallel_stitch_up
nếu (i != Treesize * 2 – 2) bắt đầu: Parallel_stitch_up_pass
gán r[i + 1:i] = r_temp[i + 1:i];
kết thúc khác bắt đầu: song song_stitch_up_product
tiền tố_logic f(
.ql(r_temp[Treesize – 1:Treesize – 2]),
.qh(r_temp[Cây kích thước * 2 – 1:Cây kích thước * 2 – 2]),
.r(r[Cây kích thước * 2 – 1:Cây kích thước * 2 – 2])
);
kết thúc
kết thúc
kết thúc
sinh ra
mô-đun cuối
// Nửa sau của cây tiền tố song song
module Parallel_prefix_tree_second_half #(tham số Treesize = `INPUTSIZE / `GROUPSIZE)(q, r);
đầu vào [Cỡ cây * 2 – 1:0] q;
đầu ra [Cỡ cây * 2 – 1:0] r;
dây [Treesize * 2 * ($clog2(Treesize) – 1) – 1:0] r_temp;
gán r_temp[Cây kích thước * 2 – 1:0] = q[Cây kích thước * 2 – 1:0];
phát ra
genvar i, j;
for (i = 0; i < $clog2(Treesize) – 2; i = i + 1) bắt đầu: two_half_level
gán r_temp[Treesize * 2 * (i + 1) + ((Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i)) * 2 – 1:Treesize * 2 * (i + 1)] = r_temp[Treesize * 2 * i + ((Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i)) * 2 – 1: Kích thước cây * 2 * i];
for (j = (Treesize / (2 ** i)) – 1 – 2 ** ($clog2(Treesize / 4) – i); j < Treesize; j = j + 2 ** ($clog2(Treesize / 2 ) – i)) bắt đầu: thứ hai_half_level_logic
tiền tố_logic f(
.ql(r_temp[Treesize * 2 * i + (j – 2 ** ($clog2(Treesize / 4) – i)) * 2 + 1:Treesize * 2 * i + (j – 2 ** ($clog2( Kích thước cây / 4) – i)) * 2]),
.qh(r_temp[Treesize * 2 * i + j * 2 + 1: Treesize * 2 * i + j * 2]),
.r(r_temp[Cây kích thước * 2 * (i + 1) + j * 2 + 1:Cây kích thước * 2 * (i + 1) + j * 2])
);
if (j != Treesize – 1 – 2 ** ($clog2(Treesize / 4) – i)) bắt đầu: two_half_level_direct_connect
gán r_temp[Treesize * 2 * (i + 1) + (j + 2 ** ($clog2(Treesize / 2) – i)) * 2 – 1: Treesize * 2 * (i + 1) + j * 2 + 2] = r_temp[Cây kích thước * 2 * i + (j + 2 ** ($clog2(Treesize / 2) – i)) * 2 – 1:Cây kích thước * 2 * i + j * 2 + 2];
kết thúc
kết thúc
gán r_temp[Treesize * 2 * (i + 2) – 1:Treesize * 2 * (i + 2) – (2 ** ($clog2(Treesize / 4) – i)) * 2] = r_temp[Treesize * 2 * (i + 1) – 1:Kích thước cây * 2 * (i + 1) – (2 ** ($clog2(Treesize / 4) – i)) * 2];
kết thúc
gán r[1:0] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + 1:Treesize * 2 * ($clog2(Treesize) – 2)];
for (i = 1; i < Treesize; i = i + 2) bắt đầu: Final_r_odd
gán r[i * 2 + 1:i * 2] = r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesize) – 2) + tôi*2];
kết thúc
for (i = 2; i < Treesize; i = i + 2) bắt đầu: Final_r_even
tiền tố_logic f(
.ql(r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 – 1:Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 – 2]),
.qh(r_temp[Treesize * 2 * ($clog2(Treesize) – 2) + i * 2 + 1:Treesize * 2 * ($clog2(Treesize) – 2) + i * 2]),
.r(r[i * 2 + 1:i * 2])
);
kết thúc
sinh ra
mô-đun cuối
mô-đun nhóm_q_Generation #(tham số Groupsize = `GROUPSIZE)(a, b, cin, s, qg);
đầu vào [Kích thước nhóm – 1:0] a;
đầu vào [Kích thước nhóm – 1:0] b;
cin đầu vào;
đầu ra [Kích thước nhóm – 1:0] s;
đầu ra [1:0] qg;
wire [2 * Groupsize – 1:0] q;
dây [Kích thước nhóm – 1:0] c;
gán c[0] = cin;
phát ra
ở đâu;
for (i = 0; i < Groupsize; i = i + 1) bắt đầu: 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) bắt đầu: Special_case
gán c[i + 1] = q[i * 2 + 1] | (q[i * 2] & c[i]);
kết thúc
kết thúc
// tạo nhóm q dựa trên Groupsize
if (Groupsize == 1) bắt đầu: case_gs1
gán qg[1] = q[1];
gán qg[0] = q[0];
kết thúc khác nếu (Groupsize == 2) bắt đầu: case_gs2
gán qg[1] = q[3] | (q[1] & q[2]);
gán qg[0] = q[2] & q[0];
kết thúc khác nếu (Groupsize == 4) bắt đầu: case_gs4
gán qg[1] = q[7] | (q[5] & q[6]) | (q[3] & q[6] & q[4]) | (q[1] & q[6] & q[4] & q[2]);
gán qg[0] = q[6] & q[4] & q[2] & q[0];
kết thúc khác nếu (Groupsize == 8) bắt đầu: case_gs8
gán 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]);
gán qg[0] = q[14] & q[12] & q[10] & q[8] & q[6] & q[4] & q[2] & q[0];
kết thúc
sinh ra
mô-đun cuối
// Logic tạo Cin
mô-đun cin_thế hệ_logic(r, c0, cin);
đầu vào [1:0] r;
đầu vào c0;
đầu ra cin;
gán cin = (r[0] & c0) | r[1];
mô-đun cuối
// Logic cơ bản cho các hoạt động tiền tố
module prefix_logic(ql, qh, r);
đầu vào [1:0] ql;
đầu vào [1:0] qh;
đầu ra [1:0] r;
gán r[0] = qh[0] & ql[0];
gán r[1] = (qh[0] & ql[1]) | qh[1];
mô-đun cuối
// Ô cộng đầy đủ với tính năng Carry Look-Ahead
mô-đun FA_CLA_prefix(a, b, cin, s, q);
nhập một;
đầu vào b;
cin đầu vào;
đầu ra s;
đầu ra [1:0] q;
gán q[0] = a ^ b;
gán s = q[0]^cin;
gán q[1] = a & b;
mô-đun cuối
Thuận lợi
Những ưu điểm của Brent Kung Adder bao gồm những điều sau.
- Đây là một bộ cộng công suất thấp vì nó sử dụng mạch điện tối thiểu để có được kết quả.
- Nó là một bộ cộng rất phổ biến và được sử dụng rộng rãi.
- Loại bộ cộng này có thể được triển khai bằng cách sử dụng ít mô-đun hơn so với bộ cộng Kogge-Stone.
- Thiết kế bộ cộng Brent-Kung rất dễ dàng.
- Bộ cộng này có ít kết nối hơn với các mô-đun khác.
- Những bộ cộng này được đề xuất chủ yếu để giải quyết những nhược điểm của bộ cộng Kogge-Stone.
Nhược điểm
Các Nhược điểm của Brent Kung Adde r bao gồm những điều sau đây.
- Các bộ cộng này có độ trễ lớn hơn và cần 2 log2 n − 2 mức logic để tính toán tất cả các bit mang.
- Hạn chế chính của bộ cộng này là quạt tản nhiệt có thể khiến dòng điện truyền qua bộ cộng bị tách ra và trở nên yếu hơn.
Ứng dụng của bộ cộng Brent Kung
Các ứng dụng của Brent Kung Adder bao gồm những điều sau đây.
- Bộ cộng Brent–Kung được sử dụng theo cách thức quy trình để giảm mức tiêu thụ điện năng bằng cách giảm độ sâu logic tổ hợp và ổn định trục trặc.
- Bộ cộng Brent-Kung cung cấp số lượng giai đoạn vượt trội từ i/p đến tất cả o/ps nhưng với tải giai đoạn Trung gian không đối xứng.
- Bộ cộng này có thể được sử dụng trong bộ nhân cũng như các phần tử đường dẫn dữ liệu khác.
Như vậy, đây là tổng quan về Brent kung adder , hoạt động, ưu điểm, nhược điểm và ứng dụng của nó. Đây là một bộ cộng rất hiệu quả và cấu trúc của nó trông giống như một cấu trúc cây được sử dụng chủ yếu cho các phép tính số học hiệu suất cao. Loại bộ cộng này rất nhanh và tập trung chủ yếu vào logic cấp cổng. Bộ cộng này được thiết kế bằng cách sử dụng ít cổng logic hơn. Do đó, nó làm giảm bộ nhớ và độ trễ được sử dụng trong kiến trúc này. Đây là một câu hỏi dành cho bạn, Brent kung adder còn được gọi là?
