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 } { } else { }

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 } { }

•

Prosedur dapat dibuat dalam tcl dengan bentuk seperti dibawah ini: proc kuadrat { par1 par2 ...} { global var1 var2 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


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>

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


#Mendefinisikan warna untuk aliran data dalam NAM $ns color 1 Blue $ns color 2 Red



#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


$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




#Buka winfile file set winfile [open WinFile w]


#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


#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 <required node>

>

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 () { @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



#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.

Bab 3. Simulasi dengan NS-2

Recommend Documents