UTS VLSI for Digital Signal Processing

Jalu Reswara Wiradjanu – 23223020

1. Persamaan sebagai berikut:
𝑦(𝑘 ) = 𝑎𝑥 (𝑘 − 1) + 𝑏𝑥 (𝑘 − 2) + 𝑐𝑥(𝑘 − 3) + 𝑑𝑦(𝑘 − 2) + 𝑒𝑦(𝑘 − 3)
Dengan waktu komputasi perkalian 2ns dan penjumlahan 1ns.
Jawaban:
Representasi blok diagram, SFG, DFG, dan DG.
Berikut gambar diagram blok:

Bentuk IIR Filter Direct Form II

Bentuk IIR Filter Direct Form I

Gambar SFG:
Teknik menggambar SFG adalah memberi tanda terlebih dahulu Source Node & Sink Node
yang menjadi input dan output dari sistem. Setelah itu, setiap blok multiplier/delay disubstitusi
menjadi sebuah garis yang menghubungkan dua node. Setiap node di bawah ini merupakan
semacam titik penjumlahan dari data yang berasal dari node-node sebelumnya (arah flow data
ditandai dengan tanda panah).

SFG IIR Filter Direct Form II

SFG IIR Filter Direct Form I

Gambar DFG:
Teknik menggambar DFG adalah setiap blok komputasi (dalam kasus ini adder & multiplier)
dijadikan suatu node yang diberikan informasi berapa lama waktu komputasinya di node
tersebut. Arah panah menandakan flow data dan jika diantara dua node terdapat sebuah elemen
delay, jumlah elemen delay tersebut dicantumkan informasinya pada arah panah yang
menghubungkan dua node tersebut. Di diagram DFG tidak ditunjukkan dimana node input &
node outputnya. Oleh karena itu, untuk DFG pada Direct Form I, delay pada bagian input yang
memberikan x(n-1), x(n-2), dan x(n-3) tidak tampak. Tapi, delay-delay tersebut baru bisa
tampak jika dilakukan teknik retiming (pergeseran elemen delay).

Gambar DFG IIR Filter Direct Form II

Gambar DFG IIR Filter Direct Form I

Gambar DFG IIR Filter Direct Form I Retimed

Gambar DG:
Dalam DG, semua node merepresentasikan suatu bagian komputasi. Dalam kasus ini,
diasumsikan bahwa sinyal input x(k) hanya terdefinisi untuk 𝑘 ≥ 0 dimana x(k)=0 untuk 𝑘 <
0. Tinjau kembali persamaan awal
𝑦(𝑘 ) = 𝑎𝑥 (𝑘 − 1) + 𝑏𝑥 (𝑘 − 2) + 𝑐𝑥(𝑘 − 3) + 𝑑𝑦(𝑘 − 2) + 𝑒𝑦(𝑘 − 3)
𝑦(0) = 𝑎𝑥(−1) + 𝑏𝑥(−2) + 𝑐𝑥(−3) + 𝑑𝑦(−2) + 𝑒𝑦(−3) = 0
𝑦(1) = 𝑎𝑥(0) + 𝑏𝑥(−1) + 𝑐𝑥(−2) + 𝑑𝑦(−1) + 𝑒𝑦(−2) = 𝑎𝑥(0)
𝑦(2) = 𝑎𝑥(1) + 𝑏𝑥(0) + 𝑐𝑥(−1) + 𝑑𝑦(0) + 𝑒𝑦(−1) = 𝑎𝑥(1) + 𝑏𝑥(0)
𝑦(3) = 𝑎𝑥(2) + 𝑏𝑥(1) + 𝑐𝑥(0) + 𝑑𝑦(1) + 𝑒𝑦(0)
𝑦(4) = 𝑎𝑥(3) + 𝑏𝑥(2) + 𝑐𝑥(1) + 𝑑𝑦(2) + 𝑒𝑦(1)
Setelah dijabarkan di atas, dapat dilihat bahwa saat k=0 nilai y(0) adalah nol. Data baru muncul
saat k=1 dimana y(1) = ax(0). Dari DG yang dibuat, ax(0) direpresentasikan oleh bulatan hijau
dengan garis orange dan langsung mengarah ke y1. Setelah itu, y2 diperoleh dengan
menjumlahkan ax(1) dengan bx(0), hal ini ditunjukkan oleh lingkaran hitam dengan garis biru
yang ditandai oleh lingkaran merah dan mengarah ke y 2. Sebenarnya y2 juga membutuhkan
dy(0) namun berhubung y(0) bernilai 0 tidak ditunjukkan pada kasus ini.

Gambar DG IIR Filter

Untuk y(3) dan seterusnya, dibutuhkan 3 elemen dari x(k-j) dan dua elemen dari y(k-i). Misal,
pada y(3), dibutuhkan ax(2)+bx(1)+cx(0)+dy(1)+ey(0). Elemen dari x ditandai dengan buletan
hitam dengan outline merah dan elemen dari y ditandai dengan buletan hitam dengan outline
hijau. Ada garis putus-putus yang menandakan elemen tersebut seolah-olah di pindah sehingga
persis berada di garis x3y3 untuk dijumlahkan. Proses ini terus berlanjut namun tidak
digambarkan karena akan terlalu penuh gambarnya dan justru akan sulit melihatnya. Proses
menghitung y4 ditandai dengan pergeseran dari garis putus-putus berwarna hijau.
Gambar DG IIR Filter Lanjutan
Menghitung critical path, maksimum frequency, loop bound, iteration bound,
throughput
Berikut menghitung critical path? Critial path ditemukan dengan mengonsiderasi path dengan
waktu komputasi paling lama. Path dapat didefinisikan dengan jarak antara delay ke delay lain,
dari input ke elemen delay, atau dari elemen delay ke output. Dengan memanfaatkan DFG,
berikut adalah beberapa path yang ada di rangkaian tersebut:
- M1 → A2 membutuhkan 3ns
- M2 →A3 → A2 membutuhkan 4ns
- M3 →A4 → A1 membutuhkan 4ns
- M5 →A4 → A1 membutuhkan 4ns
1 1
Dari informasi di atas dapat disimpulkan bahwa T crit = 4ns sehingga fmax = = 4𝑛𝑠 =
𝑇𝑐𝑟𝑖𝑡
250𝑀𝐻𝑧. Bagaimana dengan throughput? Bila diasumsikan setiap data yang diproses
berukuran 1 byte, data masuk setiap satu clock cycle baru dan data output keluar setiap satu
clock juga (setelah ada latency sebanyak 3 clock) maka pada clock ke-4 setiap data baru yang
masuk akan memberikan satu data output yang baru juga. Oleh karena itu, throughputnya
adalah 250Mbyte/s.
Bagaimana dengan iteration bound? Dapat dicari menggunakan LPM (Longest Path Matrix)
atau dengan cara satu per satu dihitung. Untuk cara satu-per-satu, digunakan representasi
diagram blok sebagai berikut:

Loop didefinisikan sebagai suatu path yang mulai dan berakhir di node yang sama. Oleh karena
itu, di rangkaian di atas, terdapat empat buah loop
Menggunakan Longest Path Matrix. Mengonsiderasi blok diagram bentuk Direct Form II,
terdapat 3 buah elemen delay sehingga nilai 𝑑 = 3. Dibuat 3 matriks, 𝐿1 , 𝐿2 , 𝐿3 . Matriks L1
dibuat dengan mengisi elemennya dengan waktu komputasi yang dibutuhkan antara elemen
delay i ke elemen delay j yang melewati (m-1) delay. Untuk m=1 maka dibuat tanpa melewati
elemen delay terlebih dahulu. Matriks 𝐿(𝑚) untuk 𝑚 ≥ 2 dapat ditentukan menggunakan rumus
rekursif berikut:
( ) ( ) ( )
𝑙𝑖,𝑗𝑚+1 = max(−1, 𝑙𝑖,𝑘
1 𝑚
+ 𝑙𝑘,𝑗 ),𝑘 ∈ 𝐾
Berikut adalah hasilnya:
−1 0 −1
𝐿(1) = 4 −1 0
4 −1 −1
( )2 ( ) 2 ( )
2
𝑙1,1 =? 𝑙1,2 =? 𝑙1,3 =?
Dicari dari baris & kolom ke- ( 2 ) ( 1 ) ( 1 ) ( 2 ) ( 1 ) ( 1)
𝑙1,2 = 𝑙1,𝑘 + 𝑙𝑘,2 =? 𝑙1,3 = 𝑙1,𝑘 + 𝑙𝑘,3 =?
1 elemen yang tidak (-1). Hanya bisa untuk k=3 namun Tidak mungkin untuk k=1
Nilai k tidak bisa 3 karena l1,3 itu tetap (-1) sehingga dan k=3 sehingga k=2.
= -1. ( 2) (2 )
(2) ( 1) ( 1) 𝑙1,2 = −1 𝑙1,3 =0
𝑙1,1 = 𝑙1,2 + 𝑙2,1 = 4

( )
2 ( )
2 ( )
2
𝑙2,1 =? 𝑙2,2 =? 𝑙2,3 =?
( 2) ( 1) ( 1) ( 2) ( 1) ( 1) ( 2) ( 1) ( 1)
𝑙2,1 = 𝑙2,𝑘 + 𝑙𝑘,1 =? 𝑙2,2 = 𝑙2,𝑘 + 𝑙𝑘,2 =? 𝑙2,3 = 𝑙2,𝑘 + 𝑙𝑘,3 =?
Nilai k tidak mungkin k=1 Nilai k yang mungkin hanya Nilai k yang mungkin hanya
dan k=2 maka k=3. k=1 dan k=3. Untuk k=3 k=1 saja. Tapi bertemu (-1)
(2) ( 1) ( 1) ketemu (-1) sehingga k=1 (1)
𝑙2,1 = 𝑙2,3 + 𝑙3,1 = 4 untuk 𝑙1,3
(2 ) ( 1) ( 1)
𝑙2,2 = 𝑙2,1 + 𝑙1,2 = 4 (2)
𝑙2,3 = −1
( )
2 2 ( ) 2 ( )
𝑙3,1 =? 𝑙3,2 =? 𝑙3,3 =?
Nilai k yang mungkin hanya Nilai k yang mungkin hanya Nilai k yang mungkin adalah
k= 2 saja, tapi bertemu (-1) k=1 k=1,2. Dua pilihan k bertemu
sehingga ( 2 ) ( 1 ) ( 1 ) (-1) maka
𝑙3,2 = 𝑙3,1 + 𝑙1,2 = 4
( 2) ( 1) ( 1) ( 2) ( 1) ( 1)
𝑙3,1 = 𝑙3,𝑘 + 𝑙𝑘,1 = −1 𝑙3,3 = 𝑙3,𝑘 + 𝑙𝑘,3 = −1

Diperoleh matriks 𝐿(2) adalah sebagai berikut:

4 −1 0
𝐿(2) = 4 4 −1
−1 4 −1
Berikut adalah proses mencari matriks 𝐿(3) :
( )3 3( ) 3 ( )
𝑙1,1 =? 𝑙1,2 =? 𝑙1,3 =?
Yang hanya memenuhi ( 3 ) ( 2 ) ( 2 ) ( 3 ) ( 2 ) ( 2)
𝑙1,2 = 𝑙1,𝑘 + 𝑙𝑘,2 =? 𝑙1,3 = 𝑙1,𝑘 + 𝑙𝑘,3 =?
adalah k=1 Hanya bisa untuk k=3 Hanya bisa untuk k=1
(3) ( 2) ( 2)
𝑙1,1 = 𝑙1,𝑘 + 𝑙𝑘,1 =4 sehingga (2)
𝑙1,3 = −1
(3 ) ( 2) ( 2)
𝑙1,2 = 𝑙1,3 + 𝑙3,2 = 4
( )
3 ( )
3 ( )
3
𝑙2,1 =? 𝑙2,2 =? 𝑙2,3 =?
( )
3 ( )
2 2( ) 3 ( )
2 ( )
2 ( )3 2 ( )
2 ( ) ( )
𝑙2,1 = 𝑙2,𝑘 + 𝑙𝑘,1 =? 𝑙2,2 = 𝑙2,𝑘 + 𝑙𝑘,2 =? 𝑙2,3 = 𝑙2,𝑘 + 𝑙𝑘,3 =?
Hanya nilai k =1 yang Nilai k yang mungkin hanya Nilai k yang mungkin hanya
mungkin. k=2 k=1 saja. Tapi bertemu (-1)
(2) ( 1) ( 1) (2 ) ( 1) ( 1) (1)
𝑙2,1 = 𝑙2,1 + 𝑙1,1 = 8 𝑙2,2 = 𝑙2,2 + 𝑙2,2 = 4 untuk 𝑙1,3
(2 )
𝑙2,3 = 4
( )
3 ( )
3 ( )
3
𝑙3,1 =? 𝑙3,2 =? 𝑙3,3 =?
 Nilai k yang mungkin hanya Nilai k yang mungkin hanya Nilai k yang mungkin adalah
k= 2 saja. k=2 k=2. Tapi tetap bertemu -1
(3) ( 2) ( 2) ( 3) ( 2) ( 2) (3) (2) ( 2)
𝑙3,1 = 𝑙3,2 + 𝑙2,1 = 8 𝑙3,2 = 𝑙3,1 + 𝑙1,2 = −1 𝑙3,3 = 𝑙3,𝑘 + 𝑙𝑘,3 =4

Diperoleh matriks 𝐿3 sebagai berikut:

4 4 −1
𝐿(3) = 8 4 4
8 −1 4
Setelah diperoleh semua matriksnya, dihitung loop bound dengan persamaan berikut:

(𝑚)
𝑙𝑖,𝑖
𝑇∞ = max { }
𝑚∈{1,2,..,𝑑} 𝑚

Maka diperoleh untuk L2

4 4
𝑇∞ = { , } = 2𝑛𝑠
2 2
Maka diperoleh untuk L3
4 4 4
𝑇∞ = { , , } = 1.34𝑛𝑠
3 3 3
Maka berdasarkan rumus LPM diperoleh iteration/loop bound sebesar 2ns. Hal ini menandakan
bahwa masih bisa dilakukan optimasi sehingga waktu komputasi critical path hanya 2ns.
Mengubah arsitektur menjadi parallel
Mengubah menjadi arsitektur parallel dengan level parallelism L = 2. Hal ini membuat sinyal
awal 𝑥 (𝑘 ) menjadi sinyal 𝑥(2𝑘) dan 𝑥(2𝑘 − 1) atau 𝑥(2𝑘 + 1) (tidak ada bedanya). Intinya
adalah memisahkan data yang masuk menjadi even & odd time instances. Hal ini membuat
x(0) dan x(1) masuk bersamaan. Persamaan yang diperoleh menjadi:
𝑦(2𝑘 + 1) = 𝑎𝑥 (2𝑘 ) + 𝑏𝑥 (2𝑘 − 1) + 𝑐𝑥(2𝑘 − 2) + 𝑑𝑦(2𝑘 − 1) + 𝑒𝑦(2𝑘 − 2)
𝑦(2𝑘 ) = 𝑎𝑥 (2𝑘 − 1) + 𝑏𝑥 (2𝑘 − 2) + 𝑐𝑥(2𝑘 − 3) + 𝑑𝑦(2𝑘 − 2) + 𝑒𝑦(2𝑘 − 3)
𝑦(2𝑘 − 1) = 𝑎𝑥 (2𝑘 − 2) + 𝑏𝑥 (2𝑘 − 3) + 𝑐𝑥(2𝑘 − 4) + 𝑑𝑦(2𝑘 − 3) + 𝑒𝑦(2𝑘 − 4)
Diinginkan nantinya y(0) dan y(1) dapat keluar bersamaan. Dapat dilihat elemen yang
digunakan untuk menghitung y(0) muncul juga di y(1). Dapat dilihat untuk y(2k) dibutuhkan
1 elemen x(2k) dan y(2k) (kelipatan genap) masing-masing serta butuh 2 elemen x(2k-1) dan
1 elemen y(2k-1) (kelipatan ganjil). Hal ini menjadi dasar pembuatan arsitektur parallel yang
dibuat dimana beberapa elemen yang didapatkan dari rangkaian x(2k) dimasukkan ke
rangkaian x(2k-1) begitupula sebaliknya.
Arsitektur Parallel ini dikembangkan dari bentuk Direct Form I karena bentuk strukturnya lebih
simetris sehingga mudah di parallelkan.
 Gambar Direct Form I

Gambar Arsitektur Parallel dengan L = 2

Menghitung critical path, maksimum frequency, loop bound, iteration bound,

throughput arstiektur parallel
Critical Path untuk arsitektur parallel adalah 5 ns yang diperoleh dari 1 multiplier dan 3 adder.
Hal yang menarik adalah setelah diubah ke arsitektur parallel ada bagian rangkaian yang
critical pathnya sama seperti critical path arsitektur awal. Berdasarkan critical path tersebut,
1
diperoleh maximum frequency 𝑓_ max = = 𝟐𝟎𝟎𝑴𝑯𝒛. Berikut adalah critical path di
5𝑛𝑠
rangkaian:
Menghitung loop bound untuk arsitektur parallel tidak terlalu sulit karena pada bagian input
tidak terdapat loop. Loop hanya muncul pada bagian output karena di arsitektur yang saya buat
diasumsikan pada bagian inputnya dia seperti di broadcast sinyal x(2k) dan x(2k+1)nya
sehingga bisa dibuat dua rangkaian yang hampir mirip. Berikut adalah loop-bound yang
memberikan Tmax:

Gambar Path Loop Bound Maksimum di Arsitektur Parallel

4 𝑎𝑑𝑑𝑒𝑟+2 𝑚𝑢𝑙𝑡𝑖𝑝𝑙𝑖𝑒𝑟 4𝑛𝑠+4𝑛𝑠

Dari loop tersebut, diperoleh loop bound = = = 𝟒𝒏𝒔. Dapat
2 𝑒𝑙𝑒𝑚𝑒𝑛 𝑑𝑒𝑙𝑎𝑦 2
diperhatikan berhubung level parallel L = 2, loop bound arsitektur parallel adalah 2 kali loop
bound arsitektur originalnya. Hal ini sudah sesuai dengan apa yang diperoleh pada arsitektur
original (loop bound arsitektur original adalah 2ns).
Throughput sistem arsitektur parallel? Berhubung sekarang input yang masuk dua kali lebih
cepat, output dari sistem juga memberikan data output dua kali lebih cepat. Berdasarkan fakta
tersebut,throughput sistem naik menjadi dua kali throughput arsitektur awal.
Mengubah arsitektur menjadi pipelined
Mengubah arsitektur menjadi pipelined dengan menyisipkan registers/elemen delay pada
tahap-tahap tertentu sehingga menurunkan critical path. Diingat kembali dari rangkaian
pertama, berikut path-path yang menghasilkan critical path:
- M2 →A3 → A2 membutuhkan 4ns
- M3 →A4 → A1 membutuhkan 4ns
- M5 →A4 → A1 membutuhkan 4ns
Dari hasil perhitungan iteration bound, optimum critical path adalah 2ns. Hal ini memberikan
hint bahwa kita bisa menyisipkan register sehingga critical pathnya adalah 2ns. Hal itu bisa
dihasilkan dengan menyisipkan register setelah melakukan proses perkalian. Hal ini dilakukan
dua kali, yakni membuat cut-set pada bagian output dan bagian input. Berikut adalah before &
after:

Membuat Cutset untuk Pipeline

Arsitektur Pipelined
Menghitung critical path, maksimum frequency, loop bound, iteration bound,
throughput arsitektur pipeline.
Critical path pada arsitektur pipeline sekarang hanyalah satu proses perkalian yang memakan
waktu 2ns. Diperoleh 𝑇𝑐𝑟𝑖𝑡 = 2𝑛𝑠.
1 1
Frekuensi maksimum arsitektur pipelined sekarang adalah 𝑓𝑚𝑎𝑥 = 𝑇 = 2𝑛𝑠 = 500𝑀𝐻𝑧.
𝑐𝑟𝑖𝑡

Throughput rangkaian bisa dikatakan meningkat karena frekuensi clock maksimum meningkat
juga. Namun, tetap diasumsikan bahwa setelah data input sudah lengkap (setelah lewat masa
latency awal sebanyak 3-4 clock), rangkaian mampu mengeluarkan output baru setiap ada input
baru yang masuk. Oleh karena itu, throughput sekarang adalah 500Mbyte/sekon.
Apabila diasumsikan supply tegangan adalah 5V dan tegangan threshold adalah 0.5V. Berikut
adalah beberapa pertanyaan.
a. Berapa supply tegangan minimum agar struktur parallel dan pipeline dapat tetap bekerja?
Berlaku untuk setiap rangkaian, propagation delay 𝑇𝑝𝑑 yang berhubungan dengan charging dan
discharging capasitor di critical path dirumuskan sebagai berikut:
𝐶𝑐ℎ𝑎𝑟𝑔𝑒 𝑉0
𝑇𝑝𝑑 =
𝑘 (𝑉0 − 𝑉𝑡 )2
Untuk Pipeline:
𝑃𝑠𝑒𝑞 = 𝐶𝑡𝑜𝑡𝑎𝑙 𝑉02 𝑓1

Dimana f1 merupakan frekuensi maksimum saat belum diterapkan pipelining. Jumlah level
pipeline yang digunakan adalah M=2 karena critical path akhir setengah dari critical path awal.
𝐶𝑐ℎ𝑎𝑟𝑔𝑒
Alhasil, charging & discharging kapasitor menjadi dengan 𝐶𝑡𝑜𝑡𝑎𝑙 tetap sama.
2

Propagation delay arsitektur awal:

𝐶𝑐ℎ𝑎𝑟𝑔𝑒 𝑉0
𝑇𝑠𝑒𝑞 =
𝑘 (𝑉0 − 𝑉𝑡 )2
Propagation delay arsitektur pipelined:
𝐶𝑐ℎ𝑎𝑟𝑔𝑒
𝑇𝑝𝑖𝑝 = 2 𝛽𝑉0
𝑘 (𝛽𝑉0 − 𝑉𝑡 )2
Diperoleh
2(𝛽𝑉0 − 𝑉𝑡 )2 = 𝛽(𝑉0 − 𝑉𝑡 )2
Substitusi nilai Vt = 0.5V dan V0 = 5V diperoleh:
2(5𝛽 − 0.5)2 = 𝛽(4.5)2
Diperoleh dua nilai 𝛽1 = 0.017007 dan 𝛽2 = 0.588. Memilih nilai 𝛽1 membuat tegangan
input menjadi lebih rendah dari Vt sehingga tidak bisa mendrive rangkaian CMOS. Untuk itu,
dipilihlah 𝛽2 = 0.588 dan memberikan tegangan minimum yang membuat arsitektur pipelined
masih berjalan adalah 2.94V atau jika dibulatkan sekitar 𝑉0′ = 3𝑉.
Untuk Parallel:
Dalam kasus ini, level parallel adalah L = 2 dengan periode data input masuk menjadi
2𝑇𝑠𝑒𝑞 . Karena periode menjadi semakin besar, kapasitor memiliki waktu lebih lama untuk
charging dan discharging. Kembali menggunakan persamaan berikutnya diperoleh
𝐶𝑐ℎ𝑎𝑟𝑔𝑒 𝑉0
𝐿𝑇𝑠𝑒𝑞 =
𝑘 (𝛽𝑉0 − 𝑉𝑡 )2
Menyusun kembali persamaan, diperoleh
𝐿(𝛽𝑉0 − 𝑉𝑡 )2 = 𝛽(𝑉0 − 𝑉𝑡 )2
Substitusi nilai 𝐿 = 2, 𝑉0 = 5, 𝑉𝑡 = 0.5
2(5𝛽 − 0.5)2 = 𝛽(4.5)2
diperoleh nilai 𝛽1 dan 𝛽2 yang sama seperti pada kasus pipelined. Dipilih 𝛽 = 0.588 ≈ 0.6.
Maka, tegangan baru yang bisa diberikan kepada arsitektur parallel adalah 2.94𝑉 𝑎𝑡𝑎𝑢 3𝑉.
b. Hitung persentase pengurangan konsumsi power pada parallel dan pipeline?
Untuk Parallel & Pipeline:
Mencari penurunan power consumption dapat dilihat dengan membandingkan persamaan
𝑃𝑝𝑖𝑝 = 𝐶𝑡𝑜𝑡𝑎𝑙 𝑉02 𝛽2 𝑓 = 𝛽2 𝑃𝑠𝑒𝑞
𝑃𝑝𝑖𝑝
= 𝛽2
𝑃𝑠𝑒𝑞

Hal itu menunjukkan bahwa perbandingan antara konsumsi daya pada arsitektur pipelined
terhadap arsitektur awal sebesar 𝛽2 . Berhubung nilai 0 < 𝛽 < 1 haruslah 𝛽2 < 1 yang
mengimplikasikan 𝑃𝑝𝑖𝑝 < 𝑃𝑠𝑒𝑞 . Tapi, saya ingin menjawab persoalan ini dari dua sisi, yakni
sisi dimana frekuensi sistem dibuat tetap sama untuk yang pipelined & original dan sisi
dimana frekuensi pipeline dibuat lebih besar dibandingkan frekuensi sistem original.
Maka, penurunan konsumsi daya untuk arsitektur pipelined (frekuensi sistem tetap):
𝛽2 = 0.62 = 0.36
𝛽2 = 0.5882 = 0.345
Maka daya konsumsi arsitektur pipeline adalah 34.5% atau 36% (jika 𝛽 dibulatkan ke 0.6)
dari arsitektur original. Dapat disimpulkan bahwa besar penurunan konsumsi daya antara
arsitektur pipelined terhadap arsitektur awal adalah (100 − 34.5)% = 𝟔𝟓. 𝟓% atau (100 −
36)% = 𝟔𝟒%. Ini adalah jawaban untuk kasus dimana 𝒇𝒑𝒊𝒑 = 𝒇𝒔𝒆𝒒 .

Kasus untuk 𝑓𝑝𝑖𝑝 = 2𝑓𝑠𝑒𝑞 adalah sebagai berikut:

𝑃𝑝𝑖𝑝 𝐶𝑡𝑜𝑡𝑎𝑙 𝑉02 𝛽2 𝑓𝑝𝑖𝑝 𝛽2 2𝑓𝑠𝑒𝑞

= = = 2𝛽2 = 0.69
𝑃𝑠𝑒𝑞 𝐶𝑡𝑜𝑡𝑎𝑙 𝑉02 𝑓𝑠𝑒𝑞 𝑓𝑠𝑒𝑞
Jika frekuensi rangkaian pipelined dinaikkan menjadi dua kali frekuensi awal, konsumsi daya
yang dihasilkan adalah 69% atau 72% (jika dibulatkan nilai 𝛽-nya) dari daya arsitektur
originalnya. Oleh karena itu, besar penurunan dayanya hanya sekitar 31% atau 28%. Dapat
dilihat bahwa dengan memperbesar frekuensi rangkaian sangat mempengaruhi konsumsi daya
rangkaian tersebut.
Berhubung arsitektur Parallel dan Pipeline memiliki nilai 𝛽 yang sama, daya arsitektur parallel
adalah sekitar 𝟑𝟒. 𝟓% atau 𝟑𝟔% (jika dilakukan pembulatan) daya arsitektur awal. Oleh karena
itu diperoleh % penurunan konsumsi daya untuk parallel juga sekitar (100-34.5)% = 65.5%
atau (100-36)% = 64%.
 2. Persamaan sebagai berikut:
for k = 0 to 10,
𝒚(𝒌) = 𝒂 ∗ 𝒙(𝒌 − 𝟏) + 𝒃 ∗ 𝒙(𝒌 − 𝟐) + 𝒄 ∗ 𝒙(𝒌 − 𝟑) + 𝒅 ∗ 𝒚(𝒌 − 𝟐) + 𝒆 ∗ 𝒚(𝒌 − 𝟑)

