Laporan VLSI

N bun

Foto

a

TUGAS 2 EL4040 Perancangan VLSI

Counter 8-bit, Adder-16bit dan Booth Multiplier Radix-2

Nama: I Made Wiratha N.

NIM : 13209057

Institut Teknologi Bandung Semester 1 2012/2013

1. Counter 8-bit Counter pada dasarnya adalah mekanisme menghitung clock yang

terjadi pada suatu periode waktu. Pada bagian ini akan didesain sebuah

counter dengan lebar data 8 bit, dam memiliki mode up dan down

counter. Konstruksi counter 8-bit ini dilakukan secara structural yaitu

dengan mengkonstruksi bagian-bagian seperti adder, multiplexer dan

register. RTL dari Counter ini dapat dilhat pada gambar dibawah ini:

Gambar 1. RTL dari Counter

Verilog dari masing-masing bagian dapat dilihat dibawah ini:

a. ADDER 8-bit

module ADD8Bit (

input [7:0] d_in1,

input [7:0] d_in2,

output [7:0] d_out);

wire [8:1] c;

FA bit0 (.a(d_in1[0]), .b(d_in2[0]), .Cin('b0),

.Cout(c[1]), .Dout(d_out[0]));

FA bit1 (.a(d_in1[1]), .b(d_in2[1]),.Cin(c[1]),


FA bit2 (.a(d_in1[2]), .b(d_in2[2]), .Cin(c[2]),












Endmodule

b. DFF 8-Bit

module DFF8Bit (

input [7:0] In,

input Clock,

output reg [7:0] Counter);

always @ (posedge Clock)

Counter = In;

endmodule

c. Full Adder (FA)

module FA (

input a,b,Cin,

output Cout,Dout);

assign Dout = (a^b)^Cin;

assign Cout = ((a^b)&Cin)|(a&b);

endmodule

d. Multiplexer 8-Bit 2 to 1

module MUX2_1 (

input [7:0] d_in1,

input [7:0] d_in2,

input sel,

output [7:0] Counter);

assign Counter[0] = (d_in1[0]&~sel)|(d_in2[0]&sel);








endmodule

e. Counter (Modul Utama)

module cn(

input [7:0] In,

input Reset, Clock, Down_Up,

output wire [7:0] Counter);

wire [7:0] add1;

wire [7:0] min1;

wire [7:0] tmp_count;

wire [7:0] tmp_mux;

wire [7:0] tmp_mux8;

assign add1 = 8'b00000001;

assign min1 = 8'b11111111;

assign tmp_mux8[0] = tmp_count[0] & Reset;








MUX2_1 updown (.d_in1(add1), .d_in2(min1),

.sel(Down_Up), .Counter(tmp_mux));

ADD8Bit counter (.d_in1(d_out), .d_in2(tmp_mux),

.d_out(tmp_count));

DFF8Bit counter_out (.In(tmp_mux8), .Clock(Clock),

.Counter(d_out));

Endmodule

1. Simulasi fungsional

Simulasi ini dilakukan untuk memeriksa apakah program yang

dibuat telah berjalan dengan benar dan valid

a. Testvector data uniform

Gambar 2. Testvector Data Uniform

Gambar diatas menunjukkan bahwa operasi penjumlahan yang

berjalan telah benar dan valid sacara logic dan fungsional dengan

testvector data uniform. Sedangkan pada testvector data random,

hasil yang diperoleh masih konsisten dengan funsi counter itu

sediri. Dengan demikian perancangan telah berjalan baik dan

benar.

b. Testvector data random

Gambar 3. Testvector data Random

2. Simulasi Timing

Pada simulasi timing, maka interval timing yang digunanakan

sebesar 10 ns, timing dengan nilai 10 ns akan mengakibatkan

delay yang cukup besar, seperti pada gambar dibawah ini. Hasil

yang diperoleh pun kurang sesuai dengan yang seharusnya.

Gambar 4. Simulasi Timing

8 bit counter ini menggunakan 14 logic elemen atau <1% dari

yang tersedia pada board yang digunakan dalam simulasi dan

menngunakan 8 register. Sedangkan critical path adalah pin

Sum[15] yang memiliki delay terpanjang sebesar 19,44 ns

2. Adder dengan berbagai arsitektur

a. 16-bit Ripple Carry Adder (RCA)

Ripple Carry Adder dapat dibentuk dengan menggunakan Half

adder dan full adder yang disusun sehingga menjadi RCA. Bagian

bagian dari blok penyusun ini dapat dilihat pada gambar dibawah

ini:

Gambar 6. Skema RCA

Dari gambar diatas dapat dilihat bahwa Ripple Carry Adder disusun

atas n buah Full Adder secara kaskade. Karena penyusunan secara

kaskade ini sinyal Carry in yang berjalan menyerupai ripple,

sehingga terdapat masalah delay dalam arsitektur ini. Jika perbagian

dari blok ini diuraikan, maka skematik dari full adder adalah:

Gambar 7. Dekomposisi dari Full Adder

Tabel kebenaran dari Full adder dapat dilihat pada gambar dan

penjelasan dibawah ini:

Tabel Keberan Full Adder

Gambar 8. Tabel Kebenaran dan K-Map

Jadi,

Si = Xi XOR Yi XOR Ci

Ci+1=XiYi + XiCi+YiCi

Kemudian Full Adder dapat dibentuk dari Half Adder, sehingga

desain yang dibuat modular. Skematik dari Half Adder adalah:

Gambar 9. Dekomposisi Half Adder

Melalui blok diagram diatas, maka sebuah RCA dapat dibentuk

menggunakan bahasa Verilog dengan pendekatan behavioral. Untuk

source code dari setiap modul dapat dilihat dibawah ini:

1. Half Adder (HA)

module half_adder(

input X,Y,

output S,C);

xor(S,X,Y);

and(C,X,Y);

endmodule

2. Full Adder (FA)

module full_adder(

input X,Y,Cin,

output S,Cout);

wire s1,c1,c2;

half_adder HA1(s1,c1,X,Y);

half_adder HA2(S,c2,s1,Cin);

or Out(Cout,c1,c2);

endmodule

3. Ripple Carry Adder

module RCA(

input [15:0] X,Y,

input Cin,

output [15:0] Sum,

output Cout);

wire c1, c2, c3, c4, c5, c6, c7, c8, c9, c10,

c11, c12, c13, c14, c15;

full_adder FA1(Sum[0],c1,X[0],Y[0],Cin),

FA2(Sum[1],c2,X[1],Y[1],c1),

FA3(Sum[2],c3,X[2],Y[2],c2),

FA4(Sum[3],c4,X[3],Y[3],c3),

FA5(Sum[4],c5,X[4],Y[4],c4),

FA6(Sum[5],c6,X[5],Y[5],c5),

FA7(Sum[6],c7,X[6],Y[6],c6),

FA8(Sum[7],c8,X[7],Y[7],c7),

FA9(Sum[8],c9,X[8],Y[8],c8),

FA10(Sum[9],c10,X[9],Y[9],c9),

FA11(Sum[10],c11,X[10],Y[10],c10),

FA12(Sum[11],c12,X[11],Y[11],c11),

FA13(Sum[12],c13,X[12],Y[12],c12),

FA14(Sum[13],c14,X[13],Y[13],c13),

FA15(Sum[14],c15,X[14],Y[14],c14),

FA16(Sum[15],Cout,X[15],Y[15],c15);

endmodule

Setelah Kode Verilog didesain, maka dikakukan langkah-langkah

sebagai berikut:

1. Kompilasi program

2. Debugging error yang terjadi

3. Simulasi

a. Silmulasi Timing dan fungsional

b. Logic Utilization

Hasil simulasi




Gambar 11. Hasil simulasi Fungsional


berjalan telah benar dan valid sacara logic dan fungsional.

2. Simulasi Timing


sebesar 100 ns, timing dengan nilai dibawah 100 ns akan

mengakibatkan delay yang cukup besar.

Gambar 12. Hasil simulasi Timing

Ripple carry adder ini menggunakan 32 logic elemen atau <1% dari

yang tersedia pada board yang digunakan dalam simulasi.

Sedangkan critical path adalah pin Sum[15] yang memiliki delay

terpanjang sebesar 19,44 ns

b. 16-bit Carry-Lookahead Adder (CLA)

Carry-Lookahead Adder merupakan suatu algoritma adder yang

cukup cepat. CLA ini diturunkann dari persamaan logika RCA

sehingga penyederhanaan ini membuat CLA bisa lebih cepat

dibanding RCA.

Si = Xi XOR Yi XOR Ci

Ci+1=XiYi + XiCi+YiCi

Ci+1=XiYi + Ci(Xi+Yi)

Ci+1=Gi +CiPi

Dengan:

Gi = XiYi

Pi = Xi + Yi

Dengan menggunakan manipulasi aljabar boolean maka dapat

diperoleh pola persamaan boolean sebagai berikut:

C1 = G0 + P0C0

C2 = G1 + P1G0 + P1P0C0

C3 = G2 + P2P1 + P2P1G0 + P2P1P0C0

C4 = G3 + P3P2 + P3P2P1 + P3P2P1G0 + P3P2P1P0C0

Carry-Lookahead Adder dapat dibentuk dengan menggunakan

persamaan boolean diatas yang disusun sehingga menjadi CLA.

Bagian bagian dari blok penyusun ini dapat dilihat pada gambar

dibawah ini:

Gambar 13. Struktur dari CLA

Gerbang logika yang ada dalam Carry-Lookahead Adder bisa

duraikan menjadi bagian perblok yang dapat dilihat pada gambar

dibawah ini:

Gambar 14, Dekomposisi CLA

Melalui blok diagram diatas, maka sebuah CLA dapat dibentuk



1. Carry-Lookeahead Adder (CLA)

module CLA(

input [15:0] A,B,

input Cin,

output [15:0] S,

output Cout,PG,GG);

wire [15:0] G,P,c;

assign G = A & B; //Generate

assign P = A ^ B; //Propagate

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[15] = G[14]| (P[14]& G[13])|...

... & P[1] & P[0] & c[0]);

assign S = P ^ c;

assign PG = P[15] & P[14] & P[13]... & P[1]

& P[0];

assign GG = G[15]| (P[15]& G[14])... & P[1] &

G[0]);

endmodule

Sebagian besar dari kode ini tidak dituliskan karena sangat panjang

dan banyak. Setelah Kode Verilog didesain, maka dikakukan

langkah-langkah sebagai berikut:



3. Simulasi



Hasil simulasi




Gambar 15.Hasil simulasi Fungsional dari CLA



2. Simulasi Timing




Gambar 16. Simulasi Timing dari CLA

Carry-Lookahead Adder ini menggunakan 99 logic elemen atau

2% dari yang tersedia pada board yang digunakan dalam

simulasi. Sedangkan critical path adalah pin dari Cin menuju pin

S[14] yang memiliki delay terpanjang sebesar 17,291 ns. Seperti

pada gambar dibawah ini.

Gambar 17. Summary Logic utilization dan Critical path

Setelah melihat kedua bentuk Adder baik RCA maupun CLA, maka dapat

dilihat bahwa pada kedua algoritma ini terdapat perbedaan yang

terlihat pada critical path atau delay terpanjang yang terjadi. Pada RCA,

delay yang terjadi adalah sebesar 19,44 ns, sedangkan pada CLA delay

yang terjadi sebesar 17,291 ns. Pada RCA, komponen logika yang

digunakan adalah sebesar 32, pada CLA sebesar 99 komponen. Secara

intuisi seharusnya CLA yang memiliki komponen paling banyak

memiliki delay yang lebih besar, ternyata sebaliknya. Hal ini terjadi

akibat algoritma dan struktur program yang berbeda. Walaupun

perbedaanya tidak terlalu mencolok, tapi pengurangan delay sekecil ini

sangat berarti dalam implementasi rangkaian yang kompleks.

c. 4-bit Kogge Stone Adder (KSA)

Kogge stone Adder atau shift and Add adder merupakan salah satu

algoritma penjumlahan yang paling cepat, hemat memori dan mudah

diimplementasikan. Kogge Stone Adder (KSA) menyelesaikan masalah

ripple Cin yang terjadi pada RCA dan critical path pada CLA. Pada KSA,

untuk melakukan penjumlahan, maka Ci+1 tidak perlu menunggu

keluaran Ci seerti pada RCA, sehingga akan mempercepat proses

penjumlahan. Untuk mengimplementasikan Kogge Stone Adder maka

dapat merujuk pada skema system dari kogge stone dibawah ini:

Gambar 18. Algoritma dari Kogge Stone Adder

Melalui blok diagram diatas, maka sebuah KSA dapat dibentuk



//4-bit KS Adder

module KSA (A, B, Sum, Cin, Cout);

input [3:0] A, B;

output [4:0] Sum;

input Cin;

output Cout;

wire [3:0] Gi, Pi,

G_1, P_1,

G_2, P_2;

//level 1 Propagate

hijau level_0A(Cin, Pi[0], Gi[0], G_1[0]);

kuning level_1A(Gi[0], Pi[1], Gi[1], Pi[0],

G_1[1], P_1[1]);


G_1[2], P_1[2]);


