Bab 3. Simulasi dengan NS-2

Bab 3. Simulasi dengan NS-2
NS simulator adalah perangkat lunak untuk kebutuhan simulasi aplikasi, protokol, tipe jaringan ,
elemen-elemen jaringan, pemodelan jaringan dan pemodelan lalu-lintas jaringan. Pada intinya
perangkat lunak ini didesain dan dikembangakan untuk kebutuhan penelitian jaringan.
Perangkat lunak ini bersifat open source dan seringkali disebut sebagai NS-2, dan dapat di
download di alamat situs http://isi.edu/nsnam/ns/.
NS simulator menggunakan dua buah bahasa pemrograman standar, yaitu simulator
berorientasi obyek yang ditulis dalam C++ dan OTcl (object oriented extension of Tcl) untuk
eksekusi terhadap perintah-perintah yang ditulis sebagai script dari NS-2.
3.1.
Pemrograman Tcl dan Otcl
Tcl (Tool Command Language) adalah salah satu bahasa pemrograman yang digunakan
oleh jutaan orang karena memiliki sintaks yang sangat mudah dan mudah diintegrasikan
dengan bahasa yang lain. Bahasa pemrograman Tcl ini dibuat pertama kali oleh Jhon
Ousterhout.
Beberapa dasar dari sintaks bahasa pemgrograman Tcl dan Otcl adalah sebagai berikut:
•
Mengisikan sebuah nilai pada sebuah variabel dilakukan dengan menggunakan
perintah ‘set’.
Misalnya: mengisikan nilai 0 ke dalam variabel b.
set b 0
•
Mengisikan nilai dari suatu variabel ke dalam variabel yang lain dilakukan
dengan menggunakan simbol $.
Misalnya: mengisikan nilai yang ada dalam variabel b ke dalam variabel x.
set x $b
•
Operasi matematika dilakukan dengan menggunakan perintah ‘expr’.
Misalnya: mengisikan nilai penjumlahan dari variabel a dan b ke dalam variabel
x.
x [expr $a + $b]
•
Dalam Tcl sebuah variabel dapat berisi string, integer bilangan real tergantung
pada nilai yang kita masukkan. Misalkan kita menuliskan x [expr 1/50],
maka hasilnya akan 0. Tetapi apabila kita menuliskan x [expr 1.0/50.0]
maka hasilnya akan berupa bilangan real.
•
Tanda # digunakan sebagai tanda baris untuk komentar, karena baris yang
memiliki tanda # di bagian awal maka baris tersebut tidak akan dieksekusi.
•
Untuk membuat sebuah file, pertama-tama kita menentukan sebuah file yang
akan digunakan misalkan ‘namafile’, dan menandai sebuah variabel misalnya
‘file1’ untuk pointer yang akan digunakan oleh Tcl menghubungkan ke file
‘namafile’.
Misalkan:
set file1 [open namafile w]
•
Untuk menampilkan hasil operasi dilakukan dengan menggunakan perintah
‘puts’. Setiap kali perintah ini dieksekusi maka secara otomatis perintah ini akan
menggeser tampilan berikutnya pada baris di bawahnya. Untuk menghindari
pembuatan baris baru tambahkan perintah –nonewline setelah perintah
puts. Penulisan di file dilakukan dengan perintah puts $file1 “text”.
•
Eksekusi terhadap perintah-perintah UNIX dilakukan dengan menggunakan
‘exec’.
Misalnya: kita ingin memerintahkan NS untuk menggambarkan kurva yang
datanya terletak dalam file bernama ‘data’.
Exec xgraph data &
Tanda & adalah simbol agar eksekusi dilakukan sebagai background.
•
Struktur percabangan dituliskan sebagai berikut:
if { ekspresi } {
<beberapa perintah>
} else {
<beberapa perintah>
}
Untuk melakukan pengujian kesamaan dalam ekspresi gunakan simbol “==”,
sedangkan ketidaksamaan menggunakan simbol “!=”.
•
Proses looping dapat dilakukan dengan cara seperti di bawah ini:
for { set i 0 } {$i < 8} { incr i } {
<beberapa perintah>
}
•
Prosedur dapat dibuat dalam tcl dengan bentuk seperti dibawah ini:
proc kuadrat { par1 par2 ...} {
global var1 var2
<perintah>
return $sesuatu
}
Prosedur menerima parameter dapat berupa object, file atau variabel. Dalam
contoh di atas adalah par1 dan par2. Perintah ‘global’ digunakan untuk
mendeklarasikan variabel sebagai variabel ekternal, artinya variabel tersebut
dapat dieksekusi dari luar prosedur, dalam contoh di atas adalah variabel var1
dan var2.
3.2.
Inisialisasi dan Terminasi
Simulasi dengan menggunakan NS selalu dimulai dengan mendefinisikan sebuah variabel
atau object sebagai instance dari kelas Simulator dengan cara sebagai berikut:
set ns [new Simulator]
Variabel ns dalam perintah diatas dapat diganti dengan nama lain, tetapi secara umum
orang menggunakan variabel dengan nama ns seperti di atas.
Untuk menyimpan data keluaran hasil dari simulasi (trace files) dan juga sebuah file lagi
untuk kebutuhan visualisasi (nam files) akan dibuat dua buah file dengan perintah
“open” seperti berikut:
#Buka trace files
set tracefile1 [open out.tr w]
$ns trace-all $tracefile1
#Buka NAM trace files
set namfile [open out.nam w]
$ns namtrace-all $namfile
Skrip di atas akan membuat file out.tr yang akan digunakan untuk menyimpan data
hasil simulasi dan file out.nam untuk menyimpan data hasil visualisasi. Deklarasi ‘w’
pada bagian akhir dari perintah open adalah perintah tulis.
Selanjutnya terminasi terhadap program dilakukan dengan cara mendeklarasikan
prosedur “finish” seperti di bawah ini:
#Mendefiniskan prosedur ‘finish’
proc finish {} {
global ns tracefile1 namfile
$ns flush-trace
close $tracefile1
close $namfile
exec nam out.nam &
exit 0
}
Perhatikan bahwa prosedur tersebut menggunakan variabel global ns, tracefile1
dan namfile. Perintah flush-trace digunakan untuk menyimpan semua data hasil
simulasi ke dalam file tracefile1 dan namfile. Perintah exit akan mengakhiri
aplikasi dan mengembalikan status dengan angka 0 kepada sistem. Perintah exit 0
adalah perintah default untuk membersihkan memori dari sistem, nilai yang lain dapat
gunakan untuk misalnya untuk memberikan status gagal.
Pada bagian akhir dari program, prosedur ‘finish’ harus dipanggil dengan indikasi waktu
(dalam detik) terminasi dari program, misalnya
$ns at 100.0 “finish”
Selanjutnya untuk memulai simulasi atau menjalankan program dapat dilakukan dengan
menggunakan perintah:
$ns run
3.3.
Membuat node dan link
Mendefiniskan sebuah node pada NS pada dasarnya adalah membuat sebuah variabel,
sebagai contoh:
set n0 [$ns node]
Selanjutnya untuk menggunakan node n0 dilakukan dengan cara memanggil variabel
$n0. Demikian pula node-node yang lain dapat dibuat dengan cara yang sama sesuai
dengan kebutuhan dalam simulasi, seperti:
set n1 [$ns node]
set n2 [$ns node]
Setelah node terbuat, maka langkah selanjutnya adalah membuat link yang akan
membuat hubungan antar node. Sebuah link untuk menghubungkan node $n0 dan $n2
dengan bi-directional link berkapasitas 10 Mb dan dengan waktu tunda akibat propagasi
sebesar 10ms dapat dibuat dengan cara seperti di bawah ini:
$ns duplex-link $n0 $n2 10Mb 10ms DropTail
Apabila diinginkan sebuah link satu arah maka dapat gunakan perintah “simplexlink” untuk menggantikan “duplex-link”.
Pada NS, antrian keluaran dari sebuah node didefiniskan sebagai bagian dari sebuah link,
karena itu kita perlu mendefinisikan karakteristik dari queue ini apabila terjadi lebihan
data yang datang pada sebuah node. Opsi “DropTail” berarti bahwa data terakhir yang
datang akan dibuang apabila kapasitas dari memori telah penuh. Alternatif lain untuk
opsi ini antara lain:
•
RED (random early discard),
•
FQ (fair queueing),
•
DRR (deficit round robin),
•
SFQ (stochastic fair queueing), dan
•
CBQ (memasukkan prioritas dan round-robin).
Karena link dianggap memiliki memori (buffer) maka kita perlu mendefiniskan kapasitas
antrian dari link sebagai berikut:
#Melakukan setting ukuran memori pada link n2-n3 sebesar 15
$ns queue-limit $n2 $n3 15
Sebagai contoh mari kita membangun simulasi jaringan sederhana dengan diagram
seperti dibawah ini:
$n0
1Mbps
8ms
$n2
1Mbps
10ms
250kbps
100ms
250kbps
100ms
$n4
600kbps
50ms
$n3
600kbps
40ms
$n5
$n1
Gambar 3.1. Jaringan sederhana untuk simulasi NS
Maka secara keseluruhan skrip NS untuk jaringan di atas adalah sebagai berikut:
#Skrip 1.
#membuat 6 buah node
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]
#membuat link antar node
$ns duplex-link $n0 $n2 1Mb 8ms DropTail
$ns duplex-link $n1 $n2 1Mb 10ms DropTail
$ns simplex-link $n2 $n3 0.25Mb 100ms DropTail
$ns simplex-link $n3 $n2 0.25Mb 100ms DropTail
$ns duplex-link $n3 $n4 0.6Mb 50ms DropTail
$ns duplex-link $n3 $n5 0.6Mb 40ms DropTail
#Melakukan setting ukuran memori pada link n2-n3 sebesar 15
$ns queue-limit $n2 $n3 15
3.4.
Menggabungkan aplikasi dalam simulasi
Setelah mendefinisikan topologi dari jaringan Internet yang akan kita simulasikan maka
langkah selanjutnya adalah membuat simulasi lalu lintas data yang akan melewati
jaringan. Karena itu kita perlu mendefinisikan proses routing (menentukan mana tujuan
dan sumber), protokol yang akan digunakan beserta aplikasinya. Berikut ini kita akan
melihat bagaimana mendefinisikan aplikasi FTP yang berjalan di atas protokol TCP.
3.4.1. File Transfer Protocol (FTP)
Sebagaimana telah kita pelajari dalam bab sebelumnya TCP adalah protokol yang
mengutamakan reliabilitas dalam pengiriman data, baik melalui mekanisme congestion
contol, flow control dan error control. Karena setiap kali pengiriman data TCP
membutuhkan konfirmasi dalam bentuk acknkowledgment, maka jelas terlihat di sini
bahwa TCP membutuhkan link yang bersifat dua arah (bidirectional link). NS-2
mendukung berbagai variasi dari TCP, antara lain: Tahoe, Reno, Newreno, dan Vegas.
Untuk mendefinisikan jenis protokol yang akan digunakan NS-2 menggunakan perintah
berikut ini:
set tcp [new Agent/TCP]
Selanjutnya untuk menggabungkan protokol ini pada sebuah node, dalam hal ini
misalnya node n0 digunakan perintah:
$ns attach-agent $n0 $tcp
Tujuan akhir dari mengalirnya aplikasi TCP didefinisikan dengan pointer yang disebut
dengan sink sebagai berikut:
set sink [new Agent/TCPSink]
Salah satu tugas node akhir ini adalah membangkitkan segment acknowledgment
sebagaimana telah kita pelajari pada mekanisme pengiriman data pada TCP.
Untuk menggabungkan tujuan akhir dari aliran data ke salah satu node, misalnya kita
ambil node n4, digunakan perintah:
$ns attach-agent $n4 $sink
Koneksi antara sumber dan tujuan akhir selanjutnya didefiniskan dengan:
$ns connect $tcp $sink
Ukuran dari paket TCP secara default adalah 1000 bytes, tetapi NS memungkinkan kita
mengubah ukuran dari paket TCP dengan nilai yang lain, misalkan kita inginkan ukuran
paket sebesar 552 bytes, maka definisi untuk ukuran paket di dalam skrip NS adalah:
$tcp set packetSize_ 552
Karena TCP mampu mengalirkan beberapa aplikasi dengan menggunakan konsep
multiplexing dan demultiplexing, maka kita tahu bahwa akan ada beberapa aliran data di
dalam link yang telah kita bangun. Untuk membedakan aliran satu dengan yang lain
dibutuhkan sesuatu sebagai identifikasi bagi masing-masing aliran data. Pemberian
identitas pada aplikasi TCP dilakukan dengan memberikan perintah berikut:
$tcp set fid_ 1
Langkah terakhir adalah menentukan jenis aplikasi dan menggabungkan dengan
protokol TCP yang telah kita definisikan sebagai berikut:
#Menggabungkan aplikasi FTP pada protokol TCP
set ftp [new Application/FTP]
$ftp attach-agent $tcp
Secara keseluruhan penentuan protokkol dan aplikasi pada skrip adalah sebagai berikut:
#Membentuk koneksi melalui protokol TCP
set tcp [new Agent/TCP]
$ns attach-agent $n0 $tcp
set sink [new Agent/TCPSink]
$ns attach-agent $n4 $sink
$ns connect $tcp $sink
$tcp set packetSize_ 552
$tcp set fid_ 1
#Menggabungkan aplikasi FTP pada protokol TCP
set ftp [new Application/FTP]
$ftp attach-agent $tcp
3.5.
Mengatur jadwal eksekusi pada skrip
Karena NS merupakan simulator kejadian diskrit, maka skrip yang telah dibuat dengan
Tcl perlu mendefinisikan waktu eksekusi dari setiap kejadian. Setiap kejadian pada skrip
Tcl dapat didefinisikan dengan perintah
$ns at <waktu> <kejadian>
Misalnya untuk menentukan kapan aplikasi FTP mulai mengirimkan data dan kapan
selesai mengirimkan data digunakan perintah berikut:
$ns at 0.2 “ftp start”
$ns at 10.0 “ftp stop”
Dengan menggunakan perintah tersebut di atas, aplikasi FTP akan mulai berjalan pada
detik ke 0.2 dan berhenti pada detik ke 10.0.
3.6.
Menjalankan skrip pada NS-2 simulator
Sekarang mari kita letakkan semua skrip di atas dalam sebuah file contoh1.tcl seperti
berikut:
#file contoh1.tcl
set ns [new Simulator]
#Mendefinisikan warna untuk aliran data dalam NAM
$ns color 1 Blue
$ns color 2 Red
#Buka trace files
set tracefile1 [open out.tr w]
$ns trace-all $tracefile1
#Buka NAM trace files
set namfile [open out.nam w]
$ns namtrace-all $namfile
#Mendefiniskan prosedur ‘finish’
proc finish {} {
global ns tracefile1 namfile
$ns flush-trace
close $tracefile1
close $namfile
exec nam out.nam &
exit 0
}
#membuat 6 buah node
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]
#membuat link antar node
$ns duplex-link $n0 $n2 1Mb 8ms DropTail
$ns duplex-link $n1 $n2 1Mb 10ms DropTail
$ns simplex-link $n2 $n3 0.25Mb 100ms DropTail
$ns simplex-link $n3 $n2 0.25Mb 100ms DropTail
$ns duplex-link $n3 $n4 0.6Mb 50ms DropTail
$ns duplex-link $n3 $n5 0.6Mb 40ms DropTail
#menentukan posisi node pada NAM (Network Animator)
$ns duplex-link-op $n0 $n2 orient right-down
$ns duplex-link-op $n1 $n2 orient right-up
$ns simplex-link-op $n2 $n3 orient right
$ns simplex-link-op $n3 $n2 orient left
$ns duplex-link-op $n3 $n4 orient right-up
$ns duplex-link-op $n3 $n5 orient right-down
#Melakukan setting ukuran memori pada link n2-n3 sebesar 15
$ns queue-limit $n2 $n3 15
#Membentuk koneksi melalui protokol TCP
set tcp [new Agent/TCP]
$ns attach-agent $n0 $tcp
set sink [new Agent/TCPSink]
$ns attach-agent $n4 $sink
$ns connect $tcp $sink
$tcp set packetSize_ 552
$tcp set fid_ 1
#Menggabungkan aplikasi FTP pada protokol TCP
set ftp [new Application/FTP]
$ftp attach-agent $tcp
$ns at 0.2 “ftp start”
$ns at 9.6 “ftp stop”
$ns at 10.0 “finish”
$ns run
Setelah menyimpan file contoh1.tcl pada home direktori, selanjutnya eksekusi untuk
menjalankan skrip contoh1.tcl pada NS simulator dilakukan dengan mengetikkan
ns contoh1.tcl
pada command prompt. Proses simulasi ditampilkan dengan menggunakan Network
Animator (NAM) seperti terlihat dalam Gambar 3.2.
Gambar 3.2. Tampilan NAM untuk skrip contoh1.tcl
3.7.
UDP
Protokol TCP menghasilkan lalu lintas data yang bersifat bursty. Hal ini terutama
disebabkan karena adanya congestion control pada TCP. Apabila TCP mengenalinya
masih ada banyak bandwidth tersisa di dalam sebuah jalur, maka TCP akan
meningkatkan lebar dari congestion window sampai terdeteksi adanya kongesi. Apabila
TCP mendeteksi adanya kongesi di dalam sebuah jalur maka TCP akan menurunkan lebar
dari congestion window menjadi setengahnya atau sampai minimum menjadi 1 MSS
saja. Lihat kembali pada sub-Bab 2.1.7. Sebagaimana kita ketahui, ukuran dari
congestion window ini berasosiasi dengan kecepatan atau throughput dari jalur. Karena
itu apabila congestion window menjadi lebar kecepatan pengiriman data akan
meningkat, sebaliknya apabila ukuran congestion window mengecil maka kecepatan
data akan turun. Dengan demikian lalu-lintas data pada TCP terihat bursty.
Sebaliknya pada UDP lalu lintas data tidak bursty melainkan cenderung konstan karena
protokol UDP tidak memiliki congestion control. Karena itu pada dasarnya protokol UDP
tidak memiliki batasan kecepatan pengiriman data, kecepatan pengiriman data akan
linier dengan ketersediaan bandwidth yang ada pada jalur komunikasi.
Pada bagian ini kita akan membuat simulasi protokol UDP pada NS-2 dengan
menggunakan aplikasi Contant Bit Rate (CBR). Aplikasi CBR ini mewakili aplikasi-aplikasi
praktis semacam Voice over IP (VoIP) pada jaringan Internet.
Dengan menggunakan diagram jaringan sebagaimana halnya pada Gambar 3.1, protokol
UDP dengan aplikasi CBR akan mengalir dari node 1 ke node 5. Definisi dari node 1
sebagai sumber dilakukan dengan cara:
set udp [new Agent/UDP]
$ns attach-agent $n1 $udp
Sedangkan definisi node 5 sebagai tujuan akhir dari data adalah sebagai berikut:
set null [new Agent/Null]
$ns attach-agent $n5 $null
Berikutnya kita membuat koneksi antara sumber dan tujuan, serta memberikan
identikasi untuk aliran data UDP sebagai berikut:
$ns connect $udp $null
$udp set fid_ 2
Sekarang mari kita definisikan aplikasi CBR dan melekatkan aplikasi ini pada protokol
UDP. Aplikasi CBR didefinisikan dengan cara:
set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp
Baris kedua dari perintah di atas berfungsi untuk melekatkan aplikasi CBR pada protokol
UDP. Mari kita asumsikan untuk aplikasi ini memiliki ukuran paket sebesar 1000 byte
dan dengan kecepatan pengiriman data sebesar 0.01 Mbps.
$cbr set packetSize_ 1000
$cbr set rate_ 0.01Mb
Karakteristik lain dari CBR adalah adanya sebuah flag random_ untuk mengindikasikan
adanya random noise pada proses transmisi atau tidak. Kita asumsikan tidak ada random
noise, maka:
$cbr set random_ false
Secara keseluruhan, perintah-perintah untuk mendefinisikan protokol UDP dan aplikasi
CBR ditunjukkan dalam skrip berikut ini:
#Membentuk koneksi melalui protokol UDP
set udp [new Agent/UDP]
$ns attach-agent $n1 $udp
set null [new Agent/Null]
$ns attach-agent $n5 $null
$ns connect $udp $null
$udp set fid_ 2
#Menggabungkan aplikasi CBR pada protokol UDP
set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp
$cbr set packetSize_ 1000
$cbr set rate_ 0.01Mb
$cbr set random_ false
Selanjutnya mari kita insert kan skrip aplikasi CBR pada protokol UDP ini pada skrip
contoh1.tcl dilengkapi dengan penentuan waktu aplikasi CBR mulai mengirimkan data.
Skrip ini juga dilengkapi dengan kemampuan untuk menulis file WinFile yang berisi
informasi tentang fluktuasi ukuran dari congestion window pada pada protokol TCP.
#file contoh1.tcl
set ns [new Simulator]
#Mendefinisikan warna untuk aliran data dalam NAM
$ns color 1 Blue
$ns color 2 Red
#Buka trace files
set tracefile1 [open out.tr w]
$ns trace-all $tracefile1
#Buka winfile file
set winfile [open WinFile w]
#Buka NAM trace files
set namfile [open out.nam w]
$ns namtrace-all $namfile
#Mendefiniskan prosedur ‘finish’
proc finish {} {
global ns tracefile1 namfile
$ns flush-trace
close $tracefile1
close $namfile
exec nam out.nam &
exit 0
}
#membuat 6 buah node
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]
#membuat link antar node
$ns duplex-link $n0 $n2 1Mb 8ms DropTail
$ns duplex-link $n1 $n2 1Mb 10ms DropTail
$ns simplex-link $n2 $n3 0.25Mb 100ms DropTail
$ns simplex-link $n3 $n2 0.25Mb 100ms DropTail
$ns duplex-link $n3 $n4 0.6Mb 50ms DropTail
$ns duplex-link $n3 $n5 0.6Mb 40ms DropTail
#menentukan posisi node pada NAM (Network Animator)
$ns duplex-link-op $n0 $n2 orient right-down
$ns duplex-link-op $n1 $n2 orient right-up
$ns simplex-link-op $n2 $n3 orient right
$ns simplex-link-op $n3 $n2 orient left
$ns duplex-link-op $n3 $n4 orient right-up
$ns duplex-link-op $n3 $n5 orient right-down
#Melakukan setting ukuran memori pada link n2-n3 sebesar 10
$ns queue-limit $n2 $n3 10
#Membentuk koneksi melalui protokol TCP
set tcp [new Agent/TCP]
$ns attach-agent $n0 $tcp
set sink [new Agent/TCPSink]
$ns attach-agent $n4 $sink
$ns connect $tcp $sink
$tcp set packetSize_ 552
$tcp set fid_ 1
#Menggabungkan aplikasi FTP pada protokol TCP
set ftp [new Application/FTP]
$ftp attach-agent $tcp
#Membentuk koneksi melalui protokol UDP
set udp [new Agent/UDP]
$ns attach-agent $n1 $udp
set null [new Agent/Null]
$ns attach-agent $n5 $null
$ns connect $udp $null
$udp set fid_ 2
#Menggabungkan aplikasi CBR pada protokol UDP
set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp
$cbr set packetSize_ 1000
$cbr set rate_ 0.01Mb
$cbr set random_ false
$ns at 0.2 “$cbr start”
$ns at 1.0 “$ftp start”
$ns at 9.6 “$cbr stop”
$ns at 9.8 “$ftp stop”
#Prosedur untuk menggambarkan ukuran congestion window
proc plotWindow {tcpSource file} {
global ns
set time 0.1
set now [$ns now]
set cwnd [$tcpSource set cwnd_]
puts $file “$now $cwnd”
$ns at [expr $now+$time] “plotWindow $tcpSource $file
}
$ns at 0.1 “plotWindow $tcp $winfile”
$ns at 10.0 “finish”
$ns run
Gambar 3.4. Tampilan NAM untuk skrip contoh1.tcl (biru: aliran TCP dan merah: aliran
UDP)
3.8.
Analisis Trace File
3.8.1. Tracing object
Simulasi dengan menggunakan NS-2 dapat menghasilkan visualisasi dari tracing dengan
menggunakan NAM dan juga file tracing dalam bentuk text (ASCII) yang berkaitan
dengan setiap kejadian dalam jaringan.
Pada saat menggunakan tracing (lihat sub-Bab 3.2), NS-2 sebetulnya menyisipkan 4
object ke dalam link, yaitu: EnqT, DeqT, RecvT dan DrpT seperti terlihat dalam Gambar
3.4. EnqT mencatat informasi berkaitan dengan sebuah paket yang datang dan
mengalami proses antrian pada input dari link (Ingat: pada NS-2 sebuah link dianggap
memiliki memory). Apabila paket mengalami overflow dan sejumlah paket yang datang
dibuang, maka informasi terkait dengan paket yang dibuang tersebut disimpan di dalam
DrpT. Sedangkan DeqT mencatat informasi dari paket yang telah keluar dari poses
antrian dan Recvt berisi informasi tentang paket yang sampai pada keluaran dari sebuah
link.
Gambar 3.4. Tracing object pada sebuah link
3.8.2. Struktur dari trace file
Keluaran dari tracing yang ditulis ke dalam text file tersusun atas 12 kolom seperti
ditunjukkan dalam Gambar 3.5.
Gambar 3.5. Field pada file trace
Fungsi dari setiap field dijelaskan sebagai berikut:
a) Field pertama adalah event. Field event merupakan salah satu dari 4
kemungkinan symbol yang berasosiasi dengan 4 macam event, yaitu: r
merupakan simbol dari receive berarti bahwa paket telah sampai ke bagian
output dari sebuah link, + merupakan simbol bahwa paket masuk ke proses
antrian, - merupakan simbol bahwa paket keluar dari proses antrian, d
merupakan simbol bahwa paket tersebut dibuang (drop).
b) Field kedua menunjuk pada waktu saat sebuah event terjadi.
c) Field ketiga menunjuk pada node input dari sebuah link saat sebuah event
terjadi.
d) Field keempat menunjuk pada node output dari sebuah link saat sebuah event
terjadi.
e) Field kelima menunjuk pada tipe dari paket.
f)
Field keenam menunjuk pada ukuran dari paket.
g) Field ketujuh menunjuk pada beberapa flag yang akan dijelaskan di belakang.
h) Field kedepalan adalah flow id.
i)
Field kesembilan adalah alamat sumber dalam bentuk “node.port”.
j)
Field kesepuluh adalah alamat tujuan dalam bentuk “node.port”.
k) Field kesebelas adalah sequence number dari paket data.
l)
Field keduabelas adalah id unik dari paket.
Contoh isi dari file trace adalah sebagai berikut:
+ 0.2 0 2 tcp 40 ------- 1 0.0 4.0 0 0
- 0.2 0 2 tcp 40 ------- 1 0.0 4.0 0 0
r 0.20832 0 2 tcp 40 ------- 1 0.0 4.0 0 0
+ 0.20832 2 3 tcp 40 ------- 1 0.0 4.0 0 0
- 0.20832 2 3 tcp 40 ------- 1 0.0 4.0 0 0
r 0.3096 2 3 tcp 40 ------- 1 0.0 4.0 0 0
+ 0.3096 3 4 tcp 40 ------- 1 0.0 4.0 0 0
- 0.3096 3 4 tcp 40 ------- 1 0.0 4.0 0 0
r 0.360133 3 4 tcp 40 ------- 1 0.0 4.0 0 0
3.8.3. Pemrosesan file data dengan Perl
Perl singkatan dari Practical Extraction and Report Language merupakan bahasa
pemrograman yang banyak digunakan untuk pemrosesan data file ASCII pada sistem
UNIX. Bahasa pmrograman ini dibuat oleh Larry Wall dengan tujuan untuk memudahkan
tugas-tugas administrasi sistem UNIX. Namun Perl saat ini telah berevolusi menjadi
bahasa pemrograman dan merupakan salah satu alat yang dapat digunakan untuk
pemrograman web.
Berikut ini akan ditunjukkan skrip Perl untuk perhitungan throughput dari koneksi TCP
yang telah dijalankan pada skrip sebelumnya contoh1.tcl. Skrip Perl ini dituliskan dalam
sebuah file bernama throughput.pl. Sebagai masukan bagi prosedur ini adalah nama dari
trace file (yaitu out.tr), nama node yang menunjukkan letak dari protokol TCP yang akan
kita cek, dan granularitas (periode waktu tertentu).
# type: perl throughput.pl <trace file> <required node>
<granularity>
>
output file
$infile=$ARGV[0];
$tonode=$ARGV[1];
$granularity=$ARGV[2];
#Menghitung jumlah paket dalam byte yang ditransmisikan
#melalui sebuah nodedalam interval waktu sebagaimana
#dispesifikasikan dalam granularity.
$sum=0;
$clock=0;
open (DATA,"<$infile")
|| die "Can't open $infile $!";
while (<DATA>) {
@x = split(' ');
#kolom 1 adalah waktu
if ($x[1]-$clock <= $granularity)
{
#kolom 0 adalah event, diambil pada saat event r saja
if ($x[0] eq 'r')
{
#kolom 3 adalah node tujuan, disesuaikan dengan argv[1]
if ($x[3] eq $tonode)
{
#kolom 4 adalah jenis paket dalam hal ini dipilih TCP
if ($x[4] eq 'tcp')
{
$sum=$sum+$x[5];
}
}
}
}
else
{
$throughput=$sum/$granularity;
print STDOUT "$x[1] $throughput\n";
$clock=$clock+$granularity;
$sum=0;
}
}
$throughput=$sum/$granularity;
print STDOUT "$x[1] $throughput\n";
$clock=$clock+$granularity;
$sum=0;
close DATA;
exit(0);
Selanjutnya jalankan prosedur throughput.pl di atas dengan menggunakan file
out.tr sebagai input, dan simpan hasil pengolahan ke dalam file bernama thp
dengan cara:
perl throughput.pl out.tr 4 1 > thp
Perintah di atas menunjukkan bahwa analisis throughput akan dilakukan pada node 4
dengan nilai granularity sebesar 1s.
3.8.4. Menggambar grafik dengan Gnuplot
Setelah mendapatkan throughput dengan cara di atas, maka langkah selanjutnya adalah
menggambarkan throughput tersebut ke dalam bentuk grafik. Salah satu cara
menggambarkan grafik adalah dengan menggunakan Gnuplot.
gnuplot
set size 0.8,0.8
set key right bottom
set xlabel “waktu (s)”
set ylabel “throughput”
plot ‘thp’ with lines 1
Ukuran congestion window pada TCP juga dapat digambarkan dengan menggunakan
gnuplot dengan memanggil file WinFile seperti pada contoh skrip di bawah ini:
gnuplot
set size 0.8,0.8
set key right bottom
set xlabel “waktu (s)”
set ylabel “CongWin”
plot ‘WinFile’ with lines 1
Tugas:
Lakukan simulasi ulang untuk menghitung throughput TCP dan fluktuasi ukuran
CongWin pada node4 dengan konfigurasi jaringan seperti dalam Gambar 3.1, tetapi
gunakan protokol-protokol Tahoe, Reno, NewReno dan Vegas. Lakukan perbandingan
dan analisis terhadap karakteristik dari keempat protokol di atas!
Cara melakukan setting untuk protokol TCP yang berbeda adalah sebagai berikut:
set tcp [new Agent/TCP/Reno]
set tcp [new Agent/TCP/Newreno]
set tcp [new Agent/TCP/Vegas]
3.9.
TCP pada Link dengan Noise
Pada simulasi sebelumnya TCP didominasi oleh kehilangan paket data akibat adanya
kongesi di dalam jaringan. Pada kenyataannya link yang mengandung noise juga dapat
mengurangi unjuk kerja dari jaringan, misalnya pada jaringan komunikasi radio semacam
WiFi, telepon selular dan komunikasi melalui satelit. Dalam beberapa kasus keberadaan
noise di dalam link dapat memutuskan komunikasi dan bahkan menyebabkan sejumlah
paket hilang. Pada bagian ini kita akan mensimulasikan TCP pada link yang mengandung
noise.
Gambar 3.6. Model jaringan untuk simulasi TCP pada link dengan noise
Gambar 3.7. Implementasi diagram jaringan pada ns-2
Sebagai contoh mari kita tambahkan link dengan error model pada jalur yang terletak di
antara node2 dan node3 dalam Gambar 3.6. Proses penambahan error model dilakukan
dengan cara sebagai berikut:
#Error model pada link n2 dan n3
set loss_module [new ErrorModel]
$loss_module set rate_ 0.2
$loss_module ranvar [new RandomVariable/Uniform]
$loss_module drop-target [new Agent/Null]
$ns lossmodel $loss_module $n2 $n3
Perintah $loss_module set rate_ 0.2 di atas menunjuk pada laju kehilangan
data yang diharapkan sebesar 20% dari jumlah paket. Selanjutnya perintah
$loss_module ranvar [new RandomVariable/Uniform] menunjukkan
bahwa
error ini dibangkitkan dengan menggunakan bilangan acak dengan distribusi
uniform.
Contoh skrip untuk mensimulasikan diagram dalam Gambar 3.6 dengan menggunakan
link yang mengandung noise dapat dilihat dalam file contoh2.tcl di bawah ini:
#file contoh2.tcl
set ns [new Simulator]
#Mendefinisikan warna untuk aliran data dalam NAM
$ns color 1 Blue
$ns color 2 Red
#Buka trace files
set tf [open out.tr w]
set windowVsTime2 [open WindowsVsTimeNReno w]
$ns trace-all $tf
#Buka NAM trace files
set nf [open out.nam w]
$ns namtrace-all $nf
#Mendefiniskan prosedur ‘finish’
proc finish {} {
global ns tf nf
$ns flush-trace
close $tf
close $nf
exec nam out.nam &
exit 0
}
#membuat 4 buah node
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
$ns at 0.1 "$n1 label \"CBR\""
$ns at 1.0 "$n0 label \"FTP\""
#membuat link antar node
$ns duplex-link $n0 $n2 2Mb 10ms DropTail
$ns duplex-link $n1 $n2 2Mb 10ms DropTail
$ns simplex-link $n2 $n3 0.07Mb 20ms DropTail
$ns simplex-link $n3 $n2 0.07Mb 20ms DropTail
#menentukan posisi node pada NAM
$ns duplex-link-op $n0 $n2 orient right-down
$ns duplex-link-op $n1 $n2 orient right-up
$ns simplex-link-op $n2 $n3 orient right
$ns simplex-link-op $n3 $n2 orient left
#Melakukan setting ukuran memori pada link n2-n3 sebesar 10
$ns queue-limit $n2 $n3 10
#Monitor queue pada link n2-n3 untuk NAM
$ns simplex-link-op $n2 $n3 queuePos 0.5
#Set error model pada link n2 - n3
set loss_module [new ErrorModel]
$loss_module set rate_ 0.2
$loss_module ranvar [new RandomVariable/Uniform]
$loss_module drop-target [new Agent/Null]
$ns lossmodel $loss_module $n2 $n3
#Membentuk koneksi melalui protokol TCP
set tcp [new Agent/TCP/Newreno]
$ns attach-agent $n0 $tcp
set sink [new Agent/TCPSink/DelAck]
$ns attach-agent $n3 $sink
$ns connect $tcp $sink
$tcp set fid_ 1
#Menggabungkan aplikasi FTP pada protokol TCP
set ftp [new Application/FTP]
$ftp attach-agent $tcp
$ftp set type_ FTP
#Membentuk koneksi melalui protokol UDP
set udp [new Agent/UDP]
$ns attach-agent $n1 $udp
set null [new Agent/Null]
$ns attach-agent $n3 $null
$ns connect $udp $null
$udp set fid_ 2
#Menggabungkan aplikasi CBR pada protokol UDP
set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp
$cbr set type_ CBR
$cbr set packetSize_ 1000
$cbr set rate_ 0.01Mb
$cbr set random_ false
$ns at 0.1 "$cbr start"
$ns at 1.0 "$ftp start"
$ns at 119.0 "$ftp stop"
$ns at 119.5 "$cbr stop"
#Prosedur untuk menggambarkan ukuran congestion window
proc plotWindow {tcpSource file} {
global ns
set time 0.1
set now [$ns now]
set cwnd [$tcpSource set cwnd_]
puts $file "$now $cwnd"
$ns at [expr $now+$time] "plotWindow $tcpSource $file"
}
$ns at 1.1 "plotWindow $tcp $windowVsTime2"
#Monitor queue setiap 0.1 sec dan simpan dalam qm.out
set qmon [$ns monitor-queue $n2 $n3 [open qm.out w] 0.1];
[$ns link $n2 $n3] queue-sample-timeout;
$ns at 120 "finish"
$ns run
Tugas
Buatlah skrip tcl untuk diagram jaringan seperti dalam Gambar 3.6 dengan data aplikasi
FTP yang berjalan di atas protokol TCP pada node0 dan data aplikasi CBR yang berjalan
di atas protokol UDP pada node1. Tambahkan skrip untuk mensimulasikan adanya noise
pada link antara node2 dan node3.
a. Dengan cara melakukan plotting terhadap throughput dari jaringan di atas
bandingkan throughput antara link dengan laju kehilangan data 20% dan 0%.
b. Dengan cara melakukan plotting terhadap ukuran CongWin dari jaringan di atas
bandingkan fluktuasi ukuran CongWin antara link dengan laju kehilangan data 20%
dan 0%.
Note: Semua simulasi dilakukan dengan menggunakan TCP Tahoe dan jalankan simulasi
selama 120 detik.
3.10. Queue Monitoring
Salah satu object yang cukup penting dalam ns adalah monitor-queue. Object ini berisi
banyak sekali informasi yang terkait dengan karakteristik proses antrian, misalnya
panjang antrian, jumlah paket yang datang, jumlah paket yang keluar dari antrian,
jumlah paket yang di drop dan sebagainya. Untuk mengaktifkan proses queue monitor
pada link antara node2 dan node3 pada diagram jaringan dalam Gambar 3.6 digunakan
perintah sebagai berikut:
set qmon [$ns monitor-queue $n2 $n3 [open qm.out w] 0.1];
[$ns link $n2 $n3] queue-sample-timeout; #start tracing
Seperti terlihat dalam perintah di atas object monitor-queue memiliki 4 buah
argumen. Dua argumen pertama berkaitan dengan letak link di antara dua buah node
yang akan diobservasi, argumen berikutnya adalah file output dalam contoh di atas file
yang dimaksud adalah qm.out, dan argumen terakhir merupakan frekuensi dari proses
pengamatan, dalam skrip di atas kita akan mengambil sampel setiap 0.1 detik.
Contoh isi dari file qm.out adalah sebagai berikut:
0
2 3 0 0 0 0 0 0 0 0
0.10000000000000001 2 3 0.0 0.0 0 0 0 0 0 0
0.20000000000000001 2 3 0.0 0.0 1 0 1 1000 0 1000
0.30000000000000004 2 3 0.0 0.0 1 0 1 1000 0 1000
0.40000000000000002 2 3 0.0 0.0 1 0 1 1000 0 1000
0.5
2 3 0.0 0.0 1 0 1 1000 0 1000
0.59999999999999998 2 3 0.0 0.0 1 0 1 1000 0 1000
0.69999999999999996 2 3 0.0 0.0 1 0 1 1000 0 1000
0.79999999999999993 2 3 0.0 0.0 1 0 1 1000 0 1000
0.89999999999999991 2 3 0.0 0.0 1 0 1 1000 0 1000
0.99999999999999989 2 3 0.0 0.0 2 0 2 2000 0 2000
1.0999999999999999
2 3 0.0 0.0 3 1 2 2040 40 2000
File output berisi informasi yang terdiri atas 11 kolom seperti berikut:
1) Waktu pengambilan sampel,
2) Node input,
3) Node output,
4) Ukuran queue dalam satuan byte (berkorespondensi dengan atribut size_
pada object monitor-queue),
5) Ukuran queue dalam satuan paket(berkorespondensi dengan atribut pkt_ pada
object monitor-queue),
6) Jumlah
paket
yang
telah
datang
(berkorespondensi
parrivals_ pada object monitor-queue),
dengan
atribut
7) Jumlah paket yang telah keluar dari queue (berkorespondensi dengan atribut
pdepartures_ pada object monitor-queue),
8) Jumlah paket yang di drop (dibuang) oleh queue (berkorespondensi dengan
atribut pdrops_ pada object monitor-queue),
9) Jumlah data dalam byte yang telah datang (berkorespondensi dengan atribut
barrivals_ pada object monitor-queue),
10) Jumlah data dalam byte yang telah keluar dari queue (berkorespondensi dengan
atribut bdepartures_ pada object monitor-queue),
11) Jumlah data dalam byte yang di drop (dibuang) oleh queue (berkorespondensi
dengan atribut bdrops_ pada object monitor-queue).
Tugas
Untuk skrip tcl yang telah dibuat dalam sus-bab 3.9 di atas tambahkan skrip untuk
memonitor queue. Selanjutnya lakukan ploting terhadap ukuran queue masing-masing
dalam satuan byte dan paket. Juga lakukan analisis terhadap kedua grafik tersebut.