end
Lakukan unfolding dengan factor J=6. Dengan perintah lanjutan sebagai berikut
a. Buat persamaan hasil unfolding
b. Buat blok diagram hasil unfolding
c. Hitung critical path system, loop bound, throughput dan frekuensi maksimum sebelum
dan sesudah unfolding
d. Buatlah Verilog code untuk persamaan awal dan unfolding. Tunjukan dari hasil
simulasi bahwa hasilnya adalah sama.
Jawab:
Membuat persamaan hasil unfolding dengan J=6.
Pertama-tama tinjau terlebih dahulu DFG dari sistem yang ingin di unfolding. Berikut gambar
untuk blok diagram dan DFG (yang sudah di mapping ke huruf kapital untuk setiap adder &
multiplier):
Dengan faktor J = 6, rule of thumb-nya adalah jumlah node pada DFG akhir adalah J kali node
DFG awal. Aturan dalam membuat Unfolding DFG adalah:
1. Untuk setiap node U di DFG original, gambarkan kembali sebanyak J kali node U0, U1,
…, UJ-1.
2. Untuk setiap edge dari 𝑈→𝑉 dengan sebuah delay sebanyak w di DFG original,
𝑖+𝑤
gambarkan sebanyak J edges dari 𝑈𝑖 → 𝑉(𝑖+𝑤)%𝐽 dengan jumlah delay sebanyak ⌊ ⌋
𝐽
untuk 𝑖 = 0,1, … , 𝐽 − 1
Berhubung terdapat 9 node di DFG original, DFG hasisl unfolding akan memiliki 9 × 6 = 54
node. Untuk menyamakan notasi, dilakukan mapping setiap adder & multiplier ke sebuah huruf
kapital sesuai tabel di bawah ini
Awal Hasil Mapping
M1 A
M2 B
M3 C
A1 D
A2 E
A3 F
A4 G
M4 H
M5 I

Bagian ABCDE tidak mengandung elemen delay sama sekali sehingga bentuk strukturnya
tetap sama seperti pada DFG original. Bagian FGHI memiliki beberapa elemen delay sehingga
harus mengimplementasikan algoitma tahap 2 (hanya untuk F → I dan F→ H saja).
Nilai i Node Awal → Akhir Algoritma Jumlah Delay
(𝑈𝑖 → 𝑉(𝑖+1)%6) 𝑖+1
⌊ ⌋
6
0 𝐹0 → 𝐻𝑥 𝐹0 → 𝐻1 0
1 𝐹1 → 𝐻𝑥 𝐹1 → 𝐻2 0
2 𝐹2 → 𝐻𝑥 𝐹2 → 𝐻3 0
3 𝐹3 → 𝐻𝑥 𝐹3 → 𝐻4 0
4 𝐹4 → 𝐻𝑥 𝐹4 → 𝐻5 0
 5 𝐹5 → 𝐻𝑥 𝐹5 → 𝐻0 1

Nilai i Node Awal → Akhir Algoritma Jumlah Delay

(𝑈𝑖 → 𝑉(𝑖+2)%6) 𝑖+2
⌊ ⌋
6
0 𝐹0 → 𝐼𝑥 𝐹0 → 𝐼2 0
1 𝐹1 → 𝐼𝑥 𝐹1 → 𝐼3 0
2 𝐹2 → 𝐼𝑥 𝐹2 → 𝐼4 0
3 𝐹3 → 𝐼𝑥 𝐹3 → 𝐼5 0
4 𝐹4 → 𝐼𝑥 𝐹4 → 𝐼0 0
5 𝐹5 → 𝐼𝑥 𝐹5 → 𝐼1 1

Persamaan awal:
𝒚(𝒏) = 𝒂 ∗ 𝒙(𝒏 − 𝟏) + 𝒃 ∗ 𝒙(𝒏 − 𝟐) + 𝒄 ∗ 𝒙(𝒏 − 𝟑) + 𝒅 ∗ 𝒚(𝒏 − 𝟐) + 𝒆 ∗ 𝒚(𝒏 − 𝟑)

maka setiap n diganti menjadi 6𝑘. Setelah itu, dibuat persamaan untuk y(6k), y(6k+1), y(6k+2),
…, y(6k+5). Berikut adalah setiap persamaan setelah diubah:
𝒚(𝟔𝒌) = 𝒂 ∗ 𝒙(𝟔𝒌 − 𝟏) + 𝒃 ∗ 𝒙(𝟔𝒌 − 𝟐) + 𝒄 ∗ 𝒙(𝟔𝒌 − 𝟑) + 𝒅 ∗ 𝒚(𝟔𝒌 − 𝟐) + 𝒆 ∗ 𝒚(𝟔𝒌 − 𝟑)

𝒚(𝟔𝒌 + 𝟏) = 𝒂 ∗ 𝒙(𝟔𝒌) + 𝒃 ∗ 𝒙(𝟔𝒌 − 𝟏) + 𝒄 ∗ 𝒙(𝟔𝒌 − 𝟐) + 𝒅 ∗ 𝒚(𝟔𝒌 − 𝟏) + 𝒆 ∗ 𝒚(𝟔𝒌 − 𝟐)

𝒚(𝟔𝒌 + 𝟐) = 𝒂 ∗ 𝒙(𝟔𝒌 + 𝟏) + 𝒃 ∗ 𝒙(𝟔𝒌) + 𝒄 ∗ 𝒙(𝟔𝒌 − 𝟏) + 𝒅 ∗ 𝒚(𝟔𝒌) + 𝒆 ∗ 𝒚(𝟔𝒌 − 𝟏)

𝒚(𝟔𝒌 + 𝟑) = 𝒂 ∗ 𝒙(𝟔𝒌 + 𝟐) + 𝒃 ∗ 𝒙(𝟔𝒌 + 𝟏) + 𝒄 ∗ 𝒙(𝟔𝒌) + 𝒅 ∗ 𝒚(𝟔𝒌 + 𝟏) + 𝒆 ∗ 𝒚(𝟔𝒌)

𝒚(𝟔𝒌 + 𝟒) = 𝒂 ∗ 𝒙(𝟔𝒌 + 𝟑) + 𝒃 ∗ 𝒙(𝟔𝒌 + 𝟐) + 𝒄 ∗ 𝒙(𝟔𝒌 + 𝟏) + 𝒅 ∗ 𝒚(𝟔𝒌 + 𝟐) + 𝒆 ∗ 𝒚(𝟔𝒌 + 𝟏)

