9주차 (2023.02.20~2023.02.26) 32bit KSA , Final Simulaion

동계 학부연구생 마지막주 .. 그동안 고생 많았댜

1. 32bit Kogge Stone adder

 

block diagram

1. Pre-Processing

propagate , generate 생성         p= A xor B g=A and B

2. Carry Look ahead network 아래의 논리방정식에 따른 중간 신호를 사용하여 그룹 genegate, propagate를 만들어낸다.

P[i:j] = p[i:k] and p [ k-1:j ] //다음(중간) 신호 p는 위에서 전해져 온 p와 이전에서 전파된 p를 and한다.   G[i:j]= g[i:k] or (p[i:k] and g [k-1:j]) //다음 [중간] 신호 g는 위에서 전해져온 p와 이전에서 전파된 g를 AND 하여 위에서 전해져온 G와 OR 한 것이다.

3. Post processing 위의 network를 통해 p,g가 [ i:0 ] 이 될 때까지 전파가 됐다면 아래 논리 계산으로 그 bit의 sum을 구할 수 있다.

Sum_i=p_i XOR g_(i-1) ( 단, 위 논리식에서 32>i>0 이다.sum[0]= p[0] XOR Cin)

---

1.1. 32bit Kogge Stone adder

32bit_KSA

∴ 보통의 RCA라면 32번의 계산 과정을 거쳤어야 했으나 5번으로 줄었다.   시간복잡도 : O(n) 32 → O(log n) 5   

 

---

1.2. Pre-Processing

p= A xor B

g=A and B

//----------------------------------Pre_Processing ---------------------------------------
module Pre_processing(sum,cout,p,g);
input [31:0] sum, cout;
output [31:0] p,g;
PG_make pgg1(sum[7:0],cout[7:0],p[7:0],g[7:0]); 
PG_make pgg2(sum[15:8],cout[15:8],p[15:8],g[15:8]);
PG_make pgg3(sum[23:16],cout[23:16],p[23:16],g[23:16]); 
PG_make pgg4(sum[31:24],cout[31:24],p[31:24],g[31:24]);
endmodule

//pg 생성 8bit
module PG_make(sum,cout,p,g);
input [7:0] sum,cout; output [7:0]  p,g;
xor(p[0],sum[0],cout[0]);xor(p[1],sum[1],cout[1]);xor(p[2],sum[2],cout[2]);xor(p[3],sum[3],cout[3]);
xor(p[4],sum[4],cout[4]);xor(p[5],sum[5],cout[5]);xor(p[6],sum[6],cout[6]);xor(p[7],sum[7],cout[7]);

and(g[0],sum[0],cout[0]);and(g[1],sum[1],cout[1]);and(g[2],sum[2],cout[2]);and(g[3],sum[3],cout[3]);
and(g[4],sum[4],cout[4]);and(g[5],sum[5],cout[5]);and(g[6],sum[6],cout[6]);and(g[7],sum[7],cout[7]);
endmoduleBASH

 

1.3. CLA_network

P[i:j] = p[i:k] and p [ k-1:j ]

G[i:j]= g[i:k] or (p[i:k] and g [k-1:j])

//----------------------------------CLA-Networt ---------------------------------------
module CLA_network(p,g,p5,g5);
input [31:0] p,g;
output [31:0] p5,g5;
wire [31:0] p1,g1,p2, g2,p3,g3 ,p4,g4;
wire gw1,gw2,gw3;
//-----------------첫번째 단 pg 연결, 생성------------------------------------------
buf(p1[0],p[0]);  buf(g1[0],g[0]);
kogge1_8bit pair1_1(p[7:0],g[7:0],p1[7:0],g1[7:0]);          kogge1_8bit pair1_2(p[14:7],g[14:7],p1[14:7],g1[14:7]);
kogge1_8bit pair1_3(p[21:14],g[21:14],p1[21:14],g1[21:14]);   kogge1_8bit pair1_4(p[28:21],g[28:21],p1[28:21],g1[28:21]);

and(p1[29],p[29],p[28]); and(p1[30],p[30],p[29]);and(p1[31],p[31],p[30]); 

and(gw1,p[29],g[28]); and(gw2,p[30],g[29]);and(gw3,p[31],g[30]); 
or(g1[29],g[29],gw1); or(g1[30],g[30],gw2); or(g1[31],g[31],gw3); 

//-----------------두번째 단 pg 연결, 생성------------------------------------------
wire gw4,gw5,gw6,gw7;
buf(p2[0],p[0]);  buf(g2[0],g[0]); 
buf(p2[1],p1[1]);  buf(g2[1],g1[1]); 

