VericodeRTL · DV · QUIZTìm bài học, kiến thức…Ctrl K
Học để hiểu. Thực hành để vững.

Bộ cộng và cộng-trừ: từ một cột bit tới ripple và lookahead

Khoảng 55 phútMức 2/3Bản nháp: một số khẳng định chưa đối chiếu spec

Tiên quyết

Sau bài này bạn sẽ

  • Dựng half/full adder từ bảng cộng bit
  • Lần carry qua ripple và khai triển carry-lookahead
  • Dùng một đường cộng cho trừ và phân biệt carry, borrow, overflow

Mỗi cột trả hai thông tin

Trong phép cộng binary, tổng của hai bit có thể bằng 2, nên một bit kết quả không đủ. Mỗi cột trả bit sum ở cùng trọng số và bit carry chuyển sang trọng số gấp đôi.

Khi cộng một từ nhiều bit, cột bên phải còn có thể gửi carry vào cột hiện tại. Tách đúng sum và carry là bước đầu để hiểu bộ cộng, bộ trừ và ALU.

Half-adder khác full-adder ở carry-in

Half-adder nhận A và B; sum là XOR, carry là AND.

A B Carry Sum
0 0 0 0
0 1 0 1
1 0 0 1
1 1 1 0

Full-adder nhận thêm carry-in C. Sum là XOR của ba đầu vào; carry bằng 1 khi ít nhất hai đầu vào bằng 1.

A B C Carry-out Sum
0 0 0 0 0
0 0 1 0 1
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 0 1 1 0
1 1 0 1 0
1 1 1 1 1

Có thể ghép hai half-adder và OR hai carry để tạo full-adder. Half-adder chưa đủ cho một cột có ba bit cần cộng; trong incrementer, một đầu vào chỉ là carry từ bước trước nên cấu trúc có thể đơn giản hơn.

Carry đi từ bit thấp tới bit cao

Đặt P_i=A_i XOR B_i, G_i=A_i·B_i. Cột i có S_i=P_i XOR C_i và C_(i+1)=G_i+P_i·C_i, trong đó dấu cộng là OR.

G nghĩa cột tự tạo carry; P nghĩa cột truyền carry vào. Ghép carry-out của cột thấp làm carry-in cột kế tạo ripple-carry.

Ví dụ bốn bit 7 cộng 1, carry-in ban đầu 0:

Cột A B Carry-in Sum Carry-out
0 1 1 0 0 1
1 1 0 1 0 1
2 1 0 1 0 1
3 0 0 1 1 0

Đọc sum từ cột 3 về 0 được 1000. Đây là bảng tính theo phụ thuộc logic, không phải waveform hay số đo thời gian cổng. Đường carry qua nhiều cột có thể trở thành đường timing cần quan tâm.

Khai triển carry thay vì đợi từng cột

Thế công thức carry vào chính nó để đưa mỗi carry về G/P và carry-in gốc:

  • C1=G0+P0·C0.
  • C2=G1+P1·G0+P1·P0·C0.
  • C3=G2+P2·G1+P2·P1·G0+P2·P1·P0·C0.
  • C4=G3+P3·G2+P3·P2·G1+P3·P2·P1·G0+P3·P2·P1·P0·C0.

Đây là carry-lookahead bốn bit với P dùng XOR như đã định nghĩa. Giá trị sum không đổi; cấu trúc phụ thuộc carry thay đổi.

Biểu thức phẳng tăng fan-in khi W lớn. Thiết kế rộng thường ghép nhóm generate/propagate hoặc dùng cấu trúc prefix; không kéo một biểu thức OR rất rộng rồi mặc định nhanh nhất. Cell, tải, wire và constraint còn quyết định kết quả thực.

Ví dụ bài chỉ đối chiếu chức năng ripple/CLA. Không có cell library và STA thì chưa so được timing hoặc area của hai bản.

XOR có điều khiển để dùng cùng bộ cộng

Two’s complement cho phép viết A-B=A+(NOT B)+1 theo modulo của độ rộng đang giữ. Dùng tín hiệu SUB: khi 0, B đi qua; khi 1, đảo từng bit B và đưa 1 vào carry-in.