G_1[3], P_1[3]);

//level 2 Generate

hijau level_1B(Cin, P_1[1], G_1[1], G_2[1]);

hijau level_2B(G_1[0], P_1[2], G_1[2],

G_2[2]);

kuning level_3B(G_1[1], P_1[3], G_1[3],

P_1[1], G_2[3], P_2[3]);

//level 3 Cout

hijau level_3C(Cin, P_2[3], G_2[3], Cout);

//persamaan masukan xor and

and_xor level_Z0(A[0], B[0], Pi[0], Gi[0]);




//Hasil

xor(Sum[0], Cin, Pi[0]);

xor(Sum[1], G_1[0], Pi[1]);

xor(Sum[2], G_2[1], Pi[2]);

xor(Sum[3], G_2[2], Pi[3]);

and(Sum[4], Cout, Cout);

endmodule

//I/O block module

module kuning(Gkj, Pik, Gik, Pkj, G, P);

input Gkj, Pik, Gik, Pkj;

output G, P;

wire Y;

and(Y, Gkj, Pik);

or(G, Gik, Y);

and(P, Pkj, Pik);

endmodule

module hijau(Gkj, Pik, Gik, G);

input Gkj, Pik, Gik;

output G;

wire Y;

and(Y, Gkj, Pik);

or(G, Y, Gik);

