Carry Look-ahead Adder Design

Carry Look-ahead Adder(캐리 예측 덧셈기)
 전가산기를 이용한 Ripple Carry Adder는 많은 bit의 연산을 하려고 할 때
지연되는 시간이 길어지는 단점을 갖는다.
 CLA(Carry Look-ahead Adder)의 경우는 carry의 발생을 bit입력시
바로 계산하여 시간의 지연 없이 바로 덧셈연산을 수행할 수 있는 장점을 갖는다.
 * 참고: http://en.wikipedia.org/wiki/Carry_lookahead_adder


< RTL(Register Transfer Level) Schematic >

사용자 삽입 이미지사용자 삽입 이미지[code]
`timescale 1ns / 1ps
////////////////////////////////////////////////////////
// Carry Lockahead Adder Unit Design
// Downrg.com
////////////////////////////////////////////////////////

module cla_16bit(i_a,i_b,i_cin,o_s);
  input [15:0] i_a,i_b;     //operand input
  input i_cin;              //carry input
  output [15:0] o_s;        //sum output

  wire [15:0] p,g;          //carry generate, propagate
  wire [14:0] c;            //carry wire
  wire [3:0] p_s,g_s;       //BCLU output carry

  //PGU module
  pgu_16bit PGU1(.i_a(i_a),.i_b(i_b),.o_p(p),.o_g(g));

   //BCLU module x4
   bclu_4bit BCLU1(.i_cin(i_cin),.i_p(p[3:0]),.i_g(g[3:0]),.o_c(c[2:0]),.o_p_s(p_s[0]),.o_g_s(g_s[0]));
   bclu_4bit BCLU2(.i_cin(c[3]),.i_p(p[7:4]),.i_g(g[7:4]),.o_c(c[6:4]),.o_p_s(p_s[1]),.o_g_s(g_s[1]));
   bclu_4bit BCLU3(.i_cin(c[7]),.i_p(p[11:8]),.i_g(g[11:8]),.o_c(c[10:8]),.o_p_s(p_s[2]),.o_g_s(g_s[2]));
   bclu_4bit BCLU4(.i_cin(c[11]),.i_p(p[15:12]),.i_g(g[15:12]),.o_c(c[14:12]),.o_p_s(p_s[3]),.o_g_s(g_s[3]));

  //CLU module
  clu_16bit CLU(.i_cin(i_cin),.i_p_s(p_s),.i_g_s(g_s),.o_c({c[11],c[7],c[3]}));
  //SU module
  su_16bit SU(.i_c(c),.i_cin(i_cin),.i_p(p),.o_s(o_s));
endmodule

//PGU Module
module pgu_16bit(i_a,i_b,o_p,o_g);
 input [15:0] i_a,i_b;     //16bit input a,b
 output [15:0] o_p,o_g;    //p:generate, g: propagate

 assign o_p = i_a ^ i_b;   //carry generate function
 assign o_g = i_a & i_b;   //carry propagate function
endmodule

//BCLU Module
module bclu_4bit(i_cin,i_p,i_g,o_c,o_p_s,o_g_s);
  input i_cin;             //carry input
  input [3:0] i_p,i_g;     //4bit carry generate,propagate
  output [3:1] o_c;        //3bit carry output
  output o_p_s,o_g_s;      //carry generate,propagate

  assign o_c[1] = i_g[0] | (i_p[0]&i_cin);
  assign o_c[2] = i_g[1] | (i_p[1]&i_g[0]) | (i_p[1]& i_p[0]&i_cin);
  assign o_c[3] = i_g[2] | (i_p[2]&i_g[1]) | (i_p[2]&i_p[1]&i_g[0]) | (i_p[2]&i_p[1]& i_p[0]&i_cin);
  assign o_p_s = i_p[0]&i_p[1]&i_p[2]&i_p[3];
  assign o_g_s = i_g[3] | i_g[2]&i_p[3] | i_g[1]&i_p[3]&i_p[2] | i_g[0]&i_p[3]&i_p[2]&i_p[1];
endmodule

//CLU Module
module clu_16bit(i_cin,i_p_s,i_g_s,o_c);
  input i_cin;             //carry input
  input [3:0] i_p_s,i_g_s; //carry generate,progpagate input
  output [3:1] o_c;        //carry output

  assign o_c[1] = i_g_s[0] | (i_p_s[0]&i_cin);
  assign o_c[2] = i_g_s[1] | (i_p_s[1]& i_g_s[0]) | (i_p_s[1]&i_p_s[0]&i_cin);
  assign o_c[3] = i_g_s[2] | (i_p_s[2]&i_g_s[1]) | (i_p_s[2]&i_p_s[1]& i_g_s[0]) | (i_p_s[2]&i_p_s[1]&i_p_s[0]&i_cin);;
endmodule

//SU Module
module su_16bit(i_c,i_cin,i_p,o_s);
  input [14:0] i_c;       //15bit carry input
  input i_cin;            //carry0 input
  input [15:0] i_p;       //16bit carry generate input
  output [15:0] o_s;      //sum output

  assign o_s = i_p^{i_c,i_cin};
endmodule
[/code]

You may also like...

댓글 남기기