𝒚(𝟔𝒌 + 𝟓) = 𝒂 ∗ 𝒙(𝟔𝒌 + 𝟒) + 𝒃 ∗ 𝒙(𝟔𝒌 + 𝟑) + 𝒄 ∗ 𝒙(𝟔𝒌 + 𝟐) + 𝒅 ∗ 𝒚(𝟔𝒌 + 𝟑) + 𝒆 ∗ 𝒚(𝟔𝒌 + 𝟐)

Merapihkan persamaan di atas berdasarkan faktor unfolding J =6 diperoleh:

𝒚(𝟔𝒌) = 𝒂 ∗ 𝒙(𝟔(𝒌 −)+) + 𝒃 ∗ 𝒙(𝟔(𝒌 − 𝟐)+) + 𝒄 ∗ 𝒙(𝟔(𝒌 − 𝟑)) + 𝒅 ∗ 𝒚(𝟔(𝒌 − 𝟐)) + 𝒆 ∗ 𝒚(𝟔(𝒌 − 𝟑))
Block Diagram hasil Unfolding:
Menghitung Critical Path, Loop Bound, Throughput, dan Max Frequency untuk sebelum &
sesudah unfolding
Kode Verilog Persamaan Awal

Kode Verilog Persamaan Unfolding

Bukti hasil simulasi dengan yang dikerjakan adalah sama:

 3. Persamaan sebagai berikut:
for k = 0 to 10,
𝑦(𝑘) = 𝑎 ∗ 𝑦(𝑘 − 2) + 𝑏 ∗ 𝑥(𝑘 − 1) + 𝑐 ∗ 𝑥(𝑘 − 2)
End
Lakukan unfold dengan factor 3. Kemudian lakukan retiming dengan retiming factor tertentu
atau cutset.
a. Buat blok diagram hasil retiming
b. Buktikan hasil retiming benar dengan simulasi verilog
c. Hitung critical path system, loop bound, throughput dan frekuensi maksimum sesudah
proses retiming
Jawab:
Gambar blok diagram awal dan DFG original dari sistem yang belum di unfolding:

Gambar Diagram Blok IIR Filter Direct Form I

Gambar SFG IIR Filter Origial

Lakukan proses unfolding dengan J=3 terlebih dahulu. Persamaan awal dengan N=11:
For k = 0 to N-1:
𝑦(𝑘 ) = 𝑎 ∗ 𝑦(𝑘 − 2) + 𝑏 ∗ 𝑥 (𝑘 − 1) + 𝑐 ∗ 𝑥 (𝑘 − 2)
Substitusi k = 3n karena faktor unfolding J=3 maka diperoleh:
For k = 0 to N/3-1:
 𝑦(3𝑛) = 𝑎 ∗ 𝑦(3𝑛 − 2) + 𝑏 ∗ 𝑥(3𝑛 − 1) + 𝑐 ∗ 𝑥 (3𝑛 − 2)
𝑦(3𝑛 + 1) = 𝑎 ∗ 𝑦(3𝑛 − 1) + 𝑏 ∗ 𝑥 (3𝑛) + 𝑐 ∗ 𝑥 (3𝑛 − 1)
𝑦(3𝑛 + 2) = 𝑎 ∗ 𝑦(3𝑛) + 𝑏 ∗ 𝑥 (3𝑛 + 1) + 𝑐 ∗ 𝑥 (3𝑛)
Membuat DFG untuk arsitektur unfolding dengan langkah-langkah berikut:
1. Mencopy seluruh node yang ada di DFG original menjadi sebanyak J kali.
2. Menghubungkan setiap node dari U → J.
Dilakukan mapping dari Multiplier & Adder menjadi huruf untuk mempermudah. Berikut
adalah mapping yang dilakukan:

Awal Hasil Mapping

M1 A
M2 B
A1 C
A2 D
A3 E
M3 F
 Gambar Arsitektur Unfolding J=3

Melakukan proses retiming dengan cutset dan pipelining untuk menurunkan critical path dari
arsitektur unfolding. Pertama, dicari terlebih dahulu critical path awal untuk arsitektur
unfolding. Terdapat banyak critical path yang mengandung 1 multiplier dan 2 adder yang
ditandai dengan gambar berikut:

Critical Path awal sistem yang didapat adalah 4 ns.

Sebelum melakukan proses retiming dengan memberikan faktor slowdown sebesar 3,
dilakukan terlebih dahulu penyusunan kembali elemen-elemen delay yang ada di arsitektur
unfolding untuk memperkecil critical path. Berikut adalah hasil penyusunan kembali elemen
delay (dengan menerapkan konsep percabangan delay):

Membuktikan prosedur retiming sudah benar dengan melakukan simulasi Verilog. Asumsi
sinyal awal x(k) punya 10 elemen bernilai {1,2,3,4,5,6,7,8,9,10}. Berikut adalah base-code
yang mengimplementasikan arsitektur sistem awal sebelum Unfolding:
`timescale 1ns / 1ps

module Pre_Unfolding(
input clock,
input reset,
input [7:0]Signal_In,
output reg [7:0]Signal_Out,
output reg [7:0]Signal_Out1,
output reg [7:0]Signal_Out2
);
//Wires for computation
//x_n1 is x(n-1), x_n2 is x(n-2), y_n1 is y(n-1) and y_n2 is y(n-2)
reg [7:0] x_1, x_2, x_3, y_1,y_2,y_3;
wire [7:0]x_n,x_n1,x_n2,y_n,y_n1,y_n2;
wire [7:0] temp_sum_2;
//Combinational Part
//This was the whole issue all along. If this line is commented, the
output is null.

assign x_n = Signal_In;

assign y_n = x_n1+x_n2+y_n2;
//Sequential Part, assume that abc are all 1's
always@(posedge clock) begin
if (reset) begin
y_1 <= 8'b0;
x_1 <= 8'b0;
x_2 <= 8'b0;
y_2 <= 8'b0;
y_3 <= 8'b0;
Signal_Out <=8'b0;
Signal_Out1 <=8'b0;
Signal_Out2 <=8'b0;
end else begin
Signal_Out <= y_n;
Signal_Out1 <=y_n1;
Signal_Out2 <=y_n2;
x_1 <= x_n1;
x_2 <= x_n2;
y_2 <= y_n1;
y_3 <= y_n2;
end
end

//Bagian Sekuensial menghubungkan wires untuk sinyal-sinyal x(n-1),x(n-2)

Delay_Element DE1
(.clock(clock),.reset(reset),.data_in(x_n),.data_out(x_n1));
Delay_Element DE2
(.clock(clock),.reset(reset),.data_in(x_n1),.data_out(x_n2));
 //Bagian Sekuensial menghubungkan wires untuk sinyal y(n-1) dan y(n-2)
Delay_Element DE3
(.clock(clock),.reset(reset),.data_in(y_n),.data_out(y_n1));
Delay_Element DE4
(.clock(clock),.reset(reset),.data_in(y_n1),.data_out(y_n2));
endmodule

Simulasi sebelum Unfolding menggunakan kode Testbench yang dapat dilihat pada bagian
Lampiran (terdapat kode pendukung Element Delay juga). Berikut adalah hasil simulasinya
untuk arsitektur sebelum unfolding:

Berikut adalah code Verilog untuk arsitektur setelah dilakukan Unfolding J=3
`timescale 1ns / 1ps

