Mérési útmutató a Mobil Kommunikáció és Kvantumtechnológiák Laboratórium méréseihez
Ns2 bevezető mérés
Mérés helye: Híradástechnikai Tanszék Mobil Kommunikáció és Kvantumtechnológiák Laboratórium (MCL) I.B.113. Összeállította: Huszák Árpád Utolsó módosítás: 2012. augusztus 17.
1. Bevezetés A távközlési- és számítógép hálózatok vizsgálatának hatékony és költségkímélő módja a szimulációs szoftverek alkalmazásával valósítható meg. Ezek a szoftverek lehetővé teszik a hálózatok átfogó és kimerítő vizsgálatát, a hálózat kiépítése nélkül is. Napjainkban számos szimulációs rendszer áll rendelkezésre (pl. NS, OPNET, OMNeT++.), ezek közül az NS az egyik legelterjedtebb. Ennek köszönhetően számos dokumentáció, mintapélda található az interneten, sőt NS fórumból is találhatunk néhányat. A mérés során a hallgató feladata a Network Simulator (NS) használatának elsajátítása, egyszerű példaprogramok segítségével. A példaprogramok bővítésével és módosításával, egyszerű hálózatok összeállítását és vizsgálatát kell a hallgatónak megvalósítania.
2. Ns2-ről általánosan A ”Network Simulator version 2”, vagyis az Ns2 [1] egy eseményvezérelt, objektum orientált hálózat szimulátor. Sikerét annak is köszönheti, hogy forráskódja szabadon elérhető, így mindenki saját szükségleteinek megfelelően módosíthatja, illetve bővítheti. A ma használatos hálózati elemek, hálózat típusok, alkalmazások, protokollok, forrás modell, forgalmi modellek azonban már mind részei a szimulációs rendszernek. Az Ns2 szimulátor két programozási nyelven alapszik: C++ és OTcl (Object Oriented Tool Command Language). A C++ a részletes protokoll, forrás modell, forgalmi modell, stb. implementálására alkalmas, hiszen ezeknél a feladatoknál a futási sebesség a lényegesebb szempont, míg az OTcl a szimulált hálózat felépítésre, a szimulációs folyamat vezérlésére használatos. Emellett OTcl nyelven lehet az időzítési és ütemezési feladatokat is megadni. Más szóval a C++ nyelven megírt objektumokat, az OTcl szintről vezérelhetjük. Ezen a szinten sokkal könnyebben tudunk változtatni a hálózat struktúráján, beállításain, ami egy szimulációs vizsgálatsorozat esetén nagyon fontos.
3. Ns2 programozás 3.1. Az OTcl programnyelv alapjai Az OTcl egy nagyon egyszerű programnyelv, melynek jellemzői: Gyors és egyszerű kódolást tesz lehetővé Hordozható, azaz számos platformmal kompatibilis Ingyenes Az Ns2 elterjedtségének köszönhetően, ma más szinte minden protokoll, forgalmi modell, forrás modell és a teszthálózat implementálásához szükséges egyéb elemek már korábban implementálva lettek. Azok a szabványok, amelyek esetleg mégsem részei az alap Ns2 rendszernek, általában már letölthetőek, és könnyedén illeszthetőek az eredeti Ns2-höz. C++ kódolásra csak akkor van szükség, ha egyedi protokollt, forgalmi modellt, stb. akarunk vizsgálni. A mai hálózatokban használt algoritmusok, protokollok, stb. használatához elegendő OTcl nyelven megírt szimulációt futtatni.
3.1.1. Változók kezelése Változók feltöltése a set paranccsal történik: set a 5
# a=5
Amennyiben egy kifejezés eredményével szeretnénk feltölteni a változót, azt a következő módon tehetjük meg: set b [expr $a/5]
# b=a/5
A # jel megjegyzések beszúrását teszi lehetővé.
3.1.2. Függvények A proc paranccsal hozhatunk létre függvényeket, ahol az első argumentum a függvény neve, míg a többi a függvény által használt változók. proc sum {a b} { expr $a + $b } A függvényt nevével és a függvény paramétereivel tudjuk meghívni: set c [sum 3 4]
# c=3+4
vagy set c [sum $valtozo1 $valtozo2]
# c=valtozo1+valtozo2
3.1.3. Fájlműveletek Az OTcl lehetővé teszi fájlok kezelését is. set testfile [open test.dat r] Ezzel a paranccsal, a ”test.dat” fájlt olvasásra nyithatjuk meg. Ha r helyett w-t használunk, írásra nyitjuk meg a fájlt.
3.2. Hálózati topológia kialakítása A hálózat vizsgálatához először a hálózati topológiát kell megadnunk. Minden hálózat csomópontokból (node) és összeköttetésekből (link) áll. A csomópontok és linkek megadása előtt azonban először egy új szimulátor objektumot kell létrehozni, amelyet a következő paranccsal tehetünk meg: set ns [new Simulator]
3.2.1. Csomópontok (nodes) A csomópontok, linkek, kapcsolódó ügynökök, stb. a Simulator osztály részei, ezért a szimuláció új elemének létrehozásakor meg kell adni a Simulator objektum nevét is. Új csomópontok létrehozása tehát a következő módon történik: set n0 [$ns node] set n1 [$ns node] set n2 [$ns node] A létrehozott csomópontokra megadott nevükkel hivatkozhatunk a továbbiakban (n0, n1, n2).
3.2.2. Forgalomszabályozó ügynökök (Traffic Agents) és forrásmodellek Abban az esetben, ha a csomópont nem egy router, hanem egy forrás vagy nyelő végpont, forgalomszabályozó ügynököt (traffic agent) kell a végponthoz rendelni. Ez az ügynök valósítja meg a szállítási réteg funkcióit, tehát valójában a transzport protokollt kell megjelölni (TCP, UDP, stb.). Emellett a forrás típusát is meg kell adni (pl. FTP (File Transfer Protocol), CBR (Constant Bit Rate), VBR (Variable Bit Rate), stb.). Leggyakrabban használt forgalomszabályozó ügynökök a TCP és UDP ügynökök, melyeknek számos típusa érhető el az alap Ns2-ben. Legismertebb TCP változatok: TCP Tahoe, TCP Reno, TCP SACK.
Agent/TCP – a Tahoe TCP forrás Agent/TCP/Reno – Reno TCP forrás Agent/TCP/Sack1 – TCP selective acknowledgement
Az UDP-nek is van módosított változata, az UDPLite, ez azonban nem része az alap Ns2-nek, ennek ellenére már az UDPLite patch már letölthető, és használható. A leggyakoribb forrásmodellek és alkalmazástípusok: Application/FTP – adatfolyam, melyet TCP továbbít Application/Traffic/CBR – állandó csomagküldési sebességet generál Application/Traffic/Exponential – olyan On-Off modell, ahol a küldési periódus és a néma periódus hossza exponenciális eloszlást mutat Application/Traffic/Trace – a forgalom egy un. trace fájl alapján alakul, melyben a csomagok mérete és a küldési időpontok szerepelnek A következő példában az n0 csomóponthoz rendelünk hozzá egy CBR forrást, amely UDP protokollt használ, az attach-agent parancs használatával: set udp0 [new Agent/UDP] $ns attach-agent $n0 $udp0 set cbr0 [new Application/Traffic/CBR] $cbr0 attach-agent $udp0 $udp0 set packet_size_ 1000 $cbr0 set rate_ 1000000 Az ügynököknek különböző konfigurációs paraméterei is vannak, mint pl. a CBR esetén a küldési sebesség, vagy UDP és TCP esetén a csomagméret byte-ban. Hasonlóan az előzőhöz, most az n1 csomóponthoz egy TCP alapú FTP alkalmazást kapcsolunk. set tcp1 [new Agent/TCP] $ns attach-agent $n1 $tcp1 set ftp1 [new Application/FTP] $ftp1 attach-agent $tcp1 $tcp1 set packet_size_ 1000 Eddig a forrásokról volt szó, azonban vevő oldali csomópontot is létre kell hozni. A TCP nyelő az Agent/TCPSink osztályban van definiálva, míg az UDP nyelő az Agent/Null osztályban.
A következő példában az n2 csomóponthoz rendelünk egy nyelő ügynököt, majd létrehozzuk a kapcsolatot a forrás és a nyelő között: set null [new Agent/Null] $ns attach-agent $n2 $null $ns connect $udp0 $null Az általános TCP nyelő minden helyesen megérkezett csomagra nyugtával válaszol. Az előzőekhez hasonlóan hozzuk létre a kapcsolatot a TCP forrás és nyelő között: set sink [new Agent/TCPSink] $ns attach-agent $n3 $sink $ns connect $tcp1 $sink
3.2.3. Linkek A csomópontokat linkek segítségével lehet összekapcsolni, mely modelljét a következő ábra mutatja:
1. ábra: Ns2 simplex link modell
Duplex link esetén két simplex linket kell elképzelni mindkét irányba. Az átküldendő csomag először tárolásra kerül a küldő sorban, ahonnan vagy továbbkerül a késleltetés szimuláló modulba, vagy a Agent/Null modulba kerül, amely a csomagvesztést szimulálja. A késleltetés szimuláló modul után a TTL (Time to Live) modulba kerül a csomag. Az alap Ns2-ben is számos sorkezelő algoritmus került implementálásra, mint pl. a RED (Random Early Discard), Drop Tail, FQ (Fair Queueing), DRR (Deficit Round Robin), SFQ (Stochastic Fair Queueing), stb. Link létrehozása a következő parancsokkal történhet, tetszőleges paraméterek megadása mellett: $ns simplex-link $n1 $n3 10Mb 5ms RED $ns duplex-link $n0 $n2 15Mb 10ms DropTail Az első esetben egy simplex linket hoztunk létre n1 és n3 csomópont között, amely RED sorkezelő algoritmust szimulál. A link kapacitása a példában 10Mbit, a késleltetése pedig 5ms. A második példában pedig egy duplex linket n0 és n2 között 10ms-os késleltetéssel, DrpoTail sorkezelő algoritmus alkalmazásával.
3.2.4. Csomagvesztés és bithiba Az Ns2-ben lehetőség van a csomagvesztés és a bithibák szimulálására is. Két csomópont között generálhatunk hibákat tetszőleges valószínűséggel, és eloszlással.. Ehhez először a hiba modult kell létrehozni (Error Module), majd ezt beilleszteni a két csomópont közé. Ennek módja a következő: Hiba modul létrehozása: set loss_module [new ErrorModel] $loss_module set rate_ 0.01 $loss_module unit pkt $loss_module ranvar [new RandomVariable/Uniform] $loss_module drop-target [new Agent/Null] Hiba modul beillesztése: $ns lossmodel $loss_module $n0 $n1
3.2.5. Vezeték nélküli hálózatok Az Ns2 szimulációs környezet természetesen lehetővé teszi vezeték nélküli hálózatok vizsgálatát is. Az ilyen hálózatokban szereplő mobil csomópontok azonban némileg különböznek a vezetékes hálózatban használtaktól, hiszen a terminálok változtatják pozíciójukat, és nem linkekkel kapcsolódnak egymáshoz. Ezek a mozgó terminálok része valamilyen routing protokoll is (pl. DSDV – Destination Sequenced Distance Vector, AODV – Ad-hoc On Demand Distance Vector, TORA – Temporally Ordered Routing Algorithm, DSR – Dynamic Source Routing, stb.). A mozgó csomóponton kívül a vezeték nélküli hálózat különböző rétegeit is megfelelően konfigurálni kell. Ehhez a feladathoz tartozik a csatorna, a rádiós terjedési modell, a MAC protokoll, a hálózati interfész, a címfeloldó protokoll modell (ARP – Address Resulotion Protocol), stb. pontos definiálása. Példa egy vezeték nélküli hálózatot leíró OTcl script-re: set set set set set set set set set set
val(chan) val(prop) val(netif) val(mac) val(ifq) val(ll) val(ant) val(ifqlen) val(nn) val(rp)
Channel/WirelessChannel Propagation/TwoRayGround Phy/WirelessPhy Mac/802_11 Queue/DropTail/PriQueue LL Antenna/OmniAntenna 50 2 DSDV
;# ;# ;# ;# ;# ;# ;# ;# ;# ;#
channel type radio-propagation model network interface type MAC type interface queue type link layer type antenna model max packet in ifq number of mobilenodes routing protocol
Vezeték nélküli hálózatok szimulációjánál a szimulációs teret, topológiát is meg kell határozni: set topo [new Topography] $topo load_flatgrid 500 500 A következő paranccsal pedig egy mátrixot hozunk létre, amelyben a szimulációs tér pontjai közötti kapcsolat információkat tároljuk.
create-god $val(nn) Az eddig ismertetett beállítások, szimulációs tér információk nélkülözhetetlenek a mobil csomópont konfigurálásánál: set chan_1 [new $val(chan)] $ns node-config -adhocRouting $val(rp) \ -llType $val(ll) \ -macType $val(mac) \ -ifqType $val(ifq) \ -ifqLen $val(ifqlen) \ -antType $val(ant) \ -propType $val(prop) \ -phyType $val(netif) \ -channel $chan_1 \ -topoInstance $topo \ -agentTrace ON \ -routerTrace ON \ -macTrace OFF \ -movementTrace ON Több darab (i) mobil terminál létrehozása, a következő módon történik: for {set i 0} {$i < $val(nn) } {incr i} { set n($i) [$ns node] $n($i) random-motion 0 ;# disable random motion } Ezzel a módszerrel létrehozott terminálok azonosítója n(0), n(1), stb. lesz, és ennek megfelelően kell hivatkozni rájuk. Nem szabad megfeledkezni arról sem, hogy vezeték nélküli szimuláció esetén, a grafikus megjelenítéshez szükséges nyomkövető fájl definiálása a 3.3 fejezetben leírtak alapján módosul!
3.2.6. Mobil csomópontok mozgása Miután létrehoztuk a mobil node-kat, megadhatjuk a kezdeti pozíciót: $n(0) set X_ 25.0 $n(0) set Y_ 20.0 $n(0) set Z_ 10.0 Ha a terminál mozgása nem véletlen, megmondhatjuk hova mozogjon a megadott időpontban indulva: $ns at 10.0 "$n(0) setdest 120.0 100.0 10.0" A mozgás leírásának és a kezdeti pozíció megadásának akkor van értelme, ha létrehozásnál letiltottuk a véletlenszerű bolyongást. A véletlenszerű mozgást a következő paranccsal indíthatjuk:
$n(0) start A szimuláció befejezését a mobilokkal is tudatni kell: for {set i 0} {$i < $val(nn) } {incr i} { $ns at 150.0 "$n($i) reset"; }
3.2.7. Csomagvesztés és bithiba vezeték nélküli hálózatokban Két csomópont közötti kapcsolat létrehozása a vezetékes esetben bemutatottakkal azonosan történik. Egyedül a csomag- vagy bithiba beillesztése különbözik. Vezeték nélküli esetben hibamodellt kell létrehozni, proc UniformErr {} { set err [new ErrorModel] $err unit packet $err set rate_ 0.1 #$err ranvar [new RandomVariable/Uniform] #$err set bandwidth_ 2Mb return $err } amire a mobilok konfigurálásánál kell hivatkozni: -IncomingErrProc UniformErr \ -OutgoingErrProc UniformErr
3.3. A szimuláció eseményeinek nyomkövetése A szimuláció eredményét kimeneti fájlban (trace file) rögzíthetjük. Ez a funkció igen hasznos, hiszen egyrészt ez alapján pontosan nyomon követhetjük az eseményeket, másrészt a grafikus megjelenítéshez is ilyen kimeneti fájlra van szükség. Nyomkövető fájl alkalmazását az OTcl script-ben is engedélyezni kell. set tracefile [open trace.tr w] #fájl megnyitása $ns trace-all $tracefile #események rögzítése a fájlba $ns flush-trace #nyomkövetés close $tracefile
#fájl bezárása
Az események az ”trace.tr” fájlban kerülnek rögzítésre. A szimuláció végén ezt a fájl be kell zárni, melyet a close paranccsal tesszünk meg. Lehetőség van grafikusan is megjeleníteni a szimuláció esményeit a NAM (graphical network animator) programmal. Ehhez azonban a nyomkövető trace fájlhoz hasonló, de a NAM program számára olvasható .nam kiterjesztésű fájlt kell generálni. set namfileazonosito [open out.nam w] $ns namtrace-all $namfileazonosito Ha vezeték nélküli hálózatot vizsgálunk, a parancssor kissé módosul és ekkor a mozgási tér méretét is meg kell adni:
$ns namtrace-all-wireless $namfileazonosito 500 500 A kimeneti fájlban a következő módon kerülnek tárolásra az események: + r r + -
1.84375 1.84375 1.84471 1.84566 1.84566 1.84566
0 0 2 2 0 0
2 2 1 0 2 2
cbr cbr cbr ack tcp tcp
210 ------- 0 0.0 3.1 225 610 210 ------- 0 0.0 3.1 225 610 210 ------- 1 3.0 1.0 195 600 40 ------- 2 3.2 0.1 82 602 1000 ------- 2 0.1 3.2 102 611 1000 ------- 2 0.1 3.2 102 611
Ahol az első oszlopot a következők alapján kell értelmezni: + enqueue dequeue d drop r receive A második oszlop az esemény időpontja, a következő kettő a forrás és cél csomópont, ezt követi a csomagtípus (protokoll, forrás modell), majd jön a csomagméret, flag, folyamazonosító, forrás és cél cím, csomag sorszám, csomagazonosító. Amennyiben olyan információkra is szükségünk van, amelyek nem szerepelnek (pl. RTT – Round Trip Time, TCP torlódási ablak, TCP csomagvesztési valószínűség, stb.) a trace fájlban, létrehozhatunk egy saját nyomkövető fájlt. Ehhez meg kell nyitnunk egy tetszőleges nevű fájlt a korábban leírtak alapján, majd puts paranccsal a megjelölt változó aktuális értékét kiírni a fájlba. Az írási műveletet és a változó tartalmának frissítését időzíteni kell (pl. tized másodpercenként mentsük az aktuális RTT értéket). Ezt csak úgy tehetjük meg, hogy egy függvényt hozunk létre, amelyet időközönként rekurzív módon meghívunk. proc rec {} { global tcp sink tracefd fileazonosito set ns [Simulator instance] set time 0.1 set rtt [$tcp set rtt_] set now [$ns now] puts $fileazonosito "$rtt" $ns at [expr $now+$time] "rec" } A rec {} függvény meghívja önmagát, de csak miután egyszer már meghívtuk a függvényt, a megadott időpontban (az időzített függvényhívásról a következő fejezetben lesz szó): $ns at 0.0 ”rec”
3.4. Időzítés és vezérlés Miután létrehoztuk a hálózati topológiát, a szimuláció eseményeinek ütemezését kell megoldani. A szimuláció elindítására a következő parancs szolgál, az OTcl script végén: $ns run
A szimuláció a felhasználó által megadott időzítő lejárta után áll le: $ns at 60.0 ”finish” A fenti példában a szimuláció 60 másodpercig fut, majd meghívódik a finish függvény, melyet szintén a felhasználónak kell megírnia. Ebben a függvényben célszerű a megnyitott fájlokat bezárni, a nyomkövetést leállítani, és leállítani a programot. Emellett lehetőség van a NAM (graphical network animator) program elindítására is az exec paranccsal, amely a szimuláció kimeneti fájlja alapján grafikusan jeleníti meg a szimulációt. Egy példa a finish függvényre: proc finish {} { global ns trace_all $ns flush-trace close $trace_all exec nam out.nam & exit 0 } Az adatok küldésének kezdeti és befejezési időpontját is megadhatjuk: $ns at 0.0 “cbr0 start” $ns at 50.0 “ftp1 start” $ns at 60.0 “cbr0 stop” $ns at 100.0 “ftp1 stop”
3.5. Mintapélda A fentiek alapján egy teljes szimulációs rendszert össze tudunk állítani. Lássunk tehát egy vezetékes példát, ahol az n0 és n3 node között TCP alapú kommunikáció folyik, míg n1 és n3 között UDP. Az Otcl script-et .tcl kiterjesztésű fájlba mentsük (pl. sample.tcl), melyet az Ns2 program meghívásával futtathatunk a script nevével paraméterezve: user@mclpc001 /home/ns-allinone-2.29/ns-2.29 $./ns sample.tcl Az elrendezés legyen a következő:
2. ábra: A példahálózat topológiája
sample.tcl: #Create a simulator object set ns [new Simulator] #Open the NAM trace file set nf [open out.nam w]
$ns namtrace-all $nf #Open the Trace file set tf [open out.tr w] $ns trace-all $tf #Define a 'finish' procedure proc finish {} { global ns nf tf $ns flush-trace #Close the NAM trace file close $nf #Close the Trace file close $tf #Execute NAM on the trace file exec nam out.nam & exit 0 } #Create four nodes set n0 [$ns node] set n1 [$ns node] set n2 [$ns node] set n3 [$ns node] #Create links between the nodes $ns duplex-link $n0 $n2 2Mb 10ms DropTail $ns duplex-link $n1 $n2 2Mb 10ms DropTail $ns duplex-link $n2 $n3 1.7Mb 20ms DropTail #Give node position (for NAM) $ns duplex-link-op $n0 $n2 orient right-down $ns duplex-link-op $n1 $n2 orient right-up $ns duplex-link-op $n2 $n3 orient right #Setup a TCP connection set tcp [new Agent/TCP] $tcp set class_ 2 $ns attach-agent $n0 $tcp set sink [new Agent/TCPSink] $ns attach-agent $n3 $sink $ns connect $tcp $sink #Setup a FTP over TCP connection set ftp [new Application/FTP] $ftp attach-agent $tcp $ftp set type_ FTP #Setup a UDP connection set udp [new Agent/UDP] $ns attach-agent $n1 $udp set null [new Agent/Null] $ns attach-agent $n3 $null $ns connect $udp $null #Setup a CBR over UDP connection set cbr [new Application/Traffic/CBR] $cbr attach-agent $udp $cbr set type_ CBR $cbr set packet_size_ 1000 $cbr set rate_ 1mb
$cbr set random_ false #Schedule events $ns at 0.1 "$cbr $ns at 1.0 "$ftp $ns at 4.0 "$ftp $ns at 4.5 "$cbr
for the CBR and FTP agents start" start" stop" stop"
#Detach tcp and sink agents (not really necessary) $ns at 4.5 "$ns detach-agent $n0 $tcp ; $ns detach-agent $n3 $sink" #Call the finish procedure after 5 seconds of simulation time $ns at 5.0 "finish" #Print CBR packet size and interval puts "CBR packet size = [$cbr set packet_size_]" puts "CBR interval = [$cbr set interval_]" #Run the simulation $ns run
Az ismertetett módszerek csupán töredékét képezik az Ns2 lehetőségeinek. Jól használható segítséget jelenthet az Ns2 témánkénti leírása és használati útmutatója, amely az ”ns-allinone-2.35\ns-2.35\doc” könyvtárban található.
4. Ellenőrző kérdések 1. Melyik két programnyelvet használjuk hálózati szimuláció megírásához? Melyiknek mi az előnye, hátránya? 2. Hogyan tudunk OTcl nyelvben egy fájlt írásra megnyitni? 3. Ábrázolja és ismertesse az Ns2 simplex link modelljének elemeit! 4. Milyen információk találhatóak nyomkövető fájlban? 5. Hogyan kell a szimuláció időtartamát megadni? Milyen feladatokat kell az időzítő lejártakor végrehajtani?
5. Mérési feladatok 1. Hozzon létre két csomópontból álló vezetékes hálózatot. A forgalom típusa CBR (1Mbit/s), a transzport protokoll UDP. A két node közötti link kapacitása 2Mbit/s, késleltetése 10ms. A csomagméret legyen 1000 byte. 2. Illesszen hibákat a két csomópont közé. A csomagvesztés valószínűsége legyen 5%. 3. Hozzon létre két véletlenszerűen mozgó csomópontból álló vezeték nélküli hálózatot. A forgalom típusa CBR (1Mbit/s), a transzport protokoll UDP. A csomagméret legyen 1000 byte. 4. A csomópontok generáljanak FTP típusú forgalmat és használjanak TCP-t. 5. Illesszen hibákat a két csomópont közé. A csomagvesztés valószínűsége legyen 5%. 6. Ábrázolja a körbefordulási idő (RTT) alakulását az idő függvényében.
6. A mérés során használandó programok [1] Ns2 website, http://www.isi.edu/nsnam/ns/index.html [2] Cygwin website, http://www.cygwin.com/
