Integración en OMNeT++ de módulos desarrollados en Python: aplicación a un simulador de redes ópticas pasivas

UNIVERSIDAD DE VALLADOLID E.T.S.I. TELECOMUNICACIÓN TRABAJO FIN DE GRADO GRADO EN INGENIERÍA DE TECNOLOGÍAS DE TELECOMUNICACIÓN Integración en OMNeT++ de módulos desarrollados en Python: Aplicación a un simulador de redes ópticas pasivas Autor: Gorka Sainz-Ezquerra Calvo Tutor: Dña. Noemí Merayo Álvarez D. Ignacio de Miguel Jiménez TÍTULO: Integracion en OMNeT++ de módulos desarrollados en Python: Aplicación a un simulador de redes ópticas pasivas AUTOR: Gorka Sainz-Ezquerra Calvo TUTOR: Dña. Noemí Merayo Álvarez y D. Ignacio de Miguel Jiménez DEPARTAMENTO: Teoría de la Señal y Comunicaciones e Ingeniería Telemática TRIBUNAL PRESIDENTE: Ignacio de Miguel Jiménez SECRETARIO: Noemí Merayo Álvarez VOCAL: Ramón J. Durán Barroso SUPLENTE: J. Carlos Aguado Manzano SUPLENTE: Evaristo J. Abril Domingo FECHA: CALIFICACIÓN: Resumen En este Trabajo Fin de Grado (TFG), se ha llevado a cabo un estudio de investigación centrado en la integración de Python en el entorno de simulación OMNeT++, originalmente basado en C++. Para ello, se ha hecho uso de la biblioteca desarrollada por Marcos Modesini, Omnetpy. Dicha biblioteca está basada en PyBind11 y se encontraba inicialmente proporcionada a través de un contenedor Docker con una versión de OMNeT++ concreta. Con el objetivo de permitir el uso de la biblioteca Omnetpy junto con diferentes versiones de OMNeT++, se ha desarrollado un proceso para extraer la biblioteca del contenedor e integrarla en otra versión de OMNeT++ distinta. Por otra parte, se ha realizado un estudio del estado del arte de las redes 10G-EPON (Ethernet Passive Optical Network) a partir de un simulador de este tipo de redes desarrollado por el Grupo de Comunicaciones Ópticas de la Universidad de Valladolid. El estudio se ha centrado en el análisis de diversos algoritmos de asignación dinámica de ancho de banda (Dynamic Bandwidth Allocation, DBA) entre los que destaca el uso de una red neuronal para controlar, de forma dinámica, los parámetros de sintonización de un controlador PID (Proportional Integral Derivative). Además, se ha añadido un módulo desarrollado en Python a dicho simulador para evaluar las posibilidades y limitaciones de Omnetpy. Palabras clave PON (Red Óptica Pasiva), OMNeT++, Python, Omnetpy, Docker, 10G-EPON, DBA (Asignación Dinámica de Ancho de Banda), PID, Red neuronal Abstract In this Final Degree Project, a research study has been carried out. It has focused on Python integration in OMNeT++ which is originally based on C++. In order to achieve that objective, the library developed by Marcos Modenesi, Omnetpy, has been used. Said library is based in PyBind11 and initially found on a Docker container in a precise OMNeT++ version. Chasing the goal of allowing Omnetpy run in different OMNeT++ versions, a proccess has been developed to extract the library from the container and integrate it into a different one. On the other hand, a study of the state of the art of 10G-EPON (Ethernet Passive Optical Network) has been carried out using a simulator developed by the Optical Communications Group of Universidad de Valladolid. The study focused on the analysis of various DBA (Dynamic Bandwidth Allocation) algorithms, among which the use of a neural network to dynamically control the tuning parameters of a PID (Proportional Integral Derivative) controller stands out. In addition, a module developed in Python has been added to the simulator to evaluate the possibilities and limitations of Omnetpy. Keywords PON (Passive Optical Network), OMNeT++, Python, Omnetpy, Docker, 10G-EPON, DBA (Dynamic Bandwidth Allocation), PID, Neural Network Agradecimientos A mi familia por apoyarme y ayudarme diariamente, permitiéndome dedicarle a mis estudios todo el tiempo que los mismos han requerido, lo cual, de otra forma, hubiera sido impensable. A mi pareja, Inés, por animarme siempre y darme la energía y la determinación para seguir adelante. A mis tutores, Noemí e Ignacio, por su inestimable ayuda, consejos y enseñanzas así como su dedicación a lo largo de toda la realización de este trabajo. A mis amigos, Daniel, Álvaro y Sergio “Pichi”, por haber estado siempre dispuestos a ayudarme cuando lo he necesitado. La investigacin desarrollada en este Trabajo Fin de Grado ha sido financiada por el Ministerio de Ciencia, Innovacin y Universidades en el marco del proyecto ONOFRE-2 (TEC2017-84423-C3-1- P) y la red de investigacin Go2Edge (RED2018-102585-T), por la Consejería de Educación de la Junta de Castilla y León en el marco de los proyectos ROBIN (VA085G19) y ARTEMIS (VA231P20), y por el Fondo Europeo de Desarrollo Regional FEDER, tanto a travs de ARTEMIS, como del proyecto DISRUPTIVE del Programa Interreg V-A Espaa-Portugal (POCTEP) 2014-2020 (0667_DISRUPTIVE_2_E). Las opiniones son de exclusiva responsabilidad del autor que las emite. Índice viii Índice Agradecimientos ........................................................................... vii Índice ........................................................................................... viii Índice de figuras ............................................................................ xi Índice de tablas ............................................................................ xiv 1 Introducción ............................................................................. 1 1.1 Motivación .......................................................................................................... 1 1.2 Objetivos ............................................................................................................. 2 1.2.1 Objetivos Generales ........................................................................................ 2 1.2.2 Objetivos específicos ...................................................................................... 2 1.3 Fases y métodología ........................................................................................... 3 1.3.1 Fase de Análisis .............................................................................................. 3 1.3.2 Fase de Implementación ................................................................................. 3 1.3.3 Fase de Pruebas ............................................................................................... 4 1.4 Estructura de la Memoria del TFG ..................................................................... 4 2 Entorno de Trabajo ................................................................. 6 2.1 Introducción ........................................................................................................ 6 2.2 OMNeT++ .......................................................................................................... 6 2.3 Omnetpy como vía de integración entre Python y OMNeT++ .......................... 7 2.4 Docker ................................................................................................................. 8 2.5 Conclusiones ....................................................................................................... 9 3 Descripción del simulador de redes PON (Passive Optical Networks) en OMNeT++ .............................................................. 10 3.1 Introducción ...................................................................................................... 10 3.2 Redes de Acceso Ópticas Pasivas (PON, Passive Optical Networks) .............. 10 Índice ix 3.3 Simulador de redes EPON en OMNeT++ ........................................................ 12 3.4 Conclusiones ..................................................................................................... 15 4 Integración de Python en OMNeT++ .................................. 16 4.1 Introducción ...................................................................................................... 16 4.2 Integración de Python y OMNeT++ en un contenedor Docker ........................ 16 4.3 Extracción de Omnetpy del contenedor Docker. Utilización de la biblioteca con otras versiones de OMNeT++ ....................................................................................... 18 4.3.1 Instalación de PyBind11 ............................................................................... 19 4.3.2 Instalación de Omnetpy ................................................................................ 20 4.3.3 Instalación de la versión 5.6.2 de OMNeT++ .............................................. 21 4.3.4 Incorporación de Omnetpy a OMNeT++ ..................................................... 22 4.4 Incorporación del simulador de redes ópticas pasivas EPON a OMNeT++ .... 24 4.5 Conclusiones ..................................................................................................... 26 5 Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON ............................................... 27 5.1 Introducción ...................................................................................................... 27 5.2 Implementación del algoritmo de polling IPACT ............................................ 28 5.2.1 Descripción del algoritmo IPACT ................................................................ 29 5.2.2 Configuración del escenario de simulación .................................................. 30 5.3 Implementación del algoritmo de polling con PID ........................................... 34 5.3.1 Descripción de un controlador PID .............................................................. 35 5.3.2 Descripción del algoritmo SPID (Service Level Agreement PID) ............... 36 5.3.3 Configuración del escenario de simulación .................................................. 37 5.4 Implementación del algoritmo NN-SPID (Neural Network-SPID) basado en redes neuronales ............................................................................................................ 41 5.4.1 Descripción de la red neuronal ..................................................................... 42 5.4.2 Configuración del escenario de simulación .................................................. 43 5.5 Conclusiones ..................................................................................................... 53 Introducción 2 Por otra parte, se pretende hacer un estudio sobre el comportamiento de una red 10G-EPON (Ethernet PON) a través de un simulador desarrollado en OMNeT++. Esta parte del trabajo se centrará en la aplicación de diversos algoritmos de asignación dinámica de ancho de banda sobre diferentes escenarios de red en el simulador desarrollado 10G-EPON. 1.2 Objetivos 1.2.1 Objetivos Generales Como ya se ha adelantado en la sección de motivación, los objetivos generales de este trabajo son dos. En primer lugar, se realizará un estudio centrado en analizar la forma de integrar módulos desarrollados en el lenguaje Python en el entorno OMNeT++. Se hará, para ello, especial hincapié en el estudio de la biblioteca Omnetpy como posible forma de lograr la consecución de este objetivo. En segundo lugar, se pretende analizar las prestaciones de diferentes algoritmos en una red 10G-EPON mediante el proyecto desarrollado en OMNeT++. Con ello, se estudiará el comportamiento de la red 10G-EPON centrando el estudio en diferentes algoritmos de asignación dinámica de ancho de banda implementados en el simulador. Además, se ha añadido un módulo desarrollado en Python a dicho simulador para evaluar las posibilidades y limitaciones de Omnetpy. 1.2.2 Objetivos específicos Se describen, a continuación, los objetivos específicos necesarios para la consecución de los objetivos generales ya comentados. 1. Estudiar la viabilidad de Omnetpy a la hora de integrar módulos programados en Python en el entorno OMNeT++. Introducción 3 2. Desarrollar un procedimiento para instalar y utilizar la biblioteca Omnetpy en diferentes versiones de OMNeT++ puesto que, actualmente, ésta se encuentra en un contenedor Docker ligada a una versión concreta de OMNeT++ (Omnet 6.0pre8). 3. Desarrollar un módulo básico en Python y comunicarlo con otros módulos programados en C++ dentro de OMNeT++. 4. Actualizar el simulador de redes 10G-EPON desarrollado previamente por el Grupo de Comunicaciones Ópticas de la Universidad de Valladolid para que pueda utilizarse en la última versión estable de OMNeT++ (versión 5.6.2). 1.3 Fases y métodología Se procede a detallar las fases seguidas y la metodología llevada a cabo en cada una de ellas durante la realización de este trabajo. 1.3.1 Fase de Análisis En esta primera fase se pretende adquirir los conocimientos necesarios para un desarrollo adecuado de este Trabajo Fin de Grado:  Estudio de los principales aspectos relacionados con la inteligencia artificial  Repaso de la topología y principales características de una red PON  Estudio del funcionamiento de la herramienta de virtualización Docker  Documentación y estudio de la biblioteca Omnetpy  Familiarización con los lenguajes de programación C++ y Python  Analísis del simulador de redes PON desarrollado en OMNeT++ 1.3.2 Fase de Implementación Durante esta fase se llevará a cabo la instalación de la biblioteca Omnetpy [1] en OMNeT++ fuera del contenedor Docker así como su integración en el simulador de redes Introducción 4 PON. Una vez instalada la biblioteca, se procederá con la integración de un módulo programado en Python en el proyecto. Para ello, se utilizará como guía los pasos indicados en [2] en los que se ilustra la creación de un módulo de ejemplo programado en Python. 1.3.3 Fase de Pruebas En esta última fase, se llevarán a cabo diversas pruebas sobre el nuevo módulo desarrollado en Python e integrado en la red del simulador con el objetivo de comprobar la operabilidad que presenta la biblioteca Omnetpy a día de hoy. Paralelamente, se realizarán pruebas, sobre diferentes algoritmos de asignación dinámica de ancho de banda en diversos escenarios de red dentro del simulador de redes PON, escalado para que su tasa de transmisión total llegue a los 10 Gbit/s, esto es, bajo tecnologías 10G-PON. 1.4 Estructura de la Memoria del TFG El Capítulo 2 describe las herramientas de trabajo que serán empleadas a lo largo de todo el trabajo. En el Capítulo 3 se comienza describiendo las principales características de las redes ópticas pasivas para proseguir, a continuación, con una explicación del simulador de redes de este tipo desarrollado en OMNeT++ por el Grupo de Comunicaciones Ópticas de la Universidad de Valladolid. En el Capítulo 4 se indican los pasos a seguir con el objetivo de integrar Python en OMNeT++ haciendo uso, para ello, de la biblioteca Omnetpy que se encuentra, inicialmente, proporcionada en un contenedor Docker. Se detallarán, además, los pasos seguidos a la hora de extraer dicha biblioteca del contenedor Docker permitiendo, así, su utilización junto con diferentes versiones de OMNeT++. Introducción 5 En el Capítulo 5 se analizarán los diferentes escenarios de red y algoritmos simulados en OMNeT++ en relación con la asignación dinámica de ancho de banda en redes 10G-EPON. El Capítulo 6 relata todas las pruebas llevadas a cabo sobre el módulo programado en Python que se pretende integrar al proyecto del simulador de redes PON en OMNeT++. También se incluye en este capítulo una descripción detallada de las limitaciones encontradas durante las pruebas realizadas, así como de los pasos seguidos para su obtención. El Capítulo 7 recoge las conclusiones generales de este Trabajo Fin de Grado y las líneas futuras que podrían suceder a este estudio. Por último, en el Capítulo 8 se encuentran las referencias bibliográficas que han servido de apoyo para la realización de este trabajo. Entorno de Trabajo 6 2 Entorno de Trabajo 2.1 Introducción Este capítulo recoge información sobre las herramientas empleadas a lo largo de la realización de este trabajo. En primer lugar, se procede a describir las principales características de OMNeT++ que es la biblioteca de simulación y entorno de trabajo empleados en este estudio para la simulación de la red de acceso óptica pasiva. A continuación, se recalca el interés por integrar módulos programados en lenguaje Python [3] en OMNeT++ [4] así como la utilización de la biblioteca Omnetpy [1] como herramienta para lograr este objetivo. Se prosigue, entonces, con algunos comentarios que resumen los rasgos de dicha biblioteca. El capítulo concluye con una breve descripción de Docker [5] puesto que, inicialmente, Omnetpy se proporciona a través de un contenedor Docker junto con una versión concreta de OMNeT++ (OMNeT++ 6.0 Preview 8). 2.2 OMNeT++ OMNeT++ es una biblioteca de simulación de redes de eventos discretos basada en el lenguaje de programación C++. Entiéndase por eventos discretos que la red únicamente cambia de estado en instantes discretos de tiempo y que no ocurre nada entre dos eventos discretos consecutivos (cuyo tiempo de realización dentro de la simulación es nulo). Entorno de Trabajo 7 OMNeT++ ofrece un entorno de desarrollo basado en Eclipse así como una interfaz gráfica de simulación desde la que poder realizar un seguimiento de las ejecuciones que se lleven a cabo. Las redes creadas en OMNeT++ están formadas por módulos interconectados, típicamente, a través de enlaces físicos los cuales poseen puertas de entrada y salida en cada módulo y las conexiones que se realicen entre ellas, o bien, en algunas ocasiones, a través de enlaces directos que únicamente requieren que el módulo receptor disponga de una puerta de entrada directa. Mientras que los módulos son programados en lenguaje C++, éstos son ensamblados a otros módulos y componentes más grandes mediante el lenguaje de alto nivel, NED (Network Description). Los módulos que componen la red se comunican intercambiando mensajes o paquetes entre ellos. Éstos pueden simular tramas o paquetes de diversos protocolos de comunicaciones usados en redes de datos tales como Ethernet. 2.3 Omnetpy como vía de integración entre Python y OMNeT++ En Python se han desarrollado numerosas bibliotecas cuyas aplicaciones podrían resultar de interés en lo referente al desarrollo de algoritmos de asignación dinámica de ancho de banda en el simulador de redes PON que se está usando en este TFG, como pueden serlo aquellas asociadas al aprendizaje automático, redes neuronales, etc. Por ello, surge la necesidad de investigar la posibilidad de integrar Python en OMNeT++, permitiendo, así, la programación de módulos en este lenguaje y el acceso a las bibliotecas que éste ofrece. Una posible vía de integración de Python en OMNeT++ recae en la biblioteca Omnetpy [1]. Esta biblioteca, desarrollada por Marcos Modenesi, permite la programación de módulos en lenguaje Python de manera sencilla. Entorno de Trabajo 8 Para funcionar, Omnetpy extiende el intérprete de Python con clases de OMNeT++ con lo que permite que éste pueda ejecutar código escrito en C++ desde Python. Por otra parte, embebe el intérprete de Python en OMNeT++ con lo que permite que OMNeT++ pueda ejecutar código programado en Python cuando lo requiera. Omnetpy está basado en PyBind11 [6]. PyBind11 es una biblioteca que permite crear conexiones entre código C++ ya existente y código Python que programe el usuario. El grado de madurez que presenta la biblioteca Omnetpy es bajo puesto que hay funcionalidades básicas de OMNeT++ que no han sido aún implementadas y que resultan, por tanto, limitantes a la hora de desarrollar módulos programados en Python. Omnetpy se proporciona en un contenedor Docker junto con la versión de OMNeT++ 6.0 Preview 8. 2.4 Docker Docker es una plataforma abierta para desarrollar y ejecutar aplicaciones permitiendo independizar las mismas del sistema operativo de la máquina desde la que se ejecuten dichas aplicaciones. [5] Esto se consigue a través de contenedores que son entornos aislados en los que se empaquetan y ejecutan las aplicaciones. Estos contenedores poseen también instaladas todas las dependencias necesarias para que funcionen correctamente las aplicaciones evitando tener que depender, así, de que éstas se encontrasen instaladas en la máquina host. Con ello, además, se tiene la certeza de que todo el que trabaje con un mismo contenedor está trabajando exactamente bajo las mismas condiciones que el resto. El uso de Docker pasa por la creación y manipulación de objetos entre los que se encuentran las imágenes, los contenedores, los volúmenes… Una imagen Docker es una plantilla (únicamente de lectura) con instrucciones para crear un contenedor Docker. Una imagen puede estar basada en otra a la que se ha añadido ciertas modificaciones adicionales. Es posible crear una imagen propia a través Entorno de Trabajo 9 de un fichero Dockerfile en el que se tienen que definir los pasos necesarios para crear la imagen y ejecutarla. Un contenedor Docker es una instancia ejecutable de una imagen. Por ello, éste viene definido por su imagen, así como cualquiera de las opciones de configuración que se le proporcionen a la hora de crearlo y ejecutarlo. Un contenedor Docker es un proceso más en la máquina en la que se esté ejecutando, el cual ha sido aislado del resto de procesos de la máquina host. La imagen asociada a dicho contenedor le proporciona un sistema de ficheros aislado, así como su configuración, variables de entorno, etc. 2.5 Conclusiones En este primer capítulo de la memoria se ha establecido el marco de trabajo sobre el que se va a desarrollar el resto del estudio. Para ello, se ha llevado a cabo, en primer lugar, una descripción superficial del entorno de simulación de redes de eventos discretos, OMNeT++, puesto que en él se realizarán la totalidad de pruebas y simulaciones recogidas en este trabajo. Por otra parte, se ha escogido Omnetpy, biblioteca basada en PyBind11, como una vía para lograr el objetivo de integrar Python en OMNeT++. Dicha biblioteca está proporcionada inicialmente en un contenedor Docker por lo que se ha incluido, también, en este capítulo, una introducción de su funcionamiento básico. Descripción del simulador de redes PON (Passive Optical Networks) en OMNeT++ 10 3 Descripción del simulador de redes PON (Passive Optical Networks) en OMNeT++ 3.1 Introducción En este capítulo, se va a comenzar describiendo, de forma breve, las principales características de las redes de acceso ópticas pasivas ya que en ellas se basan el estudio y las simulaciones que se van a ir desarrollando en este trabajo. Por otra parte, se detallarán los aspectos principales de la arquitectura de la red EPON desarrollada en el simulador OMNeT++, describiendo, para ello, la topología de la red y la estructura que presentan los módulos que simularán el OLT y cada una de las ONUs. 3.2 Redes de Acceso Ópticas Pasivas (PON, Passive Optical Networks) Una Red Óptica Pasiva o PON (Passive Optical Network) es un tipo de red de acceso que está formada únicamente por elementos ópticos pasivos entre el operador/proveedor de servicios y el cliente o abonado, interconectados mediante fibra óptica. Dichos elementos, entre los que destacan los divisores ópticos o splitters, reciben este nombre debido a que no requieren alimentación para su funcionamiento [7]. Las redes PON presentan una topología en árbol en las que se comunica el Terminal de Línea óptico u OLT (Optical Line Terminal), que se encuentra en la oficina Descripción del simulador de redes PON (Passive Optical Networks) en OMNeT++ 11 central del proveedor de servicios, con las Unidades de Red Ópticas u ONUs (Optical Network Units) a través de un splitter que se encarga de dividir la potencia de la señal proveniente del OLT entre cada una de las ramas que desembocan en las ONUs que forman parte de la red. En el canal descendente (desde el OLT hacia las ONUs), la red es puntomultipunto y el OLT se encarga de transmitir información hacia las ONUs. Para ello, el splitter reparte dicha información entre todas las ONUs, es decir, la transmisión es de tipo difusión o broadcast. Es ésta última la encargada de filtrar y recibir, únicamente, el contenido destinado a ella. El OLT hace uso de Multiplexación por División en Tiempo o TDM (Time Division Multiplexing) para enviar la información dirigida a cada ONU en distintos instantes de tiempo. La longitud de onda empleada en este sentido es de 1490 nm (nanómetros). Por su parte, en el canal ascendente (desde cada ONU hacia el OLT), la red es punto a punto y, en ella, la ONU transmite hacia el OLT para lo cual es necesario un mecanismo que evite las situaciones de contienda que se pudieran producir a causa del envío simultáneo desde diferentes ONUs hacia el OLT. Se emplea, en este caso, Acceso Múltiple por División en Tiempo o TDMA (Time Division Multiple Access). La longitud de onda usada en el canal ascendente es de 1310 nm. En la red se utilizan algoritmos de asignación dinámica de ancho de banda o DBA (Dynamic Bandwidth Allocation). Dichos algoritmos son gestionados desde el OLT que es el encargado de proporcionar el ancho de banda a las ONUs tras cada ciclo de tiempo, por ejemplo, 2 ms es el máximo tiempo de ciclo establecido en el estándar EPON. Se adapta, con ello, la cantidad de ancho de banda asignada a cada ONU según diversos factores tales como la demanda en cada momento, el tráfico que se encuentra circulando en la red o los requisitos de calidad de servicio (QoS, Quality of Service) que hayan sido contratados por cada abonado con su proveedor de servicios. Dentro de los algoritmos de asignación dinámica de ancho de banda, se puede realizar una clasificación en dos tipos de algoritmos. Por una parte, se encuentran los algoritmos centralizados. Se encuentran en este grupo aquellos algoritmos que asignan el ancho de banda a cada ONU al final de cada ciclo (cuando llega el mensaje Report de la última ONU de la red) tras conocer las demandas de ancho de banda de cada una de ellas. Integración de Python en OMNeT++ 18 contenedores activos en ese momento. Al añadir el flag “-a”, se muestran también los contenedores que estén creados pero que no se encuentren activos en ese momento. Por último, para acceder al contenedor que ha sido activado, hay que ejecutar el comando “docker attach”. De nuevo, el argumento que requiere este comando es el identificador del contenedor (o el alias) al que se desea acceder. El resumen de los comandos a ejecutar es el siguiente: docker ps –a docker start ID_del_contenedor docker attach ID_del_contenedor Una vez accedido al contenedor, el terminal pasará a ser el correspondiente al contenedor Docker. 4.3 Extracción de Omnetpy del contenedor Docker. Utilización de la biblioteca con otras versiones de OMNeT++ Se van a detallar, a continuación, los pasos seguidos a la hora de conseguir la extracción de la biblioteca Omnetpy del contenedor Docker con el objetivo de integrar Python y OMNeT++ en cualquier máquina y con diferentes versiones de OMNeT++. Omnetpy es una biblioteca basada en PyBind11 [6] por lo que, en primer lugar, se procederá con la instalación de esta biblioteca que permite crear conexiones entre código en C++ y código en Python. Una vez instalado PyBind, se proseguirá con la descarga e instalación de la biblioteca Omnetpy. Seguidamente, se expondrá, el proceso de instalación de la versión 5.6.2 de OMNeT++. Cabe resaltar que, inicialmente, se probó a instalar la misma versión de OMNeT++ que se encontraba en el contenedor Docker, es decir, la versión “OMNeT++ Integración de Python en OMNeT++ 19 6.0 Preview 8” pero, en dicha versión, resultó imposible disponer del entorno de desarrollo de OMNeT++, tal como se muestra en la Figura 4, por lo que se decidió probar a instalar una versión estable (la ya mencionada versión 5.6.2). Figura 4. Error Obtenido al intentar iniciar el IDE de OMNeT++ tras la instalación de la versión “6.0 preview 8”. Por último, la explicación se centrará en los detalles de la incorporación de la biblioteca Omnetpy a un proyecto de OMNeT++. 4.3.1 Instalación de PyBind11 Para la instalación de la biblioteca PyBind11, se siguen los pasos indicados en [10]. La versión que se va a instalar es la 2.4.3. Al ser una versión anterior a la 2.6.0, es necesario comprobar que la versión de Python instalada no sea la 3.9.0 porque podrían producirse errores. Integración de Python en OMNeT++ 20 Con el objetivo de instalar los paquetes prerrequisitos para poder instalar PyBind11, se procede a ejecutar en el terminal los siguientes comandos (se recuerda que dichos comandos se ejecutan en una máquina cuyo sistema operativo es Linux Mint 20): apt-get install python3-dev apt-get install python3-distutils apt-get install build-essential apt-get install cmake apt-get install pybind11-dev apt-get install python3-pybind11 apt-get install libeigen3-dev Con ello, la biblioteca se encuentra instalada y lista para su utilización. 4.3.2 Instalación de Omnetpy En este caso, se comienza descargando el código de [1]. Una vez descargado, se procede a su descompresión. Se puede hacer uso, para ello, del comando unzip. A continuación, es necesario configurar correctamente las variables de entorno para permitir, posteriormente, una correcta instalación de la biblioteca. Para ello, hemos de modificar el fichero “.bashrc” añadiendo las siguientes líneas: export OMNETPP_ROOT=~/Escritorio/omnetpp-5.6.2 export OMNETPY_ROOT=~/Escritorio/omnetpy-master/omnetpy Es necesario cerrar y reabrir el terminal para que las líneas añadidas surtan efecto. En las líneas anteriores, “~” se expande a la ruta personal. Nótese, también, que en mi caso tanto OMNeT++ como el código de la biblioteca Omnetpy se encuentran en el escritorio. Integración de Python en OMNeT++ 21 El siguiente paso es, entonces, ejecutar el comando make en el directorio en el que se encuentra el fichero Makefile, es decir, el directorio omnetpy. Tras esto, se indicará en el terminal que el módulo Python pyopp se ha creado con éxito por lo que se ha completado la instalación de la biblioteca. 4.3.3 Instalación de la versión 5.6.2 de OMNeT++ En lo referente a la instalación de la versión 5.6.2 de OMNeT++, se siguen las indicaciones dadas en [11]. Aunque dicha guía está originalmente diseñada para instalar la versión 5.6.1, no se ha percibido ninguna diferencia en el proceso de instalación para la versión 5.6.2 que pudiera haber producido algún error. En primer lugar, es necesario instalar los paquetes prerrequisitos ejecutando para ello: sudo apt-get update Seguido de: sudo apt-get install build-essential gcc g++ bison \ flex perl python python3 qt5-default libqt5opengl5-dev \ tcl-dev tk-dev libxml2-dev zlib1g-dev default-jre doxygen \ graphviz Además, es necesario instalar el paquete openscenegraph ejecutando para ello los siguientes comandos: sudo add-apt-repository pp:ubuntugis/ppa sudo apt-get update sudo apt-get install openscenegraph-plugin-osgearth \ libosgearth-dev Integración de Python en OMNeT++ 22 Después, se descarga el archivo comprimido de [4] y se descomprime mediante el comando: tar xvfz omnetpp-5.6.2-src.tgz OMNeT++ necesita que su directorio bin/ se encuentre en el path por lo que, a continuación, es necesario, al igual que durante la instalación de la biblioteca Omnetpy, añadir una línea al fichero “.bashrc” tal que: export PATH=$HOME/omnetpp-5.6.1/bin:$PATH Es necesario cerrar y reabrir el terminal para que los cambios surtan efecto. Posteriormente, se debe ejecutar el siguiente comando: ./configure Con él, el script “configure”, detecta el software instalado y la configuración del sistema y escribe los resultados en el fichero “Makefile.inc” que será leído por los ficheros “Makefile” durante el proceso de compilación. Por último, se procede a la compilación de la biblioteca a través del comando make. Una vez finalizado el proceso, se indicará al usuario en el terminal que todo ha transcurrido con éxito y que ahora se puede teclear el comando omnetpp para arrancar el IDE. 4.3.4 Incorporación de Omnetpy a OMNeT++ Una vez instalados OMNeT++ (en su versión 5.6.2) y la biblioteca Omnetpy, se prosigue con la incorporación de dicha biblioteca al simulador. Para ello, es necesario añadir algunas líneas más al fichero “.bashrc” las cuales se muestran a continuación: export LD_LIBRARY_PATH=$OMNETPP_ROOT/lib:$OMNETPY_ROOT/lib export PYTHONPATH=$PYTHONPATH:$HOME/Escritorio/omnetpymaster/omnetpy/bindings Integración de Python en OMNeT++ 23 Se recuerda que para que estos cambios tengan efecto es necesario reinicar el terminal desde el que se esté operando. Los siguientes cambios requeridos para conseguir una correcta integración se llevan a cabo en el propio IDE de OMNeT++ por lo que se ha de ejecutar el comando omnetpp en el terminal para acceder a él. El siguiente paso reside en instalar PyDev. Para ello, se navega hasta la sección Help->Install New Software… del IDE y se introduce la siguiente URL en el campo “Work With”: http://pydev.org/updates A continuación, se desmarca la casilla “Contact all update sites during install to find required software”. Se ha de hacer clic, varias veces, entonces, en “Next >”, aceptar los términos y condiciones y finalizar la instalación. Es necesario reiniciar el IDE para que los cambios tengan efecto. Después, hay que navegar hasta la sección: Window->Preferences->PyDev->Python Interpreter En esa ventana, se ha de añadir el intérprete python3 que se encuentra en la ruta /usr/bin/python3. Además, en esa misma ventana se encuentra la subsección Environment. Entrando en ella y haciendo clic en el botón “Add…” se debe añadir la variable de entorno WITHIN_OMNETPP_IDE con su valor puesto a yes. Con ello, ya es posible crear proyectos en los que se adjunten ficheros con código escrito en Python en ellos con un par de salvedades que se han de considerar y que se ponen de manifiesto a continuación. Para que no se produzcan errores a la hora de hacer un Build Project, se ha de añadir al proyecto un fichero makefrag, tal como se indica en [2] con las siguientes líneas: INCLUDE_PATH += $(shell python3 -m pybind11 --include) - I$(OMNETPY_ROOT)/include Integración de Python en OMNeT++ 24 LIBS = -lomnetpy $(shell python3-config --libs | cut -d" " -f1) LDFLAGS += -L$(OMNETPY_ROOT)/lib Además, hay que considerar que, en el caso de que la versión de Python que se esté utilizando sea la 3.8 o posterior, se ha de reemplazar python3-config --libs por: python3-config –-libs --embed Por otra parte, es necesario cambiar la configuración activa del modo debug a release ya que Modenesi indica en [1] que una de las limitaciones actuales de Omnetpy es que no soporta la depuración o debug de código Python. Para ello, hay que navegar hasta la sección: Project->Properties->C/C++ Build->Build Variables En dicha ventana, se debe hacer clic en la opción “Manage configurations…” y, en ella, cambiar la configuración activa de debug a release. Tras seguir todos estos pasos, se estará en disposición de crear proyectos en OMNeT++ que hagan uso de la biblioteca Omnetpy con el objetivo de poder escribir el código de los módulos en Python. 4.4 Incorporación del simulador de redes ópticas pasivas EPON a OMNeT++ En esta sección, se indican los pasos que se han de seguir para una correcta integración del proyecto del simulador EPON a OMNeT++ sobre el que se va a trabajar posteriormente. Integración de Python en OMNeT++ 25 En primer lugar, desde el IDE de OMNeT++, se debe importar el proyecto mediante: File -> Import -> Existing Project into Workspace A continuación, se ha de indicar la ruta en la que se encuentra el proyecto. Después, es necesario cambiar las rutas asociadas a los diferentes directorios y subdirectorios del proyecto, cuya inclusión es necesaria, para que se correspondan con las rutas en las que se encuentran los mismos ya que, inicialmente, contendrán rutas absolutas correspondientes a otra máquina. Se muestran, en la siguiente captura (Figura 5), algunas de esas rutas tras su modificación para que el proyecto funcione en la máquina virtual empleada para la realización de este trabajo. Figura 5. Rutas a los diferentes directorios y subdirectorios que componen el proyecto simulador PON y que han de incluirse en la sección Paths and Symbols. Para llevar a cabo las mencionadas modificaciones a las rutas, se debe navegar por el IDE hasta la sección: Project -> Properties -> C/C++ General -> Paths and Symbols En la ventana que se muestra entonces, se deben editar las rutas en los lenguajes Assembly, GNU C y GNU C++. Para ello, basta con hacer clic en “Edit…” y escribir la dirección de la ruta correspondiente a cada directorio y subdirectorio del proyecto. Integración de Python en OMNeT++ 26 Por último, también será necesario adaptar las rutas de las directivas Include que se encuentran en los ficheros fuente (.cc) y de cabeceras (.h) del proyecto. Una vez realizados los pasos anteriores, el proyecto se encontrará operativo y listo para ser ejecutado. 4.5 Conclusiones En este capítulo se ha comenzado proporcionado una explicación, en detalle, del proceso seguido a la hora de integrar Python y OMNeT++ en un contenedor Docker haciendo uso, para ello, de la biblioteca desarrollada por Marcos Modenesi, Omnetpy. Posteriormente, se han descrito los pasos necesarios para la extracción y utilización de dicha biblioteca fuera del contenedor Docker con el objetivo de integrarla en versiones diferentes de OMNeT++ lo cual aporta la versatilidad de poder seguir haciendo uso de ella junto con futuras actualizaciones de OMNeT++. Por último, se indican también, en una breve sección, los pasos y consideraciones que han de tenerse en cuenta para una correcta importación del simulador EPON en OMNeT++. Cabe resaltar que, en este capítulo, se ha podido comprobar la meticulosidad y el cuidado que ha de tener el usuario a la hora de instalar paquetes software puesto que siempre pueden producirse errores que impidan una correcta instalación como pueden ser las variables de entorno, dependencias de paquetes o incluso ciertas configuraciones que haya que establecer. Nótese que aún no se ha procedido con la explicación de los pasos a seguir para poder incorporar módulos programados en lenguaje Python a proyectos de OMNeT++. Esta cuestión será tratada en detalle en el Capítulo 6 de esta memoria. Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 27 5 Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 5.1 Introducción Este capítulo está dedicado a la implementación de algoritmos de asignación dinámica de ancho de banda (DBA, Dynamic Bandwidth Allocation) en el simulador de redes EPON en OMNeT++. En este simulador es donde se procederá, en un capítulo posterior de esta memoria, con la integración de un módulo programado en lenguaje Python. Previamente, en el presente capítulo, dicho simulador ha sido modificado para poder simular redes 10G-EPON, es decir, redes en las que la tasa de transmisión ha pasado de ser de 1 Gbps a 10 Gbps. El estudio se va a llevar a cabo sobre el algoritmo de polling IPACT, sobre un algoritmo de polling controlado por un controlador PID [12] y sobre un algoritmo de polling con un controlador PID en el que los parámetros de sintonización de dicho PID son modificados de forma dinámica por una red neuronal [13]. En primer lugar, en cada caso, se va a comenzar describiendo, de forma breve, cada uno de los algoritmos en cuestión. A continuación, se procederá a describir la configuración de cada uno de los escenarios que se van a simular y, por último, tendrá lugar el análisis de los resultados obtenidos en cada apartado y en cada variante simulada. Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 34 Por ello, el parámetro de carga se barre desde el valor 0.0276 hasta el valor 0.4276 en incrementos de 0.05 en 0.05. Se muestra, a continuación (Figura 8), la gráfica que recoge el retardo medio que presentan cada una de las tres colas de una de las ONUs. En ella, se puede apreciar, tal como sucedía para el caso anterior con una única cola, que el retardo se mantiene en niveles similares a los publicados en [8]. Esto reafirma la correcta implementación del escalado de la red a 10G-EPON. Figura 8. Retardo medio frente a la carga de la ONU para el algoritmo IPACT con un SLA y tres colas. 5.3 Implementación del algoritmo de polling con PID Las siguientes simulaciones que se van a llevar a cabo, pretenden ilustrar el comportamiento de un algoritmo de polling controlado por un controlador PID desarrollado en trabajos de investigación anteriores. Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 35 Para ello, este apartado comienza con una pequeña explicación sobre los controladores PID así como sus principales características. De forma análoga al apartado anterior, se proseguirá con la presentación del escenario de simulación del que, esta vez, se disgregarán tres variantes. Cada una de esas variantes presenta unos pesos diferentes para cada uno de los 3 SLAs presentes en la red simulada. De forma concreta, cada SLA representa un perfil de abonado con un ancho de banda garantizado que debe ser proporcionado por el proveedor de servicios. Para finalizar, se muestran las gráficas de resultados obtenidas junto con la información que se puede extraer a partir de ellas. En este caso, las gráficas se centran en el ancho de banda ofrecido y demandado por cada ONU a lo largo de los 500 segundos simulados para una carga elevada en cada ONU. 5.3.1 Descripción de un controlador PID Un PID (Proportional Integral Derivative) es un controlador simple basado en un bucle realimentado. Su objetivo es mantener una o más variables lo más cerca posible de un valor deseado [12]. El sistema tiene una entrada, la cual es una variable de control que se va modificando para conseguir que la variable de salida del sistema, la cual se corresponde con el parámetro que se pretende ajustar, se acerque lo más posible a dicho valor. Para ello, se calcula la diferencia entre el valor actual de la variable y el valor deseado. Dicha diferencia se denota como el error del sistema. Dicho error es introducido en un término proporcional, en un término con una integral y en un término con una derivada. Los tres términos son sumados para obtener la variable de control tal como se muestra, a continuación, en la siguiente ecuación (Figura 9) obtenida de [12]: Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 36 Figura 9. Ecuación que describe la variable de control de un PID. Cabe destacar que los términos Kp, Ti y Td son los parámetros de sintonización del controlador y éstos deben ser puestos a punto mediante algún método concreto para que el sistema sea estable. 5.3.2 Descripción del algoritmo SPID (Service Level Agreement PID) El algoritmo empleado para asignar ancho de banda a cada ONU es un algoritmo de polling con un esquema limitado denominado SPID (Service Level Agreement) [12]. Esto quiere decir que el ancho de banda máximo total que se puede asignar en cada ciclo está limitado por el ancho de banda máximo que se puede transmitir en un solo ciclo cuya duración máxima es de 2 ms en el estándar EPON. Mediante el uso del PID, que se ejecuta periódicamente cada T segundos, se controla el proceso de asignación de ancho de banda. En este caso, el error a la entrada del controlador PID, se corresponde con la diferencia entre el ancho de banda garantizado para una ONU perteneciente a un SLA determinado y el ancho de banda medio asignado a dicha ONU en el último ciclo. La salida del PID es, entonces, el ancho de banda medio asignado a cada ONU en el siguiente ciclo, cuyo valor se quiere mantener lo más próximo posible al ancho de banda garantizado para esa ONU según el SLA al que pertenece. El comportamiento descrito se puede apreciar, de forma visual, en el siguiente esquema (Figura 10) obtenido de [12]: Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 37 Figura 10. Diagrama de bloques que ilustra el proceso de funcionamiento del PID en la asignación dinámica de ancho de banda en redes PON. Por otra parte, es necesario asignar unos valores iniciales a los anchos de banda máximos para cada ONU. Esto se realiza a partir de los anchos de banda garantizados correspondientes a cada SLA y a unos pesos asociados a cada SLA (WSLAi) tal como se muestra en la siguiente ecuación (Figura 11) obtenida de [12]: Figura 11. Ecuación empleada durante la inicialización de los valores de ancho de banda máximo asignados a cada ONU En ella, se reparte el ancho de banda total disponible en un ciclo (Bcycle_available) entre cada una de las ONUs según el peso asociado a cada una de ellas. 5.3.3 Configuración del escenario de simulación Se describen, a continuación, en forma de tabla, los parámetros escogidos para las simulaciones que se van a llevar a cabo en este escenario en el que se pretende simular el comportamiento de un algoritmo de polling controlado por un PID. En estas simulaciones, se va a presentar una situación de carga elevada en cada ONU. Se escoge un valor de 0.9. El tiempo de simulación escogido es de 500 segundos para todas las variantes del escenario. Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 38 Se muestran en la tabla los valores de los parámetros de sintonización Kp, Ti y Td empleados en las simulaciones. Dichos valores han sido escogidos a partir del estudio realizado en [12] y realizado mediante el método manual de Ziegler-Nichols. Parámetros de Simulación Valores Número de ONUs 16 ONUs Carga de cada ONU 0.9 Número de longitudes de onda 1 longitud de onda Tasa de transmisión de la red 10 Gbit/s Periodo del ciclo 2 milisegundos Tiempo de guarda 1 microsegundo Tamaño de los paquetes Paquetes de 64, 594 y 1500 bytes con generación de paquetes trimodal Longitud pon1 (OLT-Splitter) 10 km Longitud pon2 (Splitter-ONU) Longitud aleatoria del canal que une el Splitter con cada ONU. Valores entre 0 y 10 km Tamaño de buffer 100 Mbytes Algoritmo implementado SPID Método de inserción de paquetes Método de prioridad de colas Método de extracción de paquetes Método de extracción de colas de prioridad Número de streams 32 streams Número de servicios de prioridad (número de colas) 3 (P0, P1 y P2) Número de SLAs 3 Número de ONUs asociadas al SLA0 1 Número de ONUs asociadas al SLA1 5 Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 39 Número de ONUs asociadas al SLA2 10 Kp 0,5 Ti 11 Td 2,75 BW garantizado para el SLA0 (Mbps) 1000 BW garantizado para el SLA1 (Mbps) 750 BW garantizado para el SLA2 (Mbps) 500 Tabla 2. Parámetros empleados en las simulaciones de un algoritmo de polling con un PID En este caso, se van a simular tres variantes de este escenario. En la primera variante (escenario 1), los pesos asociados a cada uno de los tres SLAs permanecen iguales entre sí (WSLA0=1, WSLA1=1, WSLA2=1). En la segunda (escenario 2), se le da un menor peso al SLA0 y un mayor peso al SLA2 (WSLA0=1, WSLA1=2, WSLA2=3). Por último, en la tercera variante (escenario 3), se le otorga un mayor peso al SLA0 y un menor peso al SLA2 (WSLA0=3, WSLA1=2, WSLA2=1). Estas variantes pretenden ilustrar cómo se adapta el algoritmo en tiempo real a la hora de asignar anchos de banda a las ONUs acorde al SLA contratado por cada abonado (ONU) y, por lo tanto, a su ancho de banda garantizado. 5.3.3.1 Evaluación de resultados La Figura 12 recoge las gráficas obtenidas mediante las simulaciones de las tres variantes del escenario para el algoritmo SPID. En ella se puede ver como, a pesar de los diferentes pesos iniciales asignados a cada SLA, el tiempo que se tarda en alcanzar el ancho de banda garantizado prácticamente no se ve alterado. Se recuerda que, en este caso, a causa del escalado de la red, el ancho de banda garantizado para el SLA0 es de 1000 Mbit/s. Se observa, además, que el comportamiento es similar al publicado en [12] pero con los valores escalados a un orden de magnitud por encima. Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 40 Figura 12. Evolución en tiempo real del ancho de banda medio asignado para una ONU pertenciente al SLA0 con un algoritmo de polling controlado mediante un PID. En la Figura 13, se presenta la misma gráfica centrada, esta vez, en los primeros 60 segundos para poder observar mejor como, a pesar de partir de diferentes pesos para el SLA0, en los tres casos se alcanza el ancho de banda medio asignado para ese nivel de servicio en un intervalo de tiempo similar. Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 41 Figura 13. Cantidad media de ancho de banda asignado frente al tiempo para una ONU pertenciente al SLA0 con un algoritmo de polling controlado mediante un PID. Zoom de los primeros 60 segundos. 5.4 Implementación del algoritmo NN-SPID (Neural Network-SPID) basado en redes neuronales Las siguientes simulaciones pretenden ilustrar el comportamiento de un algoritmo de polling controlado por un controlador PID y cuyos parámetros de sintonización son actualizados de forma dinámica por una red neuronal con capacidad de auto aprendizaje. El algoritmo se denomina NN-SPID (Neural Network-SPID) [13]. El apartado comienza con una descripción de la red neuronal diseñada e incorporada al algoritmo de asignación dinámica de ancho de banda para gestionar la calidad de servicio de una red PON. Además, se hace especial hincapié en las ventajas que proporciona su integración para la gestión automatizada de los parámetros de sintonización de un PID, frente al método manual de sintonización (Ziegler-Nichols) que incorporaba el algoritmo SPID. Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 42 Al igual que en los casos anteriores, se someten a estudio dos variantes del escenario considerado. En cada una, se otorga un ancho de banda mínimo garantizado diferente a cada SLA. Para concluir el apartado, se presentan las gráficas de resultados obtenidas junto con el análisis realizado a partir de ellas. En este caso, las gráficas se centran en el ancho de banda ofrecido y demandado por cada ONU, de nuevo, para una carga elevada en el tráfico que genera cada una de las ONUs. 5.4.1 Descripción de la red neuronal Las redes neuronales son modelos matemáticos simplificados que tratan de imitar el comportamiento del sistema nervioso humano para resolver problemas complejos. Una red neuronal está formada por una serie de capas en las que se encuentran las neuronas artificiales. Generalmente, las redes neuronales son multicapa aunque lo más habitual es que posea, únicamente, una sola capa intermedia denominada capa oculta [13]. Una neurona se puede considerar como un sistema que tiene tantas entradas como neuronas tenga la capa anterior (más una entrada adicional de sesgo o control, bias) y que produce una salida a partir de una función de activación. Las entradas a la neurona son pesadas por unos factores denominados “pesos sinápticos”. Dichos pesos definen la intensidad de la conexión entre dos neuronas. En este trabajo, la red neuronal empleada posee tres capas. Una primera capa de entrada con tres neuronas en ella, una capa oculta con cinco neuronas y una capa de salida con otras tres neuronas. Las entradas que se conectan a las tres neuronas de la capa de entrada se corresponden con los tres últimos errores calculados. Por otra parte, las salidas que producen las tres neuronas de la capa de salida del sistema se corresponden con los tres parámetros de sintonización del PID que se desean modificar de forma dinámica mediante la red neuronal. Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 43 Se muestra, a continuación, en la Figura 14, un esquema con el aspecto de la red neuronal bajo estudio, obtenida de [14]. Figura 14. Diagrama de flujo de la red neuronal empleada para controlar los parámetros de sintonización del PID. La gran ventaja de la red neuronal incorporada al algoritmo de gestión dinámica de ancho de banda, es precisamente la capacidad para modificar de forma dinámica los parámetros de sintonización del PID ya que, en estudios previos, dicha puesta a punto se llevaba a cabo de forma estática (bien a través de la técnica de Ziegler-Nichols o, posteriormente, con la implementación de un algoritmo genético), lo cual desembocaba en una peor adaptación a cambios en tiempo real de las condiciones de la red puesto que, una vez seleccionados los valores de los parámetros, estos se mantenían fijos o, en caso de querer cambiarse, debían volverse a ejecutar las técnicas de sintonización que eran procesos demasiado lentos. 5.4.2 Configuración del escenario de simulación Se describen, a continuación, en forma de tabla, los parámetros escogidos para las simulaciones que se van a llevar a cabo en este escenario en el que se pretende simular el comportamiento de un algoritmo de polling controlado por un PID y cuyos parámetros de Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 50 Figura 20. Evolución en tiempo real del ancho de banda garantizado para una ONU pertenciente a cada uno de los tres SLAs con el algoritmo NN-SPID para el escenario 2. Se muestra, de nuevo, en la Figura 21, la misma gráfica recortada a los primeros 60 segundos con el objetivo de analizar de forma más precisa la evolución que sufren cada uno de los anchos de banda garantizados a las ONUs pertenecientes a cada uno de los 3 SLAs. Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 51 Figura 21. Evolución en tiempo real del ancho de banda garantizado para una ONU pertenciente a cada uno de los tres SLAs con el algoritmo NN-SPID para el escenario 2 (Zoom 60 s). En las siguientes figuras (Figura 22, Figura 23 y Figura 24), se muestran las gráficas asociadas a la evolución temporal de los valores de los parámetros de sintonización del PID (Kp, Ti y Td). En ellas, se puede observar como, de nuevo, tal como sucedía en el primer escenario, las curvas se estabilizan pasado un tiempo cercano a los 100 segundos de simulación. Con ello, se puede concluir que, aunque las condiciones de ancho de banda garantizado para cada SLA sean diferentes, el comportamiento de la red es siempre similar gracias a la capacidad de adaptación de forma dinámica de la red neuronal. Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 52 Figura 22. Evolución temporal del parámetro Kp para NN-SPID bajo el escenario 2. Figura 23. Evolución temporal del parámetro Ti para NN-SPID bajo el escenario 2. Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 53 Figura 24. Evolución temporal del parámetro Td para NN-SPID bajo el escenario 2. 5.5 Conclusiones En este capítulo de la memoria se ha podido comprobar, a través del simulador de redes PON implementado en OMNeT++, el comportamiento que presenta una red de tipo 10G-EPON. La red del simulador se ha escalado para ofrecer una tasa de transmisión total que ha pasado de ser de 1 Gbit/s a 10 Gbit/s. Para comprobar como afecta el escalado al comportamiento de la red, se han llevado a cabo simulaciones con tres algoritmos distintos de asignación dinámica de ancho de banda, todos ellos basados en la política de polling. En el primer caso, se ha comenzado con un sencillo algoritmo de polling, a modo de introducción y toma de contacto, como lo es IPACT. En segundo lugar, se ha incorporado un controlador PID al algoritmo con las mejoras que ello conlleva en cuanto a rapidez y estabilidad a la hora de asignar ancho de banda de forma dinámica a cada ONU. Por último, se ha añadido una red neuronal de tipo feed-forward al simulador, con lo que se ha podido comprobar la mejoría que ello supone a la asignación dinámica de Implementación, simulación y validación de algoritmos DBA en el simulador 10G-EPON 54 ancho de banda a cada ONU gracias a que la red neuronal trabaja de forma dinámica permitiendo una adaptación más rápida a cambios que puedan producirse en la red. Por tanto, para estos tres casos, se ha podido comprobar a través de [8], [12] y [13] que el comportamiento exhibido se asemeja al de una red EPON pero en la que, en este caso, se ha escalado la tasa de transmisión a 10 Gbps. Por ello, queda validado el simulador de red 10G-EPON. Integración de un módulo programado en Python al simulador 10G-EPON de OMNeT++ 55 6 Integración de un módulo programado en Python al simulador 10G-EPON de OMNeT++ 6.1 Introducción En este capítulo se documentan las acciones y pasos necesarios para incorporar un módulo programado en Python al simulador de redes 10G-EPON con el que se ha estado trabajando en la sección anterior. El objetivo inicial de añadir un módulo programado en Python es el de comprobar el grado de desarrollo y operabilidad actual de la biblioteca Omnetpy. El lenguaje de programación Python ofrece numerosas bibliotecas que pueden resultar de gran utilidad en el desarrollo de futuros trabajos basados en OMNeT++ como pueden serlo aquellas bibliotecas asociadas al aprendizaje automático. Se va a describir, a continuación, los detalles del proceso seguido a la hora de integrar un nuevo módulo programado en Python al simulador 10G-EPON de OMNeT++ y, posteriormente, para finalizar el capítulo, se documentan todas las pruebas que se han llevado a cabo para examinar las limitaciones que pueden presentarse. 6.2 Incorporación del nuevo módulo Python al proyecto OMNeT++ El nuevo módulo Python se va a integrar dentro de la estructura del módulo OLT ya que se pretende que este nuevo módulo actúe como la red neuronal empleada en el Integración de un módulo programado en Python al simulador 10G-EPON de OMNeT++ 56 algoritmo NN-SPID y, para ello, debe conectarse al sub-módulo que representa la capa MAC del OLT. Este módulo tendrá una entrada y una salida que permitirán una comunicación bidireccional entre el módulo MAC_OLT y el nuevo módulo de la red neuronal programado en Python. Con este objetivo, en primer lugar, se llevará a cabo la integración de un módulo de “prueba” programado en Python que posea la estructura mencionada pero con la única funcionalidad de mostrar un mensaje tras la correcta inicialización del módulo al comenzar la simulación. Para ello, se pasará a describir, a continuación, los ficheros que se han de añadir, así como su contenido y las modificaciones que se han de realizar en ficheros ya existentes en el proyecto del simulador. 6.2.1 Definición del fichero .NED Se añade el Network Description File en el que se ha de indicar las puertas y parámetros que se quiere que posea el nuevo módulo. En este caso, el módulo cuenta con una puerta de entrada y una de salida tal como se muestra en la siguiente captura (Figura 25). Figura 25. Código del fichero “.ned” del nuevo módulo de prueba. Con ello, el nuevo módulo se conecta al módulo MAC_OLT a través de la implementación de nuevas conexiones en el fichero del módulo OLT, “OLT.ned”. Para ello, es necesario crear dos nuevas puertas en el módulo MAC_OLT tal como se muestra en la Figura 26. Integración de un módulo programado en Python al simulador 10G-EPON de OMNeT++ 57 Figura 26. Líneas de código añadidas a la sección “gates:” del fichero MAC_OLT.ned para incorporar dos nuevas puertas al módulo MAC_OLT. A continuación (Figura 27), se muestran las líneas incorporadas a dicho fichero. Figura 27. Líneas de código añadidas a la sección “connections:” del fichero OLT.ned para reflejar la conexión bidireccional entre el nuevo módulo de prueba y el módulo MAC_OLT. Una vez realizadas las conexiones, el nuevo módulo queda conectado al módulo MAC_OLT tal como se muestra en la Figura 28. Figura 28. Fichero OLT.ned visualizado en modo Design para mostrar la estructura interna del módulo OLT. 6.2.2 Definición del fichero .cc Este fichero es el único fichero que debe seguir escribiéndose en lenguaje C++ (en lo referente a la incorporación del nuevo módulo). En él, únicamente hay que añadir una llamada al fichero de cabecera de la biblioteca Omnetpy y definir el módulo como en Integración de un módulo programado en Python al simulador 10G-EPON de OMNeT++ 58 otras ocasiones pero, esta vez, en lugar de emplear la función “Define_Module”, se llama a “Define_Python_Module” para indicar que el módulo se encuentra en el fichero programado en Python que se agregará más adelante. En la Figura 29 se muestra una captura de este fichero “.cc”. Figura 29. Código del fichero “.cc” del nuevo módulo. Nótese que la ruta de la primera del código está en formato absoluto aunque bien podría encontrarse como una ruta relativa con el mismo resultado. Cabe resaltar también, que en el primer argumento de la llamada a “Define_Python_Module” ha sido necesario indicar que el nuevo módulo se encuentra dentro del subdirectorio OLT mediante “OLT.”. 6.2.3 Definición del fichero makefrag Como ya se anticipaba en el Capítulo 3 de esta memoria, se ha de añadir un fichero, denotado como “makefrag”, al proyecto con las líneas mostradas en la captura de la Figura 30. Figura 30. Código del fichero “makefrag”. Dichas líneas serán incorporadas automáticamente al fichero Makefile en el momento de ejecutar la orden make. Integración de un módulo programado en Python al simulador 10G-EPON de OMNeT++ 59 6.2.4 Definición del fichero Python Por último, se añade el fichero de extensión “.py” en el que se puede programar las características y el comportamiento del módulo tal como se hacía originalmente en los ficheros “.cc”. Para que sea posible hacer uso de métodos tales como initialize o handleMessage, es necesario importar al proyecto la clase cSimpleModule tal que: from pyopp import cSimpleModule Con ello se hace posible la programación en Python de dicha clase ya que la biblioteca se encarga de hacer la traducción entre los métodos que se programen y el código en C++ que entiende OMNeT++. En caso de ser necesarias otras funcionalidades de las clases de OMNeT++, basta con importar las clases requeridas tales como cMessage, cPacket, simTime… En una primera instancia, el aspecto del fichero de extensión “.py” creado tiene el aspecto mostrado, a continuación, en la Figura 31. Figura 31. Código del fichero de extensión “.py” inicial cuya única función es notificar el momento de su inicialización. 6.3 Pruebas realizadas y limitaciones encontradas Una vez añadidos todos los ficheros necesarios para la correcta incorporación del módulo Python al proyecto, se dispone de un módulo capaz de inicializarse de forma satisfactoria y correctamente integrado en la red del simulador. Integración de un módulo programado en Python al simulador 10G-EPON de OMNeT++ 66 Sin embargo, durante la implementación de la solución de compromiso descrita, se detectó un nuevo problema asociado al intercambio de mensajes entre el módulo MAC_OLT.cc programado en C++ y el nuevo módulo programado en Python. Se hace patente que los mensajes que previamente eran transmitidos y recibidos sin ningún problema durante la fase de inicialización de la red (en el instante de simulación cero) provocan que la simulación concluya de forma abrupta cuando éstos son, ahora, enviados en otro instante temporal distinto de cero. 6.4 Propuesta de integración final Python-OMNeT++ Con el objetivo de conseguir un correcto intercambio de mensajes que contengan parámetros entre el nuevo módulo programado en Python y otros módulos del simulador programados en C++, se llevan a cabo unas últimas pruebas que permitan identificar y clasificar de forma más precisa las posibles causas que provocan que las simulaciones aborten cada vez que se intenta realizar este tipo de comunicación entre los módulos. En primer lugar, se creó un nuevo proyecto en OMNeT++ sencillo que contaba únicamente con dos módulos, uno programado en Python y el otro programado en C++, que se intercambian mensajes con parámetros en ellos. El proyecto se ejecuta correctamente y durante las simulaciones se puede observar el intercambio satisfactorio de los mensajes entre ambos módulos. Tras llevar a cabo esta prueba, se procedió a crear un nuevo módulo programado en Python en el proyecto simulador de redes 10G-EPON, pero, esta vez, localizado en el nivel más superficial de la red, es decir, a la altura de módulos como el OLT. El resultado se muestra en la Figura 39, y tal y como se observa en nuevo módulo Python ya no está integrado dentro del módulo OLT sino a su misma altura. Integración de un módulo programado en Python al simulador 10G-EPON de OMNeT++ 67 Figura 39. Fichero SFNet_small2.ned visualizado en modo Design para mostrar la estructura de la red tras la incorporación del nuevo módulo Python. Este nuevo módulo se conecta al módulo MAC_OLT (tal como se hacía con el módulo creado previamente en la sección 6.2). En este caso, la conexión no es física ya que ambos módulos se encuentran en diferentes niveles por lo que se comunicarán mediante puertas directas. Una vez creado el módulo, se realiza una simulación en la que se intercambian mensajes con parámetros (contenidos en la cadena del nombre de cada mensaje) entre ambos módulos a través de mensajes directos y, esta vez, no ocurre ningún problema que haga que la simulación se detenga. Por ello, esta solución se presenta como la forma viable de integrar un módulo programado en Python en OMNeT++ permitiendo el intercambio de mensajes con parámetros contenidos en ellos bajo las condiciones de que el módulo a integrar se encuentre en el nivel más superficial de la red y que, la información que se quiera agregar a los mensajes transmitidos se incluya dentro de la cadena de caracteres del nombre del mensaje. En este caso, en el que el módulo programado en Python se encuentre en el nivel más superficial de la red, los otros métodos que se conocen para crear mensajes que contengan parámetros siguen sin funcionar ya que, a la hora de ser transmitidos hacia el otro módulo (ya sea en la transmisión del módulo Python hacia el módulo programado en C++ como en el caso contrario), los parámetros se pierden. Integración de un módulo programado en Python al simulador 10G-EPON de OMNeT++ 68 Por otra parte, ahora, sí que funcionan los envíos retardados de mensajes, ya sea en la generación retardada de automensajes del módulo programado en Python a través de scheduleAt, como en los mensajes intercambiados entre el módulo Python y el módulo programado en C++ (MAC_OLT). 6.5 Conclusiones Una vez llevadas a cabo todas las pruebas, se ha podido constatar que el grado de operabilidad de la biblioteca Omnetpy es bastante limitado. El objetivo inicial de incorporar al simulador de redes 10G-EPON un módulo programado en lenguaje Python con el que poder, por ejemplo, programar la red neuronal empleada en el proyecto, se ha visto limitado por las dificultades encontradas a la hora de enviar información de las variables necesarias de un módulo a otro. Mediante la solución de compromiso, se ha intentado implementar un “parche” que hubiera permitido, al menos, continuar realizando algunas pruebas más asociadas al intercambio de mensajes con variables contenidas en ellos, pero, una vez probado, se ha observado un nuevo problema asociado a los envíos de mensajes entre el módulo en C++ (MAC_OLT) y el módulo Python. Al parecer, cuando esas transmisiones se producen en un instante temporal de la simulación distinto de cero, se produce una finalización abrupta de la ejecución en ese preciso instante. Por otra parte, finalmente, se ha llevado a cabo una última prueba en la que el módulo programado en Python se encuentra en el nivel más superficial de la red (a la altura del OLT, las ONUs…) y, en este caso, no ocurre ningún problema a la hora de comunicar este nuevo módulo con el módulo MAC_OLT a través de mensajes directos. Por tanto, esta vía se presenta como la solución a seguir ya que permite la integración de un módulo Python con el que poder intercambiar mensajes que contengan parámetros en ellos, aunque éstos se encuentren incluidos en la cadena del nombre del mensaje. Además, en este caso, se hace posible el uso de envíos retardados de mensajes. Conclusiones y líneas futuras 69 7 Conclusiones y líneas futuras 7.1 Conclusiones Las principales conclusiones una vez finalizado este Trabajo Fin de Grado están relacionadas con el estado actual de la biblioteca Omnetpy cuya funcionalidad principal radica en la integración de Python en OMNeT++ al permitir la programación de los módulos en este lenguaje. Tras las numerosas pruebas realizadas a lo largo de este trabajo, se ha podido comprobar que, a día de hoy, la biblioteca aún presenta algunas limitaciones importantes que impiden la correcta integración de módulos Python en un proyecto de cierta envergadura, como así ha sido en el simulador de redes 10G-EPON que tenemos desarrollado en OMNeT++. Se ha conseguido crear un módulo programado en lenguaje Python que se comunica con otro módulo programado en C++ a través del envío de mensajes, pero, como ya se ha mencionado, con ciertas limitaciones como la dificultad a la hora de incorporar información de variables a dichos mensajes. También se ha desarrollado un procedimiento que permite la utilización de la biblioteca Omnetpy fuera del contenedor Docker en el que se encontraba inicialmente proporcionada y con versiones diferentes de OMNeT++ a la que se encontraba ligada. Por otra parte, se ha validado la correcta actualización del simulador 10G-EPON desarrollado en OMNeT++ a través de las pruebas realizadas con un conjunto de algoritmos de asignación dinámica de ancho de banda y escenarios. Conclusiones y líneas futuras 70 Este escalado se ha realizado con el objetivo de adaptarse a la creciente demanda de ancho de banda en la actualidad. Con ello, se hace posible la simulación de nuevos escenarios basados en las redes de tasa de transmisión de 10 Gbit/s. 7.2 Líneas futuras Una posibilidad que se abre tras la realización de este trabajo, a la vista de los resultados obtenidos, es la profundización en el estudio de la biblioteca Omnetpy, así como en la biblioteca en la que ésta se fundamenta, Pybind11. Con ello, se podría investigar la forma de habilitar ciertos aspectos de la integración de módulos programados en Python a OMNeT++ que, en el momento de la realización de este trabajo, se encuentran, aún, limitados. Una forma de abordar esto, podría residir en trabajar en la ampliación de las funcionalidades de la biblioteca Omnetpy, programando ciertas funciones, como la adición de parámetros a la clase cMessage (o cPacket), que no se encuentran, todavía, implementadas. Por otra parte, al disponer, ahora, de un simulador de redes 10G-EPON, se hace posible el estudio del comportamiento de diferentes algoritmos de asignación dinámica de ancho de banda en redes que transmitan a esta tasa de transmisión aumentada de 10 Gbit/s. Por supuesto, se abre la puerta al desarrollo de nuevos algoritmos de asignación dinámica de ancho de banda en este tipo de redes basados en técnicas de Machine Learning. Bibliografía 71 8 Bibliografía [1] Omnetpy Repository, [En línea]. Available: https://github.com/mmodenesi/omnetpy [Último acceso: 29 agosto 2021] [2] Omnetpy Getting Started, «How to create a simulation using Python» [En línea]. Available: https://github.com/mmodenesi/omnetpy/tree/master/getstarted [Último acceso: 29 agosto 2021] [3] Python Tutorial, [En línea]. Available: https://docs.python.org/3/tutorial/ [Último acceso: 8 septiembre 2021] [4] OMNeT++ main page, [En línea]. Available: https://omnetpp.org/ [Último acceso: 29 agosto 2021] [5] Docker Documentation, «Get started with Docker» [En línea]. Available: https://docs.docker.com/get-started/overview/ [Último acceso: 29 agosto 2021] [6] PyBind repository, [En línea]. Available: https://github.com/pybind/pybind11 [Último acceso: 29 agosto 2021] [7] G. Kramer and G. Pesavento, "Ethernet passive optical network (EPON): building a next-generation optical access network," in IEEE Communications Magazine, vol. 40, no. 2, pp. 66-73, Feb. 2002, doi: 10.1109/35.983910. [8] Jose María Robledo Sáez (2012), “Implementación de un simulador de Bibliografía 72 redes de acceso pasivas en OMNeT++”, Proyecto Fin de Carrera en Ingeniería Técnica de Telecomunicación en Sistemas de Telecomunicación, E.T.S.I. de Telecomunicación, Universidad de Valladolid. [9] Docker Install Guide, «Install Docker Engine On Ubuntu» [En línea]. Available: https://docs.docker.com/engine/install/ubuntu/ [Último acceso: 29 agosto 2021] [10] PyBind11 Documentation, [En línea]. Available: https://pybind11.readthedocs.io/_/downloads/en/latest/pdf/ [Último acceso: 29 agosto 2021] [11] OMNeT++ Installation Guide, [En línea]. Available: https://doc.omnetpp.org/omnetpp/InstallGuide.pdf [Último acceso: 29 agosto 2021] [12] T. Jiménez, N. Merayo, P. Fernández, R.J. Durán, I. de Miguel, R.M. Lorenzo, E.J. Abril (2012). Implementation of a PID controller for the bandwidth assignment in long-reach PONs. Journal of Optical Communications and Networking, 4(5), 392-401. [13] N. Merayo, D. Juárez, J.C. Aguado, I. de Miguel, R.J. Durán, P. Fernández, P., R.M. Lorenzo, E.J. Abril (2017). PID controller based on a self-adaptive neural network to ensure QoS bandwidth requirements in passive optical networks. Journal of Optical Communications and Networking, 9(5), 433-445. [14] David Juárez Estévez (2017), «Desarrollo de algoritmos de gestión de recursos en redes PON y NGPON2», Trabajo Fin de Grado, Grado en Ingeniería de Tecnologías de Telecomunicación. E.T.S.I. de Telecomunicación, Universidad de Valladolid. Disponible en: htps://uvadoc.uva.es/handle/10324/27581