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 “simplex-

link” 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

$n1

$n2 $n3

$n4

$n5

1Mbps

8ms

1Mbps

10ms

250kbps

100ms

250kbps

100ms

600kbps

50ms

600kbps

40ms

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 simplex-link $n2 $n3 0.25Mb 100ms DropTail


$ns duplex-link $n3 $n4 0.6Mb 50ms DropTail




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







$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> <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


#Mendefinisikan warna untuk aliran data dalam NAM

$ns color 1 Blue

$ns color 2 Red

#Buka trace files







proc finish {} {


$ns flush-trace

close $tracefile1

close $namfile

exec nam out.nam &

exit 0

}


set n0 [$ns node]

set n1 [$ns node]

set n2 [$ns node]

set n3 [$ns node]

set n4 [$ns node]

set n5 [$ns node]








#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












$tcp set fid_ 1




$ns at 0.2 “ftp start”

$ns at 9.6 “ftp stop”


$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






$udp set fid_ 2

#Menggabungkan aplikasi CBR pada protokol UDP






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



$ns color 1 Blue

$ns color 2 Red

#Buka trace files



#Buka winfile file

set winfile [open WinFile w]





proc finish {} {


$ns flush-trace

close $tracefile1

close $namfile

exec nam out.nam &

exit 0

}


set n0 [$ns node]

set n1 [$ns node]

set n2 [$ns node]

set n3 [$ns node]

set n4 [$ns node]

set n5 [$ns node]








#menentukan posisi node pada NAM (Network Animator)
















$tcp set fid_ 1










$udp set fid_ 2







$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 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



$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


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

}


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\""






#menentukan posisi node pada NAM







#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


set tcp [new Agent/TCP/Newreno]


set sink [new Agent/TCPSink/DelAck]



$tcp set fid_ 1




$ftp set type_ FTP







$udp set fid_ 2




$cbr set type_ CBR




$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 dengan atribut

parrivals_ pada object monitor-queue),

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

Documents

Transcript of Bab 3. Simulasi dengan NS-2 -...