Với bốn bit, 3 trừ 5: 0011 + 1010 + 1 = 1110. Kết quả giữ lại là −2 nếu đọc signed, hoặc 14 nếu đọc unsigned modulo 16.

Trong quy ước của bài, carry-out khi trừ bằng 1 nghĩa không mượn: A lớn hơn hoặc bằng B theo unsigned. Nó bằng 0 khi có borrow. Đây là quy ước cờ cần công bố, không phải mọi ISA đều dùng cùng tên/ý nghĩa.

Không dùng carry-out để suy signed overflow. Phép trừ signed có thể tràn dù không cần mượn trong cách đọc unsigned.

Giữ độ rộng và đọc cờ theo đúng miền

Tổng unsigned của hai từ bốn bit và carry-in cần năm bit. Cần giữ đủ độ rộng ngay lúc tính, không mở rộng một kết quả đã bị cắt rồi mong lấy lại carry.

Signed overflow ở bộ cộng cùng độ rộng có thể kiểm bằng XOR của carry vào MSB và carry ra MSB. Với cộng hai số cùng dấu, một dấu khác ở kết quả cũng báo overflow; với trừ phải dùng quy tắc phù hợp cho toán hạng bị trừ.

Phép bốn bit Kết quả giữ Carry Signed overflow
+7 cộng +1 1000 0 1
−1 cộng +1 0000 1 0
+7 trừ −1 1000 0 theo raw unsigned 7−15 1
−8 trừ −8 0000 1, không borrow 0

Cờ N chỉ đọc MSB kết quả; khi có overflow, nó chưa phải dấu của kết quả toán học không giới hạn. Để so signed bằng hiệu, cần hiệu chỉnh bằng overflow như ở bài ALU.

Những lỗi dễ lọt nếu chỉ thử số nhỏ

  • Dùng half-adder cho cột còn carry-in.
  • Quên cộng 1 sau khi đảo B lúc trừ.
  • Mất bit cao trong biểu thức trước khi gán sang biến rộng hơn.
  • Đồng nhất carry/no-borrow với signed overflow.
  • Gọi một cách viết CLA là chắc chắn nhanh hơn sau mọi mapping.

Hãy thử các biên 0, toàn bit 1, số dương lớn nhất và số âm nhỏ nhất. Chọn thêm ca carry đi qua nhiều cột; không chỉ kiểm vài tổng không phát sinh carry.

Tính cả sum và các cờ

  1. Full-adder nhận 1/1/1 cho sum và carry bằng bao nhiêu?
  2. Lần từng carry của 1111 cộng 0001 với carry-in 0.
  3. Với A=0101, B=0011, SUB=1, B sau XOR là gì và carry-in bằng bao nhiêu?
  4. Vì sao +7 trừ −1 không thể dùng dấu của hiệu bốn bit để kết luận thứ tự?
  5. Nếu CLA và ripple cho cùng kết quả ở mọi input nhỏ, còn cần kiểm gì để chọn vì timing?

Kiểm tra

Tự kiểm tra: Bộ cộng và cộng-trừ: từ một cột bit tới ripple và lookahead

  1. Full-adder nhận A=1,B=1,carry-in=1 cho sum và carry-out nào?
  2. Carry-lookahead thay điều gì so với ripple ở cùng hợp đồng cộng?
  3. Để dùng adder làm A−B, khi SUB=1 cần làm gì?
  4. Bốn bit +7 cộng +1: carry và signed overflow bằng gì?
  5. Theo quy ước bài, SUB có carry-out=1 nghĩa gì?

Bằng chứng kiểm chứng

Expected tính trước chạy: ADDER CHECK half=4 full=8 carry_vectors=512 carry_out=256 signed_overflow=128 addsub=512 subtract_borrow=120 addsub_overflow=128 time_ns=1036.

Half/full, ripple/CLA và cộng-trừ bốn bit

Kỳ vọng tính trước chạy: ADDER CHECK half=4 full=8 carry_vectors=512 carry_out=256 signed_overflow=128 addsub=512 subtract_borrow=120 addsub_overflow=128 time_ns=1036