kogge2_8bit pair2_1(p1[7:0],g1[7:0],p2[7:0],g2[7:0]); kogge2_8bit pair2_2(p1[13:6],g1[13:6],p2[13:6],g2[13:6]); 
kogge2_8bit pair2_3(p1[19:12],g1[19:12],p2[19:12],g2[19:12]); kogge2_8bit pair2_4(p1[25:18],g1[25:18],p2[25:18],g2[25:18]); 
kogge2_8bit pair2_5(p1[31:24],g1[31:24],p2[31:24],g2[31:24]);

//-----------------세번째 단 pg 연결, 생성------------------------------------------
buf(p3[0],p[0]);  buf(g3[0],g[0]); 
buf(p3[1],p1[1]); buf(g3[1],g1[1]); 
buf(p3[2],p2[2]); buf(g3[2],g2[2]); 
buf(p3[3],p2[3]); buf(g3[3],g2[3]); 
kogge3_8bit pair3_1(p2[7:0],g2[7:0],p3[7:0],g3[7:0]);         kogge3_8bit pair3_2(p2[11:4],g2[11:4],p3[11:4],g3[11:4]);
kogge3_8bit pair3_3(p2[15:8],g2[15:8],p3[15:8],g3[15:8]);     kogge3_8bit pair3_4(p2[19:12],g2[19:12],p3[19:12],g3[19:12]);
kogge3_8bit pair3_5(p2[23:16],g2[23:16],p3[23:16],g3[23:16]); kogge3_8bit pair3_6(p2[27:20],g2[27:20],p3[27:20],g3[27:20]);
kogge3_8bit pair3_7(p2[31:24],g[31:24],p3[31:24],g3[31:24]);

//-----------------네번째 단 pg 연결, 생성------------------------------------------
buf(p4[0],p[0]);  buf(g4[0],g[0]);  buf(p4[1],p1[1]); buf(g4[1],g1[1]); 
buf(p4[2],p2[2]); buf(g4[2],g2[2]); buf(p4[3],p2[3]); buf(g4[3],g2[3]); 
buf(p4[4],p3[4]); buf(g4[4],g3[4]); buf(p4[5],p3[5]); buf(g4[5],g3[5]);
buf(p4[6],p3[6]); buf(g4[6],g3[6]); buf(p4[7],p3[7]); buf(g4[7],g3[7]);

kogge4_16bit pair4_1(p3[15:0],g3[15:0],p4[15:0],g4[15:0]);        kogge4_16bit pair4_2(p3[23:8],g3[23:8],p4[23:8],g4[23:8]);
kogge4_16bit pair4_3(p3[31:16],g3[31:16],p4[31:16],g4[31:16]);        

//-----------------다섯번째 단 pg 연결, 생성------------------------------------------
buf(p5[0],p[0]);  buf(g5[0],g[0]);  
buf(p5[1],p1[1]); buf(g5[1],g1[1]); 
buf(p5[2],p2[2]); buf(g5[2],g2[2]); buf(p5[3],p2[3]); buf(g5[3],g2[3]); 
buf(p5[4],p3[4]); buf(g5[4],g3[4]); buf(p5[5],p3[5]); buf(g5[5],g3[5]); buf(p5[6],p3[6]); buf(g5[6],g3[6]); buf(p5[7],p3[7]); buf(g5[7],g3[7]);

buf(p5[8],p4[8]); buf(g5[8],g4[8]); buf(p5[9],p4[9]); buf(g5[9],g4[9]);buf(p5[10],p4[10]); buf(g5[10],g4[10]); buf(p5[11],p4[11]); buf(g5[11],g4[11]);
buf(p5[12],p4[12]); buf(g5[12],g4[12]); buf(p5[13],p4[13]); buf(g5[13],g4[13]);buf(p5[14],p4[14]); buf(g5[14],g4[14]); buf(p5[15],p4[15]); buf(g5[15],g4[15]);

kogge5_32bit pair32(p4[31:0],g4[31:0],p5[31:0],g5[31:0]);
endmoduleBASH

//첫번째 단 연결 8bit---------------------------------------------
module kogge1_8bit(p,g,p1,g1);
input [7:0] p,g;      output [7:0] p1,g1; wire [7:0] gw;
and(p1[1],p[1],p[0]);
and(gw[0],p[1],g[0]); or(g1[1],gw[0],g[1]);

and(p1[2],p[2],p[1]);
and(gw[1],p[2],g[1]); or(g1[2],gw[1],g[2]);

