32位先行進位加法器的實現

我的verilog處女作，已通過ise仿真，未進行FPGA開發板仿真。【處女作，一天半查資料，半天敲寫，兩天調試，共八九次修改。】

一、總體設計：

1.電子計算機是由具有各種邏輯功能的邏輯部件組成的,加法器就屬於其中的組合邏輯電路。如果對傳統的加法器電路進行改進,在超前進位鏈的基礎上,用一種新的超前進位鏈樹的設計方法不僅可以克服串行進位加法器速度低的缺點,也可以解決單純的超前進位加法器帶負載能力不足等問題,從而在實際電路中使加法器的運算速度達到最優。根據這種理論,可以推導得到最優的任意位加法器。

2.原理如下：

設二進制加法器第i位為A_i，B_i，輸出為S_i，進位輸入為C_i，進位輸出為C_i+1

則有：

S_i=A_i⊕B_i⊕C_i

C_i+1 =A_{i *} B_i+ A_{i *}C_i+ B_i*C_i =A_{i *} B_i+（A_i+B_i）* C_i

令G_i = A_i * B_i , P_i = A_i+B_i

則C_i+1= G_i+ P_{i *}C_i

當Ai和Bi都為1時，G_i = 1， 產生進位C_i+1 = 1

當Ai和Bi有一個為1時，P_i = 1，傳遞進位C_i+1= C_i

因此Gi定義為進位產生信號，Pi定義為進位傳遞信號。Gi的優先級比Pi高，也就是說：當Gi = 1時（當然此時也有Pi = 1），無條件產生進位，而不管Ci是多少;

當Gi=0而Pi=1時，進位輸出為Ci,跟Ci之前的邏輯有關。

3.總體設計思想：設計先行進位加法器的初衷是為了減少甚至消除各個位之間的進位延遲，由上面的原理可思考得到用p和g來表示進位c。但是僅僅求出每個位的p和g是遠遠不夠的，需要進行級聯，不同位之間先行進位代替串行，以保證前一個進位可以影響后面多個位的進位，換句話說，就是后面的位的進位可以由很靠前的位的進位求得，以此來減少相鄰位之間的進位延遲。進位c得出后，結果s和zero，overflow更是不再話下了。

4.原理圖：

二、功能模塊設計：

總共9個模塊，1個主模塊，4個核心模塊，4個輔助模塊。

1.主模塊mu0：即32位先行進位加法器，輸入為兩個加數32位的x1和x2，輸出為結果32位的s，以及判零標識信號和溢出標識信號。內部調用各個子模塊以及判零標識信號和溢出標識信號的產生。見3.1之原理圖。

2.核心模塊mu1：輸入為兩個加數32位的x1和x2，輸出為進位產生信號g和進位傳遞信號p。功能即由x1和x2求出p和g。p[31:0] = x1[31:0]| x2[31:0],g[31:0] = x1[31:0]&x2[31:0]。見下圖：

3.核心模塊mu2：輸入為一位的p1, g1, p2, g2, 輸出為p3, g3。即進位產生信號與進位傳遞信號的級聯模塊。p3=p1&p2; g3=g2|(p2&g1)。即a+b=11時，進位才可傳遞，p才為1；而g3若為1，則要么g2為1，最高位產生進位，要么次高位產生進位且最高位可傳遞進位。 見下圖：

4.核心模塊mu3：輸入為兩個加數32位的x1、x2和每一位的進位cin，輸出為結果s。s[31:0]=x1[31:0]^x2[31:0]^cin[31:0]。顯然是對的。見下圖：

5.核心模塊mu4：輸入為一位的進位產生信號g和進位傳遞信號p，以及上一個進位cin，輸出為下一個進位cout。cout=g|(p&cin)。見下圖：

6.輔助模塊mu01：將一級級聯的16個模塊mu2嵌套，並行處理。

7.輔助模塊mu02：將二級級聯的8個模塊mu2嵌套，並行處理。