adders_core.sv RTL
`timescale 1ns/1psmodule adders_core(input logic ha,hb,fa,fb,fc,input logic [3:0] a,b,input logic cin,subtract, output wire [1:0] half,full,output wire [4:0] ripple,lookahead,addsub,output wire ov_rc,ov_cla,ov_addsub); assign half={ha&hb,ha^hb}; assign full={(fa&fb)|(fa&fc)|(fb&fc),fa^fb^fc}; wire [3:0] p=a^b,g=a&b; wire [4:0] rc,cl; assign rc[0]=cin; for(genvar k=0;k<4;k++)begin:ripple_column  assign ripple[k]=p[k]^rc[k];  assign rc[k+1]=g[k]|(p[k]&rc[k]); end assign ripple[4]=rc[4]; assign cl[0]=cin; assign cl[1]=g[0]|(p[0]&cin); assign cl[2]=g[1]|(p[1]&g[0])|(p[1]&p[0]&cin); assign cl[3]=g[2]|(p[2]&g[1])|(p[2]&p[1]&g[0])|(p[2]&p[1]&p[0]&cin); assign cl[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]&cin); assign lookahead={cl[4],p^cl[3:0]}; assign ov_rc=rc[3]^rc[4]; assign ov_cla=cl[3]^cl[4]; wire [3:0] effective_b=b^{4{subtract}},as_p=a^effective_b,as_g=a&effective_b; wire [4:0] as_c; assign as_c[0]=subtract; for(genvar k=0;k<4;k++)begin:addsub_column  assign addsub[k]=as_p[k]^as_c[k];  assign as_c[k+1]=as_g[k]|(as_p[k]&as_c[k]); end assign addsub[4]=as_c[4]; assign ov_addsub=as_c[3]^as_c[4];endmodule
tb.sv testbench
`timescale 1ns/1psmodule tb_a3_adders; logic ha,hb,fa,fb,fc,cin,subtract;logic [3:0] a,b; wire [1:0] half,full;wire [4:0] ripple,lookahead,addsub;wire ov_rc,ov_cla,ov_addsub; adders_core dut(.*); int half_count=0,full_count=0,carry_vectors=0,carry_out=0,signed_overflow=0,addsub_count=0,borrow=0,as_overflow=0; int unsigned_sum,exact,ai,bi;bit expected_ov,expected_carry; initial begin  ha=0;hb=0;fa=0;fb=0;fc=0;cin=0;subtract=0;a=0;b=0;  for(int i=0;i<4;i++)begin   ha=1'(i/2);hb=1'(i%2);#1;half_count++;   if(half!==2'(i/2+i%2))$fatal(1,"Half-adder truth mismatch");  end  for(int i=0;i<8;i++)begin   fa=1'(i/4);fb=1'((i/2)%2);fc=1'(i%2);#1;full_count++;   if(full!==2'(i/4+(i/2)%2+i%2))$fatal(1,"Full-adder truth mismatch");  end  for(int ia=0;ia<16;ia++)for(int ib=0;ib<16;ib++)for(int ci=0;ci<2;ci++)begin   a=4'(ia);b=4'(ib);cin=1'(ci);#1;carry_vectors++;   unsigned_sum=ia+ib+ci;ai=ia<8?ia:ia-16;bi=ib<8?ib:ib-16;exact=ai+bi+ci;   expected_ov=exact < -8 || exact > 7;   if(ripple!==5'(unsigned_sum)||lookahead!==5'(unsigned_sum)||ov_rc!==expected_ov||ov_cla!==expected_ov)    $fatal(1,"Carry/CLA mismatch a=%0d b=%0d cin=%0d",ia,ib,ci);   if(ripple[4])carry_out++;if(ov_rc)signed_overflow++;  end  cin=0;  for(int ia=0;ia<16;ia++)for(int ib=0;ib<16;ib++)for(int sub=0;sub<2;sub++)begin   a=4'(ia);b=4'(ib);subtract=1'(sub);#1;addsub_count++;   unsigned_sum=sub?ia-ib:ia+ib;expected_carry=sub?(ia>=ib):(ia+ib>=16);   ai=ia<8?ia:ia-16;bi=ib<8?ib:ib-16;exact=sub?ai-bi:ai+bi;expected_ov=exact < -8 || exact > 7;   if(addsub[3:0]!==4'(unsigned_sum)||addsub[4]!==expected_carry||ov_addsub!==expected_ov)$fatal(1,"Add/sub contract mismatch a=%0d b=%0d sub=%0d",ia,ib,sub);   if(sub&&ia<ib)borrow++;if(ov_addsub)as_overflow++;  end  if(half_count!=4||full_count!=8||carry_vectors!=512||carry_out!=256||signed_overflow!=128||addsub_count!=512||borrow!=120||as_overflow!=128||$time!=1036)$fatal(1,"Adder experiment contract");  $display("ADDER CHECK half=%0d full=%0d carry_vectors=%0d carry_out=%0d signed_overflow=%0d addsub=%0d subtract_borrow=%0d addsub_overflow=%0d time_ns=%0d",half_count,full_count,carry_vectors,carry_out,signed_overflow,addsub_count,borrow,as_overflow,$time);  $finish; endendmodule