endmodule

module and_xor(a, b, p, g);

input a, b;

output p, g;

xor(p, a, b);

and(g, a, b);

endmodule


sebagai berikut:



3. Simulasi



Hasil simulasi




Gambar 19. Simulasi Fungsional dari Kogge Stone Adder



2. Simulasi Timing




Gambar 20. Simulasi Timing dari Kogge Stone Adder

Dari hasil diatas, terlihat ada delay yang terjadi pada setiap

perhitungan. Jika timing yang digunakan ketat,maka delay yang

dihasilkan akan sangat besar. Pada rancangan KSA 4 bit ini, critical

path yang terjadi adalah dari pin B(1) menuju Cout sebesar 11,079

ns, sedangkan logic element yang digunkan adalah 12.

Gambar 21. Summary dari logic utilization dan critical

path

3. Multiplier dengan algoritma Booth Radix-2

Background

Rangkaian pengali atau multiplier dapat diimplementasikan dengan berbagai

algoritma dari yang sederhana hingga yang paling kompleks seperti Grid, Long

Multiplication, Lattice multiplication dan Booth. Algoritma yang digunakan akan

mempengaruhi kecepatan perhitungan yang dilakukan. Penggunaan algoritma

yang tepat akan menghemat hardware dan membuat perhitungan menjadi