and(p1[3],p[3],p[2]);
and(gw[2],p[3],g[2]); or(g1[3],gw[2],g[3]);

and(p1[4],p[4],p[3]);
and(gw[3],p[4],g[3]); or(g1[4],gw[3],g[4]);

and(p1[5],p[5],p[4]);
and(gw[4],p[5],g[4]); or(g1[5],gw[4],g[5]);

and(p1[6],p[6],p[5]);
and(gw[5],p[6],g[5]); or(g1[6],gw[5],g[6]);

and(p1[7],p[7],p[6]);
and(gw[6],p[7],g[6]); or(g1[7],gw[6],g[7]);
endmodule

//두번째 단 연결 8bit---------------------------------------------
module kogge2_8bit(p1,g1,p2,g2);
input [7:0] p1,g1; output [7:0] p2,g2; wire gw[7:0];
and(p2[2],p1[2],p1[0]);
and(gw[0],p1[2],g1[0]); or(g2[2],gw[0],g1[2]);

and(p2[3],p1[3],p1[1]);
and(gw[1],p1[3],g1[1]); or(g2[3],gw[1],g1[3]);


and(p2[4],p1[4],p1[2]);
and(gw[2],p1[4],g1[2]); or(g2[4],gw[2],g1[4]);

and(p2[5],p1[5],p1[3]);
and(gw[3],p1[5],g1[3]); or(g2[5],gw[3],g1[5]);

and(p2[6],p1[6],p1[4]);
and(gw[4],p1[6],g1[4]); or(g2[6],gw[4],g1[6]);

and(p2[7],p1[7],p1[5]);
and(gw[5],p1[7],g1[5]); or(g2[7],gw[5],g1[7]);
endmodule

//세번째 단 연결 8bit --------------------------------------------
module kogge3_8bit(p2,g2,p3,g3);
input [7:0] p2,g2; output [7:0] p3,g3; wire gw[7:0];

and(p3[4],p2[4],p2[0]);
and(gw[0],p2[4],g2[0]); or(g3[4],gw[0],g2[4]);

and(p3[5],p2[5],p2[1]);
and(gw[1],p2[5],g2[1]); or(g3[5],gw[1],g2[5]);

and(p3[6],p2[6],p2[2]);
and(gw[2],p2[6],g2[2]); or(g3[6],gw[2],g2[6]);

and(p3[7],p2[7],p2[3]);
and(gw[3],p2[7],g2[3]); or(g3[7],gw[3],g2[7]);
endmodule

//네번째 단 연결 16bit --------------------------------------------
module kogge4_16bit(p3,g3,p4,g4);
input [15:0] p3,g3;  output [15:0] p4,g4; wire [7:0] gw;

and(p4[8],p3[8],p3[0]);
and(gw[0],p3[8],g3[0]); or(g4[8],gw[0],g3[8]);

and(p4[9],p3[9],p3[1]);
and(gw[1],p3[9],g3[1]); or(g4[9],gw[1],g3[9]);

and(p4[10],p3[10],p3[2]);
and(gw[2],p3[10],g3[2]); or(g4[10],gw[2],g3[10]);

and(p4[11],p3[11],p3[3]);
and(gw[3],p3[11],g3[3]); or(g4[11],gw[3],g3[11]);

and(p4[12],p3[12],p3[4]);
and(gw[4],p3[12],g3[4]); or(g4[12],gw[4],g3[12]);

and(p4[13],p3[13],p3[5]);
and(gw[5],p3[13],g3[5]); or(g4[13],gw[5],g3[13]);

and(p4[14],p3[14],p3[6]);
and(gw[6],p3[14],g3[6]); or(g4[14],gw[6],g3[14]);

and(p4[15],p3[15],p3[7]);
and(gw[7],p3[15],g3[7]); or(g4[15],gw[7],g3[15]);
endmodule

//다섯번째단 연결 32bit --------------------------------------------
module kogge5_32bit(p4,g4,p5,g5);
input [31:0] p4,g4; output [31:0] p5,g5; wire [15:0] gw;

and(p5[16],p4[16],p4[0]);
and(gw[0],p4[16],g4[0]); or(g5[16],gw[0],g4[16]);

and(p5[17],p4[17],p4[1]);
and(gw[1],p4[17],g4[1]); or(g5[17],gw[1],g4[17]);

and(p5[18],p4[18],p4[2]);
and(gw[2],p4[18],g4[2]); or(g5[18],gw[2],g4[18]);

and(p5[19],p4[19],p4[3]);
and(gw[3],p4[19],g4[3]); or(g5[19],gw[3],g4[19]);

