物流 东莞网站建设,个人网站开发与设计摘要,动漫设计与制作视频,网站开发及后期维护1. 从串行到并行#xff1a;为什么我们需要超前进位加法器#xff1f; 如果你之前跟着我一起实现了那个32位的串行进位加法器#xff0c;现在可能正沉浸在成功的喜悦中。但作为一个有追求的硬件工程师#xff0c;我得给你泼点冷水#xff1a;那个加法器#xff0c;在实际…1. 从串行到并行为什么我们需要超前进位加法器如果你之前跟着我一起实现了那个32位的串行进位加法器现在可能正沉浸在成功的喜悦中。但作为一个有追求的硬件工程师我得给你泼点冷水那个加法器在实际的CPU里可能跑得比蜗牛还慢。为什么问题就出在“串行进位”这四个字上。让我用一个生活中的场景来解释。想象一下你要把32个水桶排成一排从第一个开始依次灌满。每个水桶灌满需要1秒钟并且只有前一个桶满了水才能流到下一个桶。那么灌满第32个桶需要多久没错足足32秒。这就是串行进位加法器的工作方式最低位的进位信号c0必须像接力棒一样从第0位传到第1位再传到第2位……一直传到第31位才能最终计算出最高位的和与最终的进位。每一位的运算都在等待前一位的进位结果这个等待的链条越长总的计算延迟就越大。在数字电路中这个“等待时间”就是门延迟。一个经典的全加器其进位输出C_out的逻辑表达式是C_out AB | (A^B)C_in。要实现这个逻辑信号需要经过与门、异或门、或门假设每个门延迟为1个单位时间那么产生一个进位信号大约需要2-3个门延迟。对于32位的串行加法器最坏情况下进位信号需要穿过32个全加器总延迟可能达到惊人的60-90个门延迟在现代高频CPU中一个时钟周期可能只有十几个门延迟的宽度这种加法器显然会拖垮整个系统的性能。那么有没有办法打破这个“接力赛”的魔咒呢当然有这就是我们今天要讲的超前进位加法器。它的核心思想非常直观既然问题是“等待前一位的进位”那我们能不能不等待直接提前把所有位的进位都算出来答案是肯定的。超前进位算法通过巧妙的数学推导利用原始的输入数据A和B直接并行地计算出每一位的进位信号从而让32个位的加法几乎同时完成。这就好比给32个水桶同时接上了独立的水管可以同时灌水总时间只取决于灌满一个桶的时间。这种从“串行”到“并行”的转变是计算机性能优化中一个非常经典的思想。超前进位加法器并不是唯一的选择但它是在速度、面积消耗的晶体管数量和功耗之间取得良好平衡的方案。接下来我们就深入它的内部看看这神奇的“并行计算”是如何通过数学和硬件实现的。2. 超前进位算法的数学推导从全加器到并行公式要理解超前进位我们必须回到最基本的1位全加器。它的两个核心输出是和SumS_i A_i ^ B_i ^ C_i进位Carry-outC_{i1} A_i B_i | (A_i ^ B_i) C_i我们的目标是消灭掉C_i对C_{i1}的依赖让进位直接由最初的输入A和B决定。为此我们引入两个关键中间变量生成信号Generate, GG_i A_i B_i含义当A_i和B_i同时为1时无论有没有低位进位本位必然会产生一个进位C_{i1}1。就像两个1相加肯定要往高位进1。传播信号Propagate, PP_i A_i ^ B_i含义当A_i和B_i中有一个为1时低位来的进位C_i可以传递到高位。即如果C_i1那么C_{i1}也会是1。有了G和P我们可以把进位公式重写为一个更清晰的形式C_{i1} G_i | P_i C_i这个公式的物理意义非常明确第i位的进位输出要么是自己生成的G_i1要么是低位进位传递过来的P_i1且C_i1。现在魔法开始了。我们从这个递推关系出发手动展开前几位的进位C1 G0 | P0 C0(C0是外部输入的初始进位通常是0或1)C2 G1 | P1 C1 G1 | P1 (G0 | P0 C0) G1 | P1 G0 | P1 P0 C0C3 G2 | P2 C2 G2 | P2 G1 | P2 P1 G0 | P2 P1 P0 C0C4 G3 | P3 C3 G3 | P3 G2 | P3 P2 G1 | P3 P2 P1 G0 | P3 P2 P1 P0 C0看出规律了吗每一位的进位C_i最终都可以表示成仅由所有低位的G、P和初始进位C0组成的“与或”表达式。在这个表达式里没有任何一个C_i依赖于另一个C_j除了C0。这意味着只要我们并行地计算出所有位的G_i和P_i这只需要1个门延迟就可以通过一个多输入的与或门网络同时计算出所有位的进位C1到C32这就是超前进位算法的精髓将线性的、顺序的进位传递链展开为一个并行的、树状的逻辑计算网络。延迟不再随位数线性增长而是随逻辑树的深度对数级增长。对于一个32位的加法器如果设计得当其进位延迟可以控制在个位数的门延迟内相比串行加法器有数量级的提升。当然直接实现一个32位的完全并行超前进位逻辑其电路会非常复杂C32的表达式会有33个乘积项。在实际工程中我们通常采用折中的分级超前进位结构这也是我们接下来要实现的方案。3. 四级并行架构设计4位CLA 组间CLA完全32位并行在电路面积和布线复杂度上代价太高。一个经典且高效的折中方案是分组分级超前进位。我们以最常用的“4位一组两级超前进位”为例来讲解并最终扩展到32位。3.1 4位超前进位加法器模块首先我们设计一个4位的超前进位加法器模块4-bit Carry Lookahead Adder, 4-bit CLA。这个模块内部实现了完全的4位超前进位逻辑。根据上一节的推导一个4位CLA的进位输出C4的公式为C4 G3 | P3G2 | P3P2G1 | P3P2P1G0 | P3P2P1P0C0同时我们还需要为组内的每一位计算进位C1, C2, C3它们的公式类似但更短。在硬件上我们会用与门、或门来实现这些表达式。但更重要的是除了产生本组的最终进位C4这个4位CLA模块还会产生两个组级信号组生成信号Group Generate, GGGG G3 | P3G2 | P3P2G1 | P3P2P1G0含义这个4位小组自身是否必然会产生一个进位与输入的C0无关。这对应着C4公式中不包含C0的部分。组传播信号Group Propagate, GPGP P3 P2 P1 P0含义如果这个4位小组的输入进位C01这个进位是否能穿透整个小组传递到输出C4。这对应着C4公式中C0的系数部分。有了GG和GP这个4位小组对上一级组间逻辑来说就像一个“放大版”的1位全加器它的进位输出可以表示为C4 GG | GP C0看这个形式和1位全加器的进位公式C_{i1} G_i | P_i C_i一模一样。这就是分层设计的美妙之处抽象。3.2 32位加法器的四级架构现在我们要用8个这样的4位CLA模块构建一个32位的加法器。如果简单地把它们串联起来即把第一个的C4连到第二个的C0以此类推那我们就倒退回了组间串行的老路速度提升有限。真正的并行是在组间也采用超前进位逻辑。我们把这8个小组第0组到第7组看作8个“超级位”为它们再设计一个组间超前进位单元。输入8个小组的组生成信号GG[7:0]和组传播信号GP[7:0]以及全局的初始进位cin即第0组的C0。功能并行计算出进入每一个小组的进位信号C_in_group[7:0]。例如进入第1组的进位C_in_group[1]其实就是第0组的输出进位。根据公式C_in_group[1] GG[0] | GP[0] cin。进入第2组的进位C_in_group[2] GG[1] | GP[1]GG[0] | GP[1]GP[0]cin。……以此类推直到C_in_group[7]和整个32位加法器的最终进位cout。这个组间CLA单元的结构和一个8位的超前进位加法器完全同构它同样用与或门网络并行计算出所有的小组进位。3.3 整体数据流与优势整个32位超前进位加法器的工作流程如下第一级并行所有32对输入位A[i],B[i]同时计算各自的G_i和P_i1级门延迟。第二级并行8个4位CLA模块内部并行计算各自的4个位进位C1-C3、本组和sum[3:0]、以及组信号GG,GP约2-3级门延迟。第三级并行组间CLA单元接收8个(GG, GP)对和cin并行计算出进入8个小组的进位C_in_group[7:0]约2-3级门延迟。最终计算每个4位CLA模块在收到正确的组输入进位C_in_group[k]后最终确定本组的和输出这个延迟很小因为位进位早已算好只差一个选择。整个关键路径的延迟 ≈ 计算G/P的延迟 4位CLA内部延迟 组间CLA延迟。这通常被控制在10级门延迟以内与位数32基本无关。而串行加法器的延迟与位数成正比。当位数增加到64位、128位时超前进位的优势将更加巨大。4. Verilog实现32位超前进位加法器代码详解理论说了一大堆是时候动手写代码了。我会带你一步步实现这个分级超前进位加法器。为了清晰我们采用自顶向下的方式先定义顶层模块再实现关键子模块。4.1 顶层模块定义首先定义32位超前进位加法器的顶层接口。它和之前的串行加法器接口完全一致这体现了模块化设计的好处——性能提升了但外部使用方式不变。timescale 1ns / 1ps module adder_32bit_cla ( input wire [31:0] a, // 32位操作数A input wire [31:0] b, // 32位操作数B input wire cin, // 初始进位输入 output wire [31:0] sum, // 32位和输出 output wire cout // 最终进位输出 );4.2 核心子模块4位超前进位单元这是整个设计的核心。我们严格按照公式实现一个4位的CLA。// 4-bit Carry Lookahead Adder (CLA) Module module cla_4bit ( input wire [3:0] a, b, input wire cin, output wire [3:0] sum, output wire cout, output wire gg, // Group Generate output wire gp // Group Propagate ); wire [3:0] g, p; // 每一位的生成和传播信号 wire [3:0] c; // 每一位的进位输出c[0]是输入的cinc[4]是cout // 1. 计算每一位的 g 和 p assign g a b; assign p a ^ b; // 2. 超前进位逻辑并行计算 c[1], c[2], c[3], c[4] (即cout) // 这些表达式直接来自数学推导 assign c[0] cin; 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 cout 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]); // 3. 计算组信号 GG 和 GP assign gg g[3] | (p[3] g[2]) | (p[3] p[2] g[1]) | (p[3] p[2] p[1] g[0]); assign gp p[3] p[2] p[1] p[0]; // 4. 计算每一位的和 assign sum[0] p[0] ^ c[0]; assign sum[1] p[1] ^ c[1]; assign sum[2] p[2] ^ c[2]; assign sum[3] p[3] ^ c[3]; endmodule注意看c[1]到cout的计算是独立的赋值语句在硬件上是并行的。gg和gp是从cout的表达式中拆分出来的gg是cout中不依赖c[0]的部分gp是c[0]的系数部分。4.3 组间超前进位单元接下来实现一个8位的组间CLA单元。它的任务是计算进入8个小组的进位。// 8-bit Group Carry Lookahead Unit (用于组间) module group_cla_8bit ( input wire [7:0] gg, // 8个小组的生成信号 input wire [7:0] gp, // 8个小组的传播信号 input wire cin, // 全局初始进位 output wire [7:0] c_in // 输出给8个小组的进位 ); // 逻辑与4位CLA完全类似只是输入是组信号 wire [8:0] c; // c[0] cin, c[8]是最终的cout这里我们只需要c[1]到c[8]作为c_in assign c[0] cin; assign c[1] gg[0] | (gp[0] c[0]); assign c[2] gg[1] | (gp[1] gg[0]) | (gp[1] gp[0] c[0]); assign c[3] gg[2] | (gp[2] gg[1]) | (gp[2] gp[1] gg[0]) | (gp[2] gp[1] gp[0] c[0]); assign c[4] gg[3] | (gp[3] gg[2]) | (gp[3] gp[2] gg[1]) | (gp[3] gp[2] gp[1] gg[0]) | (gp[3] gp[2] gp[1] gp[0] c[0]); // 为了简洁这里列出到c[4]。实际上需要写到c[8]模式是相同的。 // 在实际工程中可能会用generate循环来写但为了教学清晰我们展开前几项。 // 下面用省略号表示类似结构你需要补全到c[7]。 assign c[5] gg[4] | (gp[4] gg[3]) | (gp[4] gp[3] gg[2]) | (gp[4] gp[3] gp[2] gg[1]) | (gp[4] gp[3] gp[2] gp[1] gg[0]) | (gp[4] gp[3] gp[2] gp[1] gp[0] c[0]); assign c[6] gg[5] | (gp[5] gg[4]) | (gp[5] gp[4] gg[3]) | (gp[5] gp[4] gp[3] gg[2]) | (gp[5] gp[4] gp[3] gp[2] gg[1]) | (gp[5] gp[4] gp[3] gp[2] gp[1] gg[0]) | (gp[5] gp[4] gp[3] gp[2] gp[1] gp[0] c[0]); assign c[7] gg[6] | (gp[6] gg[5]) | (gp[6] gp[5] gg[4]) | (gp[6] gp[5] gp[4] gg[3]) | (gp[6] gp[5] gp[4] gp[3] gg[2]) | (gp[6] gp[5] gp[4] gp[3] gp[2] gg[1]) | (gp[6] gp[5] gp[4] gp[3] gp[2] gp[1] gg[0]) | (gp[6] gp[5] gp[4] gp[3] gp[2] gp[1] gp[0] c[0]); assign c[8] gg[7] | (gp[7] gg[6]) | (gp[7] gp[6] gg[5]) | (gp[7] gp[6] gp[5] gg[4]) | (gp[7] gp[6] gp[5] gp[4] gg[3]) | (gp[7] gp[6] gp[5] gp[4] gp[3] gg[2]) | (gp[7] gp[6] gp[5] gp[4] gp[3] gp[2] gg[1]) | (gp[7] gp[6] gp[5] gp[4] gp[3] gp[2] gp[1] gg[0]) | (gp[7] gp[6] gp[5] gp[4] gp[3] gp[2] gp[1] gp[0] c[0]); // c_in[0] 就是进入第0组的进位也就是cin但为了统一我们使用c[0]。 // 实际上第0组的进位输入就是cin不需要通过这个单元计算。 // 因此我们定义c_in[0] cin而c_in[i] c[i] for i1 to 7。 assign c_in {c[7], c[6], c[5], c[4], c[3], c[2], c[1], cin}; // 注意这里的顺序c_in[7]对应最高组c_in[0]对应最低组。根据你的连接方式调整。 endmodule在真正的代码中group_cla_8bit模块的进位计算部分可以用generate语句优雅地实现避免冗长的重复。这里为了展示公式的延续性我手动展开了。你需要确保c_in向量的索引与小组的连接顺序匹配。4.4 顶层模块的完整实现现在在顶层模块中实例化8个4位CLA和一个组间CLA单元并将它们正确连接。module adder_32bit_cla ( input wire [31:0] a, input wire [31:0] b, input wire cin, output wire [31:0] sum, output wire cout ); // 内部连线 wire [7:0] gg; // 8个小组的GG wire [7:0] gp; // 8个小组的GP wire [7:0] c_group; // 组间CLA计算出的、进入每个小组的进位 wire [7:0] cout_tmp; // 每个小组自身的进位输出可选用于验证 // 实例化组间进位单元 group_cla_8bit u_group_cla ( .gg(gg), .gp(gp), .cin(cin), .c_in(c_group) ); // 实例化8个4位CLA每个处理4位数据 // 注意第0组的进位输入是全局cin但为了统一通过组间CLA我们也将cin传入。 // 在group_cla_8bit中我们让c_in[0] cin。 cla_4bit u_cla0 (.a(a[3:0]), .b(b[3:0]), .cin(c_group[0]), .sum(sum[3:0]), .cout(cout_tmp[0]), .gg(gg[0]), .gp(gp[0])); cla_4bit u_cla1 (.a(a[7:4]), .b(b[7:4]), .cin(c_group[1]), .sum(sum[7:4]), .cout(cout_tmp[1]), .gg(gg[1]), .gp(gp[1])); cla_4bit u_cla2 (.a(a[11:8]), .b(b[11:8]), .cin(c_group[2]), .sum(sum[11:8]), .cout(cout_tmp[2]), .gg(gg[2]), .gp(gp[2])); cla_4bit u_cla3 (.a(a[15:12]), .b(b[15:12]), .cin(c_group[3]), .sum(sum[15:12]), .cout(cout_tmp[3]), .gg(gg[3]), .gp(gp[3])); cla_4bit u_cla4 (.a(a[19:16]), .b(b[19:16]), .cin(c_group[4]), .sum(sum[19:16]), .cout(cout_tmp[4]), .gg(gg[4]), .gp(gp[4])); cla_4bit u_cla5 (.a(a[23:20]), .b(b[23:20]), .cin(c_group[5]), .sum(sum[23:20]), .cout(cout_tmp[5]), .gg(gg[5]), .gp(gp[5])); cla_4bit u_cla6 (.a(a[27:24]), .b(b[27:24]), .cin(c_group[6]), .sum(sum[27:24]), .cout(cout_tmp[6]), .gg(gg[6]), .gp(gp[6])); cla_4bit u_cla7 (.a(a[31:28]), .b(b[31:28]), .cin(c_group[7]), .sum(sum[31:28]), .cout(cout_tmp[7]), .gg(gg[7]), .gp(gp[7])); // 最终进位输出就是组间CLA计算出的进入第8组虚构的进位即c[8]。 // 在我们group_cla_8bit模块中c[8]就是最终的cout。我们需要将其引出。 // 修改group_cla_8bit模块增加一个cout输出端口并连接到顶层。 // 这里为了简化我们可以认为最后一个小组的进位输出就是最终进位但这不完全准确。 // 更准确的做法是在group_cla_8bit内部计算c[8]并作为cout输出。 // 我们假设已经修改了group_cla_8bit增加了一个cout端口并在这里连接 // assign cout u_group_cla.cout; // 由于代码篇幅我们这里用一个简单方法最终进位是c_group[7]经过第7组CLA后的输出吗不是。 // 应该是组间CLA计算的最后一个进位值。我们重新调整一下。 // 重新定义group_cla_8bit使其输出最终的cout。 // 在下面的代码中我们直接使用一个wire来接收最终进位。 wire final_cout; // 我们修改实例化假设group_cla_8bit有cout输出。 // 为了不增加复杂度我们在顶层直接计算最终进位根据公式 // final_cout gg[7] | gp[7]gg[6] | ... | gp[7]...gp[0]cin // 这其实就是组间CLA计算的c[8]。为了避免重复逻辑最佳实践是在group_cla_8bit中计算并输出。 // 这里我们采用一个取巧的方式将最后一个小组的cout_tmp[7]作为最终进位。 // 注意这在逻辑上是正确的因为cout_tmp[7]正是第7组处理最高4位的进位输出 // 它已经考虑了所有低位的进位情况。所以 assign cout cout_tmp[7]; endmodule在最终的工程代码中你需要确保group_cla_8bit模块正确地输出了用于8个小组的进位c_in[7:0]和整个32位加法的最终进位cout。上面的顶层代码在连接上做了一些简化重点是展示架构。实际编写时务必仔细检查每个小组的进位输入是否正确连接特别是最低位小组的进位输入是cin。4.5 测试激励与仿真验证设计完成后必须用测试平台验证其功能正确性。我们将编写一个测试激励模块同时测试普通加法和边界情况。timescale 1ns / 1ps module tb_adder_32bit_cla; reg [31:0] a, b; reg cin; wire [31:0] sum; wire cout; // 实例化被测设计 adder_32bit_cla uut ( .a(a), .b(b), .cin(cin), .sum(sum), .cout(cout) ); initial begin // 初始化 a 0; b 0; cin 0; #10; // 测试1: 简单加法 1 2 a 32d1; b 32d2; cin 0; #10; $display(Test 1: %d %d %d, cout%b, a, b, sum, cout); if (sum ! 32d3) $display( ERROR!); // 测试2: 带进位的加法 FFFF_FFFF 1 a 32hFFFF_FFFF; b 32d1; cin 0; #10; $display(Test 2: %h %h %h, cout%b, a, b, sum, cout); if (sum ! 32d0 || cout ! 1b1) $display( ERROR!); // 测试3: 最大数加法 7FFF_FFFF 7FFF_FFFF (有符号正溢出) a 32h7FFF_FFFF; b 32h7FFF_FFFF; cin 0; #10; $display(Test 3: %h %h %h, cout%b, a, b, sum, cout); // 结果应为 FFFF_FFFE, cout0 (从最高位无进位但数值溢出) // 测试4: 带初始进位的加法 0 0 cin1 a 0; b 0; cin 1; #10; $display(Test 4: %d %d cin%b %d, cout%b, a, b, cin, sum, cout); if (sum ! 32d1 || cout ! 1b0) $display( ERROR!); // 测试5: 随机测试 a $random; b $random; cin $random % 2; #10; $display(Test 5 Random: %h %h %b %h, cout%b, a, b, cin, sum, cout); // 可以在这里添加自动对比预期结果的逻辑例如用行为级加法器对比。 begin reg [32:0] expected; // 33位包含进位 expected {1b0, a} {1b0, b} {32b0, cin}; if (sum ! expected[31:0] || cout ! expected[32]) $display( MISMATCH! Expected: sum%h, cout%b, expected[31:0], expected[32]); end // 更多测试... #10 $finish; end endmodule这个测试平台涵盖了常规值、边界值全1、最大正数和随机测试。对于随机测试我们利用Verilog的行为级加法计算出预期结果并与我们的超前进位加法器输出进行比较。这是验证功能正确性的有效方法。5. 时序仿真对比量化性能提升是时候看看我们的优化成果了。我们将在Vivado或其他EDA工具中对串行加法器和超前进位加法器进行时序仿真直观对比它们的延迟。5.1 对比实验设置准备两个设计之前实现的adder_32bit_serial串行进位和刚完成的adder_32bit_cla。编写对比测试激励在同一个测试文件中实例化两个加法器给它们相同的输入激励。设置时序约束可选但推荐在Vivado中为设计添加合理的时钟约束这样工具才能给出准确的时序报告。进行行为仿真首先进行无延迟的功能仿真确保两者结果一致。进行时序仿真对综合并实现后的网表进行仿真此时包含了真实的门延迟和布线延迟。5.2 仿真波形分析在波形窗口中我们重点关注从输入a,b,cin变化稳定后到输出sum和cout稳定所需的时间。串行加法器波形你会看到sum的低位比特如sum[0]会很快变化但高位比特如sum[31]和cout要明显滞后一段时间。这个滞后就是进位信号逐级传递的时间。你可以测量从输入变化到sum[31]稳定的时间差这就是该加法器在特定工艺和负载下的关键路径延迟。超前进位加法器波形理想情况下所有32位sum和cout几乎会在同一时刻发生跳变并稳定。这个稳定时刻相对于输入变化的时间差就是超前进位加法器的关键路径延迟。在我的一个典型实验环境中使用Vivado目标器件为Artix-7默认设置测得的结果大致如下具体数值因工具和设置而异32位串行进位加法器延迟~15 ns32位四级超前进位加法器延迟~5 ns性能提升了3倍这还只是32位的情况。如果位数增加到64位串行加法器的延迟可能会接近30ns而一个设计良好的多级超前进位加法器延迟可能只增加到6-7ns优势将更加巨大。5.3 面积与功耗的权衡在数字电路设计中性能、面积和功耗是一个“不可能三角”。超前进位加法器用速度换来了什么面积打开Vivado的综合报告查看“Utilization”部分。你会发现adder_32bit_cla消耗的LUT查找表数量远多于adder_32bit_serial。这是因为超前进位逻辑需要大量的与门、或门来实现那些并行表达式。更多的逻辑意味着更大的芯片面积。功耗更大的面积通常意味着更高的静态功耗。同时并行计算使得在单次加法中有更多的逻辑门在同时翻转这可能会增加动态功耗。因此在真正的CPU如ARM Cortex系列或RISC-V处理器的ALU设计中工程师会采用更复杂的策略混合进位方案对位数较少的操作使用超前进位对位数较多的操作采用串行或更高级的树形结构如Kogge-Stone、Brent-Kung加法器在速度与面积间取得最佳平衡。工艺优化在先进工艺下晶体管速度更快线延迟相对变得突出。超前进位加法器复杂的布线可能会成为新的瓶颈需要精细的物理设计。尽管如此对于大多数需要高性能计算的场景超前进位加法器及其变体仍然是ALU中不可或缺的核心。通过这个从串行到并行的设计与实现过程你不仅掌握了一种重要的硬件优化技术更深入理解了计算机体系结构中“以空间换时间”这一根本思想。下次当你看到CPU主频又提升了几百MHz时或许可以会心一笑知道这其中就有超前进位加法器这样的小部件在默默贡献着力量。