efisien.

Pada dasarnya proses perkalian melibatkan 2 input angka M-Bit X dan N-Bit Y

dan menghasilkan MxN bit Z.

∑

∑

∑ (∑

)

Output Z dihitung dengan menambahkan produk parsial secara bersama-sama.

Implementasi yang sederhana membutuhkan adder sejumlah N-bit dan

membutuhkan siklus siklus M kali untuk menghasilkan output. Beberapa

algoritma lainnya telah dikembangkan untuk meningkatkan kecepatan dan

mengurangi konsumsi daya multiplier. Ada dua pendekatan yang digunakan

secara umum yaitu algoritma booth dan Wallace Tree compressor.

Booth menggunakanmekanisme yang lebih cepat pada pergeseran(shifting)

daripada menambah sehingga menciptakan algoritma yang cepat dan efisien.

Pada Algoritma Booth, terjadi 2 operasi yang paling penting yaitu shift dan check

2 bit LSB. Kemudian algoritma ini diterapkan pada kode pemrograma Verilog:

1. Modul Shift dan Check kondisi 2 bit terakhir

//Shift dan check 8 bit

//MD = Multiplicand

//NMD = Negative Multiplicand

//MR = Multiplier

//SR = Shift Registers

module chkshift(MD, NMD, MR, OUT);

