4bit超前进位加法器电路

描述

4bit超前进位加法器的逻辑表达式如下：

中间变量：

 和：

进位： 

 请用Verilog语言采用门级描述方式，实现此4bit超前进位加法器，接口电路如下：

输入描述

输入信号：
 
A_in[3:0],
 
B_in[3:0]
 
C_1
 
类型：wire

输出描述

输出信号：
 
S[3:0]
 
CO
 
类型：wire

 解题分析

        如果只是简单地将逻辑表达式转化为verilog语言，这道题算不上较难题。难点应该是借着这道题理解超前进位加法器。下面梳理一些常见的加法器。

半加器

        半加器是最简单的加法器。它不考虑进位输入。其中A和B是两个加数，S是和，C_o是进位输出。

assign S     = A ^ B;
assign C_out = A & B;

全加器

        全加器是多bit加法器的基础。Ci是进位输入。

 下图中红色路径是全加器的关键路径。

 代码为：

module full_adder(
    input  A,
    input  B,
    input  C_i,
    output S,
    output C_o
);
    assign S    = A ^ B ^ C_i;
    assign C_o  = A & B | C_i&(a^b);
    // assign C_o  = A & B | A & C_i | B & C_i; // 也可以
endmodule

行波进位加法器

        Ripple-carry adder, RCA。将全加器串联起来。 虽然RCA结构简单易于理解，但容易看出，每一位的运算结果SkS_kSk​都要依赖进位CkC_{k}Ck​才能得出。如下图所示，这会使得RCA的关键路径变得很长，而长关键路径会让电路难以满足时序要求。

代码为：

module rca #(
    parameter width = 4
)(
    input  [width-1:0] A,
    input  [width-1:0] B,
    output [width-1:0] S,
    
    input  C_i,
    output C_o
);
    wire [width:0] C;
    genvar i;
    generate
      	for (i=0; i<width; i=i+1)begin
            full_adder myadder(
                .A    (A[i]),
                .B    (B[i]),
                .C_i  (C[i]),
                .S    (S[i]),
                .C_o  (C[i+1]),
            );
        end
    endgenerate
  	assign C[0] = C_i;
    assign C_o  = C[width];
endmodule

超前进位加法器

        Lookahead Carry Adder，LCA。超前进位加法器的思想是并行计算进位Ck，以缩短关键路径。Ck​可以直接由加数得到。
        首先，令：

 然后有：

 对于4bit LCA有：

        超前进位加法器是通过公式直接导出最终结果与每个输入的关系，是一种用面积换性能的方法。
        对于4bit LCA，进位输出C4的计算路径如下：        

        只需要三级门电路就可以得到，并且同时还计算出了和​等可以复用的结果。而根据之前的分析，RCA产生C4​需要3+2+2+2=9级路径。加法器宽度越大，性能优势越明显。但LCA的逻辑门扇入扇出比较大，面积和复杂度都比较高。
        下面的代码来自于参考资料 

module pg_gen(
    input A,
    input B,
    output G,
    output P
);
	assign G = A & B;
	assign P = A ^ B;
endmodule
 
module lca_4bit #( width=4 ) (
    input  [width-1:0] op1,
    input  [width-1:0] op2,
    input  C_i,
    output [width-1:0] S,
    output C_o
);
    wire [width-1:0] G;
    wire [width-1:0] P;
    wire [width:0] C;
 
	genvar i;
	for( i=0; i<width; i=i+1) begin
    	pg_gen u_pg_gen(
        	.A( op1[i]),
        	.B( op2[i]),
            .G( G[i]  ),
            .P( P[i]  )
    	);
	end
 
    assign C[0] = C_i;
    assign C[1] = G[0] || ( C[0] & P[0] );
    assign C[2] = G[1] || ( (G[0] || ( C[0] & P[0]) ) & P[1] );
    assign C[3] = G[2] || ( (G[1] || ( (G[0] || (C[0] & P[0]) ) & P[1])) & P[2] );
    assign C[4] = G[3] || ( (G[2] || ( (G[1] || ( (G[0] || (C[0] & P[0]) ) & P[1])) & P[2] )) & P[3]);
    assign C_o = C[width-1];
 
	genvar k;
	for( k=0; k<width; k=k+1) begin
        assign S[k] = P[k] ^ C[k];
	end
endmodule

 最后实现代码为：

        注意+的优先级高于&和^。

`timescale 1ns/1ns
module lca_4(
	input		[3:0]       A_in  ,
	input	    [3:0]		B_in  ,
    input                   C_1   ,
 
 	output	 wire			CO    ,
	output   wire [3:0]	    S
);
    wire [3:0] C;
    
    assign S[0] = A_in[0] ^ B_in[0] ^ C_1;
    assign S[1] = A_in[1] ^ B_in[1] ^ C[0];
    assign S[2] = A_in[2] ^ B_in[2] ^ C[1];
    assign S[3] = A_in[3] ^ B_in[3] ^ C[2];
    assign C[0] = (A_in[0] & B_in[0]) || ((A_in[0] ^ B_in[0]) & C_1);
    assign C[1] = (A_in[1] & B_in[1]) || ((A_in[1] ^ B_in[1]) & C[0]);
    assign C[2] = (A_in[2] & B_in[2]) || ((A_in[2] ^ B_in[2]) & C[1]);
    assign C[3] = (A_in[3] & B_in[3]) || ((A_in[3] ^ B_in[3]) & C[2]);
    assign CO = C[3];
endmodule

注：分析内容摘取网友，如有侵权请告删之。