超前进位加法器：原理、推导与 Verilog 实现

1. 引言

加法器是数字电路中最基础的运算单元，几乎所有的算术运算（减法、乘法、除法、地址计算等）最终都要归结为加法。然而，传统的**行波进位加法器（Ripple Carry Adder, RCA）**虽然结构简单，却存在一个致命问题：高位运算必须等待低位进位逐级传递，导致延迟随位宽线性增长。当位宽达到 32 位甚至 64 位时，这种串行进位链会成为整个系统的性能瓶颈。

**超前进位加法器（Carry Lookahead Adder, CLA）**正是为解决这一问题而设计的。它通过并行计算每一位的进位信号，将进位传播延迟从 O(n) 降低到 O(log n)，从而显著提升加法速度。本文将从进位链的瓶颈出发，逐步推导超前进位加法器的原理，并给出完整的 Verilog 实现与仿真验证。

2. 行波进位加法器的瓶颈

在分析超前进位加法器之前，我们先回顾行波进位加法器的结构。一个 n 位行波进位加法器由 n 个全加器（Full Adder, FA）级联而成，第 i 位的进位输出 Ci+1C_{i+1}Ci+1 作为第 i+1 位的进位输入。

全加器的逻辑表达式为：

Si=Ai⊕Bi⊕Ci S_i = A_i \oplus B_i \oplus C_i Si=Ai⊕Bi⊕Ci

Ci+1=AiBi+(Ai⊕Bi)Ci C_{i+1} = A_i B_i + (A_i \oplus B_i) C_i Ci+1=AiBi+(Ai⊕Bi)Ci

其中 AiA_iAi、BiB_iBi 是第 i 位的两个加数，CiC_iCi 是来自低位的进位，SiS_iSi 是本位和。

关键问题 ：每一位的进位 Ci+1C_{i+1}Ci+1 都依赖于前一位的进位 CiC_iCi。因此，最高位的和 Sn−1S_{n-1}Sn−1 必须等待 C0→C1→C2→⋯→Cn−1C_0 \rightarrow C_1 \rightarrow C_2 \rightarrow \cdots \rightarrow C_{n-1}C0→C1→C2→⋯→Cn−1 逐级传递完成，总延迟约为 n 个门延迟。位宽越大，延迟越长，这就是行波进位加法器的根本缺陷。

3. 超前进位思想：把进位"算出来"而非"传下去"

超前进位加法器的核心思想是：不等待低位进位逐级传来，而是根据 AiA_iAi 和 BiB_iBi 直接判断进位是否产生、是否传播。

我们定义两个辅助信号：

• 生成信号（Generate） ：Gi=AiBiG_i = A_i B_iGi=AiBi。当 AiA_iAi 和 BiB_iBi 都为 1 时，无论进位输入 CiC_iCi 是多少，本位必然产生进位输出 Ci+1=1C_{i+1}=1Ci+1=1。
• 传播信号（Propagate） ：Pi=Ai⊕BiP_i = A_i \oplus B_iPi=Ai⊕Bi。当 AiA_iAi 和 BiB_iBi 中恰好一个为 1 时，进位输出取决于进位输入，即 Ci+1=CiC_{i+1} = C_iCi+1=Ci，进位被"传播"过去。

利用 GiG_iGi 和 PiP_iPi，进位输出可以改写为：

Ci+1=Gi+PiCi C_{i+1} = G_i + P_i C_i Ci+1=Gi+PiCi

这个式子非常直观：本位要么自己生成进位（Gi=1G_i=1Gi=1），要么把低位的进位传播上去（Pi=1P_i=1Pi=1 且 Ci=1C_i=1Ci=1）。

4. 超前进位的递推展开

现在，我们把 Ci+1=Gi+PiCiC_{i+1} = G_i + P_i C_iCi+1=Gi+PiCi 逐级展开，让每一位的进位只依赖 C0C_0C0 和低位的 GGG、PPP 信号，而不依赖相邻位的进位：

