Embed Size (px)
Citation preview
IEL1-I-04-15 IEL1-I-04-16
DESARROLLO DE LA HERRAMIENTA QUALNET PARA LA SIMULACIÓN Y EVALUACIÓN DEL DESEMPEÑO DE VOIP EN UNA WLAN
ISMAEL EDGARDO MELÉNDEZ RINCÓN
JUAN DAVID CHAVES ESPINOSA
UNIVERSIDAD DE LOS ANDES
FACULTAD DE INGENIERÍA DEPARTAMENTO DE INGENIERÍA ELÉCTRICA Y ELECTRÓNICA
BOGOTÁ 2004
IEL1-I-04-15 IEL1-I-04-16
DESARROLLO DE LA HERRAMIENTA QUALNET PARA LA SIMULACIÓN Y
EVALUACIÓN DEL DESEMPEÑO DE VOIP EN UNA WLAN
ISMAEL EDGARDO MELÉNDEZ RINCÓN
JUAN DAVID CHAVES ESPINOSA
Proyecto de grado para optar el título de Ingeniero Eléctrico
Asesor Ph.D. ROBERTO BUSTAMANTE MILLER
UNIVERSIDAD DE LOS ANDES
FACULTAD DE INGENIERÍA DEPARTAMENTO DE INGENIERÍA ELÉCTRICA Y ELECTRÓNICA
BOGOTÁ 2004
IEL1-I-04-15 IEL1-I-04-16
AGRADECIMIENTOS
Los autores expresan su agradecimiento a:
Ph.D. Roberto Bustamante Miller, Director del departamento de Ingeniería
Eléctrica y Electrónica de la Universidad de Los Andes, por su participación
en el desarrollo de este proyecto y sus invaluables aportes.
IEL1-I-04-15 IEL1-I-04-16
RESUMEN
En este documento se identifican las limitaciones, alcances y posibilidades
de desarrollo del simulador Qualnet para el modelamiento de redes
inalámbricas, adicionalmente, se proponen e implementan modelos para
mejorarlo y se analizan los resultados obtenidos.
Se desarrollaron los modelos de error del canal y políticas de asignación del
medio, permitiendo simulaciones más cercanas a una red real.
El análisis de resultados está enfocado a verificar el correcto funcionamiento
de los modelos creados y a su vez establecer valores adecuados de algunos
parámetros del sistema que permitan garantizar los requerimientos de
calidad de servicio para conversaciones de voz en la red.
El estudio mostró la necesidad de desarrollar mucho más la herramienta para
explotar todo su potencial.
IEL1-I-04-15 IEL1-I-04-16
TABLA DE CONTENIDO 1. INTRODUCCIÓN...................................................................................................8
2. BASES TEÓRICAS ................................................................................................9
2.1. WLAN.............................................................................................................9
2.2. Qualnet ..........................................................................................................11
2.2.1. Animador ...............................................................................................11
2.2.2. Analizador..............................................................................................13
2.2.3. Analizador de trazas ...............................................................................14
2.2.4. Diseñador...............................................................................................15
2.2.5. Simulador...............................................................................................16
2.3. Calidad de Servicio (QoS)..............................................................................18
2.4. Modelo del tráfico de datos ............................................................................18
2.5. Modelo del tráfico de Voz..............................................................................19
2.6. Modelo de error del canal de Gilbert-Elliott ...................................................19
2.7. Modelos de asignación del canal ....................................................................20
2.7.1. Esquema de asignación Round Robin (RR) ............................................20
2.7.2. Esquema de asignación FIFO (First In First Out)....................................20
3. MODELOS IMPLEMENTADOS..........................................................................21
3.1. Modelo de Error del canal de Gilbert-Elliott...................................................21
3.1.1. Generación de estados del canal .............................................................21
3.1.1.1. Macroalgoritmo ..............................................................................21
3.1.1.2. Implementación en Qualnet ............................................................22
3.1.2. Recepción del paquete............................................................................22
3.1.2.1. Macroalgoritmo ..............................................................................22
3.1.2.2. Implementación en Qualnet ............................................................23
3.1.3. Validación del Modelo ...........................................................................25
3.2. Round Robin (RR) .........................................................................................25
3.2.1. Macroalgoritmo......................................................................................25
3.3. FIFO (First In First Out).................................................................................27
3.3.1. Macroalgoritmo......................................................................................27
IEL1-I-04-15 IEL1-I-04-16
3.3.2. Descripción Implementación en Qualnet ................................................29
3.4. Otras implementaciones .................................................................................29
3.4.1. Archivo de almacenamiento del retardo extremo a extremo de cada
paquete en la red....................................................................................................29
3.4.2. Macroalgoritmo......................................................................................29
3.4.2.1. Implementación en Qualnet ............................................................30
3.4.3. Estadísticas del Caudal de Datos del Sistema..........................................30
3.4.3.1. Macroalgoritmo ..............................................................................31
3.4.3.2. Implementación en Qualnet ............................................................31
3.4.4. Implementación de las Trazas del Protocolo Aloha...............................31
3.4.4.1. Macroalgoritmo ..............................................................................32
3.4.4.2. Implementación en Qualnet ............................................................32
3.4.5. Implementación de las TRAZAS 802.11 ...............................................32
4. RESULTADOS .....................................................................................................34
4.1. Red Ad-Hoc...................................................................................................34
4.2. Red de Infraestructura....................................................................................37
5. CONCLUSIONES.................................................................................................41
6. TRABAJO FUTURO CON EL SIMULADOR......................................................43
7. BIBLIOGRAFÍA...................................................................................................45
Anexo A........................................................................................................................46
Anexo B........................................................................................................................49
Anexo C........................................................................................................................56
Anexo D........................................................................................................................60
Anexo E ........................................................................................................................63
IEL1-I-04-15 IEL1-I-04-16
Tabla de Figuras Fig. 1 Ejemplo de intercambio de tramas en PCF. ....................................................................10
Fig. 2 Coexistencia PCF-DCF...................................................................................................11
Fig. 3 Barra de Herramientas de Animación y Configuración.....................................................12
Fig. 4 Barra de Herramientas de Configuración de Nodos y Tráfico ..........................................12
Fig. 5 Barra de Animaciones.....................................................................................................13
Fig. 6 Capas de la Red.............................................................................................................14
Fig. 7 Ventana Superior Derecha – Analizador de Trazas .........................................................15
Fig. 8 Modelo de Voz propuesto por P. Brady..........................................................................19
Fig. 9 Modelo de error del Canal...............................................................................................19
Fig. 10 Macroalgoritmo utilizado para la generación de estados del canal.................................21
Fig. 11 Macroalgoritmo utilizado para verificación de error en la recepción de un paquete ........23
Fig. 12 Recorrido de la estructura simulcanal............................................................................24
Fig. 13 Macro Algoritmo para implementar RR en Qualnet........................................................26
Fig. 14 Macroalgoritmo utilizado para implementar FIFO en Qualnet ........................................28
Fig. 15 Configuración espacial Red Ad-Hoc..............................................................................34
Fig. 16 Efecto de la BER en el Caudal de Datos del Sistema. ...................................................36
Fig. 17 Efecto de la longitud media del paquete de datos en el Caudal de Datos del Sistema. .37
Fig. 18 Configuración espacial Red de Infraestructura ..............................................................37
Fig. 19 Función de distribución acumulada complementaria para el retardo extremo a extremo
de los paquetes de voz en el sistema. ..........................................................................39
Fig. 20 Efecto del tamaño de la carga de los paquetes de voz en el caudal de datos. ...............40
Fig. 21 Efecto del esquema de asignación de canal en el retardo extremo a extremo ...............40
Lista de Tablas
Tabla 1 Parámetros por defecto utilizados en la Red Ad-Hoc.....................................................35
Tabla 2 Parámetros por defecto utilizados en la Red de Infraestructura .....................................38
IEL1-I-04-15 IEL1-I-04-16
8
1. INTRODUCCIÓN
En la actualidad el uso de las Redes Inalámbricas de Área Local (WLAN) ha
tenido un crecimiento notable. Debido a este auge ha surgido la posibilidad de
implementar nuevas aplicaciones y servicios en este tipo de redes, entre ellos,
el servicio de transmisión de voz ha generado particular interés gracias a su
amplio campo de acción, bajos costos y flexibilidad.
En este trabajo se explorarán las capacidades, limitaciones y posibilidades de
desarrollo de Qualnet, la cual es una herramienta relativamente nueva. Se han
realizado diferentes estudios sobre el desempeño del tráfico de voz en una
WLAN (este tráfico se conoce como Voz sobre Ip o VoIp), algunos de ellos
basados en simulaciones [2, 3, 4] y otros en mediciones [9]. Los resultados
obtenidos en dichos estudios son muy variados, sin embargo, actualmente
existen muy pocas investigaciones (que utilicen el simulador Qualnet) enfocadas
a la evaluación del desempeño de VoIp en una WLAN.
IEL1-I-04-15 IEL1-I-04-16
9
2. BASES TEÓRICAS
2.1. WLAN
El funcionamiento de una red inalámbrica de área local se describe
detalladamente en [1]. Dicha referencia cubre aspectos generales de la capa
física y de la capa de control de acceso al medio (MAC), estableciendo las
reglas básicas para administrar este tipo de redes.
Los móviles pueden acceder al medio utilizando dos funciones diferentes. La
primera se denomina función de coordinación distribuida (DCF), como su
nombre lo indica en este modo de funcionamiento no existe un coordinador, por
lo tanto las estaciones compiten por el medio, esta es la forma básica de
acceder a él. La otra opción es la función de coordinación puntual (PCF) en la
cuál existe una estación coordinadora (PC) cuya función principal es asignar el
canal a las estaciones que lo soliciten y que hagan parte del Conjunto Básico de
Servicio (BSS).
DCF utiliza un método basado en sensar la portadora evitando colisión
(CSMA/CA por sus siglas en inglés). Al utilizar este método las estaciones
primero sensan el canal para verificar que no haya otra estación transmitiendo.
Si el medio no se encuentra ocupado la transmisión empieza. En caso de
encontrar el medio ocupado se establece un algoritmo de espera que consiste
en generar una ventana de contención pseudo aleatoria. Cuando la estación
destino recibe un paquete exitosamente, envía un mensaje de confirmación
(ACK) a la estación origen, notificando el éxito de la entrega.
El procedimiento para la transmisión por medio de DCF es el siguiente: La
estación origen envía un paquete de control (RTS) indicando que está preparada
a transmitir información y a la vez comunicando a las demás estaciones por
cuánto tiempo va a estar el canal reservado, la estación destino responde
enviando también un paquete de control (CTS) señalando que está lista para
IEL1-I-04-15 IEL1-I-04-16
10
recibir la información, la estación origen procede al envió del paquete y luego
espera que el receptor le envíe un ACK.
En PCF el PC (que es comúnmente el punto de acceso o AP) crea una lista con
todas las estaciones capaces de funcionar en este modo y las interroga
periódicamente, permitiéndoles transmitir información. Cuando el PC interroga
una estación puede también enviarle información y paquetes de control. Esta
característica permite optimizar la utilización del medio. El procedimiento
seguido durante PCF (ver Figura 1) es el siguiente: primero el PC gana el
acceso al medio y transmite una señal de aviso (Beacon) indicando que el
periodo libre de contienda (CFP) ha comenzado, esta señal es recibida por todas
las estaciones que hacen parte del BSS. A continuación, el PC hace la
interrogación (Poll) a la primera estación en lista (E1), dicha estación envía
información (Data) o una trama que indica que no tiene datos (Null-Data), el
mismo procedimiento es repetido para cada una de las estaciones que están en
la lista. Una vez se han enviado todos los datos o se ha alcanzado la duración
máxima del CFP el PC envía una trama indicando el fin del periodo.
Fig. 1 Ejemplo de intercambio de tramas en PCF.
IEL1-I-04-15 IEL1-I-04-16
11
Las dos funciones deben coexistir de tal manera que permitan la operación
normal de cada una de ellas dentro de un BSS. Las duraciones de PCF y DCF
se denominan periodo libre de contienda (CFP) y periodo de contienda (CP)
respectivamente. La suma (CFP + CP) se conoce como el intervalo de repetición
del periodo libre de contienda (Ver Figura 2).
Fig. 2 Coexistencia PCF-DCF.
2.2. Qualnet
Qualnet es un simulador basado en la teoría de simulación por eventos
discretos, permitiendo representar una gran variedad de redes de
comunicaciones. Está conformado por 5 herramientas que se complementan
entre si, estas son: Qualnet Animador, Analizador, Analizador de Trazas,
Diseñador y Simulador. A continuación se describe brevemente cada una de
ellas.
2.2.1. Animador
Con el Animador se pueden diseñar experimentos básicos y observar algunas
animaciones durante su simulación. En la ventana de ejecución se encuentran
algunas herramientas que facilitan la elaboración de los experimentos. Una de
estas herramientas es la conformada por el botón de configuración de
parámetros y los botones para la simulación y animación del experimento (Ver
Figura 3).
IEL1-I-04-15 IEL1-I-04-16
12
Fig. 3 Barra de Herramientas de Animación y Configuración
El botón de configuración de parámetros de la simulación es uno de lo más
importantes, ya que por medio de éste se accede a la configuración general de
un experimento. En él podemos encontrar opciones o atributos que se
incorporarán a todos los elementos de la simulación. Entre dichos atributos
están: parámetros generales (tiempo de simulación, nombre del experimento,
terreno...etc.), parámetros de los nodos, características de las redes
inalámbricas, configuración de los protocolos de red y las estadísticas que se
desean almacenar.
Los botones de animación sirven para dar inicio a la simulación, detenerla,
pausarla o realizarla paso a paso.
El siguiente grupo disponible está compuesto por las herramientas de
configuración manual (Ver Figura 4).
Fig. 4 Barra de Herramientas de Configuración de Nodos y Tráfico
Con este grupo de herramientas podemos colocar los nodos manualmente,
establecer las conexiones, configurar el tipo de tráfico a transmitir en la red, y
especificar el medio físico a utilizar para la transferencia de datos (ya sea
inalámbrico o alambrado).
IEL1-I-04-15 IEL1-I-04-16
13
El último bloque de herramientas corresponde a los botones de visualización de
la animación (Ver Figura 5), por medio de éstos se pueden habilitar o
deshabilitar las animaciones de cada una de las capas de la red (Aplicación,
MAC, Física, entre otras).
Fig. 5 Barra de Animaciones
El Animador posee otra función importante llamada “Batch experimet” (a ésta se
puede acceder a través del menú experimento). Se utiliza para permitir la
configuración y realización de varias simulaciones simultáneamente, variando
algunos de los parámetros generales de la simulación en cada experimento.
El archivo de la simulación es guardado con una extensión *.xml, adicionalmente
si se realiza una simulación se crean archivos temporales de esta.
Usar el Animador es la forma más fácil de trabajar con la herramienta pero no es
la única ni tampoco la más óptima. Al utilizar esta herramienta el cambio de
ciertas características como el tráfico en la red se hace mas lento, además el
tiempo real de simulación se hace más largo puesto que la animación en sí
requiere un esfuerzo computacional mayor.
2.2.2. Analizador
El Analizador es la herramienta utilizada para visualizar las estadísticas
recopiladas. Al finalizar una simulación se crea un archivo de extensión stat, con
el nombre del experimento que se haya asignado. En él se encuentran
IEL1-I-04-15 IEL1-I-04-16
14
almacenadas las estadísticas habilitadas durante la configuración de la
simulación. Los resultados se encuentran organizados según la capa de la red a
la que pertenecen (Ver Fig. Figura 6).
Fig. 6 Capas de la Red
Los resultados encontrados dependen de cada una de las capas, por ejemplo
en la capa de aplicación podemos encontrar resultados como: retardo, total de
datos enviados, total de datos recibidos….etc.
Las estadísticas se presentan de manera gráfica a través de barras, éstas
representan a cada uno de los nodos de la simulación. También se pueden
visualizar los resultados de varios experimentos en una sola gráfica, en este
caso, las barras están indicando el resultado de un experimento determinado.
Todas las gráficas se pueden exportar a un archivo de texto. Los resultados
también se pueden observar a través de histogramas.
2.2.3. Analizador de trazas
El analizador de trazas es una herramienta útil para seguir la vida de un paquete
a través de las capas de la red. El archivo que lo contiene es de tipo trace, para
que se cree este archivo se debe habilitar la opción correspondiente en la
IEL1-I-04-15 IEL1-I-04-16
15
configuración del experimento, la habilitación de esta opción hace que el tiempo
de simulación sea mayor.
No todas las capas de la red están configuradas para su apreciación en el
Analizador de trazas, inicialmente solo se encuentran las capas de Transporte y
Red (Network), pero se pueden habilitar las otras capas a través de la
modificación del código.
La ventana del analizador de trazas se encuentra dividida en tres partes. La
superior derecha muestra la información más importante (Ver Figura 7), a través
de una lista se muestra la información correspondiente a cada paquete en la red.
La primera columna indica el nodo que creó el paquete y, separado por una
coma, el número de identificación del paquete, la segunda columna muestra el
tiempo de simulación, la tercera indica qué nodo esta procesando este paquete y
la última columna representa el protocolo que originó el paquete.
Fig. 7 Ventana Superior Derecha – Analizador de Trazas
La ventana izquierda muestra los componentes de los encabezados que se le
han ido agregando al paquete, la información presenta en detalle el valor de
cada uno de los campos que hacen parte del encabezado. La ventana inferior
derecha da el valor del encabezado en sistema numérico hexadecimal.
2.2.4. Diseñador
Por medio del Diseñador, se pueden crear nuevos protocolos para cada una de
las capas de la red. Para la elaboración de estos protocolos se utiliza una
máquina de estados, en la cuál, se describen la transición entre estados y sus
funciones respectivas.
IEL1-I-04-15 IEL1-I-04-16
16
2.2.5. Simulador
Para realizar una simulación en Qualnet de manera más eficiente se utiliza el
simulador, de esta forma el tiempo de simulación es mucho menor. La forma de
correr una simulación en el simulador es utilizando el DOS; ubicándose en la
carpeta bin del directorio raíz donde se encuentra Qualnet, se ejecuta la
siguiente instrucción:
C:\qualnet\3.6\bin\qualnet exp.config
Donde exp.config es el archivo que contiene la configuración de los parámetros
de la simulación. Este archivo se puede crear en un editor de texto y guardarlo
como un archivo tipo config, la forma y estructura de este archivo se puede
encontrar en el archivo default.config ubicado en la carpeta bin o en el Apéndice
1 de este documento.
Además de las configuraciones de los parámetros generales, en este archivo
también se describe la red que se crea. Por ejemplo, en el siguiente texto se
definió una red inalámbrica y una conexión punto a punto.
MAC-PROTOCOL MAC802.11
SUBNET N8-192.0.0.0 { 1 thru 6, 18 }
LINK N8-192.0.1.0 { 18, 19 }
[192.0.1.1 192.0.1.2] LINK-PHY-TYPE WIRED
[192.0.1.1 192.0.1.2] LINK-PROPAGATION-DELAY 0MS
[192.0.1.1 192.0.1.2] LINK-BANDWIDTH 10000000000
Los nodos de 1 a 6 y 18 formarán una red inalámbrica que utilizará el IEEE
802.11 como protocolo para la capa MAC, mientras que 18 y 19 tendrán una
conexión punto a punto alambrada con un retardo de propagación de 0 (cable
ideal) y Velocidad de Transmisión de 10 Gbps. En este archivo también se
IEL1-I-04-15 IEL1-I-04-16
17
agregan todos los parámetros correspondientes para la configuración de una red
inalámbrica o alambrada y las propiedades de cada uno de los nodos.
Es posible además, asignar una dirección IP a cada nodo de manera manual o
automática dependiendo de la simulación, igualmente se asignan las
características que van a tener cada una de las capas de la red.
Es necesario crear otros archivos, puesto que el experimento no funciona
únicamente con el archivo de configuración (*.config). Estos archivos son de tipo
*.nodes *.app y uno opcional *.routes-static. En el archivo de extensión nodes
se coloca la ubicación de cada uno de los nodos que hacen parte de la
simulación, primero va la identificación del nodo y luego, en paréntesis y en
coordenadas cartesianas, va la ubicación, por ejemplo:
6 ( 43.28 , 22.14 )
El nodo 6 tiene las coordenadas 43,28 en x y 22,14 en y.
En el archivo de extensión app se asigna el tráfico generado por las terminales,
el cuál va a ser transportado por la red durante la simulación, la configuración de
este archivo depende del tipo de tráfico que se desee generar. A continuación se
presentan ejemplos de dos tipos de tráfico: CBR y Traffic-Gen. CBR 1 20 0 80 10MS 2MS 5S
TRAFFIC-GEN 1 20 EXP 5MS DET 0.5S RND DET 80 DET 10MS 0.352 NOLB
Por último el archivo de extensión *.routes-static indica cómo va a ser el
enrutamiento de los paquetes al interior de la red, su estructura es la siguiente:
3 192.0.4.2 192.0.0.7
18 192.0.4.2 192.0.1.2
19 192.0.4.2 192.0.4.2
IEL1-I-04-15 IEL1-I-04-16
18
Aquí se presenta una ruta del nodo 3 al nodo 22 cuya dirección IP es 192.0.4.2,
los paquetes deben pasar primero por los nodos 18 y 19 ya que no hay conexión
directa entre los extremos de la ruta.
Todos estos archivos son llamados dentro del archivo de configuración
(*.config).
2.3. Calidad de Servicio (QoS)
Cuando se habla de calidad de servicio lo que se busca es garantizar un nivel
mínimo de desempeño de la red. Dicho nivel varía dependiendo del tipo de
tráfico que se encuentre en el sistema puesto que, cada una de estas
aplicaciones necesita requerimientos diferentes. En general, los principales
parámetros a tener en cuenta cuando se quiere evaluar la calidad de servicio de
una red son: probabilidad de error, retardo, pérdida de paquetes y ancho de
banda. Haciendo énfasis en el tráfico de voz, los parámetros con mayor
relevancia son retardo y pérdida de paquetes. Si la red logra garantizar un
retardo bajo y una pérdida de paquetes pequeña, la calidad de servicio de la red
para el tráfico de voz es adecuada. Se ha encontrado que para garantizar una
buena calidad de servicio los parámetros anteriores deben cumplir con unos
requerimientos mínimos [3]. Por ejemplo: el máximo retardo permitido para
tráfico de voz en una red sin supresores de eco es de 25ms, mientras que para
una con supresores de eco el retardo máximo permisible es de 500ms. En
cuanto al parámetro de pérdida de paquetes se ha establecido que éste debe
ser menor al 1%, de lo contrario la calidad de la conversación será inadecuada.
2.4. Modelo del tráfico de datos
Para el modelo del tráfico de datos, se asume que tanto el tiempo de llegada
entre paquetes como la longitud de éstos siguen una distribución exponencial.
IEL1-I-04-15 IEL1-I-04-16
19
La tasa para la distribución del tiempo de llegada entre paquetes se calcula a
partir del la carga ofrecida al sistema, mientras que para la longitud de los
paquetes la media depende de cada experimento específico.
2.5. Modelo del tráfico de Voz
Para caracterizar el tráfico de Voz se utilizó el modelo de On-Off propuesto en
[6]. Dicho modelo asume que las fuentes de voz se pueden representar por
medio de una cadena de Markov de dos estados On y Off (Ver Figura 8). El
tiempo medio de On es 1s y de Off es 1.3 s. Durante el tiempo On la señal de
voz se muestrea a 64 kbps, generando paquetes de 80 bytes cada 10ms (Se
escogió así porque se utilizó el codec G711 propuesto por la ITU). Durante el
tiempo Off las fuentes no generan paquetes.
Fig. 8 Modelo de Voz propuesto por P. Brady
2.6. Modelo de error del canal de Gilbert-Elliott
Fig. 9 Modelo de error del Canal
Uno de los modelos implementados en el simulador fue el modelo de error del
canal propuesto en [7]. A continuación se hace una breve descripción de dicho
modelo.
IEL1-I-04-15 IEL1-I-04-16
20
Los autores propusieron modelar el canal utilizando una cadena de Markov de
dos estados, bueno y malo (Ver Figura 9). Durante el estado bueno la Tasa de
Error de Bit (BER) es baja, mientras que en el estado malo la BER es alta. El
tiempo medio de duración de los estados se distribuye exponencialmente. Las
tasas de transición de estado son Lamda (de bueno a malo) = 30s-1 y alfa (de
malo a bueno) =10s-1.
2.7. Modelos de asignación del canal
Se implementaron también en el simulador dos nuevas políticas de asignación
de canal. A continuación se describe el funcionamiento de cada una de ellas.
2.7.1. Esquema de asignación Round Robin (RR)
El esquema de asignación cíclica (Round Robin) consiste en interrogar a las
estaciones enlistables en orden ascendente (dependiendo de la dirección IP),
cuando el PC llega al final de la lista asigna nuevamente el canal a la primera
estación, este proceso se repite hasta alcanzar la duración máxima del CFP.
2.7.2. Esquema de asignación FIFO (First In First Out)
El otro esquema implementado fue el FIFO, dicho esquema asigna el canal a la
estación a la cual va dirigido el paquete que se encuentra en la primera posición
de la cola del PC. Cuando no hay ningún paquete en cola, el PC adopta el
esquema RR, si llega un paquete a la cola cambia a FIFO y cuando se vacía,
nuevamente continúa con RR.
IEL1-I-04-15 IEL1-I-04-16
21
3. MODELOS IMPLEMENTADOS 3.1. Modelo de Error del canal de Gilbert-Elliott
Para implementar el modelo de error del canal, el problema se dividió en dos
partes: Generación de estados del canal y recepción del paquete.
3.1.1. Generación de estados del canal
3.1.1.1. Macroalgoritmo
El objetivo de esta parte de la solución es crear los estados del canal durante
todo el tiempo de simulación (Ver Figura 10)
Fig. 10 Macroalgoritmo utilizado para la generación de estados del canal
Inicialmente se leen el tiempo de simulación y las tasas de transición del archivo
de configuración. Luego se generan tiempos de estado bueno y malo (los cuáles
se distribuyen exponencialmente con media que depende de las tasas de
IEL1-I-04-15 IEL1-I-04-16
22
transición) hasta que la suma de dichos tiempos alcance el tiempo de
simulación. Esto nos permite conocer el estado del canal en cualquier momento.
3.1.1.2. Implementación en Qualnet
Lo primero que se hace en la implementación del modelo del canal es situarse
en una función del código que permita leer del archivo de configuración. Para
poder hacer lectura del archivo la función seleccionada debe ingresarle las
siguientes estructuras: node y nodeInput. La función también debe cumplir con
que solo es llamada una vez y durante el inicio de la simulación. Esto es
necesario, ya que en la función también se crea el canal y este proceso solo
debe hacerse una vez.
La función que se utiliza para leer los parámetros es la de inicialización de la
capa MAC (MAC_Initialize) situada en el archivo mac.c. En este lugar también
se define una nueva estructura (simulcanal) en la cual se guardan los
parámetros leídos y el estado del canal. Las variables que deben ser leídas son:
tiempo de simulación, tasas de transición, tasas de error de bit y tasa de
transmisión. Una vez leídos y guardados estos valores se llama a la función de
crear el canal. A esta función (crearcanal) le entra el tiempo de simulación y las
tasas de transición; y devuelve un vector con los estados del canal y el tamaño
del vector (ver anexo B), estos valores también son guardados en la estructura
creada.
3.1.2. Recepción del paquete
3.1.2.1. Macroalgoritmo
Cuando se recibe un paquete se debe determinar si llegó o no con error. Para
lograr esto se utiliza el macroalgoritmo descrito en la Figura 11, inicialmente se
leen todas las variables del modelo (BERs, Tamaño del paquete, tiempo de
llegada, tasa de transmisión, entre otras). Con la tasa de transmisión se calcula
el tiempo de 1 bit. Teniendo el tamaño del paquete, el tiempo de llegada y el
IEL1-I-04-15 IEL1-I-04-16
23
tiempo de 1 bit se calcula el tiempo de transmisión del paquete. Con el tiempo
de inicio y finalización de la transmisión, se verifica el estado del canal,
obteniendo el número de bits transmitidos en estado malo y en estado bueno.
Finalmente se calcula la probabilidad de error y se determina si el paquete llegó
o no con error.
Fig. 11 Macroalgoritmo utilizado para verificación de error en la recepción de un paquete
3.1.2.2. Implementación en Qualnet
La estructura creada en la generación del canal debe ser llevada a la función
que se encarga de la recepción del paquete. El recorrido que realiza la
estructura se muestra en la Figura 12. Cuando la estructura llega a la función
Mac802_11Init los valores de esta son asignados a una estructura ya existente,
IEL1-I-04-15 IEL1-I-04-16
24
esto con el fin de no agregar parámetros adicionales a las funciones de aquí en
adelante.
Fig. 12 Recorrido de la estructura simulcanal
En la función de recepción del paquete (Mac802_11ReceivePacketFromPhy), se
llama a la función implementada que determina si un paquete tiene error. A esta
función le entran las estructuras node, msg y M802; y retorna un valor de
verdadero o falso. Dentro de esta función se llama a otra que se encarga de
hallar el valor de n1 y n2, con los valores de n1 y n2, se calcula la probabilidad
de error y se determina si el paquete llegó con errores. Si el paquete tiene error
la función devuelve un valor verdadero de lo contrario su valor es falso.
Cuando se determina si el paquete tiene error o no, en la función de recepción
se decide qué hacer. En caso de que el paquete no tenga error, el
funcionamiento se realiza normalmente, de lo contrario, si el paquete tiene error
se implementa una rutina de botar el paquete (ver anexo B).
IEL1-I-04-15 IEL1-I-04-16
25
3.1.3. Validación del Modelo
Con el fin de verificar el correcto funcionamiento del modelo de error del canal se
hizo la siguiente prueba:
Se simularon varios experimentos, imprimiendo en pantalla los siguientes
parámetros en cada uno de ellos: estados del canal durante el experimento,
tiempos de llegada, n1, n2, probabilidades de error y número aleatorio generado
para cada mensaje transmitido en el sistema.
Inicialmente se calcularon los números n1 y n2 a partir de los estados del canal
generados, luego se calculó la probabilidad de error y finalmente verificando el
número aleatorio generado, se determinó si el paquete llegaba o no con error.
Esto se hizo para cada paquete transmitido en la red y los cálculos se hicieron
utilizando una herramienta externa al modelo. Después de tener los valores de
los parámetros para cada paquete transmitido, éstos se compararon con los
valores calculados por el programa. Se pudo verificar que los valores generados
por el modelo eran correctos.
Se creó también una nueva estadística llamada paquetes recibidos con error,
esto ayudó a verificar el funcionamiento del modelo.
3.2. Round Robin (RR)
3.2.1. Macroalgoritmo.
A continuación se muestra el macro algoritmo utilizado para implementar el
esquema de asignación de canal de RR en la herramienta de simulación Qualnet
(Ver Figura 13).
IEL1-I-04-15 IEL1-I-04-16
26
Fig. 13 Macro Algoritmo para implementar RR en Qualnet
Inicialmente se verifica si el usuario ha especificado en el archivo de
configuración el modo de asignación RR. Luego, se procede a verificar si la
máxima duración del Periodo Libre de Contienda (CFP) ha sido alcanzada, si es
así el Coordinador puntual transmite una trama de finalización, dando por
terminado dicho periodo. De lo contrario, se verifica si todas las estaciones han
sido interrogadas (es decir, si el apuntador a la próxima estación a interrogar
está apuntando al final de la lista) si esto se cumple se inicia un nuevo ciclo de
interrogación, si no, simplemente se interroga a la siguiente estación en la lista.
IEL1-I-04-15 IEL1-I-04-16
27
3.2.2. Descripción Implementación en Qualnet
Para la implementación del esquema de asignación FIFO primero se agrega un
nuevo parámetro a la estructura M802_11_PcDeliveryMode indicando el nuevo
modelo de asignación. El nombre de este parámetro nuevo es:
M802_11_PC_POLL_RR, y la estructura se puede encontrar en el archivo
mac_802_11.h.
En la función Mac802_11PcInit del archivo mac_802_11.c se realiza la lectura
del modo de asignación, acá se le tiene que agregar el nuevo parámetro
implementado. La nueva variable será seleccionada en el archivo de
configuración escribiendo POLL-RR. El siguiente paso se realiza en la función
Mac802_11CfpPcTransmit, aquí se crea un nuevo caso, donde se decide qué
hacer dependiendo del esquema seleccionado y el tipo de estado del periodo
libre de contienda. En el nuevo caso se llama a la función
Mac802_11CfpPcTransmitPollRR, que en estructura es muy parecida a la
función de POLL-ONLY, dentro de esta se llama a una nueva función que se
encarga de interrogar a la siguiente estación
(Mac802_11CfpPcGetNextItemToPoll2). La nueva función hace que se repita la
lista, hasta que se alcance el tiempo máximo de interrogación o no haya mas
estaciones en la lista (ver Anexo C).
3.3. FIFO (First In First Out)
3.3.1. Macroalgoritmo
El macroalgoritmo utilizado para implementar el esquema de asignación de
canal FIFO es similar al utilizado en RR, sin embargo, tiene algunas diferencias
(Ver Figura 14).
IEL1-I-04-15 IEL1-I-04-16
28
Fig. 14 Macroalgoritmo utilizado para implementar FIFO en Qualnet
Se verifica igualmente si el usuario ha especificado en el archivo de
configuración el modo de asignación FIFO. Luego, se procede a verificar si la
máxima duración del Periodo Libre de Contienda (CFP) ha sido alcanzada, si es
así el Coordinador Puntual (PC) transmite una trama de finalización, dando por
terminado dicho periodo. De lo contrario (a diferencia de RR), se verifica si el PC
tiene paquetes en cola, si esto ocurre, el PC entrega los paquetes a las
estaciones hacia las cuáles están dirigidos, interrogando a la vez a las
estaciones destino permitiéndoles transmitir información; si tienen información
disponible. Si no hay paquetes en cola, se utiliza el esquema RR para interrogar
las estaciones.
IEL1-I-04-15 IEL1-I-04-16
29
3.3.2. Descripción Implementación en Qualnet
Para la implementación de FIFO en Qualnet es necesario hacer un
procedimiento similar al realizado con el anterior esquema de asignación.
Primero, se agrega el nuevo parámetro M802_11_PC_POLL_FIFO a la
estructura correspondiente. En seguida, se realiza la lectura del archivo de
configuración, donde para escoger el esquema FIFO se escribirá POLL-FIFO.
Luego se crea un nuevo caso en Mac802_11CfpPcTransmit y desde ahí se
llama a la función que realiza el procedimiento de FIFO
(Mac802_11CfpPcTransmitPollFIFO). En esta función también se llama a
Mac802_11CfpPcGetNextItemToPoll2 que se puede ver en el anexo C.
3.4. Otras implementaciones
3.4.1. Archivo de almacenamiento del retardo extremo a extremo de cada
paquete en la red
Antes de describir el macroalgoritmo y el proceso de implementación en el
simulador, es necesario aclarar por qué fue preciso almacenar el retardo
extremo a extremo de todos los paquetes transmitidos a lo largo de un
experimento en la red. Dicho almacenamiento se hizo evidente cuando se quizo
calcular las probabilidades mostradas en la Figura 19, ya que era indispensable
tener un número de muestras elevado para garantizar que los resultados del
histograma fueran los correctos.
3.4.2. Macroalgoritmo
El procedimiento de la implementación fue el siguiente:
• Crear todas las variables necesarias para el manejo del archivo (apuntadores,
almacenamiento del nombre, entre otras).
IEL1-I-04-15 IEL1-I-04-16
30
• Buscar dentro del simulador la función y archivo en donde se actualiza el valor
del retardo extremo a extremo total en el sistema.
• Agregar una rutina en la que se abre un archivo y se le adiciona el valor del
retardo extremo a extremo del paquete que se acaba de recibir.
3.4.2.1. Implementación en Qualnet
Luego de inspeccionar los archivos del simulador, se encontró que en el archivo
trafficgen.c en la función TrafficGenServerLayerRoutine se actualiza el valor del
retardo total en el nodo, sumándole al valor acumulado el retardo del paquete
que acaba de ser recibido.
Inicialmente se buscó una función en la que fuera posible leer datos del archivo
de configuración (APP_InitializeApplications en el archivo application.c), allí se
leyó el nombre del archivo del experimento y se le pasó a la función
TrafficGenServerInit. Adicionalmente se agregó un nuevo campo a la estructura
node en el cuál la función TrafficGenServerInit almacena el nombre del
experimento.
Como se vio, en la función TrafficGenServerLayerRoutine se puede obtener el
retardo extremo a extremo de cada paquete, sin embargo, este no se almacena
independientemente, simplemente se suma al retardo total del nodo para luego
tener un promedio. En dicha función se agregó una rutina que escribiera en el
archivo el retardo de cada uno de los paquetes. En el anexo D se encuentra
información más detallada de las modificaciones realizadas.
3.4.3. Estadísticas del Caudal de Datos del Sistema
Para verificar el valor del caudal de datos del sistema fue necesario almacenar el
número de paquetes recibidos por cada estación por segundo durante todo el
experimento.
IEL1-I-04-15 IEL1-I-04-16
31
3.4.3.1. Macroalgoritmo
El procedimiento general seguido fue:
• Buscar archivo y función en donde se almacenan e imprimen las estadísticas
del caudal de datos de cada estación.
• Modificar dicho almacenamiento, logrando guardar los datos de la forma en
que se necesita.
• Imprimir correctamente los nuevos datos en el archivo de estadísticas del
experimento.
3.4.3.2. Implementación en Qualnet
En la función TrafficGenServerNewServer del archivo traffic_gen.c, se crearon
las nuevas variables y se inicializaron (fue necesario modificar la estructura en el
encabezado del archivo). Luego, en la función TrafficGenServerLayerRoutine se
modificó la forma de almacenamiento de las estadísticas. Finalmente en la
función TrafficGenServerPrintStats se incluyeron las rutinas para imprimir las
nuevas estadísticas. Se puede encontrar información más detallada en el Anexo
E.
3.4.4. Implementación de las Trazas del Protocolo Aloha.
En [11], se encuentra una descripción general del procedimiento a seguir para
habilitar las trazas de un protocolo específico. Se puede encontrar un ejemplo
que se desarrolla con el protocolo UDP de la capa de transporte, sin embargo, al
hacer la analogía con el protocolo ALOHA de la capa MAC y desarrollar el
procedimiento de forma similar no se obtuvieron los resultados esperados.
A través del contacto con los creadores de la herramienta se vio que los pasos
necesarios para habilitar las trazas del protocolo ALOHA eran mas de los que se
describían en el manual.
IEL1-I-04-15 IEL1-I-04-16
32
3.4.4.1. Macroalgoritmo
• Incluir el nombre del protocolo en el archivo trace.h en la enumeración del
tipo de protocolo.
• Agregar la línea correspondiente en el archivo de configuración para habilitar
las trazas.
• Crear la función de inicialización del protocolo, la cuál verifica si fue o no
activado en la simulación y lo habilita.
• Agregar una función para imprimir los datos.
• Modificar la función TRACE_PrintTrace ubicada en main\trace.c para llamar a
la función anteriormente creada.
• Hacer las llamadas a la función TRACE_PrintTrace dentro del código de
Aloha cuando el paquete entre o antes de que salga de la capa MAC.
3.4.4.2. Implementación en Qualnet
Inicialmente toca seguir los pasos indicados en el capitulo 5 sección 6 de [11].
Una vez realizado el procedimiento anterior es necesario incluirle las siguientes
modificaciones:
• Incluir “TRACE_ALOHA” durante “TRACE_Initialize”, es decir colocar la
variable “node->traceData->traceList[TRACE_ALOHA] con valor de
verdadero
• Definir “MacAlohaInitTrace” durante “AlohaInit” lo cual permite habilitar la
función de selectividad del protocolo ALOHA usando “TRACE-ALL” y
“TRACE-ALOHA”
• Para Imprimir la información del paquete, toca convertir la dirección IP del
origen y destino en una cadena de caracteres.
3.4.5. Implementación de las TRAZAS 802.11
IEL1-I-04-15 IEL1-I-04-16
33
Inicialmente se hizo el estudio de la habilitación de las trazas en el protocolo
Aloha pensando en que la implementación de las trazas del 802.11 requería un
procedimiento similar.
Después de analizar detenidamente el proceso de habilitación de las trazas
utilizado para el protocolo Aloha, se vio que era bastante complicado poder
hacer lo mismo con el protocolo 802.11, ya que este es mucho más complejo
que el Aloha.
Observando esta dificultad, se estudió mas detenidamente el código del 802.11,
enfocándonos en toda la información (funciones y parámetros) relacionada con
las trazas. Después de observar detenidamente la implementación del protocolo,
vimos que éste tiene la posibilidad de generar un archivo de trazas (si la opción
correspondiente es habilitada dentro del código en C), aunque tiene un formato
muy diferente al utilizado por el Qualnet Tracer (Programa en el cuál se analizan
la mayoría de los archivos de trazas generados por Qualnet) es bastante
completo.
Decidimos utilizar el archivo generado por el protocolo 802.11 junto con los
archivos que se pueden visualizar en el Qualnet Tracer para hacer el
seguimiento de los paquetes.
IEL1-I-04-15 IEL1-I-04-16
34
4. RESULTADOS
Se simularon dos escenarios principales: Red Ad-Hoc y Red de Infraestructura
4.1. Red Ad-Hoc
A continuación se muestra la configuración espacial de la simulación (Figura 15).
En ella se observan 10 estaciones de datos, dichas estaciones generan tráfico
caracterizado, como se mencionó en la sección 2.4. En la Tabla 1 se especifican
algunos de los parámetros más importantes utilizados por defecto en dicho
experimento. La tasa de transmisión se asumió inicialmente de 1Mbps, esto se
hizo para simplificar el modelo de error del canal. Sin embargo, dicho modelo se
generalizó permitiendo especificar cualquier valor para la tasa de transmisión.
Fig. 15 Configuración espacial Red Ad-Hoc
IEL1-I-04-15 IEL1-I-04-16
35
Parámetro Valor Estaciones de Voz 10 Estaciones de Datos 10 Conexiones de Voz 5 Tasa de Transmisión 1MbpsLímite de Repetición Corto 5 Límite de Repetición Largo 7
BERB
10-10
BERM
10-5 α 10 s-1 λ 30 s-1 Umbral RTS 250 bytesSIFS 10µs DIFS 50µs
Tabla 1 Parámetros por defecto utilizados en la Red Ad-Hoc
En la Figura 16 se grafica el caudal de datos del sistema (Throughput) variando
la carga de datos ofrecida (Data offered load), para diferentes valores de BERm
(Tasa de error de bit en estado malo). El propósito de la gráfica es observar el
efecto que tiene la tasa de error del canal en el caudal de datos del sistema.
Para entender adecuadamente la gráfica es necesario pensar cómo sería el
comportamiento del sistema idealmente, es decir, si el canal fuera libre de error,
si no se agregara encabezado a los paquetes en las capas inferiores y si
además el sistema no tuviera que transmitir tramas de control. Si eso fuera así,
la carga de datos ofrecida debería ser siempre igual al caudal de datos del
sistema, sin embargo, el sistema no funciona así. En la red se transmiten tramas
de control y se agregan encabezados a los paquetes en las capas inferiores, por
lo tanto, el sistema se satura alcanzando su capacidad máxima. Finalmente es
importante anotar que la BER afecta significativamente el caudal de datos del
sistema.
IEL1-I-04-15 IEL1-I-04-16
36
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0 0.2 0.4 0.6 0.8 1
Carga de Datos Ofrecida
Cau
dal d
e D
atos
BERm = 10^-5BERm = 10^-4BERm = 10^-3
Fig. 16 Efecto de la BER en el Caudal de Datos del Sistema.
El propósito de la Figura 17 es encontrar un valor adecuado para la longitud
media de los paquetes de voz. Cuando la longitud de los paquetes de datos es
pequeña (MSDU de 200 bytes), el caudal es bajo, esto se debe a que se
generan demasiados bits de encabezado. Por otra parte cuando la longitud
media es grande (MSDU de 2000 bytes) el incremento en el caudal máximo no
es significativo, esto se puede explicar por que a mayor longitud de los paquetes
mayor probabilidad de error. Teniendo en cuenta los factores mencionados
anteriormente, se determinó que una longitud óptima de los paquetes de datos
es de 1000 bytes.
IEL1-I-04-15 IEL1-I-04-16
37
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.0 0.2 0.4 0.6 0.8 1.0
Carga de Datos Ofrecida
Cau
dal d
e D
atos
MSDU200MSDU300MSDU500MSDU1000MSDU2000
Fig. 17 Efecto de la longitud media del paquete de datos en el Caudal de Datos del Sistema.
4.2. Red de Infraestructura
Fig. 18 Configuración espacial Red de Infraestructura
En la Figura 18 se observa la configuración espacial de la simulación, en la red
inalámbrica hay 5 estaciones de voz y 10 de datos, en la red alambrada hay 5
estaciones de voz y 1 de datos hacia la cuál se dirige todo el tráfico de datos
generado en la red inalámbrica. En la Tabla 2 se especifican algunos de los
parámetros más importantes utilizados por defecto en la red de infraestructura.
IEL1-I-04-15 IEL1-I-04-16
38
Parámetro Valor Estaciones de Voz 10 Estaciones de Datos 10 Conexiones de Voz 5 Tasa de Transmisión 1MbpsLímite de Repetición Corto 5 Límite de Repetición Largo 7
BERB
10-10
BERM
10-5
α 10 s-1
λ 30 s-1 Umbral RTS 250 bytesSIFS 10µs PIFS 30µs DIFS 50µs CFP Máximo 0.39s Intervalo de Rep. CFP 0.41s
Tabla 2 Parámetros por defecto utilizados en la Red de Infraestructura
Para entender las figuras que se muestran a continuación, es primordial conocer
los factores más importantes que influyen en el retardo extremo a extremo de un
paquete en la red, dichos factores son:
• Retardo de Paquetización: Es el tiempo que deben esperar los paquetes de
voz digitalizada para ser transmitidos por las estaciones móviles. Ocurre
cuando la carga de las tramas de voz es demasiado grande.
• Uso ineficiente del canal: Ocurre cuando la relación # de bits de información a
# de bits de encabezado es alta. Esto se cumple cuando la carga de las tramas
de voz es pequeña, ya que en dichas tramas un gran porcentaje de la
información transmitida corresponde a bits del encabezado, haciendo que el
uso del canal sea ineficiente.
En la Figura 19 se grafica el tiempo en segundos (en el eje de las abcisas)
contra la P(Y>x) (en el eje de las ordenadas) donde Y es el retardo extremo a
extremo de un paquete en la red. El propósito de dicha gráfica es encontrar un
IEL1-I-04-15 IEL1-I-04-16
39
valor adecuado para la carga de las tramas de voz, de tal manera, que se
puedan cumplir los requerimientos de calidad de servicio.
Fig. 19 Función de distribución acumulada complementaria para el retardo extremo a extremo
de los paquetes de voz en el sistema.
Al analizar los resultados obtenidos se pueden ver los dos efectos mencionados
anteriormente. Cuando la carga de las tramas de voz es de 1000 bytes, el efecto
más influyente es el retardo de paquetización, dicho efecto es demasiado fuerte,
impidiendo cumplir los requerimientos de calidad de servicio para tráfico de voz
(el requerimiento es que P(Y>0.5) sea menor a 1%). Por otra parte, cuando la
carga es de 200 bytes tampoco se logran cumplir los requerimientos de calidad
de servicio, sin embargo, esta vez el factor más influyente es el uso ineficiente
del canal. Para lograr cumplir dichos requerimientos es necesario encontrar un
punto de equilibrio entre los dos efectos. En la gráfica se observa que esto se
cumple para una carga de los paquetes de voz de 400 bytes.
En la Figura 20 se puede percibir cómo afecta el tamaño de la carga de las
tramas de voz al caudal de datos del sistema. Desde el punto de vista del caudal
del sistema entre más grande sea la carga mejor, puesto que, el caudal máximo
aumenta. Sin embargo, para valores de la carga grandes (mayores a 200 bytes)
el caudal máximo alcanzado es prácticamente igual (aumenta muy poco).
IEL1-I-04-15 IEL1-I-04-16
40
0
0.05
0.1
0.15
0.2
0.25
0.3
0.35
0.4
0 0.2 0.4 0.6 0.8 1Carga de Datos Ofrecida
Cau
dal d
e D
atos
Carga = 50Carga = 90Carga = 130Carga = 170Carga = 210
Fig. 20 Efecto del tamaño de la carga de los paquetes de voz en el caudal de datos.
Finalmente, se observó el efecto que tienen las políticas de asignación de canal
en el retardo extremo a extremo de los paquetes en la red. Dicho efecto se
puede ver en la Figura 21. Para el experimento presentado en dicha figura, se
utilizaron los valores óptimos encontrados anteriormente, también se dobló el
número máximo de conexiones de voz, pasando de 5 a 10 conexiones en las
dos direcciones. El esquema de asignación FIFO tiene un mejor desempeño que
el esquema de RR, dicho esquema cumple los requerimientos de calidad de
servicio para 10 conexiones en las 2 direcciones.
Fig. 21 Efecto del esquema de asignación de canal en el retardo extremo a extremo
IEL1-I-04-15 IEL1-I-04-16
41
5. CONCLUSIONES
• Consideramos que el aporte más importante de este trabajo de investigación
es la potencialización de la herramienta, puesto que se implementaron nuevos
modelos que ayudan a describir con mayor precisión una red inalámbrica.
• El análisis de los resultados demuestra el correcto funcionamiento de los
modelos implementados en el simulador, ya que las gráficas obtenidas se
comportan de acuerdo a lo esperado.
• La herramienta en su estado natural es un poco limitada, en cuanto redes
inalámbricas se refiere, por lo tanto es necesario desarrollarla para obtener
resultados aplicables a problemas reales.
• Para llevar a cabo el proceso de análisis y visualización de resultados fue
necesaria la utilización de herramientas externas al simulador, debido a
algunas limitaciones de las aplicaciones proporcionadas por Qualnet.
• La herramienta de Simulación tiene un gran potencial, sin embargo, es
necesario incrementar su nivel de desarrollo para permitir así un modelamiento
adecuado de sistemas más complejos.
Otras conclusiones obtenidas son:
• Si se quiere garantizar un nivel de caudal alto, el estado del canal y la longitud
media de los paquetes juegan un papel decisivo, siendo el estado del medio el
factor más influyente.
• Para optimizar el retardo extremo a extremo es necesario encontrar un punto
de equilibrio entre el tiempo de paquetización y el tamaño de los paquetes de
voz, de esta forma es posible cumplir con los requerimientos de QoS para este
tipo de conversaciones.
• El tamaño de los paquetes de voz afecta significativamente el caudal de datos
en una red de infraestructura con tráfico mixto (voz y datos).
IEL1-I-04-15 IEL1-I-04-16
42
• Al implementar el esquema FIFO como política de asignación del canal, el
desempeño de los paquetes de voz se incrementa sustancialmente. Dicha
mejora se ve reflejada en la disminución del retardo extremo a extremo.
• Utilizando el modelo de asignación FIFO y el tamaño óptimo de los paquetes
de voz, es posible establecer 10 conversaciones simultáneas, garantizando el
cumplimiento de los requerimientos de QoS.
IEL1-I-04-15 IEL1-I-04-16
43
6. TRABAJO FUTURO CON EL SIMULADOR
Como se mencionó anteriormente el simulador tiene un gran potencial. Después
de trabajar con la herramienta (Qualnet Versión 3.6) sugerimos algunas áreas en
las que podría trabajarse en el futuro con el fin de explotar al máximo las
capacidades de Qualnet.
Las áreas que creemos deberían desarrollarse con el simulador son:
• Agregar a la norma 802.11 la capacidad de fragmentación, puesto que
actualmente dicha característica no ha sido desarrollada en el simulador.
Este trabajo es difícil y pensamos que podría ser adecuado para una tesis de
pregrado.
• La implementación de la norma 802.11 en el simulador Qualnet hace algunas
simplificaciones, por lo tanto consideramos importante explorar tanto el nivel
de implementación de los protocolos de seguridad y encriptación de la
información como el modo de ahorro de potencia, implementados en la
herramienta.
• Al analizar la herramienta vimos también la importancia de modelar con
mayor precisión el problema de la terminal escondida. Para hacerlo
sugerimos modificar el NAV de algunas estaciones y ver los efectos que
dichos cambios tienen en el simulador.
• Nuevos esquemas de asignación, como los esquemas de asignación de turno
en modo PCF: de prioridad y de prioridad ELF, propuestos en [4].
• Para lograr implementar las asignaciones de turno descritas anteriormente se
debe trabajar también en el desarrollo de algunos esquemas de prioridad de
tráfico.
• Implementar un modelo más preciso para tráfico de Voz.
• Como mejora general a la herramienta sugerimos trabajar en la interfaz
gráfica con el modo texto, es decir, desarrollar una aplicación capaz de
funcionar en modo gráfico que permita modificar todos los parámetros de la
IEL1-I-04-15 IEL1-I-04-16
44
simulación y visualizar los nuevos parámetros agregados a la herramienta en
un ambiente amigable para el usuario.
• Actualmente las trazas generadas por el protocolo 802.11 de Qualnet tienen
un formato diferente al de las trazas que se pueden leer con el trazador, por
lo tanto, sugerimos trabajar en la estandarización de dichas trazas con el fin
de ofrecer un entorno más amigable al usuario y permitir procesar la
información eficientemente.
Adicionalmente se puede trabajar en la implementación del protocolo 802.11e en
Qualnet.
IEL1-I-04-15 IEL1-I-04-16
45
7. BIBLIOGRAFÍA
[1] IEEE std 802.11, IEEE Standard for Wireless LAN Medium Access Control (MAC) and physical layer Specifications, 1999. [2] Chen Dongyan, et al, “Supporting VBR VoIp Traffic in IEEE 802.11 WLAN in PCF Mode”, Avaya labs research. [3] Crow B et al. “IEEE 802.11 Wireless Local Area Networks” IEEE Communications Magazine, Septiembre 1997, pp 116-126. [4] Yeh J.-Y. y Chen C., “Support of multimedia services with the IEEE 802.11 MAC protocol”, Proceedings of ICC’02, New York, Abril 2002. [5] Veeraraghavan M., Cocker N. y Moors T., “Support of voice services in IEEE 802.11 wireless LANs,” Proceedings of INFOCOM’01, 2001. [6] Brady P., “A model for generating on-off speech patterns in two-way conversation,” Bell Syst. Tech. Journal, vol. 48, no. 7, pp. 2245—2272, Sept. 1969. [7] Elliott E.O., “Estimates of error rates for codes on burst-noise channels,” Bell Syst. Tech. J., vol. 42, pp. 1977-1997, Sept. 1963. [8] Gilbert E., “Capacity of Burst Noise Channel” Bell Sys. Tech. J. Vol 39. Sept. 1960, pp 1253-66. [9] Anjum F. et al, “Voice Performance in WLAN Netwroks – An Experimental Study”, GLOBECOM 2003 - IEEE Global Telecommunications Conference. No 1, Dec. 2003. pp. 3504-3508 [10] Tanenbaum A, “Computer Networks” Fourth Edition, Prentice Hall, 2003. [11] Scalable Network Technologies Inc, “Qualnet 3.6 Developer’s Guide”, 2003.
IEL1-I-04-15 IEL1-I-04-16
46
Anexo A Archivo de configuración utilizado para simular la red de infraestructura VERSION 3.6 EXPERIMENT-NAME DATAOF0.2PAY130Plista SIMULATION-TIME 1S SEED 2 # Parallel Settings PARTITION-SCHEME AUTO # Terrain COORDINATE-SYSTEM CARTESIAN TERRAIN-DIMENSIONS ( 1500.0, 1500.0 ) DUMMY-ALTITUDES ( 1500, 1500 ) TERRAIN-DATA-BOUNDARY-CHECK YES # Nodes DUMMY-NUMBER-OF-NODES 21 NODE-PLACEMENT FILE NODE-PLACEMENT-FILE ./figura15.nodes # Mobility MOBILITY NONE MOBILITY-POSITION-GRANULARITY 5.0 MOBILITY-GROUND-NODE NO # Channel PROPAGATION-CHANNEL-FREQUENCY 2400000000 PROPAGATION-MODEL STATISTICAL PROPAGATION-LIMIT -111.0 PROPAGATION-PATHLOSS-MODEL TWO-RAY PROPAGATION-SHADOWING-SIGMA 0.0 PROPAGATION-FADING-MODEL NONE # Radio/Physical Layer PHY-MODEL PHY802.11b PHY802.11-AUTO-RATE-FALLBACK NO PHY802.11-DATA-RATE 1000000 PHY802.11b-TX-POWER-DBPSK 15.0 PHY802.11b-TX-POWER-DQPSK 15.0 PHY802.11b-TX-POWER-CCK-6 15.0 PHY802.11b-TX-POWER-CCK11 15.0 PHY802.11b-RX-SENSITIVITY-DBPSK -94.0 PHY802.11b-RX-SENSITIVITY-DQPSK -91.0 PHY802.11b-RX-SENSITIVITY-CCK-6 -87.0 PHY802.11b-RX-SENSITIVITY-CCK11 -83.0 PHY802.11b-RX-THRESHOLD-DBPSK -84.0 PHY802.11b-RX-THRESHOLD-DQPSK -81.0 PHY802.11b-RX-THRESHOLD-CCK-6 -77.0 PHY802.11b-RX-THRESHOLD-CCK11 -73.0 PHY802.11-ESTIMATED-DIRECTIONAL-ANTENNA-GAIN 15.0 PHY-RX-MODEL PHY802.11b PHY-LISTENABLE-CHANNEL-MASK 1 PHY-LISTENING-CHANNEL-MASK 1
PHY-TEMPERATURE 290.0 PHY-NOISE-FACTOR 10.0 ANTENNA-MODEL OMNIDIRECTIONAL ANTENNA-GAIN 0.0 ANTENNA-HEIGHT 1.5 # MAC Protocol MAC-PROTOCOL MAC802.11 MAC-802.11-DIRECTIONAL-ANTENNA-MODE NO MAC-802.11-SHORT-PACKET-TRANSMIT-LIMIT 5 MAC-802.11-LONG-PACKET-TRANSMIT-LIMIT 7 MAC-802.11-RTS-THRESHOLD 250 MAC-802.11-STATION-POLL-TYPE POLLABLE MAC-PROPAGATION-DELAY 0US PROMISCUOUS-MODE NO # Network Protocol NETWORK-PROTOCOL IP IP-QUEUE-NUM-PRIORITIES 3 DUMMY-PRIORITY-QUEUE-SIZE NO IP-QUEUE-PRIORITY-INPUT-QUEUE-SIZE 50000 IP-QUEUE-PRIORITY-QUEUE-SIZE 50000 DUMMY-PRIORITY-WISE-IP-QUEUE-TYPE NO IP-QUEUE-TYPE FIFO ECN NO IP-QUEUE-SCHEDULER STRICT-PRIORITY # Routing Protocol DUMMY-ROUTING NONE ROUTING-PROTOCOL NONE HSRP-PROTOCOL NO STATIC-ROUTE YES STATIC-ROUTE-FILE ./figura15.routes-static DEFAULT-ROUTE NO # MPLS configuration MPLS-PROTOCOL NO # Transport Layer TCP LITE TCP-USE-RFC1323 NO TCP-DELAY-ACKS YES TCP-DELAY-SHORT-PACKETS-ACKS NO TCP-USE-NAGLE-ALGORITHM YES TCP-USE-KEEPALIVE-PROBES YES TCP-USE-PUSH YES TCP-MSS 512 TCP-SEND-BUFFER 16384 TCP-RECEIVE-BUFFER 16384
IEL1-I-04-15 IEL1-I-04-16
47
# Application Layer APP-CONFIG-FILE ./figura15.app # Extras # Tracing PACKET-TRACE NO TRACE-ALL NO TRACE-DIRECTION BOTH ACCESS-LIST-TRACE YES # Statistics APPLICATION-STATISTICS YES TCP-STATISTICS YES UDP-STATISTICS YES ROUTING-STATISTICS YES ICMP-STATISTICS YES IGMP-STATISTICS YES EXTERIOR-GATEWAY-PROTOCOL-STATISTICS YES NETWORK-LAYER-STATISTICS YES QUEUE-STATISTICS YES SCHEDULER-STATISTICS YES MAC-LAYER-STATISTICS YES PHY-LAYER-STATISTICS YES MOBILITY-STATISTICS YES MPLS-STATISTICS YES RSVP-STATISTICS YES SRM-STATISTICS YES DIFFSERV-EDGE-ROUTER-STATISTICS YES QOSPF-STATISTICS YES ACCESS-LIST-STATISTICS YES H323-STATISTICS YES # Device properties NODE-NAME Default USE-NODE-ICON NO # Router Specs # Router Configuration Specs # Parallel Properties PARTITION 0 SUBNET N8-192.0.0.0 { 1 thru 16 } 18.3 14.7 0.0 [N8-192.0.0.0] PHY-MODEL PHY802.11b [N8-192.0.0.0] PHY802.11-AUTO-RATE-FALLBACK NO [N8-192.0.0.0] PHY802.11-DATA-RATE 1000000 [N8-192.0.0.0] PHY802.11b-TX-POWER-DBPSK 15.0 [N8-192.0.0.0] PHY802.11b-TX-POWER-DQPSK 15.0 [N8-192.0.0.0] PHY802.11b-TX-POWER-CCK-6 15.0 [N8-192.0.0.0] PHY802.11b-TX-POWER-CCK11 15.0 [N8-192.0.0.0] PHY802.11b-RX-SENSITIVITY-DBPSK -94.0
[N8-192.0.0.0] PHY802.11b-RX-SENSITIVITY-DQPSK -91.0 [N8-192.0.0.0] PHY802.11b-RX-SENSITIVITY-CCK-6 -87.0 [N8-192.0.0.0] PHY802.11b-RX-SENSITIVITY-CCK11 -83.0 [N8-192.0.0.0] PHY802.11b-RX-THRESHOLD-DBPSK -84.0 [N8-192.0.0.0] PHY802.11b-RX-THRESHOLD-DQPSK -81.0 [N8-192.0.0.0] PHY802.11b-RX-THRESHOLD-CCK-6 -77.0 [N8-192.0.0.0] PHY802.11b-RX-THRESHOLD-CCK11 -73.0 [N8-192.0.0.0] PHY802.11-ESTIMATED-DIRECTIONAL-ANTENNA-GAIN 15.0 [N8-192.0.0.0] PHY-RX-MODEL PHY802.11b [N8-192.0.0.0] PHY-LISTENABLE-CHANNEL-MASK 1 [N8-192.0.0.0] PHY-LISTENING-CHANNEL-MASK 1 [N8-192.0.0.0] PHY-TEMPERATURE 290.0 [N8-192.0.0.0] PHY-NOISE-FACTOR 10.0 [N8-192.0.0.0] ANTENNA-MODEL OMNIDIRECTIONAL [N8-192.0.0.0] ANTENNA-GAIN 0.0 [N8-192.0.0.0] ANTENNA-HEIGHT 1.5 [N8-192.0.0.0] MAC-PROTOCOL MAC802.11 [N8-192.0.0.0] MAC-802.11-AP 192.0.0.16 [N8-192.0.0.0] MAC-802.11-DIRECTIONAL-ANTENNA-MODE NO [N8-192.0.0.0] MAC-802.11-SHORT-PACKET-TRANSMIT-LIMIT 5 [N8-192.0.0.0] MAC-802.11-LONG-PACKET-TRANSMIT-LIMIT 7 [N8-192.0.0.0] MAC-802.11-RTS-THRESHOLD 250 [N8-192.0.0.0] PROMISCUOUS-MODE NO LINK N8-192.0.1.0 { 16, 17 } [192.0.1.1 192.0.1.2] LINK-PHY-TYPE WIRED [192.0.1.1 192.0.1.2] LINK-PROPAGATION-DELAY 0MS [192.0.1.1 192.0.1.2] LINK-BANDWIDTH 10000000000 LINK N8-192.0.2.0 { 16, 18 } [192.0.2.1 192.0.2.2] LINK-PHY-TYPE WIRED [192.0.2.1 192.0.2.2] LINK-PROPAGATION-DELAY 0MS [192.0.2.1 192.0.2.2] LINK-BANDWIDTH 10000000000 LINK N8-192.0.3.0 { 16, 19 } [192.0.3.1 192.0.3.2] LINK-PHY-TYPE WIRED [192.0.3.1 192.0.3.2] LINK-PROPAGATION-DELAY 0MS [192.0.3.1 192.0.3.2] LINK-BANDWIDTH 10000000000
IEL1-I-04-15 IEL1-I-04-16
48
LINK N8-192.0.4.0 { 16, 20 } [192.0.4.1 192.0.4.2] LINK-PHY-TYPE WIRED [192.0.4.1 192.0.4.2] LINK-PROPAGATION-DELAY 0MS [192.0.4.1 192.0.4.2] LINK-BANDWIDTH 10000000000 LINK N8-192.0.5.0 { 16, 21 } [192.0.5.1 192.0.5.2] LINK-PHY-TYPE WIRED [192.0.5.1 192.0.5.2] LINK-PROPAGATION-DELAY 0MS [192.0.5.1 192.0.5.2] LINK-BANDWIDTH 10000000000 LINK N8-192.0.6.0 { 16, 22 } [192.0.6.1 192.0.6.2] LINK-PHY-TYPE WIRED [192.0.6.1 192.0.6.2] LINK-PROPAGATION-DELAY 0MS [192.0.6.1 192.0.6.2] LINK-BANDWIDTH 10000000000 IP-FORWARDING NO [1 thru 16] IP-FORWARDING YES [16 thru 22] MOBILITY NONE COMPONENT 0 {N8-192.0.0.0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22} 22 750.0 750.0 0.0 1500.0 1500.0 3000.0 [17] HOSTNAME host17 [16] HOSTNAME host16 [15] HOSTNAME host15 [14] HOSTNAME host14 [13] HOSTNAME host13 [12] HOSTNAME host12 [11] HOSTNAME host11 [10] HOSTNAME host10 [21] HOSTNAME host21 [22] HOSTNAME host22 [20] HOSTNAME host20 [9] HOSTNAME host9 [8] HOSTNAME host8 [7] HOSTNAME host7 [6] HOSTNAME host6 [5] HOSTNAME host5 [4] HOSTNAME host4 [3] HOSTNAME host3 [2] HOSTNAME host2
[1] HOSTNAME host1 [19] HOSTNAME host19 [18] HOSTNAME host18 [6 thru 15] MAC-PROTOCOL MAC802.11 [6 thru 15] MAC-802.11-DIRECTIONAL-ANTENNA-MODE NO [6 thru 15] MAC-802.11-SHORT-PACKET-TRANSMIT-LIMIT 5 [6 thru 15] MAC-802.11-LONG-PACKET-TRANSMIT-LIMIT 7 [6 thru 15] MAC-802.11-RTS-THRESHOLD 250 [6 thru 15] MAC-802.11-STATION-POLL-TYPE NOT-POLLABLE [192.0.0.16 ] MAC-PROTOCOL MAC802.11 [192.0.0.16 ] MAC-802.11-DIRECTIONAL-ANTENNA-MODE NO [192.0.0.16 ] MAC-802.11-SHORT-PACKET-TRANSMIT-LIMIT 5 [192.0.0.16 ] MAC-802.11-LONG-PACKET-TRANSMIT-LIMIT 7 [192.0.0.16 ] MAC-802.11-RTS-THRESHOLD 250 [192.0.0.16 ] DUMMY-MAC-802.11-AP YES [192.0.0.16 ] MAC-802.11-PC YES [192.0.0.16 ] MAC-802.11-BEACON-INTERVAL 1500 [192.0.0.16 ] MAC-802.11-PC-CONTENTION-FREE-DURATION 1400 [192.0.0.16 ] MAC-802.11-BEACON-START-TIME 1 [192.0.0.16 ] MAC-802.11-PC-DELIVERY-MODE POLL-FIFO [192.0.0.16 ] MAC-802.11-PC-POLL-SAVE NONE [192.0.0.16 ] MAC-802.11-PC-POLL-SAVE-MIN 2 [192.0.0.16 ] MAC-802.11-PC-POLL-SAVE-MAX 5 [192.0.0.16 ] MAC-802.11-RELAY-FRAMES YES [192.0.0.16 ] MAC-802.11-STATION-POLL-TYPE POLLABLE
IEL1-I-04-15 IEL1-I-04-16
49
Anexo B Implementación del canal Gilbert-Elliott Estructura creada en mac.h: typedef struct { double simulacion; double canal[TAMVECTOR][2]; int taman; int semilla; double berbad; double bergood; double lamdabueno; double lamdamalo; double datarate; } simulcanal; Lectura de variables en la función MAC_Initialize del archivo mac.c: simulcanal* cana = simulcanal*)MEM_malloc(sizeof(simulcanal)); memset(cana, 0, sizeof(simulcanal*)); IO_ReadDouble( ANY_NODEID, ANY_ADDRESS, nodeInput, "SIMULATION-TIME", &retVal, &endTimeStr); //Lectura tasa de transición de estado IO_ReadDouble( ANY_NODEID, ANY_ADDRESS, nodeInput, "LAMDABUENO", &retVal, &numero); if (retVal) { cana->lamdabueno=numero; } else { cana->lamdabueno=30; } //Lectura tasa de transición de estado IO_ReadDouble( ANY_NODEID, ANY_ADDRESS, nodeInput, "LAMDAMALO", &retVal, &numeroa); if (retVal) { cana->lamdamalo=numeroa; } else {
IEL1-I-04-15 IEL1-I-04-16
50
cana->lamdamalo=10; } //tasa de error de bit estado malo IO_ReadDouble( ANY_NODEID, ANY_ADDRESS, nodeInput, "BERBAD", &retVal, &numerob); if (retVal) { cana->berbad=numerob; } else { cana->berbad=1e-5; } //tasa de error de bit estado bueno IO_ReadDouble IO_ReadDouble( ANY_NODEID, ANY_ADDRESS, nodeInput, "BERGOOD", &retVal, &numeroc); if (retVal) { cana->bergood=numeroc; } else { cana->bergood=1e-10; } IO_ReadInt( ANY_NODEID, ANY_ADDRESS, nodeInput, "SEED", &retVal, &semi); IO_ReadDouble( ANY_NODEID, ANY_ADDRESS, nodeInput, "PHY802.11-DATA-RATE", &retVal, &datarate); if (retVal) { cana->datarate=datarate; } else { cana->datarate=1000000; } //se llama a la función de crear canal cana->taman =creacioncanal (endTimeStr,cana->canal,cana->lamdabueno,cana->lamdamalo);
IEL1-I-04-15 IEL1-I-04-16
51
Función que crea el canal en mac.c:
int creacioncanal (double tsimulacion, double canal[TAMVECTOR][2] ,double lamdabueno, double lamdamalo ) { double tacumulado; double bueno; double malo; double a1; double a2; double b1; double b2; int i; //inicialización variables tacumulado=0; canal[0][0]=0; canal[0][1]=0; i=0; //crean canales de estado bueno y malo mientras el tiempo acumulado //sea menor al tiempo de simulación while(tacumulado<=tsimulacion) { a1 =rand(); a1=rand(); b1=a1/32767; bueno= ((-log(b1))/lamdabueno);//crea el tiempo de periodo bueno canal[i][0]=bueno; tacumulado=tacumulado + canal[i][0]; if (tacumulado>=tsimulacion) { //verifica que no sobrepase el tiempo de simulación canal [i+1] [1]=tsimulacion; canal [i] [0]= tsimulacion - canal[i][1];//acomoda el ultimo periodo de bueno canal [i+1] [0] =0; return (i); } else { canal [i+1] [1]=tacumulado; } i++; a2=rand(); b2=a2/32767; malo= ((-log(b2))/lamdamalo); //crea el tiempo de malo canal[i][0]=malo; tacumulado=tacumulado + canal[i][0]; if (tacumulado>=tsimulacion) { //verifica que no sobrepase el tiempo de simulación canal [i+1] [1]=tsimulacion; canal [i] [0]= tsimulacion - canal[i][1]; //acomoda el ultimo periodo de bueno canal [i+1] [0] =0; return (i); } else { canal [i+1] [1]=tacumulado; } i++; } return(i); }
IEL1-I-04-15 IEL1-I-04-16
52
Función modificada de recepción del paquete en el archivo mac_802_11.c void Mac802_11ReceivePacketFromPhy( Node* node, MacData802_11* M802, Message* msg) { M802_11ShortControlFrame* hdr = (M802_11ShortControlFrame*) MESSAGE_ReturnPacket(msg); BOOL paerror=FALSE; M802_11MacFrameType frameType = hdr->frameType; //se llama a la función que determina si el paquete tiene error paerror=MAC802_11tiene_error(node, M802, msg); if (!paerror){ //Si el paquete no tiene error se opera de la forma normal //el código se puede ver en el archivo mac_802_11.c else{ // El paquete tiene error //rutina para descartar el paquete. if (Mac802_11IsCfFrameType(frameType)){ M802->cfpState=M802_11_S_CFP_WF_ACK;
Mac802_11CfpHandleTimeout(node,M802, msg); } MESSAGE_Free(node, msg); return; //Código para botar el paquete. } Función que determina si un paquete tiene error en el archivo mac_802_11.c BOOL MAC802_11tiene_error( Node* node, MacData802_11* M802, Message* msg) { long double SimTime; float packetsize; int n1_n2[2]={0,0},sizebits; double perror; double BERg=1e-10; double aleat1,aleat=0; double canal[TAMVECTOR][2]; M802_11ShortControlFrame* sHdr = (M802_11ShortControlFrame*) MESSAGE_ReturnPacket(msg); NodeAddress destAddr = sHdr->destAddr; M802_11MacFrameType frameType = sHdr->frameType; /Obteniendo el tamaño del paquete. packetsize=MESSAGE_ReturnVirtualPacketSize(msg)+MESSAGE_Retur nActualPacketSize(msg); sizebits=packetsize*8; //Obteniendo el tiempo de simulación SimTime=getSimTime(node); if (Mac802_11IsCfFrameType(frameType)) {//Es trama de PCF if (M802->selfAddr==sHdr->destAddr) {//Es para estación estadocanal(SimTime,n1_n2,sizebits,M802,msg); if (n1_n2[0]!=-1){ //se calcula probabilidad de error perror = 1.0 - pow((1.0 - (M802->bergood)), n1_n2[0])*pow((1.0 - (M802->berbad)), n1_n2[1]); aleat1 = rand(); //se calcula un numero aleatorio
IEL1-I-04-15 IEL1-I-04-16
53
aleat=aleat1/32767; } else{ perror=0; } if (perror>aleat){ // si el numero aleatorio es menor a la probabilidad de error, //el paquete tiene error switch (frameType){ case M802_11_CF_DATA_POLL_ACK: case M802_11_CF_DATA_POLL: case M802_11_CF_DATA: case M802_11_CF_DATA_ACK:{ M802->pktsLostOverflow++; } break; default:{ } break; } return TRUE; } } } else{//Es trama de DCF if (destAddr == M802->selfAddr) {//Es para mi? estadocanal(SimTime,n1_n2,sizebits,M802,msg); perror = 1.0 - pow((1.0 - (M802->bergood)), n1_n2[0])*pow((1.0 - (M802->berbad)), n1_n2[1]); aleat1 = rand(); aleat=aleat1/32767; tiempo=%13.12f\n",n1_n2[0],n1_n2[1],perror,aleat,SimTime); if (perror>aleat){ switch (sHdr->frameType) { case M802_11_DATA:{ M802->pktsLostOverflow++; } break; default:{ } break; } return TRUE; } } } return FALSE; } Función que calcula los valores de n1 y n2 en el archivo mac_802_11.c void estadocanal (long double tfin,int n1_n2[2], int tam, MacData802_11* M802, Message* msg){ int temp1=0,i=0,j=0; long double datarate=0,temp=0; longdouble canal15[TAMVECTOR][2]; long double t1bit15,ttx15,tini15,tfin15,tsim15; M802_11ShortControlFrame* sHdr =
IEL1-I-04-15 IEL1-I-04-16
54
(M802_11ShortControlFrame*) MESSAGE_ReturnPacket(msg); M802_11MacFrameType frameType = sHdr->frameType; switch (frameType){//se establece la tasa de transmision para el tipo de paquete case M802_11_DATA: case M802_11_ACK: caseM802_11_CF_DATA_POLL_ACK: case M802_11_CF_DATA_POLL: case M802_11_CF_DATA: case M802_11_CF_DATA_ACK:{ datarate=M802->datarate; } break; default:{ datarate=1000000; } break; } n1_n2[0]=0; n1_n2[1]=0; tsim15=sec_to_15t(M802->tiemposimul); t1bit15=1e15/datarate; //conviertiendo a 1e15 tfin15=sec_to_6t(tfin); copiar(M802->scanal,canal15,TAMVECTOR,2); sec_to_15tv(canal15,TAMVECTOR,2); ttx15=t1bit15*tam; // tini15=tfin15-ttx15; tini15=tfin15; tfin15=tini15+ttx15; if (tfin15<tsim15){ i=0; while(canal15[i][1]<tini15){ i++; } j=0; while(canal15[j][1]<(tini15+ttx15)){ j++; } if (i==j){ if (i%2==1){//Todo el tiempo ON n1_n2[0]=tam; n1_n2[1]=0; return; } else{//Todo el tiempo OFF n1_n2[0]=0; n1_n2[1]=tam; return; } } else{ temp=(canal15[i][1]-tini15); temp1=floor(temp/t1bit15); if (i%2==1){//Empieza en ON n1_n2[0]=temp1; } else{//Empieza en OFF n1_n2[1]=temp1;
IEL1-I-04-15 IEL1-I-04-16
55
} i=i+1; while (i<=j){ if(i==j){ temp=(tini15+ttx15)-canal15[i-1][1]; temp1=ceil(temp/t1bit15); if (i%2==1){//Termina en ON n1_n2[0]=n1_n2[0]+temp1; return; } else{//Termina en OFF n1_n2[1]=n1_n2[1]+temp1; return; } } else{ temp=canal15[i][1]-canal15[i-1][1]; temp1=temp/t1bit15; if (i%2==1){//Está en ON n1_n2[0]=n1_n2[0]+temp1; } else{//Está en OFF n1_n2[1]=n1_n2[1]+temp1; } i++; } } } } else{ n1_n2[0]=-1; n1_n2[1]=-1; } } long double sec_to_15t(long double n){ return n*1e15; } long double sec_to_6t(long double n){ return n*1e6; } void sec_to_15tv(long double n[TAMVECTOR][2],int f, int c){ int i,j; for (i=0;i<f;i++){ for (j=0;j<c;j++){ n[i][j]=n[i][j]*1e15; } } } void copiar(long double ns[TAMVECTOR][2],long double nd[TAMVECTOR][2],int f, int c){ int i,j; for (i=0;i<f;i++){ for (j=0;j<c;j++){ nd[i][j]=ns[i][j]; } } }
IEL1-I-04-15 IEL1-I-04-16
56
Anexo C Implementación esquemas de asignación Lectura de variables en la función Mac802_11PcInit del archivo mac_802_11.c IO_ReadString( node->nodeId, M802->selfAddr, nodeInput, "MAC-802.11-PC-DELIVERY-MODE", &wasFound, input); if (wasFound) { if (!strcmp(input, "DELIVER-ONLY")) { pc->deliveryMode = M802_11_PC_DELIVER_ONLY; } else if (!strcmp(input, "POLL-AND-DELIVER")) { pc->deliveryMode = M802_11_PC_POLL_AND_DELIVER; } else if (!strcmp(input, "POLL-ONLY")) { pc->deliveryMode = M802_11_PC_POLL_ONLY; } else if (!strcmp(input, "POLL-RR")) { pc->deliveryMode = M802_11_PC_POLL_RR; } else if (!strcmp(input, "POLL-FIFO")) { pc->deliveryMode = M802_11_PC_POLL_FIFO; } else { ERROR_ReportError("Mac802_11PcInit: " "Invalid value for MAC-802.11-PC-DELIVERY-MODE " "in configuration file.\n " "Expecting DELIVER-ONLY | POLL-ONLY | POLL-AND-DELIVER | POLL-RR | POLL-FIFO.\n"); } } else { pc->deliveryMode = M802_11_PC_DELIVERY_MODE_DEFAULT; }
IEL1-I-04-15 IEL1-I-04-16
57
Implementación de los dos nuevos casos en la función Mac802_11CfpPcTransmit case M802_11_PC_POLL_RR: switch (M802->cfpState) { case M802_11_S_CFP_NONE: Mac802_11CheckForOutgoingPacket(node, M802);
Mac802_11CfpPcTransmitPollRR(node, M802, &destAddr, &frameType, sendDelay, &stationItem);
break; case M802_11_S_CFP_WF_ACK: case M802_11_S_CFP_WF_DATA:
case M802_11_S_CFP_WF_DATA_ACK: Mac802_11CfPollListUpdateForNullDataResponse(node, M802, pc->prevPolledItem->data->macAddr); // Continue polling Mac802_11CfpPcTransmitPollRR(node, M802, &destAddr, &frameType, sendDelay, &stationItem); break; default: ERROR_ReportError("Mac802_11CfpPcTransmit: " "Unknown CFP state for POLL-RR mode.\n"); break; } //switch break; case M802_11_PC_POLL_FIFO: switch (M802->cfpState) { case M802_11_S_CFP_NONE: Mac802_11CheckForOutgoingPacket(node, M802); Mac802_11CfpPcTransmitPollFIFO(node, M802, &destAddr, &frameType, sendDelay,
&stationItem); break; M802_11_CF_END; case M802_11_S_CFP_WF_ACK: case M802_11_S_CFP_WF_DATA: case M802_11_S_CFP_WF_DATA_ACK: if (!pc->allStationsPolled) {
//Mac802_11CfPollListUpdateForNullDataResponse(node, // M802, pc->prevPolledItem->data->macAddr); // Continue polling Mac802_11CfpPcTransmitPollFIFO(node, M802, &destAddr, &frameType, sendDelay,
&stationItem); } else { // In delivery mode, the packet in buffer timed out. // End PCF. frameType = M802_11_CF_END; destAddr = ANY_ADDRESS; } break; default: ERROR_ReportError("Mac802_11CfpPcTransmit: " "Unknown CFP state for POLL-FIFO mode.\n"); break; } //switch break;
IEL1-I-04-15 IEL1-I-04-16
58
Función que permite que la lista se repita hasta la máxima duración del CFP. static M802_11_CfPollListItem * Mac802_11CfpPcGetNextItemToPoll2( Node* node, MacData802_11* M802) { M802_11_PcVars* pc = M802->pcVars; M802_11_CfPollListItem* next; M802_11_CfPollListItem* temp; //Agregue una variable temp M802_11_CfPollListItem* itemToPoll = NULL; int i=0; ERROR_Assert(Mac802_11IsPC(M802) && Mac802_11PcSendsPolls(pc), "Mac802_11CfpPcGetNextItemToPoll: " "Poll list not applicable to PC configuration.\n"); if (pc->pollableCount > 0 && !pc->allStationsPolled) { next = Mac802_11CfPollListGetNextItem(node, M802, pc->prevPolledItem); while (next != pc->firstPolledItem) { if (next->data->pollType == M802_11_STA_POLLABLE_POLL) { if (Mac802_11CfpPollCanBeSkipped(node, M802, next)) { // TRUE parameter indicates skipped poll Mac802_11CfpUpdateForPoll(node, M802, next, TRUE); } else { itemToPoll = next; break; } } next = Mac802_11CfPollListGetNextItem(node, M802, next); } //while if (next == pc->firstPolledItem) { if (Mac802_11CfpPollCanBeSkipped(node, M802, next)){//Verificando si el primero de la lista se puede
saltar i=i+1; } temp=Mac802_11CfPollListGetNextItem(node, M802,next); while (temp != pc->firstPolledItem) {//Contando cuantos de la lista se pueden saltar if (temp->data->pollType == M802_11_STA_POLLABLE_POLL) { //Si la estación es enlistable if (Mac802_11CfpPollCanBeSkipped(node, M802, temp)) { //Si se puede saltar i=i+1; } } temp=Mac802_11CfPollListGetNextItem(node, M802,temp);//Avance una posición en la lista } if(i<pc->cfPollList->size){ //Si todas las estaciones no han sido sacadas de la lista //Decida donde Arrancar if (Mac802_11CfpPollCanBeSkipped(node, M802, next)){ //Verificando si el primero de la lista se puede saltar temp=Mac802_11CfPollListGetNextItem(node,
M802,next); } else{ temp=next } while (temp != pc->firstPolledItem) {
IEL1-I-04-15 IEL1-I-04-16
59
//Contando cuantos de la lista se pueden saltar if (temp->data->pollType == M802_11_STA_POLLABLE_POLL) { //Si la estación es enlistable if (Mac802_11CfpPollCanBeSkipped(node, M802, temp)) { //Si se puede saltar temp=Mac802_11CfPollListGetNextItem(node, M802,temp); } else{ break; } } } pc->allStationsPolled = FALSE; itemToPoll = temp; //Empiece en la primera que no se puede saltar } else{ pc->allStationsPolled = TRUE; //Si todas fueron sacadas de la lista termine el CFPf itemToPoll = NULL; Mac802_11CfPollListResetAtStartOfCfp(node, M802); } } } return itemToPoll; }
IEL1-I-04-15 IEL1-I-04-16
60
Anexo D Leyendo el nombre del experimento en la función APP_InitializeApplications del archivo Application.c Esta función le pasa el nombre del experimento a la función TrafficGenServerInit del archivo traffic_gen.c //Leyendo Nombre Archivo IO_ReadString( ANY_NODEID, ANY_ADDRESS, nodeInput, "EXPERIMENT-NAME", &retVal, arch); if (!retVal){ strcat(arch,"pordefecto.dat"); } //Leyendo Semilla IO_ReadString( ANY_NODEID, ANY_ADDRESS, nodeInput, "SEED", &retVal, semilla); strcat(arch,semilla); strcat(arch,".dat"); archivo = fopen( arch, "w" ); fclose( archivo ); fflush(archivo); Agregando el nombre del experimento al campo arch de la estructura node. void TrafficGenServerInit(Node* node, char arch[MAX_STRING_LENGTH]) { strcpy(node->arch,arch); if (EXCEL) { remove(TRAFFIC_GEN_SERVER_FILE); } } Modificando el código de la función TrafficGenServerLayerRoutine para almacenar en el archivo el retardo de cada paquete en la red
IEL1-I-04-15 IEL1-I-04-16
61
void TrafficGenServerLayerRoutine(Node* node, Message* msg) { char clockStr[MAX_STRING_LENGTH]; char errMsg[MAX_STRING_LENGTH]; char origen[MAX_STRING_LENGTH]; TrafficGenServer* serverPtr = NULL; UdpToAppRecv* info = NULL; TrafficGenData data; clocktype timesim; int timeround; FILE *archivo; double retardo; switch (msg->eventType) { case MSG_APP_FromTransport: { info = (UdpToAppRecv*)MESSAGE_ReturnInfo(msg); memcpy(&data, MESSAGE_ReturnPacket(msg), sizeof(data)); serverPtr = TrafficGenServerGetServer( node, info->sourceAddr, data.sourcePort); // New connection, so create new traffic gen server to handle client. if (serverPtr == NULL) { serverPtr = TrafficGenServerNewServer( node, info->sourceAddr, info->destAddr, data.sourcePort); } if ((data.seqNo == serverPtr->seqNo && data.fragNo == serverPtr->fragNo) || (data.seqNo > serverPtr->seqNo && data.fragNo == 0)) { if (data.fragNo == 0) { serverPtr->fragByte = 0; serverPtr->fragTm = data.txTime; } serverPtr->startTm = data.startTm; serverPtr->endTm = data.endTm; serverPtr->lastRcvTm = getSimTime(node); serverPtr->seqNo = data.seqNo; serverPtr->fragNo = data.fragNo; serverPtr->totFrag = data.totFrag; serverPtr->fragByte += MESSAGE_ReturnPacketSize(msg); if (serverPtr->fragNo == serverPtr->totFrag - 1) { serverPtr->totDataRcvd++;
IEL1-I-04-15 IEL1-I-04-16
62
serverPtr->totByteRcvd += serverPtr->fragByte; serverPtr->totDelay += getSimTime(node) - serverPtr->fragTm; retardo=getSimTime(node)- serverPtr->fragTm; IO_ConvertIpAddressToString(msg->originatingNodeId,origen); archivo=fopen(node->arch,"a"); fprintf(archivo,"%s; %s; %f;\n",origen,node->hostname,retardo); fclose(archivo); fflush(archivo); serverPtr->seqNo++; serverPtr->fragNo = 0;
IEL1-I-04-15 IEL1-I-04-16
63
Anexo E
Inicializando nuevas variables creadas. static TrafficGenServer* TrafficGenServerNewServer( Node* node, NodeAddress remoteAddr, NodeAddress localAddress, short sourcePort) { TrafficGenServer* serverPtr; FILE *archivo; char arch[MAX_STRING_LENGTH]; serverPtr = (TrafficGenServer*) MEM_malloc(sizeof(TrafficGenServer)); // Initialize //Código del Ususario strcpy(arch,node->arch); //strcat(arch,".dat"); //strcpy(node->arch,arch); archivo = fopen( arch, "a" ); fclose( archivo ); fflush(archivo); serverPtr->localAddr = localAddress; serverPtr->remoteAddr = remoteAddr; serverPtr->sourcePort = sourcePort; serverPtr->startTm = 0; serverPtr->endTm = 0; serverPtr->lastRcvTm = 0; serverPtr->totByteRcvd = 0; serverPtr->totDataRcvd = 0; serverPtr->totDataRcvd1 = 0; serverPtr->totDataRcvd2 = 0; serverPtr->totDataRcvd3 = 0; serverPtr->totDataRcvd4 = 0; serverPtr->totDataRcvd5 = 0; serverPtr->totDataRcvd6 = 0; serverPtr->totDataRcvd7 = 0; serverPtr->totDataRcvd8 = 0; serverPtr->totDataRcvd9 = 0; serverPtr->totDataRcvd10 = 0; serverPtr->totDataRcvd11 = 0; serverPtr->totDataRcvd12 = 0; serverPtr->totDataRcvd13 = 0; serverPtr->totDataRcvd14 = 0; serverPtr->totDataRcvd15 = 0; serverPtr->totDataRcvd16 = 0; serverPtr->totDataRcvd17 = 0; serverPtr->totDataRcvd18 = 0;
IEL1-I-04-15 IEL1-I-04-16
64
serverPtr->totDataRcvd19 = 0; serverPtr->totDataRcvd20 = 0; serverPtr->totDataRcvd21 = 0; serverPtr->totDataRcvd22 = 0; serverPtr->totDataRcvd23 = 0; serverPtr->totDataRcvd24 = 0; serverPtr->totDataRcvd25 = 0; serverPtr->totDataRcvd26 = 0; serverPtr->totDataRcvd27 = 0; serverPtr->totDataRcvd28 = 0; serverPtr->totDataRcvd29 = 0; serverPtr->totDataRcvd30 = 0; MsTmWinInit(&serverPtr->rcvThru, (clocktype) TRAFFIC_GEN_SERVER_SSIZE, TRAFFIC_GEN_SERVER_NSLOT, TRAFFIC_GEN_SERVER_WEIGHT, getSimTime(node)); serverPtr->totDelay = 0; serverPtr->seqNo = 0; serverPtr->fragNo = 0; serverPtr->totFrag = 0; serverPtr->fragByte = 0; serverPtr->fragTm = 0; serverPtr->isClosed = FALSE; serverPtr->lastInterArrivalInterval = 0; serverPtr->lastPacketReceptionTime = 0; serverPtr->totalJitter = 0; APP_RegisterNewApp(node, APP_TRAFFIC_GEN_SERVER, serverPtr); if (TRAFFIC_GEN_DEBUG) { FILE *fp; char fileName[MAX_STRING_LENGTH]; sprintf(fileName, "ServerGenFile_%d_%d_%d", serverPtr->remoteAddr, serverPtr->localAddr, serverPtr->sourcePort); fp = fopen(fileName, "w"); fclose(fp); } return serverPtr; } Modificando la forma de almacenamiento del caudal de datos del sistema void TrafficGenServerLayerRoutine(Node* node, Message* msg) { char clockStr[MAX_STRING_LENGTH]; char errMsg[MAX_STRING_LENGTH]; char origen[MAX_STRING_LENGTH]; TrafficGenServer* serverPtr = NULL; UdpToAppRecv* info = NULL; TrafficGenData data;
IEL1-I-04-15 IEL1-I-04-16
65
clocktype timesim; int timeround; FILE *archivo; double retardo; switch (msg->eventType) { case MSG_APP_FromTransport: { info = (UdpToAppRecv*)MESSAGE_ReturnInfo(msg); memcpy(&data, MESSAGE_ReturnPacket(msg), sizeof(data)); serverPtr = TrafficGenServerGetServer( node, info->sourceAddr, data.sourcePort); // New connection, so create new traffic gen server to handle client. if (serverPtr == NULL) { serverPtr = TrafficGenServerNewServer( node, info->sourceAddr, info->destAddr, data.sourcePort); } if ((data.seqNo == serverPtr->seqNo && data.fragNo == serverPtr->fragNo) || (data.seqNo > serverPtr->seqNo && data.fragNo == 0)) { if (data.fragNo == 0) { serverPtr->fragByte = 0; serverPtr->fragTm = data.txTime; } serverPtr->startTm = data.startTm; serverPtr->endTm = data.endTm; serverPtr->lastRcvTm = getSimTime(node); serverPtr->seqNo = data.seqNo; serverPtr->fragNo = data.fragNo; serverPtr->totFrag = data.totFrag; serverPtr->fragByte += MESSAGE_ReturnPacketSize(msg); if (serverPtr->fragNo == serverPtr->totFrag - 1) { serverPtr->totDataRcvd++; serverPtr->totByteRcvd += serverPtr->fragByte; serverPtr->totDelay += getSimTime(node) - serverPtr->fragTm; retardo=getSimTime(node)- serverPtr->fragTm; IO_ConvertIpAddressToString(msg->originatingNodeId,origen); archivo=fopen(node->arch,"a");
fprintf(archivo,"%s; %s;%f;\n",origen,node->hostname,retardo);
fclose(archivo);
IEL1-I-04-15 IEL1-I-04-16
66
fflush(archivo); serverPtr->seqNo++; serverPtr->fragNo = 0; //Modificando el código timesim=getSimTime(node); timeround=ceil(timesim/1e9); switch (timeround){ case 1:{ serverPtr->totDataRcvd1++; } break; case 2:{ serverPtr->totDataRcvd2++; } break; case 3:{ serverPtr->totDataRcvd3++; } break; case 4:{ serverPtr->totDataRcvd4++; } break; case 5:{ serverPtr->totDataRcvd5++; } break; case 6:{ serverPtr->totDataRcvd6++; } break; case 7:{ serverPtr->totDataRcvd7++; } break; case 8:{ serverPtr->totDataRcvd8++; } break; case 9:{ serverPtr->totDataRcvd9++; } break; case 10:{ serverPtr->totDataRcvd10++; } break; case 11:{ serverPtr->totDataRcvd11++; } break; case 12:{ serverPtr->totDataRcvd12++;
IEL1-I-04-15 IEL1-I-04-16
67
} break; case 13:{ serverPtr->totDataRcvd13++; } break; case 14:{ serverPtr->totDataRcvd14++; } break; case 15:{ serverPtr->totDataRcvd15++; } break; case 16:{ serverPtr->totDataRcvd16++; } break; case 17:{ serverPtr->totDataRcvd17++; } break; case 18:{ serverPtr->totDataRcvd18++; } break; case 19:{ serverPtr->totDataRcvd19++; } break; case 20:{ serverPtr->totDataRcvd20++; } break; case 21:{ serverPtr->totDataRcvd21++; } break; case 22:{ serverPtr->totDataRcvd22++; } break; case 23:{ serverPtr->totDataRcvd23++; } break; case 24:{ serverPtr->totDataRcvd24++; } break; case 25:{ serverPtr->totDataRcvd25++; } break; case 26:{ serverPtr->totDataRcvd26++;
IEL1-I-04-15 IEL1-I-04-16
68
} break; case 27:{ serverPtr->totDataRcvd27++; } break; case 28:{ serverPtr->totDataRcvd28++; } break; case 29:{ serverPtr->totDataRcvd29++; } break; case 30:{ serverPtr->totDataRcvd30++; } break; default:{ } break; } //Terminando de modificar el código MsTmWinNewData(&serverPtr->rcvThru, serverPtr->fragByte * 8.0, getSimTime(node)); // Calculate jitter. if (serverPtr->totDataRcvd > 1) { clocktype now = getSimTime(node); clocktype interArrivalInterval; interArrivalInterval = (now - serverPtr->lastPacketReceptionTime); // Jitter can only be measured after receiving // three packets. if (serverPtr->totDataRcvd > 2) { serverPtr->totalJitter += (clocktype) abs((int) (interArrivalInterval - serverPtr->lastInterArrivalInterval)); } serverPtr->lastInterArrivalInterval = interArrivalInterval; } serverPtr->lastPacketReceptionTime = getSimTime(node); if (TRAFFIC_GEN_DEBUG) { FILE *fp; char fileName[MAX_STRING_LENGTH]; char dataBuf[MAX_STRING_LENGTH]; clocktype currentTime = getSimTime(node);
IEL1-I-04-15 IEL1-I-04-16
69
sprintf(fileName, "ServerGenFile_%d_%d_%d", serverPtr->remoteAddr, serverPtr->localAddr, serverPtr->sourcePort); fp = fopen(fileName, "a"); if (fp) { sprintf(dataBuf, "%.6f\t%d\t%.6f\t%.6f\n", (currentTime / (double)SECOND), serverPtr->sourcePort, MsTmWinAvg(&serverPtr->rcvThru, currentTime), MsTmWinTotalAvg(&serverPtr->rcvThru, currentTime)); fwrite(dataBuf, strlen(dataBuf), 1, fp); fclose(fp); } } } else { serverPtr->fragNo++; } } break; } default: { ctoa(getSimTime(node), clockStr); sprintf(errMsg, "TRAFFIC_GEN Server: At time %s, node %ld received " "message of unknown type %ld.\n", clockStr, node->nodeId, msg->eventType); ERROR_Assert(FALSE, errMsg); break; } } MESSAGE_Free(node, msg); } Imprimiendo las nuevas variables en el archivo de configuración del experimento void TrafficGenServerPrintStats( Node* node, TrafficGenServer* serverPtr) { FILE* excel = NULL; clocktype throughput; clocktype avgJitter; char remoteAddrStr[MAX_STRING_LENGTH];
IEL1-I-04-15 IEL1-I-04-16
70
char jitterStr[MAX_STRING_LENGTH]; char delayStr[MAX_STRING_LENGTH]; char startTmStr[MAX_STRING_LENGTH]; char endTmStr[MAX_STRING_LENGTH]; char statusStr[MAX_STRING_LENGTH]; char throughputStr[MAX_STRING_LENGTH]; char buf[MAX_STRING_LENGTH]; if (EXCEL) { excel = fopen(TRAFFIC_GEN_SERVER_FILE, "a"); if (excel == NULL) { fprintf(stderr, "TRAFFIC_GEN Server: cannot open excel stat file.\n"); ERROR_Assert(FALSE, "TRAFFIC_GEN Server: cannot open excel stat file"); } } TIME_PrintClockInSecond(serverPtr->startTm, startTmStr); TIME_PrintClockInSecond(serverPtr->endTm, endTmStr); if (serverPtr->endTm != 0 && getSimTime(node) >= serverPtr->endTm) { serverPtr->isClosed = TRUE; } if (serverPtr->isClosed == FALSE) { sprintf(statusStr, "Not closed"); } else { sprintf(statusStr, "Closed"); } if (serverPtr->totDataRcvd == 0) { TIME_PrintClockInSecond(0, delayStr); } else { TIME_PrintClockInSecond( serverPtr->totDelay / serverPtr->totDataRcvd, delayStr); } if (serverPtr->lastRcvTm > serverPtr->startTm) { throughput = (clocktype) ((serverPtr->totByteRcvd * 8.0 * SECOND) / (serverPtr->lastRcvTm - serverPtr->startTm)); } else
IEL1-I-04-15 IEL1-I-04-16
71
{ throughput = 0; } ctoa(throughput, throughputStr); IO_ConvertIpAddressToString(serverPtr->remoteAddr, remoteAddrStr); sprintf(buf, "Client Address = %s", remoteAddrStr); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Session Start Time (s) = %s", startTmStr); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Session End Time (s) = %s", endTmStr); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Session Status = %s", statusStr); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total bytes Received = %u", serverPtr->totByteRcvd); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received = %ld", serverPtr->totDataRcvd); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server",
IEL1-I-04-15 IEL1-I-04-16
72
ANY_DEST, serverPtr->sourcePort, buf); //Modificando el código sprintf(buf, "Total Data Units Received1 = %ld", serverPtr->totDataRcvd1); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received2 = %ld", serverPtr->totDataRcvd2); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received3 = %ld", serverPtr->totDataRcvd3); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received4 = %ld", serverPtr->totDataRcvd4); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received5 = %ld", serverPtr->totDataRcvd5); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received6 = %ld", serverPtr->totDataRcvd6); IO_PrintStat( node, "Application",
IEL1-I-04-15 IEL1-I-04-16
73
"TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received7 = %ld", serverPtr->totDataRcvd7); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received8 = %ld", serverPtr->totDataRcvd8); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received9 = %ld", serverPtr->totDataRcvd9); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received10 = %ld", serverPtr->totDataRcvd10); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received11 = %ld", serverPtr->totDataRcvd11); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received12 = %ld", serverPtr->totDataRcvd12); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST,
IEL1-I-04-15 IEL1-I-04-16
74
serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received13 = %ld", serverPtr->totDataRcvd13); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received14 = %ld", serverPtr->totDataRcvd14); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received15 = %ld", serverPtr->totDataRcvd15); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received16 = %ld", serverPtr->totDataRcvd16); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received17 = %ld", serverPtr->totDataRcvd17); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received18 = %ld", serverPtr->totDataRcvd18); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf);
IEL1-I-04-15 IEL1-I-04-16
75
sprintf(buf, "Total Data Units Received19 = %ld", serverPtr->totDataRcvd19); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received20 = %ld", serverPtr->totDataRcvd20); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received21 = %ld", serverPtr->totDataRcvd21); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received22 = %ld", serverPtr->totDataRcvd22); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received23 = %ld", serverPtr->totDataRcvd23); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received24 = %ld", serverPtr->totDataRcvd24); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received25 = %ld", serverPtr->totDataRcvd25);
IEL1-I-04-15 IEL1-I-04-16
76
IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received26 = %ld", serverPtr->totDataRcvd26); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received27 = %ld", serverPtr->totDataRcvd27); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received28 = %ld", serverPtr->totDataRcvd28); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received29 = %ld", serverPtr->totDataRcvd29); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Total Data Units Received30 = %ld", serverPtr->totDataRcvd30); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); //Terminando de modificar el código sprintf(buf, "Throughput (bits/s) = %s", throughputStr);
IEL1-I-04-15 IEL1-I-04-16
77
IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); sprintf(buf, "Average End-to-End Delay (s) = %s", delayStr); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); if (serverPtr->totDataRcvd - 2 <= 0) { avgJitter = 0; } else { avgJitter = serverPtr->totalJitter / (serverPtr->totDataRcvd - 2); } // Jitter can only be measured after receiving three packets. TIME_PrintClockInSecond(avgJitter, jitterStr); sprintf(buf, "Average Jitter (s) = %s", jitterStr); IO_PrintStat( node, "Application", "TRAFFIC-GEN Server", ANY_DEST, serverPtr->sourcePort, buf); if (EXCEL) { fprintf(excel, "%ld\t%ld\t%d\t%s\t%s\t%u\t%ld\t%s\t%s\n", serverPtr->remoteAddr, serverPtr->localAddr, serverPtr->sourcePort, startTmStr, endTmStr, serverPtr->totByteRcvd, serverPtr->totDataRcvd, delayStr, throughputStr); fflush(excel); fclose(excel); } }