input [8:0] MD;

input [8:0] NMD;

input [8:0] MR;

output [8:0] OUT;

reg signed [8:0] SR;

always @(MR)

//Memeriksa 4 kondisi untuk melakukan

prnjumlahan/pengurangan atau tidak

case(MR[1:0])

2'b00 : SR=MR;

2'b01 : SR=MR+MD;

2'b10 : SR=MR+NMD;

2'b11 : SR=MR;

endcase

assign OUT = SR>>>1;

endmodule

2. Modul Gabungan

module gabung(A, B, MD, NMD, MR);

input [3:0] A;

input [3:0] B;

output[8:0]MD;

output[8:0]NMD;

output[8:0]MR;

wire [3:0] nA;

wire [8:0] MD;

wire [8:0] NMD;

wire [8:0] MR;

assign nA = (~A) + 1'b1;

assign MD = {A,4'h0,1'b0};

assign NMD = {nA,4'h0,1'b0};

assign MR = {4'h0,r,1'b0};

endmodule

3. Modul Utama Algoritma Booth

module booth_m(X, Y, Z);

input [3:0] X;

input [3:0] Y;

output[7:0]Z;

wire [7:0] Z;

wire [8:0] MD;

wire [8:0] NMD;

wire signed [8:0] P0;





gabung(.m(X), .r(Y), .MD(MD), .NMD(NMD),

.MR(P0));

chkshift(.MD(MD), .NMD(NMD), .MR(P0), .OUT(P1));




assign Z = P4[8:1];

endmodule


sebagai berikut:



6. Simulasi

3. Silmulasi Timing dan fungsional

4. Logic Utilization

Hasil simulasi




Gambar 22. Hasil Simulasi Fungsional dari Booth Multiplier

Gambar diatas menunjukkan bahwa operasi perkalian baik

bilangan positif maupaun negatif yang berjalan telah benar dan

valid sacara logic dan fungsional.

2. Simulasi Timing



mengakibatkan delay yang cukup besar. Hasil yang diperoleh

adalah:

Gambar 23. Hasil Simulasi Timing

Booth multiplier ini menggunakan 50 logic elemen atau 1% dari

yang tersedia pada board yang digunakan dalam simulasi.

Sedangkan critical path adalah pin dari XR menuju pin Z[5] yang

memiliki delay terpanjang sebesar 18,474 ns. Seperti pada

gambar dibawah ini.

Gambar 24. Summary dari logic utilization

Setelah melakukan rancangan multiplier ini, maka dapat dilihat bahwa

pemilihan algoritma yang tepat akan sangat meminimalisasi delay dan

memaksimalkan kecepatan serta menghemat memori dan disipasi

daya.

Referensi

1. http://en.wikipedia.org/wiki/Booth_encoding

2. Digital logic, VHDL design zvonko vranesic

http://en.wikipedia.org/wiki/Booth_encoding

Documents

Laporan VLSI