Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues (OBS)

TREBALL DE FI DE CARRERA TÍTOL: Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues (OBS) AUTOR: Marc Garcia i Masgrau DIRECTOR: Cristina Cervelló i Pastor DATA: 5 de Setembre de 2005 Títol: Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues (OBS) Autor: Marc Garcia i Masgrau Director: Cristina Cervelló i Pastor Data: 5 de Setembre de 2005 Resum Aquest document mostra una introducció a la commutació òptica de ràfegues (OBS) i descriu el disseny i la construcció d’un simulador per a modelar una xarxa òptica de commutació de ràfegues. Més endavant, es mostren exemples de com utilitzar el simulador. Finalment, es presenta un estudi d’algoritmes bàsics de creació de ràfegues i els seus efectes en les característiques del tràfic d’aquestes. El simulador OBS està dissenyat i construït sobre el simulador ns-2, realitzat amb C++ i que utilitza OTcl com a interfície de comandes i configuració. Les diferents simulacions realitzades permeten la comprovació del funcionament del simulador així com entendre l’impacte que té en una xarxa un tràfic de Poisson introduït en ràfegues. Title: Study and simulation with NS of the optical burst-switched networks (OBS) Author: Marc Garcia i Masgrau Director: Cristina Cervelló i Pastor Date: September, 5th 2005 Overview This document gives an introduction to the optical burst switching (OBS) and describes the design and implementation of a network simulator to model a optical burst-switched network. In addition to that some examples of how to use the simulator are explained. Finally, a study of basic burst assembly algorithms and their effect on assembled burst traffic characteristics are described. The OBS network simulator is designed and built over the ns-2 simulator framework that is implemented in C++ and uses OTcl as the command and configuration interface. Simulation experiments permit to test the simulator and also to understand the impact of assembled Poisson traffic on a network. ÍNDEX INTRODUCCIÓ ............................................................................................................................. 1 CAPÍTOL 1. XARXES ÒPTIQUES DE COMMUTACIÓ DE RÀFEGUES.................................... 2 1.1. INTRODUCCIÓ................................................................................................................. 2 1.2. TIPUS DE XARXES BASADES EN WDM.............................................................................. 2 1.3. FUNCIONAMENT.............................................................................................................. 3 1.4. ELEMENTS DE LA XARXA OBS......................................................................................... 3 CAPÍTOL 2. SIMULADOR DE XARXES OBS............................................................................. 5 2.1. INTRODUCCIÓ................................................................................................................. 5 2.2. EL SIMULADOR DE XARXES TELEMÀTIQUES NS.................................................................. 5 2.2.1. Definició i ús ............................................................................................................ 5 2.2.2. Funcionament i estructura ....................................................................................... 5 2.2.3. Implantació de la xarxa OBS sobre el ns ................................................................ 6 2.3. EL NODE FRONTERA ....................................................................................................... 7 2.3.1. Descripció ................................................................................................................ 7 2.3.2. El Classificador........................................................................................................ 7 2.3.3. El Classificador de ports.......................................................................................... 8 2.4. L’AGENT OBS................................................................................................................ 8 2.4.1. Introducció ............................................................................................................... 8 2.4.2. Estructura ................................................................................................................ 8 2.4.3. Format de les ràfegues.......................................................................................... 10 2.4.4. L’estructura BurstMan............................................................................................ 11 2.4.5. La classe BurstAgent............................................................................................. 13 2.4.5.1. El mètode recv() ........................................................................................................14 2.4.5.2. Introducció de paquets IP en una ràfega...................................................................14 2.4.5.3. Creació i enviament de la ràfega i del BHP...............................................................15 2.4.5.4. Identificació de les ràfegues......................................................................................18 2.4.5.5. Extracció dels paquets IP de les ràfegues.................................................................19 2.5. TEMPORITZADORS........................................................................................................ 21 2.5.1. Introducció ............................................................................................................. 21 2.5.2. Temporitzador de temps de procés (ProcesTimer)............................................... 21 2.5.3. Temporitzador de temps de Offset (OffsetTimer).................................................. 22 2.5.4. Temporitzador de temps de creació de ràfegues (BurstTimeOutXX) ................... 23 2.6. EL NODE NUCLI DE LA XARXA OBS ................................................................................ 23 2.6.1 Descripció .............................................................................................................. 23 2.6.2. Funcionament ........................................................................................................ 23 CAPÍTOL 3. FUNCIONAMENT DEL SIMULADOR ................................................................... 26 3.1. INTRODUCCIÓ............................................................................................................... 26 3.2. EXEMPLE DE SIMULACIÓ................................................................................................ 26 3.2.1. Topologia i paràmetre de la xarxa OBS ................................................................ 26 3.2.2. Visualització de la simulació i fitxer de log ............................................................ 27 3.2.3. Recopilació de resultats ........................................................................................ 28 CAPÍTOL 4. ESTUDI DE LA CREACIÓ DE RÀFEGUES.......................................................... 30 4.1. INTRODUCCIÓ............................................................................................................... 30 4.2. ESCENARI.................................................................................................................... 30 4.2.1 Descripció .............................................................................................................. 30 4.2.2. Desenvolupament teòric........................................................................................ 31 4.2.3. Primer cas: encapçalament a baixa velocitat ........................................................ 32 4.2.3.1. Descripció..................................................................................................................32 4.2.3.2. Dades obtingudes en el càlcul de probabilitats..........................................................32 4.2.4. Segon cas: encapçalament a alta velocitat ........................................................... 36 4.2.4.1 Descripció..................................................................................................................36 4.2.4.2 Dades obtingudes en el càlcul de probabilitats..........................................................36 4.2.4.3. Altres resultats...........................................................................................................39 4.2.4.4 Conclusions...............................................................................................................42 ANNEX........................................................................................................................................ 46 BIBLIOGRAFIA........................................................................................................................... 51 Introducció 1 INTRODUCCIÓ L’objectiu d’aquest document és presentar un estudi realitzat sobre xarxes òptiques de commutació de ràfegues (OBS, optical burst switching). Per a la realització d’aquest estudi s’ha programat un simulador de xarxes OBS que permet fer un model de part del seu funcionament. El simulador programat està basat en el simulador ns-2 implementat en el llenguatge de programació orientat a objectes C++ i en el llenguatge interpretat OTcl, també orientat a objectes. Al primer capítol es fa una breu introducció a les xarxes òptiques i en especial a les de commutació de ràfegues, explicant en que consisteixen i els seus elements principals. El segon capítol tracta sobre el disseny i la implantació del simulador programat, començant per un petit repàs al funcionament del simulador ns per donar pas a l’explicació de l’estructura del simulador i el seu funcionament a nivell de programació. En el tercer capítol es mostra un exemple de simulació i el funcionament del programa a nivell d’usuari, explicant com s’introdueixen els paràmetres en les simulacions, els resultats facilitats per aquestes i la manera d’interpretar-los. En el quart i últim capítol s’explica en tot detall l’estudi d’una xarxa OBS portat a terme amb el simulador quan en aquest s’hi introdueixen fonts de Poisson. Els resultats de les simulacions es mostren en taules i gràfics acompanyats de les conclusions extretes a partir d’unes i altres. 2 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues CAPÍTOL 1. XARXES ÒPTIQUES DE COMMUTACIÓ DE RÀFEGUES 1.1. Introducció La multiplexació per divisió de longitud d’ona (WDM, Wavelength Division Multiplexed) està considerada com un dels camps més prometedors pel que fa a la millora de la utilització dels enllaços de fibra en el futur de les xarxes òptiques. Dividir l’ampla de banda proporcionat per les fibres òptiques permet l’obtenció de múltiples canals d’alta velocitat, cada un dels quals pot ser commutat i encaminat individualment. En aquest capítol s’analitzen breument els avantatges i les problemàtiques que hi ha actualment en l’àmbit de les xarxes òptiques, així com els diferents tipus que n’hi ha i especialment les xarxes òptiques commutades. 1.2. Tipus de xarxes basades en WDM Dins de l’àmbit de les xarxes de dades basades en WDM, hi ha tres tipus de commutació que en l’actualitat s’estan estudiant: commutació de circuits, de paquets i de ràfegues (veure[1] i [2]). • En la commutació de circuits es crea un circuit des de l’origen fins al destí que queda establert durant tota la sessió. Tot i ser una tècnica que redueix el procés de commutació del circuit (ja que la ruta només es commuta al principi de la sessió) els inconvenients que presenta són la pèrdua total de la comunicació en cas de caiguda d’un node (s’ha de tornar a crear el circuit), i el desaprofitament de l’ampla de banda en aquelles sessions que no necessiten la capacitat total d’un canal per a elles. • En la commutació de paquets, aquests són commutats pels nodes de la xarxa gràcies a la informació que porten a la capçalera. Tot i que quan falla un node la comunicació no queda interrompuda (es commuta un altre camí per als paquets), és necessària una alta velocitat de procés per part dels nodes. • En la commutació òptica de ràfegues (OBS), els paquets IP són introduïts en ràfegues que s’envien a la xarxa. L’ampla de banda utilitzat per a cada ràfega és proporcional a la durada d’aquesta permeten un aprofitament millor dels recursos de la xarxa. El funcionament d’aquest últim tipus de xarxa òptica s’explica en l’apartat següent. Xarxes òptiques de commutació de ràfegues 3 1.3. Funcionament El funcionament d’una xarxa OBS consisteix en la introducció de paquets procedents d’una xarxa IP en ràfegues que van destinades a una altre xarxa IP. Aquestes ràfegues viatgen, en tot moment en el domini òptic, per la xarxa OBS i no són processades per cap node. Per tant no pateixen els retards derivats de la conversió de medi òptic a medi elèctric per al seu processat i viceversa. Per ser encaminades per la xarxa, a cada ràfega li correspon un paquet de control (BHP, Burst Header Packet), enviat abans i que si que és processat pels nodes de la xarxa. Amb la informació dels paquets de control, els nodes de la xarxa calculen el temps que trigarà en arribar la ràfega i la seva durada per tal de tenir el camí commutat per quan arribi aquesta (es reserva l’ampla de banda per a la ràfega) [3], [4]. El guany que s’obté amb aquestes xarxes és que en cada node no cal processar tots els paquets IP d’informació un per un, ja que s’agrupen en una ràfega, el paquet de control de la qual es processa una vegada en cada node (un sol temps de procés en cada node serveix per encaminar cap al seu destí a varis paquets). El fet de que amb la informació del paquet de control els nodes de la xarxa reservin l’ampla de banda suficient per a cada ràfega permet no malgastar-lo i, ja que amb el procés d’un sol paquet per part dels mateixos nodes s’encaminen molts, no es perd tant de temps en el procés de capçaleres com en la commutació de paquets. Per altra banda, el fet de que per cada paquet de control que arriba a un node de la xarxa s’hagi de reservar ampla de banda per a la seva ràfega corresponent pot portar problemes quan dues o més reserves s’han de fer en el mateix instant de temps i no hi hagin suficients canals disponibles. Com que en el medi òptic no existeixen buffers per tal de guardar-hi les ràfegues abans de ser commutades, s’ha de fer ús d’algoritmes de planificació de l’ampla de banda (algorithms for burst scheduling). Aquests algoritmes poden tenir diferent complexitat i és un dels camps d’investigació més importants pel que fa a les xarxes OBS. 1.4. Elements de la xarxa OBS Les xarxes OBS estan formades principalment per una estructura de dos tipus de nodes diferenciats: els nodes frontera situats als límits de la xarxa i els nodes del nucli. Tot seguit es descriuen aquests dos elements juntament amb d’altres que també formen part de la xarxa: • Node Frontera: Els nodes frontera actuen com a enllaços entre diferents xarxes IP externes i la xarxa OBS. Reben els paquets IP per tal de formar les ràfegues de dades i els seus corresponents paquets de control. Seguint el funcionament de la xarxa OBS, envien primer el 10 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues 2.4.3. Format de les ràfegues Com ja s’ha dit anteriorment l’agent OBS és l’encarregat de la creació de les ràfegues i dels seus respectius paquets de control (BHP). La definició de l’estructura d’aquests i dels camps que els componen està realitzada per l’estructura hdr_burst. Tot seguit es mostra part del codi que defineix l’estructura i els seus elements: struct hdr_burst { int burst_id_; int burst_type_; //Indica si és ràfega de dades o un BHP. int burst_size_; int npkts_; double offset_time_; //Mètodes per a obtenir els camps de la ràfega. int &burst_id() {return (burst_id_);} int &burst_type() {return (burst_type_);} int &burst_size() {return (burst_size_);} int &npkts() {return (npkts_);} static int offset_burst_; inline static hdr_burst* access_burst(Packet *p){ return(hdr_burst*) p->access(offset_burst_); } }; Els camps de les capçaleres de les ràfegues de dades i els BHP són els mateixos. L’única diferència que hi entre els dos tipus de paquets és el camp de dades, inexistent en els paquets de control i de mida variable en les ràfegues de dades ja que conté els paquets IP introduïts en aquesta. Tot i que en una xarxa OBS real serien necessaris múltiples camps en les capçaleres dels seus paquets per al seu funcionament, aquí només s’hi han inclòs aquells estrictament necessaris per a les simulacions. Aquests camps són: • burst_id_: enter encarregat de la identificació de la ràfega. El mètode per tal d’assignar el nombre de identificació va a càrrec de la classe BurstAgent i s’explicarà més endavant. • burst_type_: enter que indica el tipus de paquet OBS del que es tracta. Si el valor d’aquest camp és 0 tenim un paquet de control (BHP). En cas de ser 1 es tractaria d’una ràfega de dades. • burst_size_: suma total dels bytes que ocupen tots els paquets IP introduïts a la ràfega associada al valor del camp identificació de ràfega. Aquesta informació permet saber la longitud de informació que transporta la ràfega. Simulador de xarxes OBS 11 • npkts_: enter que indica la quantitat de paquets IP que inclou la ràfega de dades que està associada al valor del camp identificació de ràfegues esmentat abans. • offset_time_: nombre real que indica el temps de offset que hi ha entre el BHP i la seva ràfega corresponent. Fig 2.4: Forma de la ràfega i del BHP L’estructura hdr_burst també defineix mètodes per tal que l’agent OBS pugui recuperar en tot moment el valor dels camps esmentats anteriorment. 2.4.4. L’estructura BurstMan Tal i com s’ha explicat anteriorment l’estructura BurstMan és l’encarregada de la gestió i emmagatzematge del contingut de les ràfegues a enviar. Principalment els elements que componen aquest estructura són diferents vectors que emmagatzemen paràmetres necessaris per a la formació de la capçalera de la ràfega (com són la mida d’aquesta, els paquets IP que conté, etc), i una matriu on es dipositen els paquets IP que després formaran part de la ràfega. La definició en el codi d’aquesta estructura es mostra a continuació: struct BurstMan { Packet *BurstBuffer_[N_NODES][MAXBURSTSIZE]; int npudp_[N_NODES]; int burst_size_[N_NODES]; void resetBurst(int destnode); inline BurstMan(){ for (int j = 0; j < N_NODES; j++){ for(int i = 0; i < MAXBURSTSIZE; i++) BurstBuffer_[j][i] = NULL; 12 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues } for (int j = 0; j < N_NODES; j++){ npudp_[N_NODES] = 0; burst_size_[N_NODES] = 0; } } }; La part més important de l’estructura BurstMan és la matriu BurstBuffer_. Aquesta emmagatzema els paquets IP en les seves cel·les. Cada cel·la conté un paquet IP. L’estructura de la matriu es mostra en la següent figura: Fig 2.5 Estructura de la matriu BurstBuffer_. La matriu té tantes files com nodes frontera hi ha en la topologia a simular (N_NODES) i tantes columnes com paquets poden ser introduïts en una ràfega de dades (MAXBURSTSIZE). Cada fila de la matriu és un buffer on es van introduint els paquets que van dirigits a un node destí comú: la primera fila conté en cada cel·la un paquet IP destinat al node frontera N0, les cel·les de la segona fila contenen els paquets destinats al node N1 i així fins l’últim node frontera de la xarxa OBS. Tots els paquets destinats a un mateix node són emmagatzemats en una fila fins que aquesta està totalment plena o fins que un temporitzador associat a aquesta fila expira. Just en aquest moment, es realitza un procés d’encapçalament on s’hi incorpora la capçalera amb les dades corresponents i la ràfega s’envia, després del seu paquet de control corresponent, al seu destí. Aquest procediment és realitzat per a cada ràfega de dades destinada a cada node frontera de la topologia. D’aquesta manera es permet crear al mateix temps diferents ràfegues que continguin només aquells paquets destinats als agents IP connectats al node frontera destí de la ràfega. Cada node IP origen i destí té un node frontera al que hi està connectat per tal de poder enviar i rebre informació a través de la xarxa OBS. Aquesta Simulador de xarxes OBS 13 associació és coneguda per cada node frontera per tal de que quan rep un paquet IP sàpiga en quina ràfega, i per tant a quina fila de la matriu, l’ha de posar. Mentre els nodes frontera OBS coneguin quins nodes IP hi estan connectats a cada un d’ells, a partir de l’adreça IP destí d’un paquet, cada node frontera sap on haurà de posar-lo. Tot i que per cada node hi haurà una fila de la matriu BurstBuffer_ que no s’utilitzarà (la fila corresponent a la ràfega de paquets destinada a ell mateix) i que no faria falta realitzar el manteniment d’aquesta, aquest mètode redueix la complexitat en la realització del codi del simulador. Per altra banda es pot veure una limitació del simulador, i és que en la topologia de la xarxa OBS no hi poden haver més nodes frontera que files en la matriu, ja que qualsevol paquet destinat a un node frontera que no té lloc en la matriu no serà guardat en lloc i per tant es perdrà (la simulació deixaria de funcionar mostrant una violació de segment com a missatge d’error a nivell de codi de C++). Els vectors npudp_ i burst_size_ contenen en cada cel·la un enter. En el cas del vector npudp_ aquest enter indica el nombre de paquets que conté la ràfega que va destinada al node corresponent a la posició de la cel·la (la posició 0 correspon al node 0, la posició 1 al node 1, etc...). De idèntica manera funciona el vector burst_size_ on cada valor indica la suma en bytes del total de paquets inclosos en la ràfega en aquell moment. Per tant aquests vectors tenen tantes columnes com nodes frontera hi ha en la topologia (N_NODES). Fig 2.6 Estructura dels vectors npudp_ i burst_size_. 2.4.5. La classe BurstAgent La classe BurstAgent és el nucli de l’agent OBS. Com ja s’ha dit anteriorment, la classe BurstAgent hereta atributs i mètodes de la classe Agent definida pel codi C++ del ns. Les principals funcions d’aquesta classe són el muntatge i el desmuntatge de les ràfegues, la creació d’aquestes juntament amb els seus paquets de control corresponents i la inclusió del temps de offset entre elles. Tot això fent ús de les estructures BurstMan i hdr_burst explicades abans. Els següents subapartats expliquen com es realitzen les funcions de la classe BurstAgent. 14 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues 2.4.5.1. El mètode recv() El mètode recv() és el punt d’entrada dels paquets a l’agent BurstAgent, ja siguin paquets IP, paquets de control (BHP) o ràfegues. El classificador de ports invoca aquest mètode per tal d’enviar paquets a l’agent OBS. Els paquets IP generats en el mateix node i amb destí un altre necessiten ser introduïts en una ràfega. De manera similar les ràfegues rebudes pel node i amb paquets IP destinats a agents IP del mateix node necessiten ser extrets. Per tant el mètode recv() ha de poder distingir entre paquets IP (destinats o no al mateix node) i ràfegues de dades per tal de enviar-los als mètodes de muntatge i desmuntatge corresponents. 2.4.5.2. Introducció de paquets IP en una ràfega La introducció dels paquets IP en les ràfegues es realitza en la funció addPacket() de la classe BurstAgent. Quan un paquet IP arriba a l’agent per tal de ser introduït és enviat a aquesta funció que el posa en la posició de memòria corresponent dins de la matriu BurstBuffer_ en funció de l’agent IP receptor al qual va destinat (cada agent IP estarà enllaçat amb un node frontera, que serà el destí de les ràfegues amb paquets IP destinats a aquests agents). La funció addPacket() gestiona els valors dels vectors npudp_ i burst_size_ per tal de que vagin en concordança amb el contingut de la matriu. Quan s’introdueix un paquet IP dins de la matriu només s’hi introdueixen els valors dels camps de la capçalera ja que la informació que hi ha en el camp de payload no interessa per a les simulacions. Tot i així la mida de la ràfega és la suma del total de les longituds dels paquets que la composen. El simulador realitzat funciona amb dos criteris per tal de decidir el moment d’enviar una ràfega, els paquets de la qual encara estan a la matriu BurstBuffer_[6]: • El primer és que finalitza la introducció de paquets en el buffer de la matriu quan la suma de la longitud en bytes de tots aquests supera un límit establert per l’usuari a través del codi TCL. Aquest mètode basat en la longitud de ràfegues (burstlength-based) és el primer i més fàcil implementat en el simulador. • El segon criteri es basa en temps i consisteix en finalitzar la introducció de paquets al buffer un cop que un temporitzador (BurstTimeOut) hagi expirat. Aquest temporitzador comença a contar en el moment en que el primer paquet IP es diposita en la primera cel·la de la fila corresponent a un node. Aquest mètode (timer-based) requereix d’un temporitzador, el qual és un dels mencionats anteriorment i que es descriuran més endavant. Per tant aquest simulador funciona amb una barreja dels dos modes anteriorment descrits (mixed timer/burstlength-based). La comparació entre un mode de funcionament i l’altre i la seva interacció entre ells, així com els Simulador de xarxes OBS 15 avantatges i inconvenients de cada un seran descrits en la part d’aquest document dedicada a l’estudi d’una xarxa OBS. Tan en el cas que s’hagi d’enviar una ràfega perquè hagi expirat el temps o perquè s’hagi arribat a un màxim de mida la funció addPacket() envia la informació necessària a la funció sendBurst() per tal de que completi la ràfega (omplint els camps de la capçalera) i crea el paquet de control corresponent (el BHP, Burst Header Packet). 2.4.5.3. Creació i enviament de la ràfega i del BHP Quan la funció sendBurst() és cridada es recullen el valor del nombre de paquets introduïts en la fila corresponent de la matriu BurstBuffer_, que es troba en el vector npudp_, i la suma total en bytes de les longituds dels paquets a enviar extreta del vector burst_size_. Tots aquests valors són utilitzats per a omplir els camps de les capçaleres de la ràfega de dades i del BHP. En primer lloc es crea el BHP i la ràfega de dades. Per al camp d’identificació de ràfegues es fa servir un mètode explicat en el següent apartat Identificació de les ràfegues. Un cop el paquet de control i la ràfega de dades estan creats són enviats a un buffer de sortida de l’agent anomenat MainBuffer_, un vector que conté els paquets OBS que han de sortir del node. El paquet de control i la ràfega ocupen cada un una cel·la del vector (les dues primeres lliures). Emmagatzemar en aquest buffer els paquets OBS permet borra la fila de la matriu BurstBuffer_ corresponent al destí d’aquesta ràfega i poder-la tenir disponible de forma més immediata de cara a pròximes introduccions de paquets IP que arribin a l’agent posteriorment. D’aquesta manera es redueix el temps d’ocupació de la matriu BurstBuffer_. En el cas de no introduir aquest nou buffer s’hauria d’utilitzar la fila de la matriu com a tal, provocant que els paquets IP que arribessin amb el mateix destí no poguessin ser introduïts en ell. Si fos així podria provocar un mal funcionament del simulador i incoherències entre els valors de la capçalera de la ràfega i el contingut d’aquesta (els valors de les capçaleres, com la quantitat de paquets i la mida total, ja han estat introduïts i en cas de que hi entressin nous paquets els canvis no quedarien hi reflectits). També es redueix a zero la probabilitat de pèrdua dels paquets IP que arribin posteriorment, ja que mentre la ràfega a enviar està guardada en un altre buffer, es poden anar emmagatzemant els paquets IP a la fila de la matriu reservada per aquell destí. S’ha triat aquest mode de funcionament de cara al simulador per la seva simplicitat en el moment de processar la ràfega i per la seva fiabilitat (no es perd cap paquet IP). 16 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues Fig 2.7 Creació de la ràfega m destinada al node n Una altre opció de funcionament que evitaria l’ús d’un buffer extra seria dotar al simulador d’una predicció de la longitud de la ràfega (burst length prediction),on en el camp de longitud es ficaria l + f(t): l seria la longitud de la ràfega i f(t) la predicció. Si el nombre de paquets IP que arriben al node frontera fan que la longitud extra sigui més gran que f(t), aquesta informació es perdrà en els moments en que els paquets de control facin les reserves de l’ampla de banda en els nodes del nucli. En cas de que la longitud excedent sigui més petita, es desaprofitarà ampla de banda dels enllaços. Tot i que aquest mètode requereix una complicació més elevada en programació permet introduir nous paquets en una ràfega a punt de sortir, evitant així el retard provocat en el cas de que s’haguessin de deixar per a la següent ràfega. Emmagatzemats els dos paquets OBS creats, es fa una comprovació sobre l’estat del canal consultant la variable free_channel_. Aquesta variable té un valor superior a 0 en cas de que el canal no estigui ocupat. En cas contrari, el canal està reservat per a la transmissió d’altres paquets OBS i el valor de la variable és 0. Per tant els casos que es poden donar en el moment en que es consulta la variable free_channel_ són els següents: • Si el canal està lliure s’envia el BHP al classificador del node encarregat de encaminar-lo al seu destí, es reordena el buffer de sortida desplaçant cada paquet una posició a l’esquerra i s’indica que el canal està reservat posant la variable free_channel_ a 0. Enviat el BHP, el temporitzador de Offset comença a funcionar (OffsetTimer). Aquest temporitzador té un valor inicial, corresponent al temps de offset entre el BHP i la ràfega de dades, establert com a paràmetre i definit en la simulació a través del codi TCL. El comptador va decreixent i en el moment en que arriba a 0 és dóna pas a la ràfega de dades per tal de que sigui enviada al classificador del node i encaminada cap al seu destí darrera del BHP. Un cop s’ha enviat la ràfega de dades, es torna a reordenar el buffer de Simulador de xarxes OBS 17 sortida i es posa la variable free_channel_ a 1 indicant que el canal deixa d’estar reservat. • Si el canal està ocupat els paquets OBS queden emmagatzemats en el buffer de sortida esperant a ser enviats en el moment en que el canal està lliure. Quan el canal, després d’estar ocupat, es queda lliure es mira el buffer de sortida per tal de repetir el procés d’enviament per als dos següents paquets OBS (la ràfega de dades que ocuparà la posició 1 i el seu paquet de control corresponent que ocuparà la posició 0). Amb el funcionament actual del simulador el valor màxim de la variable free_channel_ és 1 al només haver-hi un sol canal. Aquest valor es pot incrementar en el cas de introduir més canals al node (més enllaços de FO que anessin a la xarxa OBS). Per tant es permet una certa escalabilitat amb aquest mètode de creació i enviament de paquets OBS. Els paquets de control i les ràfegues són en realitat paquets IP definits en el ns però modificats per tal de que incorporin la capçalera definida per l’estructura hdr_burst. Per tant, ja que la seva estructura inicial només ha estat modificada per a contenir una capçalera més, els paquets de control i les ràfegues incorporen també la capçalera IP definida en el codi de ns. Aquesta capçalera és la que s’utilitza per tal de introduir, entre d’altres, l’adreça del node destí al qual va destinada la ràfega o el BHP (camp daddr_), els paquets IP introduïts (camp de payload) i un valor en el camp prio_. Aquest últim camp de la capçalera IP ens serveix per a que els classificadors dels nodes de la topologia sàpiguen si el paquet OBS és una ràfega de dades o és un BHP. Realitzar una distinció entre els tipus de paquets OBS a nivell de la capçalera IP és útil ja que els classificadors no entenen de capçaleres de ràfegues definides per l’estructura hdr_burst (a aquesta capçalera només hi pot arribar un agent OBS i per tant és l’únic que pot llegir el camp burst_type_). És necessari que els classificadors dels nodes puguin distingir entre els BHP i les ràfegues de dades ja que els paquets de control han de tenir un temps de procés en cada node del camí, mentre que les ràfegues de dades no han de patir aquesta penalització temporal ja que, en arribar a un node, la commutació del seu camí ja ha estat realitzada gràcies al procés que el node ha fet del BHP. El funcionament i l’assignació de valors al camp prio_ s’expliquen més endavant en l’apartat reservat als nodes del nucli de la xarxa OBS. 18 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues Fig 2.8 Recorregut de paquets IP i OBS en un node frontera origen La figura anterior mostra el camí realitzat pels paquets IP, els paquets de control i les ràfegues de dades en un node frontera origen. L’agent IP és la font de paquets IP, que els envia al classificador del node. Aquest decideix enviarlos a l’agent OBS per tal de poder crear la ràfega que serà enviada, després d’un temps de Offset del seu paquet de control, a l’enllaç de fibra òptica. El cercle que hi ha a l’esquerra del classificador representa un simple punt d’accés al node (en el nostre simulador no té més importància). 2.4.5.4. Identificació de les ràfegues Per a la identificació de les ràfegues i la seva associació amb els seus paquets de control corresponents s’ha incorporat tant en l’estructura de la ràfega com en la dels paquets de control un camp d’identificació anomenat burst_id_. A cada node se li assigna un rang de valors d’identificació de ràfega. Aquesta solució s’ha adoptat per tal de que en la xarxa OBS no hi hagin dos ràfegues amb el mateix valor en la identificació procedents de nodes diferents i que produeixin problemes en la associació d’un paquet de control amb la seva ràfega. Utilitzant aquest mètode també es simplifica la programació. Simulador de xarxes OBS 19 L’algoritme d’assignació del rang d’identificadors es descriu tot seguit: • Per mitjà del codi TCL s’assigna a cada node amb un agent OBS un identificador de node (un número) i un valor a la variable id_manager_ (per defecte és 100). • La funció d’inicialització de l’agent OBS rep el valor de l’identificador de node i el id_manager_. Amb aquestes dues variables s’obtenen els valors mínim (burst_id_min_) i màxim (burst_id_max_) d’identificació que utilitzarà el node: burst_id_min_ = (node_ + 1) * id_manager_; burst_id_max_ = ((node_ + 1) * id_manager_) + id_manager_ - 1; current_burst_id_ = burst_id_min_; • La variable current_burst_id_ indica l’identificador que es ficarà en la següent ràfega i BHP a enviar. El seu valor inicial correspon al del límit inferior del rang d’identificació i es va incrementant en cada ràfega enviada. Quan el seu valor arriba al màxim del rang es torna a posar el valor inicial. Un detall important per al bon funcionament del simulador és que el valor de la variable id_manager_ ha de ser d’un 1 seguit de zeros. Aquest mètode d’assignació d’identificadors per node permet incloure un node amb identificador 0 i la variable id_manager_ permet controlar des del codi interpretat el rang d’identificadors de cada node. Per a topologies molt complexes amb molts nodes intermedis és recomanable posar valors alts (de l’ordre de 100 o 1000), mentre que per a topologies senzilles amb valors més petits ja funciona correctament (com per exemple 10). 2.4.5.5. Extracció dels paquets IP de les ràfegues Quan els paquets OBS de control i les ràfegues de dades arriben al node destí són redirigits a l’agent OBS d’aquest últim. Mentre que els paquets de control són eliminats en la mateixa funció recv() de l’agent, les ràfegues de dades són enviades a la funció deBurst(). La funció deBurst() és l’encarregada de l’extracció dels paquets IP continguts en el camp de payload de les ràfegues de dades. Per a realitzar aquesta funció accedeix a les diferents capçaleres de la ràfega (especialment a la capçalera burst per tal d’obtenir el nombre de paquets IP que hi han introduïts, npkts_) i al camp de dades on estan els paquets. Un cop a accedit a les dades, comença el procés d’extracció consistent en recuperar cada paquet IP i enviar-lo al classificador del node. Aquest procés es repeteix en forma de bucle decrementant la variable que conté el número de paquets inclosos dins la ràfega fins a arribar a 0, moment en que finalitza la funció eliminant la ràfega de dades. 26 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues CAPÍTOL 3. FUNCIONAMENT DEL SIMULADOR 3.1. Introducció En aquest capítol es vol mostrar, utilitzant un exemple de simulació, el funcionament del simulador des del punt de vista de l’usuari: la topologia de la xarxa, la visualització de la simulació i el recull de dades juntament amb la seva presentació realitzada pel simulador. Pel que fa a la realització i l’estructura del codi TCL de la simulació, aquesta es comenta en detall a l’annex d’aquest document. 3.2. Exemple de simulació 3.2.1. Topologia i paràmetre de la xarxa OBS La topologia de la xarxa OBS la componen quatre nodes frontera connectats entre ells per dos node nucli. En aquest cas el node frontera 0 envia dades en el node frontera 1 passant pel node del nucli 10. Fig. 3.1 Esquema de la topologia utilitzada L’agent utilitzat per a la generació de paquets és una font CBR (Constant Bit Rate): els paquets s’envien a una taxa constant i d’una mida sempre igual. Per a obtenir uns resultats fàcilment interpretables, la simulació és realitza a baixa velocitat, és a dir, les velocitats dels enllaços i la taxa de la font de paquets IP són baixes i els temps de procés dels paquets de control, el de offset i el de creació de ràfegues són alts. Les dades es faciliten tot seguit per tal de poder interpretar els resultats més endavant: Funcionament del simulador 27  Ampla de banda dels enllaços: 10Mb  Retard de propagació dels enllaços: 10ms  Llindar màxim de longitud de ràfega: 1999 bytes  Temps de procés de paquets de control : 0,001 segons  Temps de Offset: 0,01 segons  Temps màxim de creació de ràfega: 0,8 segons La font genera paquets IP de 400 bytes cada 0,1 segons, rebuts i introduïts en ràfegues pel node frontera 0 i enviats a l’agent IP destí connectat al node frontera 1. La font comença a generar paquets als 0,2 segons de començar la simulació i finalitza als 3 segons. 3.2.2. Visualització de la simulació i fitxer de log Per tal de poder visualitzar les simulacions de forma gràfica el simulador utilitza el programa de nam: amb aquest programa s’obre una finestra en la X- Windows del sistema operatiu on es veu un dibuix de la topologia i el recorregut dels paquets de control i les ràfegues seguint l’evolució temporal de la simulació. En la figura inferior es mostra una captura corresponent a la simulació, els paràmetres de la qual s’han anomenat anteriorment: la ràfega de dades s’ha etiquetat com a 0 mentre que el paquet de control que va davant com a 1. Fig. 3.2 Captura d’una simulació amb el programa nam 28 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues Pel que fa als esdeveniments de la simulació (inicialització de nodes, recepció de paquets, enviament de ràfegues, etc) són mostrats en text i en temps real per pantalla, a la consola del sistema operatiu. Tots ells també queden guardats en el fitxer de log esdeveniments_simulacio. Aquest fitxer es sobreescriu cada cop que es fa corre una simulació, amb la qual cosa en el moment que es vulgui tirar endavant una nova simulació cal guardar aquest fitxer amb un altre nom per tal de que quedi intacte. 3.2.3. Recopilació de resultats El simulador recull tots els resultats en un fitxer anomenat dades_simulació. Aquest fitxer mostra els següents paràmetres de cada node un cop finalitzada la simulació:  Paquets IP rebuts  Paquets IP enviats  Paquets de control rebuts  Paquets de control enviats  Ràfegues de dades enviades  Ràfegues de dades rebudes  Bytes de paquets IP rebuts  Bytes de paquets IP enviats  Bytes de ràfegues de dades rebuts  Bytes de ràfegues de dades enviats També es mostren el nombre de ràfegues que tenen tal número de paquets IP en el seu interior. Totes aquestes dades les pot utilitzar el programa per tal de poder realitzar gràfiques passant-les al programa X Graph: en cada simulació podem demanar quines dades de les anteriors vol que ens mostri el programa en format gràfic incloent aquestes peticions en el codi TCL. Cada un cert període de temps, indicat en el codi de TCL, es recullen les dades i es posen a les gràfiques, mostrant el nombre de bytes, paquets o ràfegues enviades o rebudes en aquell interval de temps per cada node. Posant un exemple, en la figura següent, corresponent a la simulació anterior, la traça vermella indica el nombre paquets IP rebuts pel node frontera 0 i la traça blava els enviats pel node frontera 1: en aquest cas els paquets IP van en ràfegues de 5 paquets i els pics blaus indiquen que s’envien els paquets extrets de la ràfega en un interval de temps menor que el període indicat (recordem que el node 0 rep paquets IP i el node 1 els envia un cop extrets de la ràfega cap al seu destí en la xarxa IP). És important remarcar que les traces no indiquen els paquets rebuts en el node des del principi de la simulació, si no des del interval de captura de dades anterior, tot i que al final, el total de les dades de la simulació es recullin en el fitxer dades_simulació. Funcionament del simulador 29 Fig. 3.3 Captura d’una simulació amb el programa nam En la figura anterior es veu com totes les ràfegues enviades, amb excepció de l’última tenen cinc paquets IP. Això es degut a que amb cinc paquets IP enviats per la font, cada un d’ells de 400 bytes donant un total de 2000 bytes, és supera el llindar de longitud màxima de la ràfega, que és de 1999 bytes. Es comprova, per tant, el funcionament de l’enviament de ràfega basat en la mida d’aquesta. Per altra banda, l’última ràfega de només tres paquets és enviada ja que el temps de creació de ràfega expira sense que aquesta arribi al màxim de la seva capacitat (mode basat en temps). També, a part de les dades anteriors, el simulador dóna una gràfica on es mostren quantes ràfegues hi ha hagut de tants paquets (els paquets es mostren a l’eix x i les ràfegues es mostren a l’eix y). La figura següent continua amb l’exemple de la simulació anterior, mostrant un pic que indica una ràfega de tres paquets (l’última) i un pic indicant les cinc ràfegues de cinc paquets cada una. Fig. 3.4 Relació de ràfegues i paquets IP 30 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues CAPÍTOL 4. ESTUDI DE LA CREACIÓ DE RÀFEGUES 4.1. Introducció Els següents apartats d’aquest document recullen les dades i conclusions de l’estudi portat a terme amb el simulador descrit anteriorment. La generació de ràfegues de dades i el comportament del node frontera programat davant la recepció de paquets IP generats per una font de Poisson són l’objectiu d’aquest estudi. 4.2. Escenari 4.2.1 Descripció En aquest escenari es substitueixen les fonts constants de paquets CBR per fonts de Poisson, dotant a les simulacions d’un element no determinista en la generació de paquets IP i en el seu encapçalament per a la formació de ràfegues. Es situa un agent generador de tràfic en un node frontera OBS i un agent destí en un altre node frontera. En mig dels dos nodes frontera s’ha introduït un node del nucli de la xarxa. Fig. 4.1 Topologia física de la xarxa OBS Abans de la comprovació dels resultats proporcionats per la simulació es fa un estudi teòric sobre el comportament esperat en les simulacions, tant en la generació dels paquets com en el seu encapçalament. A continuació es mostren diverses comprovacions de la viabilitat que atorga el generador de tràfic de Poisson del programa per donar pas, finalment, als resultats de les simulacions i les conclusions. Estudi de la creació de ràfegues 31 4.2.2. Desenvolupament teòric Suposant que tenim una població infinita i fixant un interval de temps T, Poisson especifica que la probabilitat de que hi hagin n arribades en un sistema en el període de temps T és: ( ) T k e k kP λ λ − = ! T )Ten arribades ( (4.1) En el nostre cas utilitzem fonts de Poisson per tal de simular el comportament d’un node frontera OBS davant d’una població infinita d’usuaris que generen paquets IP de forma aleatòria (els usuaris actuen com a fonts independents) amb una taxa de λ paquets per segon. Considerem en tot moment el cas homogeni en que el valor de λ és constant i no depèn del temps. Essent T, el període de temps límit (burts_time_out_) que triga una ràfega en crear-se, en el cas que aquesta no arribi a la mida màxima, i n el nombre de paquets IP arribats al node en aquest interval, amb la fórmula de Poisson indicada anteriorment es vol calcular la probabilitat que una ràfega estigui plena amb el màxim de paquets IP quan és enviada a la xarxa. Per tal que una ràfega sigui enviada a la xarxa OBS totalment plena per un node frontera han d’haver arribat a aquest el nombre màxim de paquets que pot contenir la ràfega en un temps menor que T, ja que en el cas contrari la ràfega és enviada sense estar plena del tot. El càlcul de la probabilitat que una ràfega amb capacitat per a n paquets sigui enviada a la xarxa, totalment plena, en un temps màxim de creació de ràfega T i amb una taxa λ d’arribada de paquets IP al node s’especifica a continuació [7]: • Primer calculem la probabilitat que no s’ompli la ràfega, la qual és la suma de les probabilitats que en un temps T hi hagin des de 0 fins a n-1 arribades: ( ) ( ) ( ) ( ) ( ) 1...3210)Ten ràfaga la omplis' no( −+++++= nPPPPPP (4.2) • Per tal de calcular la probabilitat que s’ompli la ràfega restem a 1 l’anterior resultat. D’aquesta manera es tenen en compte totes les arribades possibles: ( ) ( ) ( ) ( ) ( )( ) ( ) ∑ − = −=−+++++−= 1 0 11...32101 n r rPnPPPPPP (4.3) 32 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues Amb l’expressió anterior podrem calcular en base de probabilitats el nombre de ràfegues que seran enviades al màxim de la seva capacitat al llarg d’una simulació. Un altre paràmetre que es fa servir en el estudi és el càlcul de l’esperança per tal de poder fer una previsió de quants paquets IP esperem que continguin la majoria de ràfegues que circularan per la xarxa OBS. En el cas de l’esperança en un procés de Poisson el seu valor es calcula de la següent manera: [ ] ( ) ( ) ( ) ( ) ( ) ( ) TTeeTTe Te k kee k kkE TTT T k k T k T k λλ λλ λλ λλ λ λλ λλλ λλλ ==      ++++= =      +++=== −− − ∞ = − ∞ = −∑∑ ... !3 T !2 T 1 ... !3 T 3 !2 T 2 ! T ! T 32 32 00 (4.4) Aquesta expressió ens dóna el nombre mig de paquets IP que arriben en un interval T amb una taxa λ. Per tant ens indica el nombre de paquets IP que s’espera que siguin introduïts en una ràfega. 4.2.3. Primer cas: encapçalament a baixa velocitat 4.2.3.1. Descripció En aquest apartat es realitzen simulacions en una hipotètica xarxa OBS de baixa velocitat. Aquesta velocitat reduïda no afecta a l’ampla de banda dels enllaços de fibra òptica si no als diferents paràmetres temporals dels nodes frontera (temps de procés, temps de offset i temps de creació de ràfega), sent bastant grans, de l’ordre de mil·lisegons, així com la taxa λ d’enviament de paquets IP sent petita, de l’ordre de 10 paquets per segon. Caracteritzant d’aquesta manera els paràmetres del programa es simularan els encapçalaments de paquets IP provenints d’una font de Poisson per tal de veure el seu comportament en un escenari més senzill de configurar que en el cas d’un encapçalament a alta velocitat, on els temps serien de l’ordre de microsegons. 4.2.3.2. Dades obtingudes en el càlcul de probabilitats Amb un primer grup de 10 simulacions es vol fer una comparació de les probabilitats teòriques i simulades que les ràfegues tinguin el nombre màxim de paquets (10 en aquest cas) i per tant s’hagin enviat per aquesta condició en lloc de per que el temps de creació de la ràfega expiri. En un cas posterior on la Estudi de la creació de ràfegues 33 velocitat d’encapçalament és més alta s’ampliarà l’estudi amb la inclusió d’altres paràmetres. En aquestes primeres simulacions el valor de λ és de 20 arribades per segon mentre que el valor del temps de creació de ràfegues va variant de 0,1 segons a 1 segon. Els resultats obtinguts es mostren a la taula següent: Taula 4.1. Probabilitat d’omplir la ràfega en funció de T (λ = 20p/s, n = 10p). Temps BHP/Raf env Prob. Teòr. Dades Simul. Esp. Calcul. Esp. Gràfica 0,1 135 0,00005 0,00000 2 2 0,2 80 0,00813 0,03750 4 4 0,3 60 0,08392 0,18333 6 7 0,4 50 0,28340 0,44000 8 10 0,5 44 0,54200 0,65000 10 10 0,6 43 0,75760 0,76000 12 10 0,7 42 0,89060 0,88000 14 10 0,8 41 0,95670 0,95120 16 10 0,9 40 0,98460 1,00000 18 10 1 40 0,99500 1,00000 20 10 Les diferents columnes de la taula són (d’esquerra a dreta): el temps de creació de ràfegues, el nombre de ràfegues o paquets de control BHP enviats pel node frontera, la probabilitat teòrica de que s’ompli la ràfega calculada a partir de l’expressió 4.3, la probabilitat calculada a partir de les dades del simulador, el nombre mig de ràfegues totalment plenes calculat de forma teòrica a partir de l’expressió 4.4 i finalment el valor del nombre mig proporcionat per les dades resultants de la simulació. La probabilitat de que s’ompli la ràfega donada per la simulació es calcula dividint el nombre de ràfegues enviades totalment plenes entre el nombre total de ràfegues enviades pel node. Els valors de temps d’aquestes simulacions han estat escollits juntament amb la taxa λ per tal de veure els canvis que hi ha en passar d’enviar ràfegues gairebé buides a totalment plenes. Per tant, com es pot veure a partir de la taula, les probabilitats calculades i resultants van de 0 a 1. Gràficament la figura següent mostra les corbes resultants: 34 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues Probabilitat d'omplir la ràfaga 0,0 0,2 0,4 0,6 0,8 1,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 0,8 0,9 1 T(ms) Probabilitat Probabilitat Teòrica Probabilitat Simulador Fig. 4.2 Probabilitat d’omplir les ràfegues en funció de T Com es pot veure en la gràfica tant en el cas teòric com en el calculat a partir de les dades de la simulació el comportament és similar. Tot i que en el cas de la simulació les probabilitats comencen a pujar una mica abans que en el cas teòric, tenint en compte que la font de Poisson del simulador és una aproximació i que en el recull de dades s’han hagut d’eliminar decimals, es pot considerar com a bo el comportament del simulador. En el cas dels nombres mig de paquets IP esperats en les ràfegues representats en les dues últimes columnes, l’esperança donada en la simulació també és superior al càlcul teòric a mesura que augmenta el temps (passa a estar de 0 a 2 punts per sobre). Les raons serien les mateixes que en el paràgraf anterior ja que si la probabilitat d’omplir la ràfega augmenta en una simulació, també ha d’augmentar el nombre de ràfegues que tenen més paquets en comparació de la simulació anterior. S’ha de remarcar que la meitat de files de la última columna està en vermell ja que els valors de la simulació no podran ser iguals als teòrics en el cas que aquests donin valors de nombre de paquets IP superiors al màxim permès pel simulador (en aquest cas és 10). En les següents 10 simulacions es pren com a variable λ essent n de valor 10 igual a les simulacions anteriors i T igual a 0,5ms. L’estudi realitzat en aquestes simulacions és idèntic a l’anterior amb la diferència de que la introducció dels paquets IP a la ràfega ara depèn de la taxa d’arribada d’aquests. Les dades recollides es mostren en la següent taula: Estudi de la creació de ràfegues 35 Taula 4.2. Probabilitat d’omplir la ràfega en funció de λ (T = 0,5s, n = 10p). λ BHP/Raf env Prob. Teòr. Dades Simul. Esp. Calcul. Esp. Gràfica 4 28 0,00005 0,00000 2 2 8 34 0,00813 0,08823 4 5 12 37 0,08392 0,18900 6 7 16 41 0,28340 0,48780 8 10 20 44 0,54200 0,66000 10 10 24 51 0,75760 0,78000 12 10 28 58 0,89060 0,91370 14 10 32 66 0,95670 0,95450 16 10 36 73 0,98460 1,00000 18 10 40 81 0,99500 1,00000 20 10 Com en el cas anterior el comportament del simulador en l’encapçalament ha de ser similar al teòric. La figura següent mostra la comparació entre el resultat esperat i el donat pel simulador: Probabilitat d'omplir la ràfaga 0,0 0,2 0,4 0,6 0,8 1,0 4 8 12 16 20 24 28 32 36 40 λ Probabilitat Probabilitat Teòrica Probabilitat Simulador Fig. 4.3 Probabilitat d’omplir les ràfegues en funció de λ El comportament de l’encapçalament, com en les de simulacions dependents de T, dóna una certa similitud entre el cas teòric i el pràctic. Com en les anteriors simulacions la gràfica de les dades proporcionades pel programa puja cap a 1 abans que en el cas teòric. Les diferències apreciades entre el resultat teòric i el pràctic són degudes a les ja anunciades en el apartat anterior (el fet que el programa realitza una aproximació per a simular un tràfic de Poisson i els errors propagats per l’eliminació de decimals en el recull de dades i els càlculs realitzats). 42 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues ràfega conté 10 paquets) i això es compleix en totes les simulacions de taxa superior a 40000 paq/s (totes les ràfegues aniran totalment plenes). Pel que fa a la eficiència, els resultats obtinguts són similars als donats quan es varia T en lloc de λ: començant per una eficiència inferior al 94%, aquesta es va acostant al màxim de 98% a mesura que la taxa λ puja i també ho fa la probabilitat d’omplir les ràfegues. Eficiència 91 92 93 94 95 96 97 98 99 4000 8000 12000 16000 20000 24000 28000 32000 36000 40000 λ Eficiència % Fig. 4.8 Eficiència en funció de λ quan T és igual a 500µs 4.2.4.4 Conclusions Tal i com s’ha vist en les diferents simulacions realitzades anteriorment, els càlculs teòrics per a obtenir les probabilitats de que s’omplin les ràfegues es comproven perfectament amb el simulador, el qual segueix amb molta similitud el model teòric. Pel que fa al càlcul de l’eficiència del simulador hem vist, com és lògic, que aprofitant el màxim la capacitat de les ràfegues, s’introdueixen a la xarxa OBS un nombre menor de bytes de capçalera i de paquets de control. En les primeres simulacions, de cada cas, en que la probabilitat d’omplir al màxim una ràfega és petita (ja sigui en el cas en que T és massa petita com en que ho sigui λ), l’encapçalament depèn del temps T de creació de ràfegues. En aquest cas, el programa es podria aproximar a un simulador amb introducció de paquets basada per temps (timer-based). En el cas de tenir un simulador així, s’ha de tenir en compte que un temps de creació de ràfegues massa petit pot omplir de forma innecessària la xarxa de paquets de control i de bytes de capçaleres de ràfegues en enviar moltes més de les necessàries, contenint aquestes molts pocs paquets IP (simulacions de la Taula 4.3 on T és igual a 100µs, 200µs i 300µs són un clar exemple). En el moment en que és λ el paràmetre que varia s’ha de posar un valor de T coherent per tal de que no passi això. Estudi de la creació de ràfegues 43 Si es tingués un valor de T massa elevat el retard que patirien els paquets IP introduïts a la ràfega podria arribar a ser intolerable. Aquest retard seria el més alt, en el pitjor dels casos, per al primer paquet en entrar a la ràfega, el qual ha d’esperar un temps T de creació de ràfega que començaria a contar només entrar el paquet. A aquest temps també s’hi hauria de sumar el temps de offset que hauria d’esperar la ràfega un cop creada i enviat el BHP. Finalment s’hauria d’incloure el retard per temps de propagació que patiria la ràfega en el seu viatge fins al node frontera destí de la xarxa OBS. Un cas com aquest seria el que es donaria si les simulacions de la Taula 4.3 tinguessin un valor de T molt alt i el simulador no pogués enviar ràfegues seguint el criteri de la longitud de la ràfega (introducció de paquets basada en longitud de ràfega o burstlength-based). Gràcies a aquest criteri, en que el simulador també té un nombre màxim de paquets IP per introduir en una ràfega, no es pot donar el cas en que el retard sigui massa gran, sempre i quan el simulador també es basi en introducció per màxim de temps i el valor d’aquest temps sigui coherent amb la taxa λ. És per tant recomanable una introducció de paquets com la del nostre simulador que fa servei dels dos modes d’encapçalament (mixed timer/burstlength-based). En el cas de el simulador només depengués de la mida de la ràfega per a que aquesta sigui enviada, l’elecció de la mida màxima vindria donada per la taxa λ, ja que si aquesta fos molt petita, el node trigaria en enviar la ràfega ja que aquesta no s’ompliria ràpidament, llavors no hi hauria cap garantia de que el retard sofert pels paquets sigui menor d’un llindar acceptable. Tot i que l’eficiència seria màxima, en aquest últim cas, aquesta no és un bon indicador per a comprovar el bon funcionament de la xarxa (l’eficiència seria molt bona però el retard, massa alt, no quedaria reflectit en aquest paràmetre). Si la taxa és petita és recomanable tenir un límit de paquets baix per tal de que el node no trigui gaire en enviar la ràfega. Uns exemples clars d’introducció basada en longitud de ràfega (aproximant amb el simulador utilitzat) serien les últimes simulacions de la Taula 4.4 en que la taxa λ és tan elevada que la introducció deixa de dependre de T per a que totes les ràfegues enviades pel node frontera tinguin el nombre màxim de paquets donada la seva capacitat. Una observació a fer en el cas de que el simulador s’acosti a un funcionament basat en temps és el fet de que la taxa de ràfegues de sortida del node frontera és més o menys constant. A la figura inferior es mostra aquest fet: els pics vermells representen els paquets IP arribats en un temps t al node frontera origen, mentre que els blaus representen el nombre de paquets IP que contenen les ràfegues arribades al node frontera destí en un altre temps. Tal i com es veu, cap de les ràfegues conté el nombre màxim de paquets (com a molt una ràfega enviada entre els 1,5 i 2 segons conté 7 paquets IP mentre que el màxim és de 10). Els intervals de temps en que arriben les ràfegues al node destí són constants (les petites variacions que es poden veure són donades pel fet de que el temps en que arriben les ràfegues també va en funció del temps de transmissió, diferent en cada cas per la mida de la ràfega). 44 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues . Fig. 4.9 Comportament de l’encapçalament basat en temps En el cas de que la introducció de paquets depengui de la longitud de la ràfega, la distància en temps entre una i altra varia. Aquesta distància pot arribar a ser molt petita en el cas que el tràfic de paquets IP sigui molt gran, podent provocar col·lisions a la xarxa OBS en transmetre una quantitat de paquets de control i de ràfegues molt alta. Fig. 4.10 Comportament de l’encapçalament basat en longitud de ràfegues Estudi de la creació de ràfegues 45 Tal i com s’ha dit abans és recomanable que la introducció de paquets en una ràfega es realitzi utilitzant les dues vessants: per longitud de ràfega i per temps de creació d’aquesta. Per tal de que no s’arribi a funcionar en un sol mode, evitant així els problemes que es produeixen comentats abans, el temps T s’hauria de triar en funció de λ de tal manera que la probabilitat (resultant de la simulació) de que el node frontera enviï ràfegues totalment plenes estigui entre el 0,6 i 0,95 (T entre 500µs i 700µs quan el valor de λ és de 20000paq/s), valors en que l’eficiència no pateix una variació molt alta (passa del 97,87% al 98,02%), i es pot reduir el retard dels paquets fins a uns 300µs. 46 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues ANNEX En aquest annex és presenta el codi de la simulació del capítol 3 com a exemple de model utilitzat per el simulador de xarxes OBS. Com ja es descriu en el capítol, la topologia està composta per dos nodes nucli i quatre nodes frontera. Tot i que la informació va des d’un node frontera cap a un altre passant per un sol node del nucli, sense que els altres nodes no hi tinguin participació, es vol que aquest exemple serveixi com a model per a la realització de topologies més complicades. Primer es posa valor als paràmetres de la simulació: l’ample de banda dels enllaços (en bits per segon), el seu retard (en segons) el llindar màxim de longitud de ràfegues (en bytes), el temps de procés de paquets de control, el de Offset, el de creació de ràfega (tots tres en segons) i el valor de la variable id_manager_. set BWLink 10Mb set MaxBurst 1999 set DelayLink 10m set ProcesTime 0.001 set OffsetTime 0.01 set burst_time_out_ 0.8 set IDMan 100 set time 0.1 S’inicialitza el simulador tal com es fa en el ns normalment i es creen els fitxers on es guardaran les dades recollides pel simulador, per tal de fer la realització posterior de gràfiques i la visualització de la simulació. És necessita un fitxer per a cada node en el qual es volen recollir les dades. #Create a simulator object set ns [new Simulator] #Open a trace file set nf [open out.nam w] $ns namtrace-all $nf set f0 [open out0.tr w] set fburst_00 [open fburst00.tr w] set fit00 [open fitxer00.tr w] set fit01 [open fitxer01.tr w] set fit02 [open fitxer02.tr w] set fit03 [open fitxer03.tr w] set fit04 [open fitxer04.tr w] S’indica per mitjà d’una ruta la ubicació d’altres fitxers TCL necessaris per a la simulació: en aquest cas es tracta del fitxer ns-obs.procs.tcl on estan les funcions de recollida de dades. Annex 47 source /usr/local/ns-allinone-2.27/ns-2.27/burst/nsobs.procs.tcl En el següent pas es defineix la funció que es crida un cop finalitza la simulació. Aquesta funció tanca els fitxers on s’hi han posat les dades i es criden els programes externs com el nam, per tal de visualitzar la simulació, i el X Graph, que construeix les gràfiques amb les dades obtingues i guardades en el fitxer. #Define a 'finish' procedure proc finish {} { global ns nf f0 fburst_00 fit00 fit01 fit02 fit03 fit04 p0 p1 p2 p3 ns flush-trace $p0 endAgent $p1 endAgent close $fburst_00 close $fit00 close $fit01 close $fit02 close $fit03 close $fit04 close $nf close $f0 exec ./nam out.nam & exec ./xgraph fburst00.tr -geometry 600x400 & exec ./xgraph fitxer00.tr fitxer01.tr fitxer02.tr fitxer03.tr fitxer04.tr -geometry 800x400 & exit 0 } Un cop definits els paràmetres i les funcions de la simulació es procedeix a la construcció de la topologia. Es crea cada node (nX), s’indica el color i la forma (per tal de distingir els dos tipus que hi han) i s’uneixen entre si amb els enllaços corresponents a la topologia #Nodes frontera set n0 [$ns node] $n0 shape "circle" $n0 color "blue" set n1 [$ns node] $n1 shape "circle" $n1 color "blue" set n2 [$ns node] $n2 shape "circle" $n2 color "blue" set n3 [$ns node] $n3 shape "circle" $n3 color "blue" #Nodes del nucli 48 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues set n10 [$ns node] $n10 shape "hexagon" $n10 color "red" set n11 [$ns node] $n11 shape "hexagon" $n11 color "red" #Connect the nodes with two links $ns duplex-link $n0 $n10 $BWLink $DelayLink DropTail $ns duplex-link $n1 $n10 $BWLink $DelayLink DropTail $ns duplex-link $n2 $n11 $BWLink $DelayLink DropTail $ns duplex-link $n3 $n11 $BWLink $DelayLink DropTail $ns duplex-link $n10 $n11 $BWLink $DelayLink DropTail Es creen els agents OBS i s’enllacen als nodes, tant als frontera com als nodes del nucli. S’introdueixen les variables corresponents als diferents paràmetres de la simulació juntament amb l’identificador de node (Node) i la variable utilitzada per a l’assignació d’identificadors a les ràfegues (IDMan). Un cop fet això s’avisa a la funció initagentBurst situada en el fitxer ns-obs.procs.tcl per tal posar en funcionament l’agent. set p0 [new Agent/Burst] $ns attach-agent $n0 $p0 set Node 0 $p0 set offset_time_ $OffsetTime $p0 set proces_time_ $ProcesTime $p0 set burst_time_out_ $burst_time_out_ $p0 set maxburst_ $MaxBurst $p0 initagentBurst $Node $IDMan Una vegada realitzada la configuració de l’agent OBS es procedeix a la creació de l’agent generador de tràfic IP: en aquest cas es tracta d’un agent UDP al qual li serà assignat un tràfic CBR. Les característiques d’aquest tràfic CBR s’han d’introduir en la simulació (mida del paquet i interval de temps entre paquets enviats). set udp00 [new Agent/UDP] $ns attach-agent $n0 $udp00 # Create a CBR traffic source and attach it to udp00 set cbr00 [new Application/Traffic/CBR] $cbr00 set packetSize_ 400 $cbr00 set interval_ 0.1 $cbr00 attach-agent $udp00 En el node destí, en aquest cas el 1, es situa un agent receptor de tràfic. Les línies a incloure són: set p1 [new Agent/Burst] $ns attach-agent $n1 $p1 Annex 49 set Node 1 $p1 set offset_time_ $OffsetTime $p1 set proces_time_ $ProcesTime $p1 set burst_time_out_ $burst_time_out_ $p1 set maxburst_ $MaxBurst $p1 initagentBurst $Node $IDMan set null10 [new Agent/Null] $ns attach-agent $n1 $null10 Es connecten els dos agents IP, el que envia els paquets amb els que els rep. #Connect the traffic source with the traffic sink $ns connect $udp00 $null10 Finalment s’introdueixen els diferents esdeveniments que han de tenir lloc en la simulació com són els inicis del funcionament de les funcions que recullen dades (recordDataTipus-de-dades Node) i els temps d’inici i final de generació de paquets IP. S’arrenca la simulació en les últimes línies. #Dades a recopilar a incloure en la crida de la funcio recordData #IP_PKT_RECV 0 // Paquets ip rebuts #IP_PKT_SEND 1 // Paquets ip enviats #BHP_PKT_RECV 2 // BHP rebuts #BHP_PKT_SEND 3 // BHP enviats #BURST_PKT_RECV 4 // Rafegues de dades enviades #BURST_PKT_SEND 5 // Rafegues de dades rebudes #IP_BYTES_RECV 6 // Bytes de paquets ip rebuts #IP_BYTES_SEND 7 // Bytes de paquets ip enviats #BURST_BYTES_RECV 8 // Bytes de rafegues de dades rebuts #BURST_BYTES_SEND 9 // Bytes de rafegues de dades enviats Schedule events $ns at 0.0 "recordData00 0" $ns at 0.0 "recordData01 1" $ns at 0.2 "$cbr00 start" $ns at 3 "$cbr00 stop" $ns at 4 "recordBurst00" $ns at 4.1 "finish" #Run the simulation $ns run En el cas de realitzar una simulació on les fonts IP generin un tràfic de Poisson en lloc d’un CBR, s’han de treure les línies que configuren aquest últim i incloure les següents per tal de configurar els nous generadors de paquets IP. Amb les dues primeres es crea l’agent que rebrà el tràfic IP en el node n1. En les següents es crea una font de Poisson en el node n0 que envia paquets de 50 Estudi i simulació amb NS de xarxes òptiques de commutació de ràfegues 1000bytes i on 1/λ és igual a 0.02s L’últim número indica la velocitat en bits per segon en el moment en que s’envien el paquets (ha de ser molt alta per tal de que funcioni correctament l’aproximació que es fa de la font de Poisson tal com indica el manual del ns). Finalment s’introdueixen els esdeveniments que activen i desactiven el tràfic de Poisson. set sink0 [new Agent/LossMonitor] $ns attach-agent $n1 $sink0 set source0 [attach-expoo-traffic $n0 $sink0 1000 0s 0.02s 99999999999999.9k] $ns at 0.1 "$source0 start" $ns at 5.1 "$source0 stop" Bibliografia 51 BIBLIOGRAFIA [1] Shenai, R. Gowda, S., and Sivalingam, K.M. “Optical Burst-Switched Wavelength Division Multiplexed Network Simulator” November (2001). [2] Quiao, C and Yoo, M., “Choices, Features and Issues in Optica Burst Switching” (1999) [3] Quiao, C and Yoo, M., “Optical burst switchig (OBS)-a new paradigm fora n optical internet”, J. High Speed Netw. 8, 69-84 (1999)” [4] Li, J. and Quiao, C., “Recent progress in the scheduling algorithms in optical-burst-switched networks”, Journal of Optical Networking 3 (4), 229-241 April (2004). [5] Fall, K., “The Ns Manual (formerly ns Notes and Documentation)” (2003) [6] Chen, Y., Quiao, C. and Yu, X., “Optical Burst Switching (OBS): A New Area in Optica Networking Research”. [7] Aroca, J.M., ”Probabilitat i Processos Estocàstics; Notes de Classe”, Ed Cpet, Barcelona, (2002). [8] Schildt, H., “Turbo C/C++, Manual de Referencia”, Ed. McGraw-Hill, Nueva York, (1992).