C1=G0+P0C0 C_1 = G_0 + P_0 C_0 C1=G0+P0C0

C2=G1+P1C1=G1+P1G0+P1P0C0 C_2 = G_1 + P_1 C_1 = G_1 + P_1 G_0 + P_1 P_0 C_0 C2=G1+P1C1=G1+P1G0+P1P0C0

C3=G2+P2C2=G2+P2G1+P2P1G0+P2P1P0C0 C_3 = G_2 + P_2 C_2 = G_2 + P_2 G_1 + P_2 P_1 G_0 + P_2 P_1 P_0 C_0 C3=G2+P2C2=G2+P2G1+P2P1G0+P2P1P0C0

C4=G3+P3C3=G3+P3G2+P3P2G1+P3P2P1G0+P3P2P1P0C0 C_4 = G_3 + P_3 C_3 = G_3 + P_3 G_2 + P_3 P_2 G_1 + P_3 P_2 P_1 G_0 + P_3 P_2 P_1 P_0 C_0 C4=G3+P3C3=G3+P3G2+P3P2G1+P3P2P1G0+P3P2P1P0C0

观察这些展开式可以发现一个规律：每一位的进位 Ci+1C_{i+1}Ci+1 都可以表示为一个只包含 GGG、PPP 和 C0C_0C0 的与或表达式 ，与中间进位无关。这意味着所有进位信号可以并行计算，不再需要逐级等待。

以 4 位为例，所有进位只需两级门延迟即可同时得到：

• 第一级：并行计算所有 GiG_iGi、PiP_iPi；
• 第二级：并行计算所有 C1∼C4C_1 \sim C_4C1∼C4。

随后，每一位的和 Si=Pi⊕CiS_i = P_i \oplus C_iSi=Pi⊕Ci 再经过一级异或门即可得到。因此，4 位超前进位加法器的总延迟约为 3 级门延迟，与行波进位加法器的 4 级进位链相比，优势明显，且位宽越大优势越突出。

5. 电路结构

超前进位加法器的整体结构分为三个层次：

1. 预处理层 ：并行计算每一位的 Gi=AiBiG_i = A_i B_iGi=AiBi 和 Pi=Ai⊕BiP_i = A_i \oplus B_iPi=Ai⊕Bi。
2. 超前进位层（CLA 逻辑） ：根据 GGG、PPP 和 C0C_0C0 并行计算所有进位 C1∼CnC_1 \sim C_nC1∼Cn。
3. 求和层 ：并行计算每一位的和 Si=Pi⊕CiS_i = P_i \oplus C_iSi=Pi⊕Ci，最高位进位 CnC_nCn 作为溢出标志。