Đã kiểm chứng thế nào

  • Phân tích và elaborate theo LRM (pyslang 12.1.0)
  • Lint -Wall (Verilator 5.050)
  • Mô phỏng, exit 0 và output khớp kỳ vọng tính tay (Verilator 5.050, 2-state)
  • Tổng hợp, số cell khớp kỳ vọng (Yosys 0.70)

Output phải khớp: ADDER CHECK half=4 full=8 carry_vectors=512 carry_out=256 signed_overflow=128 addsub=512 subtract_borrow=120 addsub_overflow=128 time_ns=1036

Kỳ vọng sau tổng hợp: adders_core: $_*DFF* = 0adders_core: $_*LATCH* = 0

Verilator 5.050 two-state and finite four-bit domains; no all-width/XZ conformance. Generic combinational synthesis, not physical timing/PPA or exact cell mapping.

Các kiểm tra chạy lúc xây dựng nội dung (2026-11-11), không chạy trong trình duyệt. Kỳ vọng được tính tay trước khi chạy.

Half/full kiểm đủ bốn/tám hàng bằng tổng số nguyên. Ripple/CLA kiểm 512 tổ hợp A/B/carry-in; tham chiếu có 256 carry-out và 128 signed overflow. Add/sub kiểm 512 tổ hợp nữa, gồm 120 borrow ở nhánh trừ và 128 overflow tổng hai mode.

Tham chiếu signed giải mã raw u trừ 16 ở nửa âm, rồi xét tổng/hiệu toán học ngoài −8 tới +7. Không dùng lại chuỗi carry hoặc biểu thức dấu của DUT để sinh cờ mong đợi. Parser/lint/simulation/synthesis đạt; generic không có FF/latch. Không claim gate-delay, mapping/STA/PPA hoặc mọi W/X/Z.

[1] [2] [3] [4]

Bài liên quan

Nguồn và mức độ đối chiếu

  1. Digital Full-Adder Circuit — bản chụp resources.zip, Quick Answer: Full-Adder; Building the Full Adder; Generate and Propagate; The Ripple-Carry Adder; Subtraction and Overflow With the Same Adder. Trích dẫn; nguồn đã đọc các mục liên quan.
  2. Thí nghiệm nguyên bản A3.adders, Four half-adder/eight full-adder rows, 512 ripple/CLA and 512 add-sub vectors with independent arithmetic flags. Trích dẫn; nguồn đã đọc toàn văn.
  3. IEEE 1800-2023 SystemVerilog LRM, Integral expression widths, concatenation, generated combinational carries and signed-overflow interpretation — chưa đối chiếu LRM. Chưa đối chiếu với văn bản nguồn (chưa mở).
  4. Digital Half-Adder Circuit — bản chụp resources.zip, Quick Answer: Half-Adder; The Half-Adder Circuit; Chaining Half-Adders: An Incrementer. Trích dẫn; nguồn đã đọc các mục liên quan.