and(p5[20],p4[20],p4[4]);
and(gw[4],p4[20],g4[4]); or(g5[20],gw[4],g4[20]);

and(p5[21],p4[21],p4[5]);
and(gw[5],p4[21],g4[5]); or(g5[21],gw[5],g4[21]);

and(p5[22],p4[22],p4[6]);
and(gw[6],p4[22],g4[0]); or(g5[22],gw[6],g4[22]);

and(p5[23],p4[23],p4[7]);
and(gw[7],p4[23],g4[7]); or(g5[23],gw[7],g4[23]);

and(p5[24],p4[24],p4[8]);
and(gw[8],p4[24],g4[8]); or(g5[24],gw[8],g4[24]);

and(p5[25],p4[25],p4[9]);
and(gw[9],p4[25],g4[9]); or(g5[25],gw[9],g4[25]);

and(p5[26],p4[26],p4[10]);
and(gw[10],p4[26],g4[10]); or(g5[26],gw[10],g4[26]);

and(p5[27],p4[27],p4[11]);
and(gw[11],p4[27],g4[11]); or(g5[27],gw[11],g4[27]);

and(p5[28],p4[28],p4[12]);
and(gw[12],p4[28],g4[12]); or(g5[28],gw[12],g4[28]);

and(p5[29],p4[29],p4[13]);
and(gw[13],p4[29],g4[13]); or(g5[29],gw[13],g4[29]);

and(p5[30],p4[30],p4[14]);
and(gw[14],p4[30],g4[14]); or(g5[30],gw[14],g4[30]);

and(p5[31],p4[31],p4[15]);
and(gw[15],p4[31],g4[15]); or(g5[31],gw[15],g4[31]);
endmoduleBASH

1.4. Post-Processing

Sum_i=p_i XOR g_(i-1)

( 단, i는 32>i>0 이다.)

 SUM_0= p[0] XOR Cin이다.

하지만 Cin이 없으므로 Cin=0으로 간주하여 SUM[0]=p[0]이다.

//---------------3. Post processing. 32bit sum
module Post_processing(p,g5,sum,cout);
input [31:0] p,g5;
output [31:0] sum;
output cout;
buf(sum[0],p[0]);
pgxor_8bit pg_pair1(p[7:0],g5[7:0],sum[7:0]);
pgxor_8bit pg_pair2(p[14:7],g5[14:7],sum[14:7]);
pgxor_8bit pg_pair3(p[21:14],g5[21:14],sum[21:14]);
pgxor_8bit pg_pair4(p[28:21],g5[28:21],sum[28:21]);
xor(sum[29],p[29],g5[28]);xor(sum[30],p[30],g5[29]);xor(sum[31],p[31],g5[30]);
buf(cout,g5[31]);
endmodule


module pgxor_8bit(p,g,s);
input [7:0] p,g;
output [7:0] s;

xor(s[1],p[1],g[0]); xor(s[2],p[2],g[1]);
xor(s[3],p[3],g[2]); xor(s[4],p[4],g[3]);
xor(s[5],p[5],g[4]); xor(s[6],p[6],g[5]);
xor(s[7],p[7],g[6]); 

endmoduleBASH

 

---

1.5. Kogge_stone_adder

module Kogge_stone_adder(Wallace_sum,Wallace_cout,Kogge_sum,Kogge_cout );
input [31:0] Wallace_sum,Wallace_cout;
output [31:0] Kogge_sum;
output Kogge_cout;
wire [31:0] p,g,p5,g5;
Pre_processing pe_process(Wallace_sum,Wallace_cout,p,g);
CLA_network cla_net(p,g,p5,g5);
Post_processing post_process(p,g5,Kogge_sum,Kogge_cout);
endmoduleBASH

 

 

그동안 만든 booth algorithm, wallace tree, kogge stone adder 연결

module buterfly_multiplier(x,y,sum,cout);
input [15:0] x,y;
output [31:0] sum;
output cout;
wire [31:0] product1,product2,product3,product4,product5,product6,product7,product8;
Modified_booth_algorithm modified_booth_alg(x,y,product1,product2,product3,product4,product5,product6,product7,product8);

wire [31:0] Wallace_sum,Wallace_cout;
Wallace_tree Wallace(product1,product2,product3,product4,product5,product6,product7,product8,Wallace_sum,Wallace_cout);

Kogge_stone_adder Kogge_Stone(Wallace_sum,Wallace_cout,sum,cout);

endmoduleBASH

---

2. Simulation

2.1. testbench