下面是 4 位超前进位加法器的结构示意图：
#mermaid-svg-9IJRnMafZodr2WXh{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-9IJRnMafZodr2WXh .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-9IJRnMafZodr2WXh .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-9IJRnMafZodr2WXh .error-icon{fill:#552222;}#mermaid-svg-9IJRnMafZodr2WXh .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-9IJRnMafZodr2WXh .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-9IJRnMafZodr2WXh .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-9IJRnMafZodr2WXh .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-9IJRnMafZodr2WXh .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-9IJRnMafZodr2WXh .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-9IJRnMafZodr2WXh .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-9IJRnMafZodr2WXh .marker{fill:#333333;stroke:#333333;}#mermaid-svg-9IJRnMafZodr2WXh .marker.cross{stroke:#333333;}#mermaid-svg-9IJRnMafZodr2WXh svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-9IJRnMafZodr2WXh p{margin:0;}#mermaid-svg-9IJRnMafZodr2WXh .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-9IJRnMafZodr2WXh .cluster-label text{fill:#333;}#mermaid-svg-9IJRnMafZodr2WXh .cluster-label span{color:#333;}#mermaid-svg-9IJRnMafZodr2WXh .cluster-label span p{background-color:transparent;}#mermaid-svg-9IJRnMafZodr2WXh .label text,#mermaid-svg-9IJRnMafZodr2WXh span{fill:#333;color:#333;}#mermaid-svg-9IJRnMafZodr2WXh .node rect,#mermaid-svg-9IJRnMafZodr2WXh .node circle,#mermaid-svg-9IJRnMafZodr2WXh .node ellipse,#mermaid-svg-9IJRnMafZodr2WXh .node polygon,#mermaid-svg-9IJRnMafZodr2WXh .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-9IJRnMafZodr2WXh .rough-node .label text,#mermaid-svg-9IJRnMafZodr2WXh .node .label text,#mermaid-svg-9IJRnMafZodr2WXh .image-shape .label,#mermaid-svg-9IJRnMafZodr2WXh .icon-shape .label{text-anchor:middle;}#mermaid-svg-9IJRnMafZodr2WXh .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-9IJRnMafZodr2WXh .rough-node .label,#mermaid-svg-9IJRnMafZodr2WXh .node .label,#mermaid-svg-9IJRnMafZodr2WXh .image-shape .label,#mermaid-svg-9IJRnMafZodr2WXh .icon-shape .label{text-align:center;}#mermaid-svg-9IJRnMafZodr2WXh .node.clickable{cursor:pointer;}#mermaid-svg-9IJRnMafZodr2WXh .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-9IJRnMafZodr2WXh .arrowheadPath{fill:#333333;}#mermaid-svg-9IJRnMafZodr2WXh .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-9IJRnMafZodr2WXh .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-9IJRnMafZodr2WXh .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-9IJRnMafZodr2WXh .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-9IJRnMafZodr2WXh .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-9IJRnMafZodr2WXh .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-9IJRnMafZodr2WXh .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-9IJRnMafZodr2WXh .cluster text{fill:#333;}#mermaid-svg-9IJRnMafZodr2WXh .cluster span{color:#333;}#mermaid-svg-9IJRnMafZodr2WXh div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-9IJRnMafZodr2WXh .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-9IJRnMafZodr2WXh rect.text{fill:none;stroke-width:0;}#mermaid-svg-9IJRnMafZodr2WXh .icon-shape,#mermaid-svg-9IJRnMafZodr2WXh .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-9IJRnMafZodr2WXh .icon-shape p,#mermaid-svg-9IJRnMafZodr2WXh .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-9IJRnMafZodr2WXh .icon-shape .label rect,#mermaid-svg-9IJRnMafZodr2WXh .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-9IJRnMafZodr2WXh .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-9IJRnMafZodr2WXh .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-9IJRnMafZodr2WXh :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} A3:0 加数
预处理层

G_i = A_i·B_i

P_i = A_i⊕B_i
B3:0 加数
超前进位层

并行计算 C1~C4
C0 进位输入
求和层

S_i = P_i ⊕ C_i
S3:0 和输出
C4 进位输出

6. Verilog 实现

下面给出 4 位超前进位加法器的完整 Verilog 代码。为了清晰展示超前进位的逻辑，这里采用行为级描述，直接按递推公式书写进位表达式。

module cla_adder_4bit (
    input  [3:0] A,
    input  [3:0] B,
    input        C_in,
    output [3:0] S,
    output       C_out
);

    wire [3:0] G;  // 生成信号
    wire [3:0] P;  // 传播信号
    wire [3:0] C;  // 进位信号，C[0] 为 C_in

    // 预处理层：并行计算 G 和 P
    assign G[0] = A[0] & B[0];
    assign G[1] = A[1] & B[1];
    assign G[2] = A[2] & B[2];
    assign G[3] = A[3] & B[3];

    assign P[0] = A[0] ^ B[0];
    assign P[1] = A[1] ^ B[1];
    assign P[2] = A[2] ^ B[2];
    assign P[3] = A[3] ^ B[3];

    // 超前进位层：并行计算所有进位
    assign C[0] = C_in;
    assign C[1] = G[0] | (P[0] & C[0]);
    assign C[2] = G[1] | (P[1] & G[0]) | (P[1] & P[0] & C[0]);
    assign C[3] = G[2] | (P[2] & G[1]) | (P[2] & P[1] & G[0]) | (P[2] & P[1] & P[0] & C[0]);
    assign C[4] = G[3] | (P[3] & G[2]) | (P[3] & P[2] & G[1]) | (P[3] & P[2] & P[1] & G[0]) | (P[3] & P[2] & P[1] & P[0] & C[0]);

    // 求和层
    assign S[0] = P[0] ^ C[0];
    assign S[1] = P[1] ^ C[1];
    assign S[2] = P[2] ^ C[2];
    assign S[3] = P[3] ^ C[3];

    assign C_out = C[4];