8.輔助模塊mu03：將三級級聯的4個模塊mu2嵌套，並行處理。

9.輔助模塊mu04：將四級級聯的2個模塊mu2嵌套，並行處理。

三、源代碼：

module mu0(x1,x2,s,zero,overflow);
input [31:0]x1,x2;
output [31:0]s;
output zero,overflow;
wire [31:0]p,g,c;
wire [15:0]p1,g1;
wire [7:0]p2,g2;
wire [3:0]p3,g3;
wire [1:0]p4,g4;
reg zero,overflow;
assign c[0]=0;

mu1 i0 (x1[31:0],x2[31:0],p[31:0],g[31:0]);
mu01 i161 (p[31:0],g[31:0],p1[15:0],g1[15:0]);
mu02 i162 (p1[15:0],g1[15:0],p2[7:0],g2[7:0]);
mu03 i163 (p2[7:0],g2[7:0],p3[3:0],g3[3:0]);
mu04 i164 (p3[3:0],g3[3:0],p4[1:0],g4[1:0]);
mu4 i001 (p[0],g[0],c[0],c[1]);
mu4 i002 (p1[0],g1[0],c[0],c[2]);
mu4 i003 (p[2],g[2],c[2],c[3]);
mu4 i004 (p2[0],g2[0],c[0],c[4]);
mu4 i005 (p[4],g[4],c[4],c[5]);
mu4 i006 (p1[2],g1[2],c[4],c[6]);
mu4 i007 (p[6],g[6],c[6],c[7]);
mu4 i008 (p3[0],g3[0],c[0],c[8]);
mu4 i009 (p[8],g[8],c[8],c[9]);
mu4 i010 (p1[4],g1[4],c[8],c[10]);
mu4 i011 (p[10],g[10],c[10],c[11]);
mu4 i012 (p2[2],g2[2],c[8],c[12]);
mu4 i013 (p[12],g[12],c[12],c[13]);
mu4 i014 (p1[6],g1[6],c[12],c[14]);
mu4 i015 (p[14],g[14],c[14],c[15]);
mu4 i016 (p4[0],g4[0],c[0],c[16]);
mu4 i017 (p[16],g[16],c[16],c[17]);
mu4 i018 (p1[8],g1[8],c[16],c[18]);
mu4 i019 (p[18],g[18],c[18],c[19]);
mu4 i020 (p2[4],g2[4],c[16],c[20]);
mu4 i021 (p[20],g[20],c[20],c[21]);
mu4 i022 (p1[10],g1[10],c[20],c[22]);
mu4 i023 (p[22],g[22],c[22],c[23]);
mu4 i024 (p3[2],g3[2],c[16],c[24]);
mu4 i025 (p[24],g[24],c[24],c[25]);
mu4 i026 (p1[12],g1[12],c[24],c[26]);
mu4 i027 (p[26],g[26],c[26],c[27]);
mu4 i028 (p2[6],g2[6],c[24],c[28]);
mu4 i029 (p[28],g[28],c[28],c[29]);
mu4 i030 (p1[14],g1[14],c[28],c[30]);
mu4 i031 (p[30],g[30],c[30],c[31]);
mu3 i1 (x1[31:0],x2[31:0],c[31:0],s[31:0]);

always @(s)
begin
 zero=~(|s);
end
always @(x1[31] or x2[31] or s[31])
begin
 overflow=~((x1[31]^x2[31])|(~(s[31]^x1[31])));
end

endmodule

module mu1(x1,x2,p,g);
input [31:0]x1,x2;
output [31:0]p,g;
assign p[31:0]=x1[31:0]|x2[31:0],g[31:0]=x1[31:0]&x2[31:0];
endmodule

module mu2(p1,g1,p2,g2,p3,g3);
input p1,g1,p2,g2;
output p3,g3;
assign p3=p1&p2;
assign g3=g2|(p2&g1);
endmodule

module mu3(x1,x2,cin,s);
input [31:0]x1,x2,cin;
output [31:0]s;
assign s[31:0]=x1[31:0]^x2[31:0]^cin[31:0];
endmodule

