Informatika | Távközlés » Huszák Árpád - Ns2 bevezető mérés

Mérési útmutató a Mobil kommunikációs laboratórium méréseihez Ns2 bevezető mérés Mérés helye: Híradástechnikai Tanszék Mobil Távközlési és Informatikai Laboratórium (MC2L) I.B113 Összeállította: Huszák Árpád, PhD hallgató Utolsó módosítás: 2006. augusztus 25 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 (p. 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 0] 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.11 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.12 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.13 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.21 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.22 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/Sink] $ns attach-agent $n3 $sink $ns connect $tcp1 $sink 3.23 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.24 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.25 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 interface, 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 } 3.26 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 Ezek után pedig megmondhatjuk hova mozogjon, a megadott időpontban indulva: $ns at 10.0 "$n(0) setdest 1200 1000 100" A mozgás leírásának akkor van értelme, ha létrehozásnál letiltottuk a véletlenszerű bolyongást. 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.27 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 31 225 610 210 ------- 0 0.0 31 225 610 210 ------- 1 3.0 10 195 600 40 ------- 2 3.2 01 82 602 1000 ------- 2 0.1 32 102 611 1000 ------- 2 0.1 32 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 sampletcl), melyet az Ns2 program meghívásával futtathatunk: ./ns sampletcl 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.29 s-229doc” 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. Hivatkozások [1] Ns2 website, http://www.isiedu/nsnam/ns/indexhtml