module Unfolding(
input clock,
input reset,
//Deklarasi untuk x(3k), x(3k+1), dan x(3k+2)
input [7:0]Signal_In_1,
input [7:0]Signal_In_2,
input [7:0]Signal_In_3,
//Deklarasi untuk y(3k), y(3k+1), dan y(3k+2)
output reg [7:0]Signal_Out1,
output reg [7:0]Signal_Out2,
output reg [7:0]Signal_Out3
);
//Wires for computation
//x_3k itu x_3n, x_3k-1 itu x_n31, x_3k-2 itu x_n32
// y_3k itu y_3n y_3k-1 itu y_n31, y_3k-2 itu y_n32
wire [7:0]x_3n,x_n31,x_n32,y_3n,y_n31,y_n32;
//Khusus untuk sinyal x_3k+1, x_3k+2, y_3k+1 dan y_3k+2
wire [7:0]x_3n_plus_1, x_3n_plus_2, y_3n_plus_1,y_3n_plus_2;

//Combinational Part

// Bagian membuat sinyal y_3n

// y(3k) = ay(3k-2)+bx(3k-1)+cx(3k-2)
assign y_3n = y_n32+x_n31+x_n32;
// Bagian membuat sinyal y_3n+1
assign y_3n_plus_1 = y_n31+x_3n+x_n31;
//Bagian membuat sinyal y_3n+2
assign y_3n_plus_2 = y_3n+x_3n_plus_1+x_3n;
//Assume all coefficients are 1.

//Connecting the input wires and the output wires

assign x_3n = Signal_In1;
assign x_3n_plus_1 = Signal_In_2;
assign x_3n_plus_2 = Signal_In_3;

//Sequential Part, assume that abc are all 1's

always@(posedge clock) begin
if (reset) begin
Signal_Out <=8'b0;
 Signal_Out1 <=8'b0;
Signal_Out2 <=8'b0;
end else begin
Signal_Out1 <= y_3n;
Signal_Out2 <=y_3n_plus_1;
Signal_Out3 <=y_3n_plus_2;
end
end

//Bagian Sekuensial menghubungkan wires untuk sinyal-sinyal x(n-1),x(n-2)

Delay_Element DE1
(.clock(clock),.reset(reset),.data_in(x_3n_plus_1),.data_out(x_n32));
Delay_Element DE2
(.clock(clock),.reset(reset),.data_in(x_3n_plus_2),.data_out(x_n31));
//Bagian Sekuensial menghubungkan wires untuk sinyal y(n-1) dan y(n-2)
Delay_Element DE3
(.clock(clock),.reset(reset),.data_in(y_3n_plus_2),.data_out(y_n31));
Delay_Element DE4
(.clock(clock),.reset(reset),.data_in(y_3n_plus_1),.data_out(y_n32));
endmodule

Berikut adalah hasil simulasi untuk arsitektur Unfolding yang belum dilakukan retiming &
pipelining (menggunakan test vector sinyal x(k) yang sama) :

Berikut adalah code Verilog untuk arsitektur Unfolding yang sudah dilakukan retiming

Simulasi setelah Unfolding menggunakan kode Testbench yang sama dan berikut adalah hasil
simulasinya:
 LAMPIRAN
Testbench Unfolding Nomor 3 (Pre-Unfolding)
`timescale 1ns / 1ps

module Testbench;
reg clock;
reg reset;
reg [7:0] Signal_In;
wire [7:0] Signal_Out,Signal_Out1,Signal_Out2;

// Instantiate the module under test

Pre_Unfolding dut (
.clock(clock),
.reset(reset),
.Signal_In(Signal_In),
.Signal_Out(Signal_Out),
.Signal_Out1(Signal_Out1),
.Signal_Out2(Signal_Out2)
);

// Clock generation
always begin
#5 clock = ~clock;
end

// Reset generation (active high)

initial begin
clock = 0;
reset = 1;
#10 reset = 0;
end

// Apply input signal with values 1 to 10

initial begin
Signal_In = 8'b00000001;
#10;
Signal_In = 8'b00000010;
#10;
Signal_In = 8'b00000011;
#10;
Signal_In = 8'b00000100;
#10;
Signal_In = 8'b00000101;
#10;
Signal_In = 8'b00000110;
#10;
Signal_In = 8'b00000111;
#10;
Signal_In = 8'b00001000;
#10;
Signal_In = 8'b00001001;
#10;
Signal_In = 8'b00001010;
#10;
end

endmodule

Testbench Unfolding Nomor 3

Testbench Unfolding Nomor 2