module mu4(p,g,cin,cout);
input p,g,cin;
output cout;
assign cout=g|(p&cin);
endmodule

module mu01(p,g,p1,g1);
input [31:0]p,g;
output [15:0]p1,g1;
mu2 i101 (p[0],g[0],p[1],g[1],p1[0],g1[0]);
mu2 i102 (p[2],g[2],p[3],g[3],p1[1],g1[1]);
mu2 i103 (p[4],g[4],p[5],g[5],p1[2],g1[2]);
mu2 i104 (p[6],g[6],p[7],g[7],p1[3],g1[3]);
mu2 i105 (p[8],g[8],p[9],g[9],p1[4],g1[4]);
mu2 i106 (p[10],g[10],p[11],g[11],p1[5],g1[5]);
mu2 i107 (p[12],g[12],p[13],g[13],p1[6],g1[6]);
mu2 i108 (p[14],g[14],p[15],g[15],p1[7],g1[7]);
mu2 i109 (p[16],g[16],p[17],g[17],p1[8],g1[8]);
mu2 i110 (p[18],g[18],p[19],g[19],p1[9],g1[9]);
mu2 i111 (p[20],g[20],p[21],g[21],p1[10],g1[10]);
mu2 i112 (p[22],g[22],p[23],g[23],p1[11],g1[11]);
mu2 i113 (p[24],g[24],p[25],g[25],p1[12],g1[12]);
mu2 i114 (p[26],g[26],p[27],g[27],p1[13],g1[13]);
mu2 i115 (p[28],g[28],p[29],g[29],p1[14],g1[14]);
mu2 i116 (p[30],g[30],p[31],g[31],p1[15],g1[15]);
endmodule

module mu02(p1,g1,p2,g2);
input [15:0]p1,g1;
output [7:0]p2,g2;
mu2 i21 (p1[0],g1[0],p1[1],g1[1],p2[0],g2[0]);
mu2 i22 (p1[2],g1[2],p1[3],g1[3],p2[1],g2[1]);
mu2 i23 (p1[4],g1[4],p1[5],g1[5],p2[2],g2[2]);
mu2 i24 (p1[6],g1[6],p1[7],g1[7],p2[3],g2[3]);
mu2 i25 (p1[8],g1[8],p1[9],g1[9],p2[4],g2[4]);
mu2 i26 (p1[10],g1[10],p1[11],g1[11],p2[5],g2[5]);
mu2 i27 (p1[12],g1[12],p1[13],g1[13],p2[6],g2[6]);
mu2 i28 (p1[14],g1[14],p1[15],g1[15],p2[7],g2[7]);
endmodule

module mu03(p2,g2,p3,g3);
input [7:0]p2,g2;
output [3:0]p3,g3;
mu2 i31 (p2[0],g2[0],p2[1],g2[1],p3[0],g3[0]);
mu2 i32 (p2[2],g2[2],p2[3],g2[3],p3[1],g3[1]);
mu2 i33 (p2[4],g2[4],p2[5],g2[5],p3[2],g3[2]);
mu2 i34 (p2[6],g2[6],p2[7],g2[7],p3[3],g3[3]);
endmodule

module mu04(p3,g3,p4,g4);
input [3:0]p3,g3;
output [1:0]p4,g4;
mu2 i41 (p3[0],g3[0],p3[1],g3[1],p4[0],g4[0]);
mu2 i42 (p3[2],g3[2],p3[3],g3[3],p4[1],g4[1]);
endmodule

教訓：看書真心不可不求甚解，走了好多彎路。。。

 

有個網址的16位先行進位加法器設計很不錯：http://wenku.baidu.com/link?url=0rD1UQWOlEreA_09-jYhruuWrpBgk_YKFm0UlfB8jrfIxbDVO-j8Fm80NXRYBkXKtXIIlZiW0aLq7PAoHuXbW11lEFTIdhvdk0AOHbqz70u