endmodule

代码说明：

• G 和 P 由输入并行计算，互不依赖；
• 进位 C[1] 到 C[4] 全部由 G、P 和 C_in 直接组合得到，没有任何一条路径依赖相邻进位，这正是超前进位的核心；
• 求和层用 P_i ^ C_i 得到本位和，因为 Si=Ai⊕Bi⊕Ci=Pi⊕CiS_i = A_i \oplus B_i \oplus C_i = P_i \oplus C_iSi=Ai⊕Bi⊕Ci=Pi⊕Ci。

7. 仿真验证

为了验证正确性，我们编写一个简单的 testbench，遍历所有输入组合（4 位加数共 256 种组合，加上进位输入共 512 种），并与参考加法结果比对。

`timescale 1ns / 1ps

module tb_cla_adder_4bit;

    reg  [3:0] A;
    reg  [3:0] B;
    reg        C_in;
    wire [3:0] S;
    wire       C_out;

    cla_adder_4bit uut (
        .A(A),
        .B(B),
        .C_in(C_in),
        .S(S),
        .C_out(C_out)
    );

    integer i;
    integer j;
    integer k;
    integer errors;

    initial begin
        errors = 0;
        // 两层循环遍历 A、B、C_in 的全部 512 种组合
        for (i = 0; i < 16; i = i + 1) begin
            for (j = 0; j < 16; j = j + 1) begin
                for (k = 0; k < 2; k = k + 1) begin
                    A    = i[3:0];
                    B    = j[3:0];
                    C_in = k[0:0];
                    #10;
                    // 参考结果：A + B + C_in
                    if ({C_out, S} !== A + B + C_in) begin
                        $display("Error: A=%h B=%h C_in=%b -> S=%h C_out=%b", A, B, C_in, S, C_out);
                        errors = errors + 1;
                    end
                end
            end
        end

        if (errors == 0)
            $display("All test cases passed!");
        else
            $display("Total errors: %0d", errors);

        $finish;
    end

    // 波形输出：将信号导出到 VCD 文件，供仿真波形查看
    initial begin
        $dumpfile("tb_cla_adder_4bit.vcd");
        $dumpvars(0, tb_cla_adder_4bit);
    end

endmodule

说明：上述 testbench 使用三层循环分别遍历 A（16 种）、B（16 种）和 C_in（2 种），共覆盖全部 512 种输入组合。同时通过 $dumpfile 和 $dumpvars 将仿真信号导出为 VCD 文件，可在 Vivado、ModelSim 等工具中查看完整波形。

仿真结果分析

在 Vivado 或 ModelSim 中运行上述 testbench 后，打开导出的 VCD 波形文件，应能观察到以下关键特征，用于验证超前进位加法器的正确性：

关键波形特征：

• 进位信号同时跳变 ：在输入 A、B、C_in 变化后的同一时刻（约 10ns 处），内部进位 C[1]、C[2]、C[3]、C[4] 会同时 跳变到最终值，而不是像行波进位加法器那样逐级延迟跳变。这是超前进位并行计算最直观的体现------所有进位只依赖 G、P 和 C_in，彼此之间没有串行依赖。
• 和输出与参考值对齐 ：S[3:0] 与 C_out 组合成的 {C_out, S} 应始终等于 A + B + C_in。在波形上，每个 10ns 周期内 S 的取值都与当前输入组合的算术和一致，且 C_out 在发生溢出时正确置 1。
• 无毛刺与稳定建立：由于是纯组合逻辑，信号在输入变化后经过约 3 级门延迟即稳定，波形上不会出现因进位链逐级传播而产生的"阶梯式"过渡。

典型时序图描述 （以 A=4'hF、B=4'h1、C_in=1'b1 为例）：

• 0ns 时刻 ：A、B、C_in 被赋值为 F、1、1，此时 S 和 C_out 仍为上一周期的旧值（或初始的 x）。
• 10ns 时刻 ：testbench 中的 #10 延时结束，组合逻辑已稳定。此时 G、P 信号在预处理层并行算出，C[1]~C[4] 在超前进位层同时 更新，S 与 C_out 同步变为正确结果：F + 1 + 1 = 17，即 S=4'h1、C_out=1。波形上可见 C[1]~C[4] 在同一时刻一起跳变，随后 S 稳定为 0001、C_out 拉高为 1。
• 20ns 时刻 ：进入下一组输入组合，重复上述过程。整个仿真过程中，{C_out, S} 始终与 A + B + C_in 对齐，最终控制台打印 All test cases passed!，errors 计数保持为 0。

若波形中观察到 C[1]~C[4] 出现逐级延迟跳变（阶梯式过渡），或 S 与参考值不一致，说明进位表达式存在串行依赖或逻辑错误，应回到第 6 节的 Verilog 实现检查进位赋值语句。

8. 性能对比与扩展

延迟对比（以门延迟为单位，忽略线延迟）：

位宽	行波进位加法器	超前进位加法器
4 位	约 8 级	约 3 级
8 位	约 16 级	约 4 级
16 位	约 32 级	约 4~5 级
32 位	约 64 级	约 5~6 级

下面是两种加法器在不同位宽下的延迟对比柱状图：
#mermaid-svg-h7fA2CiKN3EA4oHj{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-h7fA2CiKN3EA4oHj .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-h7fA2CiKN3EA4oHj .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-h7fA2CiKN3EA4oHj .error-icon{fill:#552222;}#mermaid-svg-h7fA2CiKN3EA4oHj .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-h7fA2CiKN3EA4oHj .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-h7fA2CiKN3EA4oHj .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-h7fA2CiKN3EA4oHj .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-h7fA2CiKN3EA4oHj .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-h7fA2CiKN3EA4oHj .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-h7fA2CiKN3EA4oHj .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-h7fA2CiKN3EA4oHj .marker{fill:#333333;stroke:#333333;}#mermaid-svg-h7fA2CiKN3EA4oHj .marker.cross{stroke:#333333;}#mermaid-svg-h7fA2CiKN3EA4oHj svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-h7fA2CiKN3EA4oHj p{margin:0;}#mermaid-svg-h7fA2CiKN3EA4oHj :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 行波进位 vs 超前进位：延迟对比（门延迟） 4位8位16位32位 7065605550454035302520151050 门延迟

图中蓝色柱状表示行波进位加法器的延迟，红色折线表示超前进位加法器的延迟。可以看到，行波进位加法器的延迟随位宽线性增长（8 → 16 → 32 → 64），而超前进位加法器的延迟增长极为平缓（3 → 4 → 5 → 6）。位宽越大，两者的差距越悬殊：4 位时仅相差约 5 级，32 位时差距已拉大到约 58 级，超前进位在高位宽下的优势被充分放大。

延迟对比（以门延迟为单位，忽略线延迟）：

位宽	行波进位加法器	超前进位加法器
4 位	约 8 级	约 3 级
16 位	约 32 级	约 4~5 级
32 位	约 64 级	约 5~6 级

超前进位加法器的优势在于进位并行计算 ，但代价是逻辑复杂度随位宽快速增长 。当位宽超过 8 位时，直接展开全部进位表达式会导致扇入过大、布线拥塞，反而降低实际性能。因此，工程中通常采用分组超前进位 或树形结构（如 Brent-Kung、Kogge-Stone 加法器）来折中。

常见扩展方案：

• 分组 CLA：将 n 位分成若干 4 位小组，组内用超前进位，组间用行波或二级超前进位；
• Brent-Kung 加法器：用二叉树结构计算前缀进位，面积小、规则性好；
• Kogge-Stone 加法器：用并行前缀树，延迟最低但面积和布线开销大。

下面给出一个 8 位分组超前进位加法器的 Verilog 实现示例，通过级联两个 4 位 CLA 模块来展示组间进位传播的处理方式：

module cla_adder_8bit (
    input  [7:0] A,
    input  [7:0] B,
    input        C_in,
    output [7:0] S,
    output       C_out
);

    wire C_mid;  // 低 4 位到高 4 位的组间进位

    // 低 4 位 CLA：处理 A[3:0] + B[3:0] + C_in
    cla_adder_4bit low_cla (
        .A    (A[3:0]),
        .B    (B[3:0]),
        .C_in (C_in),
        .S    (S[3:0]),
        .C_out(C_mid)
    );

    // 高 4 位 CLA：处理 A[7:4] + B[7:4] + C_mid
    cla_adder_4bit high_cla (
        .A    (A[7:4]),
        .B    (B[7:4]),
        .C_in (C_mid),
        .S    (S[7:4]),
        .C_out(C_out)
    );

endmodule

组间进位传播的处理方式：

• 低 4 位 CLA 模块的进位输出 C_mid 直接作为高 4 位 CLA 模块的进位输入，这就是组间行波进位；
• 组内（4 位内部）仍采用超前进位并行计算，延迟约为 3 级门延迟；
• 组间只有一级进位传递，因此 8 位分组 CLA 的总延迟约为 4 级门延迟，远优于 8 位行波进位加法器的 8 级延迟；
• 若位宽进一步增大，可在组间再引入二级超前进位（即组间也并行计算进位），形成多级分组 CLA 结构。

8 位加法器的延迟对比（以门延迟为单位，忽略线延迟）：

实现方案	延迟	说明
8 位行波进位加法器	约 16 级	进位链逐级传递，每位约 2 级门延迟
8 位单级 CLA	约 3~4 级	直接展开全部进位表达式，但扇入过大
8 位分组 CLA	约 4 级	组内超前进位 + 组间一级行波进位

为什么分组 CLA 比直接展开 8 位 CLA 更实用：

• 扇入可控 ：8 位单级 CLA 的最高位进位 C8C_8C8 需要同时与 8 个 GGG、PPP 信号相与，扇入高达 9 个输入，在标准单元库中往往需要多级门才能实现，实际延迟反而接近甚至超过行波进位；而分组 CLA 把扇入限制在 4 位以内，每个进位表达式最多 5 个输入，逻辑实现更规整。
• 布线友好 ：单级 CLA 的进位信号需要跨越整个 8 位宽度，长走线带来显著线延迟；分组 CLA 的进位只在 4 位小组内部传播，组间仅有一条 C_mid 走线，布局布线更紧凑。
• 可扩展性强：分组 CLA 可以递归地继续分组（如 8 位分成两组、16 位分成四组），形成多级结构，而单级 CLA 的复杂度随位宽呈指数增长，位宽稍大就难以综合。
• 延迟收益明显：8 位分组 CLA 约 4 级门延迟，相比行波进位加法器的 16 级延迟提升约 4 倍，同时避免了单级 CLA 的扇入爆炸问题，是工程中延迟与复杂度之间的最佳折中。

9. 总结

本文从行波进位加法器的串行瓶颈出发，推导了超前进位加法器的核心公式 Ci+1=Gi+PiCiC_{i+1} = G_i + P_i C_iCi+1=Gi+PiCi，并通过递推展开实现了进位的并行计算。超前进位加法器以增加逻辑复杂度为代价，换取更低的进位传播延迟 ，是高性能数字系统中的经典选择。理解 GGG（生成）与 PPP（传播）这两个基本概念，是掌握各类快速加法器（包括各种并行前缀加法器）的钥匙。