123MC JM

SEP SNIT SEIT
CENTRO NACIONAL DE INVESTIGACIÓN Y

DESARROLLO TECNOLÓGICO
Cenidet
ACADEMIA DE LA MAESTRÍA EN ELECTRÓNICA
TESIS
"ENRUTADOR DE ARREGLOS EMBRIÓNICOS

UTILIZANDO ALGORITMOS GENÉTICOS"
Director de Tesis: Dr. César Ortega Sánchez
Codirector de Tesis: Dr. José Torres Jiménez
Alumno Solicitante: Ing. Jorge Morales Cruz.
Cuernavaca Morelos, Agosto de 2002.
1
Dedicatoria
A Dios, por darme la oportunidad de existir.

A mis padres, por su enorme apoyo y gran cariño incondicional en
todo momento.
A mis hermanos, por confiar siempre en mí.
A mis amigos, por regalarme un poco de su tiempo.
A mis maestros, por contribuir a la realización de este sueño.
2
Agradecimientos
Al Dr. César Ortega Sánchez y al Dr. José Torres Jiménez, por su

atinada dirección en la realización de esta tesis.
A los maestros en ciencias: José de Jesús Moreno, José A. Hoyo, Pedro
Sibaja, Marco A. Paz, por su valiosa contribución en este trabajo.
Al Centro Nacional de Investigación y Desarrollo Tecnológico (Cenidet),
por brindarme la oportunidad de estudiar la maestría.
A Conacyt y Sep por el apoyo económico proporcionado durante el
desarrollo de este trabajo.
3
ÍNDICE
INTRODUCCIÓN ...................................................................................................................12
1. ARREGLOS EMBRIÓNICOS...........................................................................................18
1.1 INTRODUCCIÓN ................................................................................................................... 18

1.1.1 Antecedentes.................................................................................................................18
1.1.2 Definición ....................................................................................................................20
1.1.3 Conceptos tomados de la biología..................................................................................20
1.2 ESTRUCTURA ...................................................................................................................... 20
1.2.1 Memoria ......................................................................................................................21
1.2.2 Generador de coordenadas............................................................................................22
1.2.3 Enrutador de entrada / salida ........................................................................................23
1.2.4 Elemento de procesamiento ...........................................................................................24
1.2.5 Registro de configuración..............................................................................................26
1.3 MECANISMOS DE RECONFIGURACIÓN ................................................................................... 26
1.3.1 Estrategia de eliminación de una fila o una columna.......................................................27
1.3.2 Estrategia de eliminación de una célula .........................................................................28
1.4 METODOLOGÍA PARA IMPLEMENTAR APLICACIONES .............................................................. 28
1.4.1 Planteamiento del problema..........................................................................................28
1.4.2 Obtención de la tabla de verdad ....................................................................................29
1.4.3 Obtención del diagrama binario de decisión...................................................................29
1.4.4 Simplificación de los BDD.............................................................................................30
1.4.5 Implementación del OBDD como árbol de multiplexores.................................................31
1.4.6 Enrutado del árbol de multiplexores en el Arreglo Embriónico........................................32
1.5 EJEMPLO : CIRCUITO VOTADOR............................................................................................. 32
1.6 RESUMEN............................................................................................................................ 34
2. ALGORITMOS GENETICOS Y ENRUTADORES .......................................................35
2.1 INTRODUCCIÓN ................................................................................................................... 35

2.1.1 Antecedentes.................................................................................................................35
2.1.2 Aplicaciones.................................................................................................................36
2.2 FUNCIONAMIENTO DE LOS ALGORITMOS GENÉTICOS............................................................. 37
2.2.1 Representación del problema.........................................................................................38
4
2.2.2 Evaluación ...................................................................................................................38
2.2.3 Selección......................................................................................................................38
2.2.4 Función de aptitud........................................................................................................39
2.2.5 Cruza...........................................................................................................................39
2.2.6 Mutación......................................................................................................................40
2.3 ENRUTADORES .................................................................................................................... 40
2.3.1 Definición de enrutador ................................................................................................40
2.3.2 El problema de enrutar .................................................................................................41
2.3.3 Enrutamiento usando algoritmos genéticos....................................................................42
2.4 RESUMEN............................................................................................................................ 43
3. ENRUTADOR PROPUESTO ...........................................................................................44
3.1 REPRESENTACIÓN DE LA CONECTIVIDAD ENTRE CÉLULAS DEL ARREGLO EMBRIÓNICO........... 44

3.2 LLENADO DE LA MATRIZ DE CONECTIVIDAD .......................................................................... 48
3.2.1 Decodificación de los bits correspondientes al enrutador de E/S......................................48
3.2.2 Cargar variables de entrada de la aplicación.................................................................49
3.2.3 Propagación de las variables.........................................................................................50
3.2.4 Llenado de las entradas del elemento de procesamiento ..................................................54
3.2.5 Verificación de las entradas de cada célula ....................................................................56
3.3 ELEMENTOS DEL ALGORITMO GENÉTICO P ROGRAMADO (AGP)............................................ 57
3.3.1 Representación de los cromosomas del AGP...................................................................58
3.3.2 Función de aptitud (FA)................................................................................................58
3.3.3 Selección por torneo .....................................................................................................60
3.3.4 Cruza...........................................................................................................................61
3.3.5 Mutación......................................................................................................................61
3.4 IMPLEMENTACIÓN DEL AGP................................................................................................ 62
3.4.1 Ajuste de los parámetros del AGP..................................................................................66
3.5 RESUMEN ........................................................................................................................... 67
4. RESULTADOS ...................................................................................................................68
4.1 AMBIENTE DE DESARROLLO FOUNDATION DE XILINX............................................................. 68

4.2 RELOJ DE 12 HORAS ............................................................................................................ 69
4.2.1 Contador 0-9................................................................................................................70
4.2.2 Contador 0-5................................................................................................................75
4.2.3 Contador 0-11..............................................................................................................77
5
4.3 OTRAS APLICACIONES ......................................................................................................... 80
4.3.1 CONTADOR ASCENDENTE/DESCENDENTE DE 2 BITS............................................................. 80
4.3.2 Circuito votador de 3 bits..............................................................................................82
4.3.3 Sumador paralelo de 2 bits............................................................................................83
4.3.4 Generador de Redundancia Cíclica de 4 bits (CRC-4).....................................................85
4.3.5 Generador de paridad par de 4 bits ...............................................................................87
4.3.6 Generador de paridad par de 5 bits ...............................................................................88
4.4 RESUMEN............................................................................................................................ 91
CONCLUSIONES ...................................................................................................................92
APÉNDICE ..............................................................................................................................97
BIBLIOGRAFÍA Y REFERENCIAS ..................................................................................105
6
FIGURAS
Figura 0.1.- Estructura de la tesis................................................................................................... 16

Figura 1.1.- Componentes básicos de un arreglo embriónico............................................................ 21
Figura 1.2.- Estructura de la memoria de un arreglo embriónico. ..................................................... 22
Figura 1.3.- Generación de coordenadas para cada célula. ............................................................... 23
Figura 1.4.- Estructura del enrutador [Ort00b]. ............................................................................... 24
Figura 1.5.- Arquitectura del elemento de procesamiento de la célula [Ort00b]. ................................ 25
Figura 1.6.- Registro de configuración. .......................................................................................... 26
Figura 1.7.- Sistema celular con células de repuesto [Ort00b].......................................................... 27
Figura 1.8.- Proceso de eliminación de una fila en un arreglo embriónico. ........................................ 27
Figura 1.9.- Tolerancia a fallas mediante la eliminación de una célula [Ort00b]. ............................... 28
Figura 1.10.- Árbol binario de decisión de la tabla de verdad de la tabla 1.1. .................................... 30
Figura 1.11.- Reducción de un árbol de decisión en OBDD............................................................. 31
Figura 1.12.- Árbol de multiplexores del OBDD de la figura 1.11c. ................................................. 31
Figura 1.13.- Función implementada en un arreglo embriónico. ....................................................... 32
Figura 1.14.- BDD del circuito votador. ......................................................................................... 33
Figura 1.15.- Implementación en un árbol de multiplexores del circuito votador. .............................. 33
Figura 1.16.- Circuito votador implementado en un arreglo embriónico............................................ 33
Figura 2.1.- Funcionamiento básico de un algoritmo genético. ......................................................... 37
Figura 2.2.- Representación gráfica de la solución del problema del agente viajero. .......................... 41
Figura 3.1.- Árbol de multiplexores del votador.............................................................................. 44
Figura 3.2.- Conectividad de un Arreglo Embriónico de tamaño 2x3. ............................................... 45
Figura 3.3.- Enrutador de E/S de una célula.................................................................................... 46
Figura 3.4.- Registro de configuración de una célula embriónica...................................................... 48
Figura 3.5.- Elemento de procesamiento......................................................................................... 54
Figura 3.6.- Representación de un cromosoma................................................................................ 58
Figura 3.7.- Árbol de multiplexores y acomodo en un AE del circuito votador.................................. 59
Figura 3.8- Generación de nuevos cromosomas mediante la cruza. .................................................. 61
Figura 3.9.- Aplicación de la mutación a un cromosoma de la población. ......................................... 62
Figura 3.10.-Diagrama de flujo del AGP........................................................................................ 63
Figura 4.1.- Cuenta máxima del reloj de 0 a 12 horas...................................................................... 69
Figura 4.2.- Estructura del reloj de 0 a 12 horas.............................................................................. 70
7
Figura 4.3.- OBDD para el contador 0-9......................................................................................... 71
Figura 4.4.- Árboles de multiplexores del contador 0-9. .................................................................. 71
Figura 4.5.- Enrutamiento del contador 0-9. ................................................................................... 74
Figura 4.6.- Simulación del contador 0-9 con todas las células en buen estado. ................................. 74
Figura 4.7.- Simulación del contador 0-9 con una fila dañada.......................................................... 75
Figura 4.8.- Árboles de multiplexores del contador 0-5. .................................................................. 76
Figura 4.9.- Enrutamiento del contador 0-5. ................................................................................... 76
Figura 4.10.- Simulación del contador 0-5...................................................................................... 77
Figura 4.11.- Árboles de multiplexores del contador 0-11................................................................ 78
Figura 4.12.- Enrutamiento parcial del contador 0-11, primera parte. ............................................... 79
Figura 4.13.- Enrutamiento parcial del contador 0-11, segunda parte................................................ 79
Figura 4.14.- Simulación del contador 0-11. ................................................................................... 80
Figura 4.15.- Árboles de multiplexores del contador ascendente/descendente de 2 bits...................... 80
Figura 4.16.- Enrutamiento del contador ascendente/descendente de 2 bits. ...................................... 81
Figura 4.17.- Simulación del contador ascendente/descendente de 2 bits. ......................................... 81
Figura 4.18.- Árbol de multiplexores del circuito votador de 3 bits. ................................................. 82
Figura 4.19.- Enrutamiento del circuito votador de 3 bits................................................................. 82
Figura 4.20.- Simulación del circuito votador de 3 bits.................................................................... 83
Figura 4.21.- Árboles de multiplexores del sumador paralelo de 2 bits. ............................................ 83
Figura 4.22.- Enrutamiento del sumador paralelo de 2 bits. ............................................................. 84
Figura 4.23.- Simulación del sumador paralelo de 2 bits.................................................................. 84
Figura 4.24.- Árboles de multiplexores del CRC-4.......................................................................... 86
Figura 4.25.- Enrutamiento del CRC-4........................................................................................... 86
Figura 4.26.- Simulación del CRC-4. ............................................................................................. 86
Figura 4.27.- Árbol de multiplexores del generador de paridad par de 4 bits. .................................... 87
Figura 4.28.- Enrutamiento del generador de paridad par de 4 bits. .................................................. 88
Figura 4.29.- Simulación del generador de paridad par de 4 bits....................................................... 88
Figura 4.30.- Árbol de multiplexores del generador de paridad par de 5 bits. .................................... 89
Figura 4.31.- Enrutamiento del generador de paridad de 5 bits......................................................... 90
Figura 4. 32.- Simulación del generador de paridad par de 5 bits...................................................... 90
Figura A.1.- Módulo de memoria................................................................................................... 98
Figura A.2.- Generador de coordenadas. ........................................................................................ 99
Figura A.3.- Enrutador de Entrada / Salida. .................................................................................. 100
Figura A.4.- Elemento de procesamiento. ..................................................................................... 101
8
Figura A.5.- Arquitectura de una célula embriónica. ..................................................................... 102
Figura A.6.- Símbolo creado a partir del esquemático de la figura A.5. .......................................... 103
Figura A.7.- Arreglo embriónico de 5x8 para simular el contador 0-9 y su detector de rebose (DR). 104
9
TABLAS
Tabla 0.1.- Diferencias entre inteligencia artificial y vida artificial [Ort00a]. .................................... 14
Tabla 1.1.- Ejemplo de una tabla de verdad. ................................................................................... 29
Tabla 1.2.- Tabla de verdad del circuito votador. ............................................................................ 32
Tabla 3.1.- Tabla de verdad del circuito votador. ............................................................................ 44
Tabla 3.2.- Entradas fuentes del circuito votador............................................................................. 44
Tabla 3.3.- Matriz que representa la conectividad del AE de la figura 3.2. ........................................ 47
Tabla 3.4.- Decodificación de los bits correspondientes al enrutador de E/S. .................................... 48
Tabla 3.5.- Carga de variables de entrada al AE.............................................................................. 49
Tabla 3.6.- Propagación parcial de las variables del AE................................................................... 51
Tabla 3.7.- Propagación de las variables, primera pasada................................................................. 52
Tabla 3.8.- Propagación de las variables, segunda pasada................................................................ 53
Tabla 3.9.- Propagación completa de las variables. ......................................................................... 53
Tabla 3.10.- Significado de las entradas del registro de configuración. ............................................. 54
Tabla 3.11.- Llenado de las entradas del elemento de procesamiento. ............................................... 55
Tabla 3.12.- Entradas fuentes del árbol de multiplexores del circuito votador. .................................. 56
Tabla 3.13.- Actualización de las salidas de las células.................................................................... 57
Tabla 3.14.- Matriz de conectividad parcial de un cromosoma que no resuelve el enrutado. ............... 60
Tabla 3.15.- Población ordenada de acuerdo con la mejor aptitud. ................................................... 65
Tabla 4.1.- Tabla de verdad para el contador 0-9............................................................................. 70
Tabla 4.2.- Resultados de las corridas del programa del algoritmo genético. ..................................... 72
Tabla 4.3.- Tabla de verdad para el contador 0-5............................................................................. 75
Tabla 4.4.- Tabla de verdad para el contador 0-11........................................................................... 77
Tabla 4.5.- Tabla de verdad para el contador ascendente/descendente de 2 bits. ................................ 80
Tabla 4.6.- Tabla de verdad para el circuito votador de 3 bits........................................................... 82
Tabla 4.7.- Tabla de verdad para el sumador paralelo de 2 bits. ....................................................... 83
Tabla 4.8.- Tabla de verdad del CRC-4.......................................................................................... 85
Tabla 4.9.- Tabla de verdad del generador de paridad par de 4 bits................................................... 87
Tabla 4.10.- Tabla de verdad del generador de paridad par de 5 bits................................................. 89
10
LISTADOS
Listado 3.1.- Archivo de entrada del AGP...................................................................................... 62
Listado 3.2.- Archivo de salida del AGP. ....................................................................................... 66
Listado 4.1.- Archivo de entrada para enrutar el contador 0-9. ......................................................... 72
Listado 4.2.- Archivo VHDL que describe la memoria del reloj de 12 horas. ................................... 73
Listado 4.3.- Archivo de entrada para enrutar el contador 0-5. ......................................................... 76
Listado 4.4.- Archivos de entrada para enrutar el contador 0-11....................................................... 78
Listado 4.5.- Archivo de entrada para enrutar el contador ascendente/descendente de 2 bits............... 81
Listado 4.6.- Archivo de entrada para enrutar el circuito votador de 3 bits. ....................................... 82
Listado 4.7.- Archivo de entrada para enrutar el sumador paralelo de 2 bits. ..................................... 84
Listado 4.8.- Archivo de entrada para enrutar el CRC-4. ................................................................. 85
Listado 4.9.- Archivo de entrada para enrutar el generador de paridad par de 4 bits........................... 87
Listado 4.10.- Archivo de entrada para enrutar el generador de paridad par de 5 bits......................... 89
11
INTRODUCCIÓN
Sistemas Bioinspirados
Desde hace algunos años hemos sido testigos de una fusión de ideas innovadoras con
tecnologías avanzadas, dando origen al viejo sueño de construir máquinas capaces de imitar
algunos de los mecanismos que encontramos en los seres vivientes. Esta temática, en su
forma moderna, fue tomada por primera vez hace casi 50 años por el padre de la cibernética,
John Von Neumann. La idea central de su trabajo eran los conceptos de autoreproducción y
autoreparación. Desafortunadamente, la tecnología disponible en su época no era suficiente
para realizar sus ideas.
En los años siguientes, hemos visto el surgimiento de sistemas bioinspirados tales como
las redes neuronales, acompañado por la aparición de una nueva rama de estudio llamada
vida artificial. La idea central del estudio de la vida artificial es la aplicación de mecanismos
que presenta la evolución natural a sistemas artificiales. John Holland fue otro pionero de
estas investigaciones y propuso las bases de lo que hoy se conocen como algoritmos
genéticos. Aunque los conceptos de la vida artificial han avanzando muy lentamente, han
encontrando un lugar dentro de muchas disciplinas tradicionales de la ingeniería [Ort00a].
El incremento considerable en el poder computacional y más recientemente, la aparición

de una nueva generación de dispositivos lógicos programables, han hecho posible la
realización de modelos de codificación genética y evolución artificial. Esto ha permitido la
simulación y finalmente la realización en hardware de un nuevo tipo de máquinas. Hemos
cruzado una barrera tecnológica que nos impedía en lugar de diseñar, evolucionar máquinas
para obtener el comportamiento deseado. Este nuevo enfoque ha sido llamado ingeniería
evolutiva: “El arte de usar algoritmos evolutivos para construir sistemas complejos”. Aunque
sólo se han dado los primeros pasos, promete revolucionar la forma de diseñar nuestras
máquinas futuras. Estamos siendo testigos del nacimiento de una nueva era, en la cual los
términos ‘adaptación’ y diseño no serán conceptos opuestos [Ort00a].
Introducción
La evolución natural implica poblaciones de individuos, cada uno conteniendo una

descripción de sus características físicas, el genotipo. Una nueva generación de individuos
es creada a través del proceso de reproducción, en el cual los genotipos son transmitidos a
sus descendientes con modificaciones debido a la cruza y la mutación. Estas operaciones
genéticas se realizan de manera autónoma dentro de cada entidad, esto es, dentro del
genotipo. A la manifestación física del genotipo se le conoce como el fenotipo, esto es, el
individuo que resulta de interpretar el genotipo. Durante su vida, el individuo es sometido al
medio ambiente el cual, a través de un proceso de selección natural, mantiene a los
individuos mejor adaptados. El proceso evolutivo no tiene un controlador central; la aptitud
de un individuo está implícitamente determinada por su capacidad para sobrevivir y
reproducirse en el medio ambiente [Ort00a].
La vida natural sobre la tierra está organizada en por lo menos cuatro niveles
fundamentales de estructura:
? Nivel de población-ecosistema.
? Nivel de organismo
? Nivel celular
? Nivel molecular.
El estudio de la vida en cualquier contexto requiere del entendimiento de los cuatro

niveles, por ello las ciencias biológicas están usando sistemas de vida artificial para entender
la vida natural. Los sistemas de hardware son usados para estudiar el nivel de organismos.
Los niveles de población y celular son estudiados a través del uso de sistemas de software.
El nivel molecular es estudiado a través de experimentos con moléculas RNA (Ácido
Ribonucleico) [Ort00a].
El trabajo en vida artificial puede ser dividido en dos ramas generales: el diseño de
sistemas con “propiedades biológicas” para realizar una tarea particular, por ejemplo las
redes neuronales artificiales; y el uso de técnicas de la ingeniería para precisar un modelo
biológico con el propósito de probar una hipótesis en la biología por ejemplo, la ingeniería
genética. La investigación sobre inteligencia artificial se ha llevado a cabo en los laboratorios
de ciencias de la computación por más de cuarenta años. En contraste, el estudio de la vida
artificial es más moderno y aún está en sus inicios. Es importante hacer una clara distinción
entre inteligencia artificial y este nuevo paradigma llamado vida artificial. La tabla 0.1 muestra
algunas diferencias importantes entre las dos disciplinas [Ort00a].
13
Introducción
INTELIGENCIA ARTIFICIAL (AI) VIDA ARTIFICIAL (ALIFE)

Enfocado a individuos Enfocado a un grupo o población
Conocimiento sobre operaciones Conocimiento sobre operaciones de
de lógica sistemas nerviosos
Inicia con el conocimiento del nivel Conocimiento situado con experiencias
humano sensora/motríz
Jerarquía principal: sistemas Jerarquía principal: cuenta con la
complejos de ingeniería evolución, desarrollo y aprendizaje
Especificación directa de Especificación indirecta de conocimiento
conocimiento de arquitecturas de arquitecturas por medio de mapeo de
genotipo y fenotipo
Tareas mentales a nivel humano Sobrevivencia en ambientes complejos
Tiempo de trabajo en horas Evolución, generación y vida de los
individuos
Tabla 0.1.- Diferencias entre inteligencia artificial y vida artificial [Ort00a].
El Modelo POE
Para clasificar los sistemas bioinspirados, Sánchez et al. proponen el modelo POE
(Phylogenia, Ontogenia y Epigénesis) [San97]. En este modelo, los sistemas bioinspirados
se clasifican de acuerdo al nivel donde se lleva a cabo la adaptación al ambiente. En la
Phylogenia se encuentran los sistemas que se adaptan al medio ambiente a través de la
transmisión de material genético de una generación a otra. La adaptación se logra a nivel de
especies. En este eje encontramos a todas las estrategias evolutivas (algoritmos genéticos,
programación evolutiva, etc.). La Ontogenia agrupa a los sistemas multicelulares que logran
su adaptación al medio ambiente a través de mecanismos de regeneración a nivel local
(sanar, cicatrización); en este eje se encuentran los arreglos celulares y Embriónicos.
Finalmente, la epigénesis agrupa a los sistemas que logran su adaptación al medio ambiente
mediante el aprendizaje. Aquí encontramos a las redes neuronales, los sistemas
inmunológicos artificiales y los sistemas inteligentes [Ort00a].
El trabajo en esta tesis combinará dos ejes del modelo: la phylogenia (algoritmos
genéticos) y la ontogenia (arreglos Embriónicos).
Los arreglos Embriónicos forman parte del estudio de la vida artificial. En embriónica se
pretende tomar conceptos de la biología y realizar un sistema celular que pueda desarrollar
una función deseada, aún cuando existan fallas en algunas de sus unidades básicas
(propiedades de tolerancia a fallas). En otras palabras, un sistema embriónico trata de
14
Introducción
emular las propiedades de la naturaleza como lo son reproducción, sobrevivencia,

adaptabilidad, para seguir operando cuando se presente algún daño al arreglo embriónico.
Hipótesis
La idea primordial en embriónica es tomar los conceptos de la Biología para realizar un

arreglo de células electrónicas que sea capaz de reconfigurarse y proporcionar un sistema
tolerante a fallas. Las células embriónicas tienen una conectividad limitada, por lo que el
problema de enrutar una aplicación se vuelve más difícil a medida que la aplicación crece en
complejidad.
La hipótesis a comprobar en esta tesis es que es posible

resolver el enrutado de un arreglo embriónico utilizando un
algoritmo genético.
Objetivo general
Diseñar, desarrollar y probar un enrutador automático basado en algoritmos genéticos

para resolver el problema de enrutado en los arreglos embriónicos.
Objetivos particulares
? Representar en forma abstracta de la conectividad del arreglo embriónico (enrutado

deseado).
? Generar los cromosomas del problema de enrutado.
? Desarrollar un algoritmo genético que resuelva el enrutado del arreglo embriónico.
? Convertir la salida del algoritmo genético en registros de configuración.
? Sintetizar el arreglo embriónico para un FPGA.
? Comprobar los resultados por simulación.
Alcances
Al desarrollar el presente tema de tesis se propone obtener los siguientes alcances:
? Representación abstracta de la topología del arreglo de multiplexores y de la

conectividad del arreglo embriónico que sea adecuada para usarse en un algoritmo
genético.
15
Introducción
? Algoritmo genético que resuelva el enrutado del arreglo de multiplexores en el arreglo

embriónico.
? Programa que genere automáticamente el contenido de los registros de configuración
del arreglo embriónico diseñado.
? Selección de una aplicación típica para probar el sistema diseñado.
Aportación o contribución del trabajo
Con el presente trabajo de tesis se pretende obtener:
? Inicio del estudio de los arreglos embriónicos en México.

? Uso de los algoritmos genéticos para solucionar un problema de enrutado.
? Diseño y desarrollo de un enrutador automático de arreglos embriónicos el cual
puede contribuir al estado del arte en esta área.
Estructura de la tesis
En la figura 0.1 se muestra la estructura de la tesis:
Capítulo I Capítulo II
Arreglos embriónicos Algoritmos genéticos
? Introducción ? Introducción
? Estructura ? Funcionamiento de los
? Mecanismos de reconfiguración algoritmos genéticos
? Metodología para implementar aplicaciones ? Enrutadores
? Ejemplo
Capítulo III
Enrutador propuesto
? Representación de la
conectividad entre células
? Algoritmo genético programado
Capítulo IV
Resultados
? Foundation de Xilinx
? Diseño del reloj
? Otras aplicaciones
Figura 0.1.- Estructura de la tesis.
16
Introducción
El capítulo I presenta los conceptos básicos tomados de la biología por la embriónica.

Se describen los antecedentes, estructura y funcionamiento de los arreglos embriónicos. Se
presenta una aplicación realizada mediante una metodología rústica y poco manejable. De
aquí surge la problemática del enrutamiento de los arreglos embriónicos, motivo por el cual
se propone una forma más rápida y automática de enrutamiento mediante los algoritmos
genéticos.
El capítulo II trata todo lo referente a los algoritmos genéticos como son sus
características, estructura y funcionamiento. Se describen los elementos que constituyen a
un algoritmo genético en forma general. Se presenta una definición y clasificación de lo que
es un enrutador. Se muestra el enrutamiento basado en los algoritmos genéticos como una
herramienta de optimización de problemas.
El capítulo III describe la forma de implementar a los elementos que constituyen al

algoritmo genético programado que resuelve el enrutamiento de los arreglos embriónicos. El
algoritmo genético se implementó en el lenguaje de programación C.
En el capítulo IV, se presentan los resultados de la simulación en Foundation de Xilinx

de varios circuitos combinacionales y secuenciales para probar el enrutador de arreglos
embriónicos basado en los algoritmos genéticos propuesto en este trabajo de investigación.
Como parte final se plasmarán las conclusiones obtenidas a través del desarrollo de
este trabajo. En el se mostrarán los detalles, aspectos relevantes y sucesos importantes que
se vivieron durante la realización de los objetivos. Así también se mostrarán las aportaciones
y trabajos futuros relacionados con el desarrollo del presente trabajo.
17
CAPÍTULO I
1. ARREGLOS EMBRIÓNICOS
Este capítulo presenta en la sección 1.1 los antecedentes y conceptos

tomados de la biología que definen a los arreglos embriónicos. La estructura
de los arreglos embriónicos se presenta en la sección 1.2. En la sección 1.3
se muestran dos estrategias para realizar la reconfiguración de un arreglo
embriónico en caso de falla. La sección 1.4 presenta el procedimiento para
implementar aplicaciones en un arreglo embriónico. En la sección 1.5 se
presenta una aplicación siguiendo el procedimiento planteado en la sección
1.4.
1.1 Introducción
1.1.1 Antecedentes
Una de las instituciones dedicadas al estudio de la electrónica inspirada en la biología es la

Universidad de York, en York, Inglaterra, denominando su campo de trabajo como
“Ingeniería bioinspirada”, la cual comprende diversas ramas de estudio como son:
? Embriónica: La embriónica propone una nueva familia de arreglos de procesadores

tolerantes a fallas inspirados en el desarrollo ontogénico de organismos multicelulares
[Ort00b].
? Embriónica Asíncrona: La embriónica asíncrona intenta aplicar la metodología para
implementar circuitos asíncronos al diseño de circuitos embriónicos [Jac01].
? Hardware Evolutivo: Es la aplicación de Algoritmos Evolutivos (como Algoritmos
Genéticos o Programación Genética) para el diseño de circuitos electrónicos. Este
CAPÍTULO I Arreglos embriónicos
proyecto incluye la investigación de tolerancia a fallas como una propiedad implícita

de circuitos electrónicos evolucionados [Tyr01].
? Inmunotrónica: Diseño de sistemas electrónicos tolerantes a fallas inspirados en el
sistema inmune humano. Los sistemas electrónicos aprenden a diferenciar entre la
operación correcta y la operación no correcta del sistema [Bra02].
? Programación Genética de Enzimas: Se utiliza como una herramienta para generar
automáticamente programas. Usa una representación derivada del sistema natural
genético para incrementar la capacidad para evolucionar de programas en desarrollo
[Lon01].
Otra institución dedicada a la búsqueda de nuevas aplicaciones electrónicas inspiradas

en la biología es el Politécnico de Lausana, en Lausana, Suiza. En esta institución se
realizan estudios acerca del modelo POE utilizado para clasificar a los sistemas de hardware
bioinspirados (ver sección 1.1.2) [Ort00a]. Su proyecto de embriónica está inspirado en los
procesos básicos de la biología molecular y el desarrollo embrionario de los seres vivientes.
Adoptando ciertas características de organización celular, y adaptándolas al mundo
bidimensional de los circuitos integrados de silicio, se logran propiedades del mundo viviente,
tales como auto replicación y auto reparación.
El objetivo principal del grupo de investigación en el Politécnico de Lausana es el

desarrollo de circuitos de muy grande escala de integración (VLSI) capaces de auto
repararse y auto replicarse. La auto reparación permite la reconstrucción parcial en caso de
una falla menor, mientras la auto replicación permite la reconstrucción completa del
dispositivo original en caso de una falla mayor. Estas dos propiedades son particularmente
deseables para sistemas artificiales complejos tales como:
? Aplicaciones que requieren muy alto nivel de confiabilidad, como la electrónica

aeronáutica o médica.
? Aplicaciones diseñadas para ambientes hostiles, como el espacio, donde el
incremento de los niveles de radiación reducen la eficiencia de los componentes.
? Aplicaciones avanzadas que manejan niveles bajos de consumo de potencia, y alta
velocidad de operación.
Estas áreas de aplicación requieren del desarrollo de un nuevo paradigma de diseño que
sea capaz de soportar pruebas confiables en tiempo real de circuitos VLSI y sobre todo
soluciones que permitan la auto reparación.
19
Enrutador de arreglos embriónicos utilizando algoritmos genéticos
1.1.2 Definición
Embriónica es un término adoptado para describir un hardware reconfigurable capaz de

repararse y de reproducirse dinámicamente. Toma su nombre de la fusión de la embriología
con los sistemas electrónicos. La embriónica fue propuesta originalmente por Mange y
Marchal [2, 3]. La embriónica también ha sido estudiada como una técnica que proporciona
propiedades de tolerancias a fallas en una arquitectura celular. El proyecto Embriónica se
ubica en el marco del Hardware Evolutivo (EHW), el cual comprende el diseño y la
realización de sistemas electrónicos bioinspirados capaces de adaptarse a cambios del
medio ambiente de manera autónoma.
1.1.3 Conceptos tomados de la biología
Las células son las unidades básicas de los seres vivos. Los animales están formados
por células especializadas que forman la sangre, los huesos, los cartílagos, los músculos y
las células nerviosas. Los humanos tienen cerca de 350 tipos de células diferentes. Todas
las células que constituyen a un ser vivo, que se reproduce sexualmente, tienen su origen en
la división repetida de un óvulo fecundado.
Las células se diferencían dentro de un embrión de acuerdo a la posición que guardan

con respecto a las otras células. La información de la posición la adquieren por medio de
gradientes químicos. Cada célula tiene un conjunto de instrucciones (información genética),
que define su función para cada posición [Ort00b]. Se puede decir que cada célula en un
organismo tiene una biblioteca donde está almacenado el código para controlar sus
acciones: el ácido desoxirribonucleico o ADN. Una célula tiene una planta quím ica y una
respuesta química que actúan como sus dispositivos de entrada y salida. Diferentes dosis de
químicos y en combinaciones diferentes causan que una célula actúe de formas diferentes.
1.2 Estructura
Las arquitecturas embriónicas permiten emular algunos de los mecanismos observados

durante la ontogénesis de los organismos que se reproducen sexualmente. Un sistema
embriónico es un arreglo bidimensional de células, donde cada una es un elemento de
procesamiento. Todas las células realizan la misma operación básica y su función específica
está determinada por su posición dentro del sistema celular. En la figura A.7 del apéndice se
20
muestra un arreglo embriónico de 5x8 células implementado para simular diseños digitales
utilizando el ambiente de desarrollo Foundation de Xilinx.
La función lógica de cada célula es determinada por uno de los registros de

configuración localizados en su memoria. Los registros de configuración son seleccionados
por las coordenadas de la célula en relación a sus vecinos. La figura 1.1 muestra la
arquitectura básica de un sistema embriónico genérico.
32 Al vecino N
Arreglo embriónico
Enrutador
O de E/S
30 31 32 33 E
Elemento de
20 21 22 23 procesamiento
Gen.
10 11 12 13 de
Memoria
coord .
00 01 02 03
21 Al vecino 23
Coordenadas únicas 12 Desde el vecino S
Figura 1.1.- Componentes básicos de un arreglo embriónico.
La arquitectura mostrada en la figura 1.1 presenta las siguientes ventajas:
? Es altamente regular, lo cual facilita su implementación en silicio. El elemento de

procesamiento (multiplexor en este caso) puede ser diseñado para realizar otras
funciones lógicas.
? La arquitectura del elemento de procesamiento es simple, por lo que es posible llevar
a cabo autodiagnóstico sin incrementar excesivamente el área de silicio.
En un arreglo embriónico convencional se requiere tener en cada célula, memoria

suficiente para almacenar los registros de configuración de todas las células del arreglo
(cromosoma de la célula). Esta arquitectura requiere de una cantidad de memoria por célula
muy grande y difícil de implementar.
1.2.1 Memoria
Cada célula embriónica contiene una copia de los registros de configuración de todas
las células del arreglo embriónico. La configuración transparente configura a la célula de tal
21
manera que la entrada de un punto cardinal del enrutador de E/S se propague a la salida del
punto cardinal contrario correspondiente, por ejemplo, la entrada del bus del Sur se
propague a la salida del bus del Norte. La configuración transparente se selecciona cuando
se detecta una falla en la célula.
El elemento de procesamiento de la célula requiere de 17 bits para su configuración. La

cantidad total de memoria requerida en cada célula embriónica es: (n registros del arreglo
embriónico)*(17 bits por registro) = 17n bits. La figura 1.2 muestra la estructura de la
memoria utilizada en un arreglo embriónico.
La figura A.1 del apéndice muestra el esquemático de la memoria implementada para

simular diseños digitales sobre Foundation de Xilinx. Este esquemático ha sido generado a
partir de un archivo VHDL que proporciona el algoritmo genético programado en el capítulo
3. El archivo VHDL contiene los registros de configuración de todas las células del arreglo
embriónico. La memoria es la misma para todas las células. De acuerdo a las coordenadas
(m, n) de cada célula, se decodifica su registro de configuración correspondiente.
Células embriónicas
m,0 m,0 m,n Generador de

coordenadas
Memoria
1,0 1,1 1,n
Palabra de 17
configuración
Elemento de
0,0 0,1 0,n procesamiento
Figura 1.2.- Estructura de la memoria de un arreglo embriónico.
1.2.2 Generador de coordenadas
Cada célula genera una coordenada (m, n) para sus vecinos del norte y del este. El
valor de la coordenada m depende del estado de la célula que lo genera. Solo si la célula
está en buenas condiciones de operación, la coordenada m se incrementa en 1 y el valor
resultante se propaga hacia la célula del norte. La coordenada n siempre se incrementa en 1
y el valor resultante se propaga hacia la célula del este.
22
Si la célula está en malas condiciones de operación entonces se vuelve transparente, es

decir, todas las entradas del sur se propagan hacia las salidas del norte y la coordenada m
se propaga hacia el norte sin incrementar. La figura 1.3 ilustra el proceso de la generación de
coordenadas. La figura A.2 del apéndice muestra el circuito generador de coordenadas de
la célula implementado para simular diseños digitales sobre Foundation de Xilinx.
Coordenada m Hacia el
Coor- vecino m,0 m,0 m,n
denada del
del oeste
OK +1
1 0
este Coor-
denada
n 1,0 1,1 1,n
+1
Al bloque de 0,0 0,1 0,n

memoria
Coordenada del sur
a) Generador de coordenadas b) Coordenadas generadas
Figura 1.3.- Generación de coordenadas para cada célula.
El circuito que genera las coordenadas es combinacional, por lo tanto, el tiempo

requerido para reconfigurar un arreglo completo es muy corto ya que depende solamente del
número de células en el arreglo y el retardo de propagación de las compuertas involucradas.
La reconfiguración de un arreglo embriónico incluye dos fases: la fase de inicialización,
donde las coordenadas son calculadas y el cromosoma (registros de configuración) es
descargado y la fase operacional, donde el arreglo realiza la función deseada. Durante la
fase de inicialización las coordenadas son ignoradas y las salidas del arreglo son
consideradas inválidas. Cada célula dentro del arreglo selecciona un registro de
configuración y las salidas se vuelven válidas.
1.2.3 Enrutador de entrada / salida
En un arreglo celular convencional la comunicación entre células está restringida a los

vecinos más próximos. Para sobrellevar esta limitación el enrutador proporciona trayectorias
adicionales para que la información pueda ser propagada hacia células no vecinas.
La figura 1.4 muestra la estructura interna del enrutador. El enrutador está formado por
cuatro selectores 4-1, uno para cada salida. Las etiquetas en negrillas representan los bits
23
de selección de cada selector y se encuentran presentes en el registro de configuración. Los

bits de configuración N1:0, S1:0, E1:0 y W1:0 ajustan la salida del selector correspondiente.
La figura A.3 del apéndice muestra el circuito del enrutador de la célula implementado para
simular diseños digitales sobre Foundation de Xilinx.
NOBUS NIBUS
N0
N1 0 2 3 1
E1 E0
Nout
WIBUS
0
1 1 EOBUS
WOBUS 3 Nout Nout 3
2 2
EIBUS
0
Nout
WO W1
2 3 1 0 S1
S0
SIBUS SOBUS
Figura 1.4.- Estructura del enrutador [Ort00b].
1.2.4 Elemento de procesamiento
El elemento de procesamiento de la célula la realiza un multiplexor 2-1, donde cada

entrada puede ser seleccionada de 8 posibles fuentes. La salida puede ser almacenada y
realimentada para realizar circuitos secuenciales. La figura 1.5 muestra la estructura interna
del elemento de procesamiento. La figura A.4 del apéndice muestra el circuito del elemento
de procesamiento de la célula implementado para simular diseños digitales sobre Foundation
de Xilinx.
Los selectores mostrados en la figura 1.5 permiten varias combinaciones de entrada-

salida, una de las cuales es seleccionada por los registros de configuración (escritos en
negrillas en la figura 1.5). Esta capacidad de selección, junto con el enrutador de
entrada/salida (Enrutador), permite la implementación de diagramas binarios de decisión
ordenados (OBDD).
24
NOBUS NIBUS CLK Nout
EOBUS
WIBUS ENRUTADOR
DE E / S
WOBUS
EIBUS
GND A0
VDD A1
A2
A3
Q
A4
A5 Z
* FF
A6 A0 A1
A1 Z Q
A7 A0 Z
L0 S0 S0 REG S0
MUX
L1 S1
L2 S2 PRINCIPAL
A0
A1
Ein A2 Z
A3
GND A0 S
VDD A1 Win
A2
A3 EBUS1:0
A4
Q A5 Z
A6
A7
R0 S0
R1 S1
R2
1 S2
Eout
Wout
SIBUS SOBUS
Sin
Figura 1.5.- Arquitectura del elemento de procesamiento de la célula [Ort00b].
Existen dos tipos de datos de entrada para este módulo: aquellos que son propagados
naturalmente y no requieren de configuración alguna (EIN, WIN, SIN, NOUT, WOUT y
EOUT); y aquellos cuya fuente y destino son seleccionados mediante el registro de
configuración y el módulo enrutador (EOBUS, EIBUS, SIBUS y SOBUS). El enrutador
permite el intercambio de información entre células no vecinas. Los prefijos N, E, W, y S
indican el vecino que está recibiendo o transmitiendo la señal correspondiente. Por ejemplo,
NOUT es la salida que va al vecino del norte, mientras que EIBUS es la entrada controlada
que viene del vecino del este.
L2:0 y R2:0 seleccionan una salida en sus multiplexores respectivos. Es posible

propagar las constante cero o uno para facilitar la implementación de los nodos finales en los
OBDD. La salida Q es realimentada a la entrada 5 de cada multiplexor 8-1, esto permite la
implementación de circuitos secuenciales. El bit REG del registro de configuración determina
si la salida del elemento de procesamiento es combinacional o secuencial. La entrada de
selección para el multiplexor principal (marcado con un asterisco en la figura 1.5) puede ser
una de cuatro señales. El valor de los bits de EBUS [1...0] del registro de configuración
25
determinan si EOBUS, EIBUS, EIN o WIN seleccionará la salida del bloque. La entrada SIN
es automáticamente propagada a través de las salidas EOUT y WOUT.
1.2.5 Registro de configuración
La figura 1.6 muestra el contenido del registro de configuración.
16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
W1:0
E1:0
S1:0
N1:0
R2:0
REG
L2:0
EBUS1:0
Figura 1.6.- Registro de configuración.
EBUS1:0.- Determina si la entrada de selección para el multiplexor principal será

EOBUS (EBUS = 0), EIBUS (EBUS = 1), EIN (EBUS = 2) o WIN (EBUS = 3).
REG.- Si el bit REG está a 1, la salida del bloque lógico es combinacional, en caso
contrario es secuencial.
N1:0, E1:0, W1:0, S1:0 .- Estos pares de bits seleccionan la entrada que será propagada
hacia las salidas NOBUS, EOBUS, WOBUS y SOBUS de los selectores del enrutador.
L2:0, R2:0.- Las entradas izquierda (L, left) y derecha (R, right) del multiplexor principal
son seleccionadas de acuerdo con los valores de estos bits. Existen ocho posibles señales
que pueden ser seleccionadas por la combinación de estos bits.
Una vez cargado el valor del registro de configuración, éste permanece sin cambios. Al
final del proceso de configuración, el contenido de la memoria de todas las células del
arreglo es el mismo. La posición de la célula dentro del arreglo es la que determina el
registro de configuración que será decodificado.
1.3 Mecanismos de reconfiguración
El problema de la tolerancia a fallas en un arreglo de procesadores de tamaño m x n

implica garantizar que siempre se tendrá un subarreglo de menor tamaño (r x k) trabajando
correctamente. La figura 1.7 ilustra estas aseveraciones.
26
Célula
Activa
m
Célula de
r repuesto
Figura 1.7.- Sistema celular con células de repuesto [Ort00b].

En la figura 1.7, las células activas son el número mínimo de células necesarias para
realizar la función deseada. Las células de repuesto están presentes, pero no contribuyen a
la operación normal del arreglo, sólo se vuelven activas cuando sustituyen a células en falla.
1.3.1 Estrategia de eliminación de una fila o una columna
En esta estrategia la falla de una célula provoca la eliminación de la fila (o columna)

correspondiente [Ort00b]. Esta es la estrategia que se adoptó para el desarrollo este trabajo.
Las células son lógicamente movidas hacia arriba haciendo uso de una fila de repuesto. La
figura 1.8 muestra un ejemplo de eliminación de una fila en un arreglo con una fila de
repuesto.
Propagación de la señal que indica una falla
30 31 32 33 30 31 32 33
coordenadas
Cálculo de
20 21 22 23 20 21 22 23
10 11 12 13 10 11 12 13
00 01 02 03 00 01 02 03
a) Arreglo completo b) Error en una célula
20 21 22 23
Célula activa
10 11 12 13
Célula de repuesto
00 01 02 03
Célula transparente
c) Error corregido
Figura 1.8.- Proceso de eliminación de una fila en un arreglo embriónico.
27
Cuando una fila es eliminada, las coordenadas de las células son recalculadas y nuevos
registros de configuración son seleccionados en cada célula. La reconfiguración se considera
concluída cuando cada célula ha seleccionado el registro de configuración que corresponde
a sus nuevas coordenadas y los flip flops han actualizado sus salidas.
Esta estrategia está muy lejos de ser óptima con respecto al uso de células de repuesto,
pero el corto tiempo de recuperación cuando ocurre una falla lo hace atractivo para
implementarlo en sistemas tolerantes a fallas de tiempo real.
1.3.2 Estrategia de eliminación de una célula
En esta estrategia, las células en falla se reemplazan en dos etapas. Primero, se

localizan repuestos en la misma fila para reemplazar a las células en falla. Cuando el número
de células que han fallado en una fila sobrepasa el número de células de repuesto en esa
fila, se elimina la fila. La figura 1.9 muestra un ejemplo con una columna y una fila de
repuesto.
13 14 15 16 13 14 15 16 13 14 15 16 9 10 11 12
9 10 11 12 9 10 11 12 9 10 11 12 5 6 7 8
5 6 7 8 5 6 7 5 6 7
1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4
Célula activa Célula de repuesto Célula inactiva (muerta)
Figura 1.9.- Tolerancia a fallas mediante la eliminación de una célula [Ort00b].
1.4 Metodología para implementar aplicaciones
1.4.1 Planteamiento del problema.
Para realizar un circuito lógico utilizando un arreglo embriónico, la descripción del

circuito debe estar dada como un conjunto de ecuaciones booleanas. Ejemplos de circuitos
que se pueden implementar son: contadores, sumadores, restadores, temporizadores,
relojes, decodificadores, circuitos de detección de error, divisores de frecuencia, etc.
28
1.4.2 Obtención de la tabla de verdad
Una vez que se tiene el problema en forma de ecuaciones booleanas, se realiza la tabla
de verdad respectiva. La tabla 1.1 muestra un ejemplo de una tabla de verdad de una
función y = f(A,B,C).
C B A y
0 0 0 0
0 0 1 1
0 1 0 0
0 1 1 1
1 0 0 0
1 0 1 1
1 1 0 1
1 1 1 1
Tabla 1.1.- Ejemplo de una tabla de verdad.
1.4.3 Obtención del diagrama binario de decisión
Un árbol o diagrama binario de decisión (BDD: Binary Decision Tree or Diagram) es la

representación gráfica de una función booleana. Los BDD encuentran diversas aplicaciones
en campos como: bases de datos [Han77], reconocimiento de patrones [Bel78], identificación
y taxonomía, diagnóstico de máquinas [Cha70] y aplicaciones de algoritmos [Wei77]. La
amplia variedad de aplicaciones, hacen que los BDD sean utilizados en campos como la
biología, ciencia computacional, teoría de la información y teoría de la conmutación.
Cada nodo no terminal (dibujado como un círculo en la figura 1.10) tiene dos líneas de
decisión. La línea dibujada en negrilla indica cuando el valor de la variable del nodo vale 1 y
la otra línea indica cuando vale cero. Cada nodo terminal (dibujado como un rectángulo en la
figura 1.10) contiene el valor de una constante (cero ó uno). Para una asignación dada de
variables, el valor proporcionado por la función es determinado trazando una trayectoria
desde el nodo superior hacia el nodo terminal, siguiendo los saltos indicados por los valores
a las variables. El valor de la función es entonces dado por el valor del nodo terminal.
29
0 1
B B
0 1 0 1
A A A A
0 1 0 1 0 1 0 1
0 1 0 1 0 1 1 1
Figura 1.10.- Árbol binario de decisión de la tabla de verdad de la tabla 1.1.
1.4.4 Simplificación de los BDD
Para facilitar la transformación de los árboles binarios de decisión en árboles de

multiplexores, es necesario realizar la simplificación de los mismos obteniendo árboles
binarios de decisión ordenados (OBDD). Para llevar a cabo la simplificación, se deben
aplicar las siguientes reglas [Ort00a]:
? Remover los nodos terminales duplicados.- Eliminar todos los nodos terminales
repetidos, menos uno a donde se deberán redirigir o
l s demás nodos terminales
eliminados. Ver figura 1.11a.
? Remover los nodos no terminales duplicados.- Si dos nodos no terminales u y v con
var(u)=var(v), tienen lo(u)=lo(v), y hi(u)=hi(v), entonces eliminar uno de los dos nodos
no terminales y redirigir todas las líneas al vértice no eliminado. Ver figura 1.11b.
? Remover nodos redundantes.- Si un nodo no terminal v tiene lo(v)=hi(v), entonces
eliminar v. Ver figura 1.11c.
El término OBDD se refiere a la máxima reducción del BDD siguiendo las reglas
anteriores.
30
Y Y Y
C C
C
1 0 1 0 1
0
B B B B B
0
1 0 1 0 0
1 0
1 A
1 1
A A A A A A
0
1 0 1 1
0
1 1 0 1 0 0 1 0
0
1 0 1 0
a) b) c)
Figura 1.11.- Reducción de un árbol de decisión en OBDD.
1.4.5 Implementación del OBDD como árbol de multiplexores
Los OBDD pueden ser implementados en hardware como árboles y redes de

multiplexores [Cer79]. En un árbol de multiplexores cada nodo no terminal interno del OBDD
se representa como un multiplexor 2-1 controlado por la variable del nodo y cada nodo
terminal se implementa como una constante (cero ó uno). Ver figura 1.12.
Out 2
1 s 0
Out 1
1 s 0
0 B Out 0
1 s 0
0 A 1
Figura 1.12.- Árbol de multiplexores del OBDD de la figura 1.11c.
La evaluación de una función entonces inicia desde los nodos terminales (constantes)
hacia el multiplexor final. Las variables de la función se usan como variables de control, las
cuales seleccionan una trayectoria única desde la parte superior hasta los nodos terminales
y el valor asignado a los nodos terminales se propaga a lo largo de la trayectoria a la salida
del multiplexor final. Ver figura 1.12. Es importante notar que el número de multiplexores
usados en una red es precisamente el número de nodos no terminales.
31
1.4.6 Enrutado del árbol de multiplexores en el Arreglo Embriónico
Una vez obtenido el árbol de multiplexores que representa la función, se necesita

trasladar la red de multiplexores a las células del arreglo embriónico, asignando un
multiplexor del árbol a cada célula. La experiencia adquirida en este trabajo ha demostrado
que este es el paso más complicado debido a la conectividad limitada de las células. La
figura 1.13 muestra el enrutado del arreglo de multiplexores de la figura 1.12 sobre un
arreglo embriónico 3x2. Solo se muestra la parte final del enrutado. En la sección 1.5 se
detalla este procedimiento mediante un ejemplo.
Y
Fila de
repuesto
0 1
A C B
Figura 1.13.- Función implementada en un arreglo embriónico.
1.5 Ejemplo: Circuito votador
Este ejemplo es un circuito combinacional que realiza la función de votador. Los

votadores son utilizados en sistemas redundantes tolerantes a fallas para comparar la salida
de los elementos replicados y de esa manera detectar y enmascarar los errores. En general
un votador recibe n entradas y genera una salida. El valor de la salida es verdadera cuando
recibe por los menos n/2 + 1 entradas verdaderas. En un votador de 3 entradas, la salida
es alta o baja si por lo menos dos de las entradas son altas o bajas respectivamente. La
tabla 1.2 muestra la tabla de verdad para esta función.
C B A y
0 0 0 0
0 0 1 0
0 1 0 0
0 1 1 1
1 0 0 0
1 0 1 1
1 1 0 1
1 1 1 1
Tabla 1.2.- Tabla de verdad del circuito votador.
32
La función lógica reducida es F(A,B,C) = AB + AC + BC. La figura 1.14 muestra el árbol

binario de decisión para este ejemplo, con su respectiva reducción (1.14c).
Y Y
C C
0 1 0 1
Y
B B B B B
0 1 0 1 0 1 0 1 0 1
A A A A A A A A A
1 0
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 0 1 0 1 1 1 0 0 0 1 1 1 0 A 1
a) BDD completo a) BDD semireducido a) OBDD final
Figura 1.14.- BDD del circuito votador.
Una vez obtenido el OBDD del circuito votador, es necesario reemplazar cada nodo del
OBDD por un multiplexor 2-1. La figura 1.15 muestra este proceso.
Out 2
0 s 1
Out 0 Out 1
0 s 1 0 s 1
0 B A A B 1
Figura 1.15.- Implementación en un árbol de multiplexores del circuito votador.

La figura 1.16 muestra la asignación de los tres multiplexores que representan el circuito
votador dentro de un arreglo embriónico.
Y
Fila de
repuesto
0 1
A C B
Figura 1.16.- Circuito votador implementado en un arreglo embriónico.
33
1.6 Resumen
En este capítulo se desarrolló el tema de los arreglos embriónicos, presentando sus

antecedentes y conceptos básicos que toman de la biología para surgir como línea de
investigación. También se describió la arquitectura utilizada para llevar a cabo la presente
tesis. Se describieron dos tipos de reconfiguración de células de un arreglo embriónico en
caso de ocurrir una falla. Se incluyó una sección donde se dió a conocer el procedimiento
necesario para realizar aplicaciones en un arreglo embriónico. Se describió la forma de
utilizar un arreglo embriónico mediante el ejemplo sencillo de un circuito votador.
34
CAPÍTULO II
2. ALGORITMOS GENETICOS Y ENRUTADORES
Este capítulo presenta en la sección 2.1 los antecedentes y aplicaciones de

los algoritmos genéticos. La sección 2.2 describe el funcionamiento general
de los algoritmos genéticos así como las partes que constituyen a un
algoritmo genético común. La sección 2.3 trata sobre enrutadores, dando a
conocer su definición, una clasificación y sus aplicaciones. También muestra
un panorama del problema de enrutar dos o más elementos de un sistema
que opera en forma conjunta y presenta la propuesta de enrutar a los
arreglos embriónicos mediante los algoritmos genéticos.
2.1 Introducción
2.1.1 Antecedentes
Durante los últimos 30 años ha habido un crecimiento en el interés por resolver

problemas utilizando sistemas basados en los principios de la evolución y la herencia. Tales
sistemas mantienen una población de soluciones potenciales a las cuales se les aplica un
proceso de selección basado en la aptitud de los individuos, además de algunos operadores
genéticos. Un tipo de estos sistemas lo constituyen las estrategias evolutivas, que son
algoritmos que imitan los principios de la evolución natural para solucionar problemas de
optimización [Rec73][Sch81]. La programación evolutiva de Fogel [Fog66] es una técnica de
búsqueda en un espacio de pequeñas máquinas de estado finito. Otro tipo de sistemas
basados en la evolución son los algoritmos genéticos de Holland [Hol92].
CAPÍTULO II Algoritmos genéticos y enrutadores
En la naturaleza, las estructuras biológicas que son más exitosas en adaptarse al

ambiente, sobreviven y se reproducen en una proporción más alta. Los biólogos interpretan
las estructuras que ellos observan como una consecuencia natural de la selección
darwiniana operando en un medio ambiente durante un período de tiempo. En la naturaleza,
la creación de una estructura está determinada por mecanismos tales como la selección
natural y los efectos creativos de la recombinación sexual (cruza genética) y mutación. John
Holland, un investigador de la Universidad de Michigan, impresionado por los
descubrimientos de los genetistas desarrolló a finales de los años sesenta una técnica que
permitió adaptarlos a una computadora, su sueño era lograr que las computadoras
aprendieran por sí mismas.Los algoritmos genéticos de Holland son una herramienta muy
poderosa de optimización que realiza una búsqueda paralela de soluciones satisfactorias a
un problema dado. Es muy utilizada para resolver problemas cuyo espacio de búsqueda es
muy grande. Son algoritmos muy rápidos y poderosos debido a su capacidad de
procesamiento. La búsqueda paralela que realizan les permite no caer en un máximo o
mínimo local, si se está maximizando o minimizando, respectivamente. Es importante
mencionar que los algoritmos genéticos son poderosos pero existe una pequeña
probabilidad de no encontrar el máximo o mínimo total buscado [Zbi96].
Los algoritmos genéticos tratan de emular el proceso de selección natural al generar

una población de individuos virtuales representados por bits y someterlos a un medio
ambiente (función de aptitud) durante un periodo de tiempo (ciclos computacionales). La
función de aptitud es básicamente una función matemática que discrimina a aquellos
individuos lejanos a una solución deseada y favorece el crecimiento de aquellos que se
encuentran cerca de ella. Los algoritmos genéticos requieren de un enorme poder de
procesamiento, pero pueden suministrar soluciones a problemas que no sabemos como
resolver o no sabemos resolver rápidamente. Los algoritmos genéticos también nos permiten
obtener soluciones a problemas que no pueden ser resueltos de manera directa, analítica o
algorítmicamente.
2.1.2 Aplicaciones
Debido a las características atractivas que poseen y por su funcionamiento en paralelo,

los algoritmos genéticos están siendo ampliamente utilizados en la solución de problemas de
optimización y búsqueda. Existen diversas aplicaciones prácticas como por ejemplo,
enrutamiento de canales de comunicación o redes [Ahn95, Lie96, Göc96, You01],
enrutamiento de componentes electrónicos para el diseño de circuitos impresos [Wol96,
36
Mil99, Sch95, Man97, Sin01], determinación de la ruta más corta [Ina01], solución de
problemas matemáticos [Zbi96], solución del problema del agente viajero [Zbi96], etc.
2.2 Funcionamiento de los Algoritmos Genéticos
La forma de operar de los algoritmos genéticos es mediante la generación aleatoria de

posibles soluciones a un problema determinado (población de individuos virtuales), donde
estas soluciones son codificadas mediante cadenas de caracteres binarios o decim ales,
denominados cromosomas (a este proceso se le conoce como representación del problema).
En la población generada se realiza la evaluación de cada individuo para determinar su

aptitud (capacidad para resolver el problema dado), para posteriormente realizar con esta
evaluación una discriminación a favor de los individuos más aptos. El proceso de selección
se puede realizar de diversas formas, de esta manera se permite la utilización de los
individuos creados. Después de la selección se realiza la reproducción entre los individuos
seleccionados mediante la cruza (apareamiento de dos individuos) y la mutación (cambio de
un caracter aleatorio dentro de un individuo) para producir a la siguiente generación de
individuos virtuales.
Este proceso se lleva a cabo de manera cíclica hasta satisfacer la función de aptitud
requerida, que se encarga de medir el proceso de aproximación a la solución final. La figura
2.1 muestra el funcionamiento básico de un algoritmo genético.
Generar la ¿Se ha cumplido Si Mejor

Evaluación Selección el criterio de
población inicial indiviudo
optimización?
No
Inicio
Resultado
Cruza
Generar nueva
población
Mutación
Figura 2.1.- Funcionamiento básico de un algoritmo genético.
37
2.2.1 Representación del problema
Tal vez la parte más difícil de todo problema sea su representación en términos de los
parámetros necesarios para poder solucionarlos mediante los algoritmos genéticos. Resulta
indispensable dedicar la suficiente atención para plantear la representación del problema en
forma de cromosomas (cadenas de caracteres) de tal forma que dichos cromosomas
representen en realidad la solución del problema.
Es necesario que los cromosomas definidos representen posibles soluciones al

problema para poder ser manipulados correctamente por el algoritmo genético. A
continuación se presentan tres ejemplos de la representación de cromosomas (individuos
virtuales) en forma de cadenas de caracteres:
? En forma binaria: 11001010100111101.

? En forma decimal: 1233534556958874.
? Combinación de letras y números decimales: 3CD4YT5DF6KJ3JKE.
La representación dependerá del tipo de problema a solucionar. Para algunos

problemas será más oportuno y práctico utilizar la primera representación, en otros no tanto.
2.2.2 Evaluación
Consiste en determinar el valor potencial (aptitud) de cada cromosoma generado

aleatoriamente, mediante la función que lo relaciona con el problema a solucionar. Por
ejemplo si se requiere solucionar la ecuación: f(x) = x² + 2x + 3 = 0, entonces cada valor
codificado de x se sustituirá en la función para determinar su valor. En la evaluación se
determina el valor de aptitud de cada cromosoma.
2.2.3 Selección
La selección determina a los cromosomas padres que generarán a la siguiente

generación de cromosomas. Es de vital importancia determinar el mejor método de selección
de acuerdo con el problema dado. Existen diversas técnicas para realizar la selección de
individuos, a continuación se listan las más comunes:
? Selección por rueda de la ruleta [Gol89].- Se calcula la probabilidad de selección

(Ps) de cada cromosoma con respecto al total de cromosomas de la población. Se
obtiene una probabilidad acumulativa (Pa) para cada cromosoma de la siguiente
manera: para el primer cromosoma su Pa es igual a su Ps porque es el primer
38
cromosoma y para el último cromosoma su Pa es igual a la suma de todas las Ps de

los cromosomas calculados anteriormente. Se genera un número r entre 0 y 1 en
forma aleatoria. Se busca un cromosoma i con una Pa tal que r < Pai entonces ese
cromosoma es seleccionado como padre.
? Selección por torneo [Bli95].- En este tipo de selección se toman a dos cromosomas
de la población en forma aleatoria. Se comparan las aptitudes de los dos
crosomomas y el que resulte tener la mejor aptitud será el cromosoma seleccionado
como padre.
? Selección por rango [Bak85].- Los cromosomas son tomados proporcionalmente de
acuerdo a su taza de rango proporcionada por la evaluación actual. Este método se
basa en la creencia de que una causa común de la convergencia rápida (prematura)
es la presencia de superindividuos que son mucho mejores que la aptitud promedio
de la problación. Tales superindividuos generan un gran número de descendientes
(hijos) y evitan que otros individuos contribuyan a la formación de descendientes para
las siguientes generaciones. En pocas generaciones un superindividuo puede no
considerar material cromosómico deseable y aún así causar una convergencia rápida
al óptimo (posiblemente local).
2.2.4 Función de aptitud
La función de aptitud sirve para medir la aproximación de un cromosoma hacia la

solución del problema planteado. De esta manera la función de aptitud proporciona un índice
de desempeño de la cadena de caracteres. Es importante plantear correctamente la función
de aptitud porque de ella dependerá la convergencia del problema hacia una mejor solución
en cada generación.
Satisfacer la función de aptitud puede ser uno de los criterios de paro en el ciclo de
búsqueda de los algoritmos genéticos; al obtener la aptitud requerida por el problema el ciclo
se rompe. Otro criterio de paro puede ser al concluir un número determinado de ciclos en el
programa del algoritmo genético. Este trabajo combina los dos criterios de paro antes
mencionados.
2.2.5 Cruza
Este operador genético consiste en aparear dos cromosomas seleccionados

(cromosomas padres) a través del intercambio de algunos de sus elementos para generar
dos nuevos cromosomas (cromosomas hijos) de la siguiente generación. A continuación se
39
muestra un ejemplo donde se obtienen dos nuevos cromosomas (A’ y B’) a partir de dos
cromosomas padres (A y B):
Padres: A = 110010010110 y B = 001101011010

Partición: A = 110010 010110 y B = 001101 011010
Hijos: A’ = 110010011010 y B’ = 001101010110
2.2.6 Mutación
La mutación es otro operador genético, para representaciones binarias consiste en

tomar aleatoriamente un bit de un cromosoma seleccionado y negarlo, es decir, si es 1
convertirlo en 0 y viceversa. La probabilidad con que se realiza la mutación varía
dependiendo de la aplicación, pero de manera común se propone de 0.001 [Paz99]. A
continuación se muestra el proceso de mutación:
Antes de la mutación: 110010010011.

Después de la mutación: 110011010011.
La mutación es importante ya que permite explorar otras regiones del espacio de

búsqueda.
2.3 Enrutadores
2.3.1 Definición de enrutador
Un enrutador es una herramienta que permite conectar diversos puntos (nodos o

terminales) entre sí, de tal manera que puedan interactuar para poder realizar una actividad,
cumpliendo con los requerimientos de enlace y comunicación planteados [Ron98, Tan97,
Ahn95].
Los enrutadores se clasifican principalmente en dos grandes grupos. El primer grupo

engloba a los enrutadores comúnmente usados en la Internet, lo forman computadoras
especializadas que mandan mensajes a través de paquetes de datos llamados datagramas a
diferentes puntos del mundo a través de diversas trayectorias de enrutamiento. Este tipo de
enrutador es muy conocido por los expertos en la transmisión de datos a través de redes de
computadoras [Tan97].
El segundo grupo comprende la aplicación de diversas herramientas de programación

utilizadas para enrutar, entre las cuales podemos mencionar a los algoritmos genéticos,
programación entera, programación evolutiva, recocidos simulados, algoritmos
40
evolucionarios, entre otros. Estas herramientas se utilizan genéricamente en la búsqueda y

optimización de soluciones a problemas tales como: localización de células [Ars96],
enrutamiento de canales [Ahn95, Lie96, Göc96, You01], procesamiento de señales basados
en circuitos VLSI [Sch95, Sin01], optimización de problemas matemáticos [Zbi96], etc.
2.3.2 El problema de enrutar
La solución al problema de conectar dos nodos tal vez resulte muy trivial, pero a medida
que el número de nodos crece, al igual que la complejidad de su ubicación, el problema se
vuelve mucho más complicado. Por tal motivo se hace necesaria la utilización de
herramientas que faciliten alcanzar el objetivo fijado.
Los problemas de enrutamiento requieren encontrar una trayectoria que satisfaga las
condiciones del problema bajo prueba. Encontrar trayectorias libres de problemas de
enrutamiento en dos dimensiones implica la determinación de una trayectoria en el plano que
optimice un conjunto de criterios.
El problema de conectar un número de puntos es muy común encontrarlo en el diseño

de circuitos VLSI, en problemas de optimización como el del agente viajero [Zbi96] (ver figura
2.2), en la conectividad de células procesadoras, diseño de redes y sistemas de
computadoras, entre otras aplicaciones.
Figura 2.2.- Representación gráfica de la solución del problema del agente viajero.
Diseñar un programa o mecanismo que permita resolver el enrutado deseado, necesita

del delicado planteamiento de las condiciones y requerimientos especiales del enrutado
mismo para poder lograr la conectividad.
Una representación correcta del problema es importante para determinar y seleccionar

la herramienta que lo resuelva, porque dependiendo del problema se deberá seleccionar el
método más adecuado.
41
Una vez que se ha descrito perfectamente el problema de enrutamiento y se ha

seleccionado el método de solución, se debe realizar la programación de la herramienta. El
programa propuesto deberá resolver el problema de enrutamiento de manera efectiva al
satisfaciendo los requerimientos especiales establecidos.
2.3.3 Enrutamiento usando algoritmos genéticos
En problemas de enrutamiento utilizando algoritmos genéticos cada cromosoma de la

población representa una posible solución al problema. La representación de los
cromosomas como cadena de caracteres debe incluir la información necesaria que permita
manejar adecuadamente los parámetros y condiciones del enrutamiento deseado. La función
de aptitud debe estar encaminada hacia la obtención del mejor enrutamiento (ruta más corta
o conexión de todos los elementos) mediante la evaluación de cada cromosoma. La
aplicación del proceso de selección y de los operadores genéticos (cruza y mutación) a los
posibles enrutados hace que la búsqueda de la solución sea más eficiente porque explora en
paralelo diferentes regiones del espacio de búsqueda.
Durante los últimos años los algoritmos genéticos han sido muy utilizados para realizar
búsquedas, optimización y creación de máquinas que puedan aprender. En muchas áreas
resultan muy superiores a las técnicas clásicas de optimización [Göc96].
Los algoritmos genéticos han sido satisfactoriamente aplicados a problemas duros y

recientemente se han usado como herramienta de optimización en el Diseño Asistido por
Computadora (CAD: Computer Aided Design), en aplicaciones tales como localización,
generación de patrones de prueba y síntesis lógica. Frecuentemente los algoritmos
genéticos se usan en combinación con otras técnicas que explotan el conocimiento de
problemas específicos. Los algoritmos genéticos resultantes son llamados algoritmos
genéticos Híbridos (HGA) y sus operadores genéticos (cruza y mutación) son establecidos
de acuerdo con las características del problema específico [Göc96].
Los registros de configuración de las células embriónicas presentados en el capítulo 1

forman la memoria del arreglo embriónico. Esta memoria determina el enrutamiento interno y
funcionamiento de cada célula dentro del arreglo. La facilidad de trasladar estos registros de
configuración en cromosomas que representen una solución al problema de enrutamiento de
los arreglos embriónicos hace atractivo el uso de los algoritmos genéticos [Ort00b].
Agregando a lo anterior las eficientes propiedades que poseen los algoritmos genéticos
42
descritos en este capítulo se han elegido para realizar el enrutamiento de los arreglos
embriónicos.
2.4 Resumen
Este capítulo fue dedicado a la descripción detallada de los algoritmos genéticos dando
a conocer sus antecedentes, propiedades y aplicaciones. Se describió el funcionamiento
básico de cada elemento de los algoritmos genéticos como son: representación del
problema, evaluación, selección, función de aptitud y los operadores genéticos (cruza y
mutación). Se describió el concepto de enrutador y se planteó la dificultad de enrutar
diversos elementos. Por último se propuso resolver el problema de enrutamiento mediante el
uso de los algoritmos genéticos.
43
CAPÍTULO III
3. ENRUTADOR PROPUESTO
Este capítulo presenta el desarrollo del algoritmo genético que resuelve el

enrutado de los arreglos embriónicos. En la sección 3.2 se describe la
representación de la conectividad entre células del arreglo embriónico. En la
sección 3.3 se muestra la manera de implementar cada elemento del
algoritmo genético. En el apartado 3.4 se presenta la implementación del
algoritmo genético utilizando el lenguaje de programación C.
3.1 Representación de la conectividad entre células del Arreglo Embriónico
Para explicar la representación de la conectividad entre células del arreglo embriónico

(AE), se utilizará como ejemplo el circuito votador presentado en el capítulo 2. Su tabla de
verdad se encuentra en la tabla 3.1 y su árbol de multiplexores en la figura 3.1.
C B A y
y
0 0 0 0
0 0 1 0 Out 2
0 s 1 MUX 0 MUX 1 MUX 2
0 1 0 0
Nout y1 y2 y
0 1 1 1 C Sel B B C
y1 y2
1 0 0 0 R(1) A 1 y2
Out 0 Out 1
1 0 1 1 0 s 1 0 s 1
L(0) 0 A y1
1 1 0 0
0 B A A B 1
1 1 1 1 Tabla 3.2.- Entradas fuentes del
circuito votador.
Tabla 3.1.- Tabla de Figura 3.1.- Árbol de
verdad del circuito multiplexores del votador.
votador.
CAPÍTULO III Enrutador propuesto
El circuito votador se ha enrutado en un AE de tamaño 2x3 (2 filas y 3 columnas). La

figura 3.2 muestra el enrutado obtenido, del cual se describen los siguientes aspectos:
? Existen dos tipos de conexiones: las que se programan en el registro de configuración,

denominadas buses (conexiones con líneas punteadas) y las que no se programan,
llamadas naturales por conectarse sin necesidad de ser programadas (conexiones con
líneas sólidas). Ambos tipos de conexiones no pueden mezclarse, con excepción de la
salida Nout (Salida del elemento de procesamiento).
? Las etiquetas con terminación “OBUS” (Output Bus = Bus de salida) indican una salida
del enrutador de la célula. La señal que se propaga en cada salida del bus puede
provenir de cuatro fuentes diferentes (las tres entradas que tienen diferente dirección que
la salida y Nout), ver figura 3.3. Estas salidas “OBUS” propagan sus variables hacia sus
células vecinas correspondientes.
NOB NIB Nout NOB NIB Nout NOB NIB Nout
Win Eo Win Eo Win Eo
Wo Ein Wo Ein Wo Ein
WIB 10 EOB WIB 11 EOB WIB 12 EOB
WOB EIB WOB EIB WOB EIB
SIB SOB Sin SIB SOB Sin SIB SOB Sin
NOB NIB Nout NOB NIB Nout NOB NIB Nout
Win Eo Win Eo Win Eo
Wo Ein Wo Ein Wo Ein
WIB 00 EOB WIB 01 EOB WIB 02 EOB
SIB SOB Sin SIB SOB Sin SIB SOB Sin
A B C
Figura 3.2.- Conectividad de un Arreglo Embriónico de tamaño 2x3.
? Las etiquetas con terminación “IBUS” (Input Bus = Bus de entrada) indican una entrada
hacia el enrutador de la célula. Estas entradas provienen de las terminales OBUS de las
células vecinas correspondientes.
? La salida Nout puede ser propagada hacia cualquier punto cardinal del enrutador.
También se conecta con la entrada natural del sur Sin de la célula vecina del norte.
45
? Sin se propaga de manera directa hacia las salidas naturales este (Eo) y oeste (Wo) de
la misma célula. Estas son las conexiones en líneas sólidas de la figura 3.2.
? Las entradas naturales del este (Ein) y oeste (Win) de una célula provienen de las
células vecinas, de las salidas Wo y Eo respectivamente.
? Las variables de entrada para el árbol de multiplexores sólo pueden introducirse en el

lado sur del arreglo, a través de las entradas SIB y Sin de cada célula colocada en la fila
inferior del AE.
? Cada célula puede tener diferente enrutado. Existen 256 maneras de enrutado que se
pueden realizar con el enrutador de E/S ya que es programado por los 8 bits menos
significativo del registro de configuración. Cada posibilidad puede habilitar solo cuatro
conexiones para cada enrutado. Existen dos conexiones naturales que no se programan:
la entrada de Sin propagada hacia Wo y Eo pero formana parte de la conectividad de la
célula.
NOBUS NIBUS
N0
N1 0 2 3 1
E1 E0
Nout
WIBUS
0
1 1 EOBUS
WOBUS 3 Nout Nout 3
2 2
EIBUS
0
Nout
WO W1
2 3 1 0 S1
S0
SIBUS SOBUS
Figura 3.3.- Enrutador de E/S de una célula.
La necesidad de representar la conectividad entre células surge del problema de realizar

la propagación de las variables de entrada del árbol de multiplexores a través de las
conexiones (enrutado) del AE. De esta manera se podrá efectuar la evaluación de los
enrutados propuestos durante la ejecución del algoritmo genético.
La tabla 3.3 contiene la información que describe todas las conexiones posibles dentro
de cada célula. Esta tabla sirve para llevar el control de la propagación de las variables de
entrada del árbol de multiplexores del circuito votador de la figura 3.1 (o cualquier otra
aplicación) a través de las conexiones válidas de cada célula.
46
00 01 02 10 11 12
S-N
00
01 E-N
10 W-N
11
No-N
N-S
00
01 E-S
10 W-S
11
No-S
W-E
00
01 N-E
10 S-E
11
No-E
E-W
00
01 N-W
10 S-W
11
No-W
Sin=Wo=Eo
Ein
Win
Nout
Sel
R (1)
L (0)
Tabla 3.3.- Matriz que representa la conectividad del AE de la figura 3.2.
La descripción de los elementos de la tabla 3.3 se encuentra a continuación. El AE de la

figura 3.2 se tomará como ejemplo para llenar la matriz:
? Cada par de columnas contienen la información de la célula referenciada en la parte

superior de la matriz.
? Las etiquetas en negrillas representan las 16 posibles conexiones de entrada-salida del
enrutador interno de cada célula. Donde N = norte, S = sur, E = este, W = oeste y No =
Nout. Solamente cuatro combinaciones de E/S pueden ser válidas. Si la etiqueta está
antes del guión es fuente (entrada), si está después es destino (salida).
? Las siguientes cuatro etiquetas (Sin = Wo = Eo, Ein, Win, Nout) representan las
entradas y salidas naturales de la célula y éstas no se programan.
? Las últimas tres etiquetas (Sel, R(1) y L(0)) hacen referencia a las entradas del
multiplexor principal que se encuentra dentro de cada célula del arreglo.
47
3.2 Llenado de la matriz de conectividad
3.2.1 Decodificación de los bits correspondientes al enrutador de E/S
Se decodifican los 8 bits menos significativos del registro de configuración (figura 3.4)
que corresponde a los 4 pares de bits que definen la salida de cada multiplexor 4-1 del
enrutador (figura 3.3). La tabla 3.4 muestra las 16 conexiones posibles (etiquetadas en
negrillas) divididas en grupos de cuatro. Se colocará una bandera de “1” para señalar la
conexión que es válida de acuerdo con la decodificación de los bits del enrutador de E/S.
16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
W1:0
E1:0 Enrutador
S1:0 de E/S
N1:0
R2:0 Definen las entradas
REG del Mux de
L2:0 procesamiento
EBUS1:0
Figura 3.4.- Registro de configuración de una célula embriónica.

00 01 02 10 11 12
S-N 1 1 1
00
01 E-N 1 1
10 W-N
11
No-N 1
N-S 1 1 1
00
01 E-S 1
10
W-S 1 1
11
No-S
W-E 1 1 1
00
01 N-E 1
10
S-E 1 1
11
No-E
E-W 1 1 1
00
01 N-W 1
10
S-W 1 1
11
No-W
Sin=Wo=Eo
Ein
Win
Nout
Sel
R (1)
L (0)
Tabla 3.4.- Decodificación de los bits correspondientes al enrutador de E/S.
48
En la célula 00, la entrada SIBUS está conectada con la salida NOBUS (S-N = 1), la
entrada EIBUS está conectada con la salida SOBUS (E-S = 1), la entrada WIBUS está
conectada con la salida EOBUS (W-E = 1) y la entrada NIBUS está conectada con la salida
WOBUS (N-W = 1). Ver las celdas sombreadas de la tabla 3.4.
En la célula 11, la entrada Nout está conectada con la salida NOBUS (No-N = 1), la
entrada WIBUS está conectada con la salida SOBUS (W-S = 1), la entrada SIBUS está
conectada con la salida EOBUS (S-E = 1) y la entrada EIBUS está conectada con la salida
WOBUS (E-W = 1).
3.2.2 Cargar variables de entrada de la aplicación
Las entradas al AE sólo se pueden recibir en la fila 0 a través de las entradas SIB y Sin
de cada célula. En la figura 3.2 se observa la colocación de las tres variables de entrada (A,
B y C). Se llena la columna de variables en la tabla 3.5 de la siguiente manera: la variable “A”
se introduce por el SIB de la célula 01, entonces se coloca dicha letra en cada una de las
salidas a donde puede ser direccionada la entrada SIB por el enrutador de E/S (S-N, S-E y
S-W).
00 01 02 10 11 12
00 S-N 1 A C 1 1
01 E-N 1 1
10 W-N
11
No-N 1
00 N-S 1 1 1
01 E-S 1
10 W-S 1 1
11
No-S
00 W-E 1 1 1
01 N-E 1
10 S-E 1 A C 1
11
No-E
00 E-W 1 1 1
01 N-W 1
10 S-W 1 A 1 C
11
No-W
Sin=Wo=Eo B
Ein
Win
Nout X00 X01 X02 X10 X11 X12
Sel
R (1)
L (0)
Tabla 3.5.- Carga de variables de entrada al AE.
49
Las letras cargadas en S-E y S-W de la célula 01 (casillas sombreadas) pueden ser
propagada porque la conexión de esas combinaciones han sido seleccionadas (indicada por
el 1 en la casilla de la izquierda). La variable “B” se introduce por Sin de la célula 01, y se
propaga automáticamente al Wo y Eo de la misma célula. La variable “C” se introduce por la
entrada SIB de la célula 02. A las salidas de los elementos de procesamiento (Nout) se les
carga una etiqueta de identificación xi,j, porque aun no se sabe si proporcionan una salida
útil.
3.2.3 Propagación de las variables
La propagación de las variables a través de las células del AE se realiza de izquierda a

derecha y de abajo hacia arriba. En el ejemplo de la figura 3.2 la propagación lleva la
siguiente secuencia de células: 00, 01, 02, 10, 11 y 12. La propagación de las señales
consiste en colocar la variable correspondiente en cada casilla habilitada, tomando la
variable de la salida de la célula vecina. Las variables podrán ser propagadas a través de las
conexiones habilitadas con la bandera de “1”.
a) Primera propagación:
En la célula 00, la conexión S-N toma su valor de SIB de esta misma célula por
portenecer a la fila 0, en este caso debe contener un cero (0) ya que la entrada SIB sirve
para introducir las variables de entrada y por esa entrada no se introduce ninguna variable
(ver figura 3.2). La conexión E-S toma su valor de la salida oeste (WOB) de la célula 01
(casilla sombreada), en este caso le corresponde la letra A. La conexión W-E no está
conectada con ninguna célula por la entrada oeste (WIB), por ese lado solo se introducen
ceros, por lo tanto esa casilla contiene un cero. La conexión N-W toma su valor de la salida
sur (SOB) de la célula 10, como la célula 10 aún no ha sido propagada sus variables
(casillas sombreadas vacías), esta casilla (N-W) queda vacía en esta primera propagación.
Para las entradas naturales: la entrada Sin depende del valor cargado en esa entrada, en
este caso no existe variable de entrada por lo que se coloca un cero. Ein toma su valor de la
salida natural del oeste (Sin=Wo=Eo) de la célula 01, en este caso su valor es la letra B.
Win no tiene conexión con ninguna célula, por lo cual su valor es cero. Ver figura 3.6a.
En la célula 01, la conexión E-N toma su valor de la salida oeste (WOB) de la célula 02,
por lo tanto le corresponde la letra C a esta casilla. La conexión N-S toma su valor de la
salida sur (SOB) de la célula 11, como la célula 11 aún no ha sido propagada, esta casilla
permanece vacía. La conexión S-E toma su valor SIB de esta misma célula, en este caso
50
debe contener la letra A ya que por SIB se introduce la variable A. La conexión S-W toma su
valor de SIB de esta misma célula, en este caso debe contener la letra A ya que por SIB se
introduce la variable A. Para las entradas naturales: la entrada Sin depende del valor
cargado en esa entrada, en este caso la variable de entrada es la letra B. Ein toma su valor
de la salida natural del oeste (Sin=Wo=Eo) de la célula 02, por lo tanto su valor es cero
porque no se introdujo ninguna variable de entrada por ahí. Win toma su valor de la salida
natural del este (Sin=Wo=Eo) de la célula 00, por lo tanto su valor es cero porque no se
introdujo ninguna variable de entrada por Sin. Ver figura 3.6b.
00 01 02 10 00 01 02 10
S-N 1 0 1 S-N 1 0 1
00 00
01 E-N 1 1 01 E-N 1 C 1
10 W-N 10 W-N
11 11
No-N No-N
N-S 1 1 N-S 1 1
00 00
01 E-S 1 A 01 E-S 1 A
10 W-S 1 10 W-S 1
11 11
No-S No-S
W-E 1 0 1 W-E 1 0 1
00 00
01 N-E 1 01 N-E 1
10 S-E 1 A 10 S-E 1 A
11 11
No-E No-E
E-W 1 E-W 1
00 00
01 N-W 1 01 N-W 1
10 S-W 1 A 1 C 10 S-W 1 A 1 C
11 11
No-W No-W
Sin=Wo=Eo 0 B Sin=Wo=Eo 0 B
Ein B Ein B 0
Win 0 Win 0 0
Nout X00 X01 X02 X10 Nout X00 X01 X02 X10
Sel Sel
R (1) R (1)
L (0) L (0)
a) b)
Tabla 3.6.- Propagación parcial de las variables del AE.
La propagación de las células restantes se realiza de manera similar a las células 00 y

01. Se puede notar que en una propagación no se puede realizar el llenado completo de la
tabla con las conexiones de los buses (ver casillas en color gris en la tabla 3.7), porque al
momento de actualizar una célula existen células posteriores que aun no han sido
51
propagadas (por ejemplo el caso de la célula 00). La tabla 3.7 muestra la propagación de
todas las células del AE en una primera pasada.
00 01 02 10 11 12
00 S-N 1 0 1 0 1 0
01 E-N 1 C 1 0
10 W-N
11
No-N 1 X11
00 N-S 1 0 1 0 1 0
01 E-S 1 A
10 W-S 1 A 1 0
11
No-S
00 W-E 1 0 1 0 1 C
01 N-E 1
10 S-E 1 A 1 C
11
No-E
00 E-W 1 1 1 0
01 N-W 1
10 S-W 1 A 1 C
11
No-W
Sin=Wo=Eo 0 B 0 X00 X01 X02
Ein B 0 0 X01 X02 0
Win 0 0 B 0 X00 X01
Nout X00 X01 X02 X10 X11 X12
Sel
R (1)
L (0)
Tabla 3.7.- Propagación de las variables, primera pasada.
b) Segunda propagación:
En esta segunda propagación solo se buscan las casillas que aún se encuentran vacías.
En la tabla 3.7 se observa que la conexión N-W de la célula 00 está vacía, toma su valor de
la salida sur (SOB) de la célula 10, ahora ya está actualizado esa casilla (cuadro sombreado
de la tabla 3.8), y su valor equivalente es cero. La conexión E-W de la célula 10 también se
encuentra vacía, toma su valor de la salida oeste (WOB) de la célula 11, pero esta casilla de
esta célula se encuentra vacía, entonces no se puede llenar aun esta conexión. La conexión
E-W de la célula 11 se encuentra vacía, toma su valor de la salida oeste (WOB) de la célula
12, en este caso su valor será de cero.
Se puede observar en la tabla 3.8 que en la segunda propagación de las variables de

entrada, solo falta llenar una conexión, por lo cual requerirá una tercera propagación para
completar la tabla. El proceso de llenado puede necesitar varias propagaciones para
completar todas las casillas habilitadas. La tabla 3.9 muestra el proceso terminado.
52
00 01 02 10 11 12
00 S-N 1 0 1 0 1 0
01 E-N 1 C 1 0
10 W-N
11
No-N 1 X11
00 N-S 1 0 1 0 1 0
01 E-S 1 A
10 W-S 1 A 1 0
11
No-S
00 W-E 1 0 1 0 1 C
01 N-E 1
10 S-E 1 A 1 C
11
No-E
00 E-W 1 1 0 1 0
01 N-W 1 0
10 S-W 1 A 1 C
11
No-W
Ein B 0 0 X01 X02 0
Win 0 0 B 0 X00 X01
Nout X00 X01 X02 X10 X11 X12
Sel
R (1)
L (0)
Tabla 3.8.- Propagación de las variables, segunda pasada.

00 01 02 10 11 12
00 S-N 1 0 1 0 1 0
01 E-N 1 C 1 0
10 W-N
11
No-N 1 X11
00 N-S 1 0 1 0 1 0
01 E-S 1 A
10 W-S 1 A 1 0
11
No-S
00 W-E 1 0 1 0 1 C
01 N-E 1
10 S-E 1 A 1 C
11
No-E
00 E-W 1 0 1 0 1 0
01 N-W 1 0
10 S-W 1 A 1 C
11
No-W
Ein B 0 0 X01 X02 0
Win 0 0 B 0 X00 X01
Nout X00 X01 X02 X10 X11 X12
Sel
R (1)
L (0)
Tabla 3.9.- Propagación completa de las variables.
53
3.2.4 Llenado de las entradas del elemento de procesamiento
Se realiza decodificando ocho de los nueves bits más significativos del registro de
configuración (figura 3.4). El elemento de procesamiento principal es un multiplexor 2-1,
donde cada una de sus entradas (A0 y A1) es seleccionada de 8 diferentes fuentes y a su
vez la entrada de selección (S0) puede ser seleccionada de cuatro diferentes fuentes (figura
3.5). Se sigue el mismo ejemplo del capítulo para el llenado de la tabla 3.10.
NOBUS NIBUS CLK Nout
EOBUS
WIBUS ENRUTADOR
DE E / S
WOBUS
EIBUS
GND A0
VDD A1
A2
A3
Q
A4
A5
* FF
Z A0 A1
A6 Q
A7 A1 Z A0 Z
L0 S0 S0 REG S0
L1 MUX
S1
L2 S2 PRINCIPAL
A0
A1
Ein A2 Z
A3
GND A0 S
VDD A1 Win
A2
A3 EBUS1:0
A4
Q A5
A6 Z
A7
R0 S0
R1 S1
R2
1 S2
Eout
Wout
SIBUS SOBUS
Sin
Figura 3.5.- Elemento de procesamiento.
L2:0/R2:0
EBUS 000 0
00 EOB 001 1
01 EIB 010 Sin
10 Ein 011 Ein
11 Win 100 Win
101 Q
(a) 110 SIB
111 SOB
(b)
Tabla 3.10.- Significado de las entradas del registro de configuración.
54
a) Para la célula 00, su registro de configuración es:
EBUS R2:0 REG L2:0 N S E W

1 0 1 1 1 0 0 0 0 0 0 0 1 0 0 0 1
Los bits de EBUS indican la señal que se tomará como entrada de selección (Sel), en
este caso tiene el valor binario de “10” y de acuerdo con la tabla 3.10a le corresponde la
variable presente en la entrada Ein, entonces de la tabla 3.11 se toma el valor de Ein (“B”) y
se carga al campo “Sel” de la célula 00 de la misma tabla. La entrada uno (Right) vale “111”
y corresponde al valor de la salida SOB según la tabla 3.10b, por lo tanto el valor de la
entrada uno es “A”. La entrada cero (Left) vale “000” y corresponde al valor la constante cero
(0) según la tabla 3.10b, por lo tanto el valor de la entrada cero es “0”. Ver celdas
sombreadas de la tabla 3.11.
00 01 02 10 11 12
00 S-N 1 0 1 0 1 0
01 E-N 1 C 1 0
10 W-N
11
No-N 1 X11
00 N-S 1 0 1 0 1 0
01 E-S 1 A
10 W-S 1 A 1 0
11
No-S
00 W-E 1 0 1 0 1 C
01 N-E 1 0
10 S-E 1 A 1 C
11
No-E
00 E-W 1 0 1 0 1 0
01 N-W 1 0
10 S-W 1 A 1 C
11
No-W
Ein B 0 0 X01 X02 0
Win 0 0 B 0 X00 X01
Nout X00 X01 X02 X10 X11 X12
Sel B C B X01 C 0
R (1) A 1 1 1 X02 1
L (0) 0 1 A 1 X00 1
Tabla 3.11.- Llenado de las entradas del elemento de procesamiento.
b) Para la célula 01, su registro de configuración es:

0 1 0 0 1 0 0 0 1 0 1 0 0 1 0 1 0
La selección (EBUS) vale “01” y le corresponde la variable presente en la entrada EIB,

entonces el valor del campo Sel es la “C”. La entrada uno (R) vale “001” y corresponde al
55
valor constante uno, por lo tanto el valor de la entrada uno es “1”. La entrada cero (L) vale
“001” y corresponde al valor constante uno, por lo tanto el valor de la entrada cero es “0”. Ver
celdas sombreadas de la tabla 3.11.
c) Para la célula 02, su registro de configuración es:

1 1 0 0 1 0 1 1 1 0 1 1 0 0 1 1 0
La selección (EBUS) vale “11” y le corresponde la variable presente en la entrada Win,

entonces el valor del campo Sel es la “B”. La entrada uno (R) vale “001” y corresponde al
valor constante uno, por lo tanto el valor de la entrada uno es “1”. La entrada cero (L) vale
“111” y le corresponde la variable presente en la salida SOB, por lo tanto el valor de la
entrada cero es “A”. Ver celdas sombreadas de la tabla 3.11.
El llenado de la tabla continúa de igual forma para las siguientes células. La tabla 3.11
muestra el proceso terminado.
3.2.5 Verificación de las entradas de cada célula
Una vez que se han llenado las entradas del elemento de procesamiento principal de
cada célula, se procede a verificar que las entradas fuentes (las del circuito votador
mostradas en la tabla 3.12) coincidan con las entradas de alguna célula de la tabla 3.11.
MUX 0 MUX 1 MUX 2

Nout y1 y2 y
Sel B B C
R(1) A 1 y2
L(0) 0 A y1
Tabla 3.12.- Entradas fuentes del árbol de multiplexores del circuito votador.
En la tabla 3.11 se observa que las entradas (Sel, R, L) de la célula 00 coinciden con las
entradas (Sel, R, L) del multiplexor 0 de la tabla 3.12, entonces la salida Nout de la célula 00
se actualiza colocando la etiqueta “y1” (casilla de color gris) en la tabla 3.13. Se actualizan
los lugares donde se encontraba la etiqueta anterior de la salida Nout de la célula 00 (casillas
sombreadas).
Las entradas (Sel, R, L) de la célula 02 coinciden con las entradas (Sel, R, L) del
multiplexor 1, entonces la salida Nout de la célula 02 se actualiza colocando la etiqueta “y2”
(casilla de color gris) en la tabla 3.13. Se actualizan los lugares donde se encontraba la
etiqueta anterior de la salida Nout de la célula 02.
56
Las entradas (Sel, R, L) de la célula 11 coinciden con las entradas (Sel, R, L) del
multiplexor 2, entonces la salida Nout de la célula 11 se actualiza colocando la etiqueta “y”
(casilla de color gris) en la tabla 3.13. Se actualizan los lugares donde se encontraba la
etiqueta anterior de la salida Nout de la célula 11.
Con el llenado de la tabla 3.13 se comprueba la efectividad de la matriz de conectividad

para controlar la propagación de las variables de entrada a través del AE.
00 01 02 10 11 12
00 S-N 1 0 1 0 1 0
01 E-N 1 C 1 0
10 W-N
11
No-N 1 y
00 N-S 1 0 1 0 1 0
01 E-S 1 A
10 W-S 1 A 1 0
11
No-S
00 W-E 1 0 1 0 1 C
01 N-E 1 0
10 S-E 1 A 1 C
11
No-E
00 E-W 1 0 1 0 1 0
01 N-W 1 0
10 S-W 1 A 1 C
11
No-W
Sin=Wo=Eo 0 B 0 y1 X01 y2
Ein B 0 0 X01 y2 0
Win 0 0 B 0 y1 X01
Nout y1 X01 y2 X10 y X12
Sel B C B X01 C 0
R (1) A 1 1 1 y2 1
L (0) 0 1 A 1 y1 1
Tabla 3.13.- Actualización de las salidas de las células.
3.3 Elementos del Algoritmo Genético Programado (AGP)
En el capítulo 2 se habló acerca de los elementos que componen a un algoritmo

genético en general. La manera de implementar cada uno de estos elementos dependerá del
problema a resolver, resultando un algoritmo genético particular para cada aplicación. En los
siguientes apartados se presenta la forma en que se desarrollaron los elementos que
conforman el AG que resuelve el problema de enrutado de arreglos embriónicos.
57
3.3.1 Representación de los cromosomas del AGP
La función y conectividad de cada célula del AE las determina su registro de

configuración (figura 3.4). Los 8 bits menos significativos del registro de configuración
corresponden a los bits de selección del enrutador, que determinan las conexiones de los
buses de la célula (ver enrutado de la figura 3.2). En el algoritmo genético desarrollado,
únicamente se toman en cuenta los bits de los registros de configuración relacionados con el
enrutado, es decir, los ocho bits menos significativos del registro de configuración (fig. 3.4).
Estos bits forman lo que en adelante se denominará un semiregistro.
Un cromosoma o individuo de la población del AGP está formado por la

concatenación de los semiregistros de todas las células del arreglo. El número de
semiregistros depende del tamaño del AE, que equivale al número de filas multiplicados por
el número de columnas del AE. Así por ejemplo, para un arreglo de 2?3 células, cada
individuo o cromosoma tendrá 6 semiregistros ó 48 bits. Para generar una población inicial,
los semiregistros son generados aleatoriamente. La figura 3.6 muestra uno de los múltiples
cromosoma posibles para el AE de la figura 3.2.
C: SM00 SM01 SM02 SM10 SM11 SM12
Semiregistro N1 N0 S1 S0 E1 E0 W1 W2
SM00 = 0 0 0 1 0 0 0 1
SM01 = 0 1 0 0 1 0 1 0
SM02 = 0 1 1 0 0 1 1 0
SM10 = 0 0 0 0 0 0 0 0
SM11 = 1 1 1 0 1 0 0 0
SM12 = 0 0 0 0 0 0 0 0
Donde: C = cromosoma
SM = semiregistro
N1, N0 = bits de selección para la salida norte
S1, S0 = bits de selección para la salida sur
E1, E0 = bits de selección para la salida este
W1, W0 = bits de selección para la salida oeste
Figura 3.6.- Representación de un cromosoma.
3.3.2 Función de aptitud (FA)
La idea principal del enrutamiento es lograr trasladar el árbol de multiplexores (fig. 3.7a)
que describe a la aplicación en un conjunto bidimensional de células embriónicas (fig. 3.7b).
58
y
y
c
Out 2 Fila de
0 s 1 repuesto
C 2
a b
Out 0 Out 1
0 s 1 0 s 1 0 1
0 B A A B 1 A C B
a) b)
Figura 3.7.- Árbol de multiplexores y acomodo en un AE del circuito votador.
Cada multiplexor del árbol de multiplexores será acomodado en alguna célula del AE. El
objetivo del AGP es lograr acomodar un árbol de multiplexores con todas sus conexiones y
valor de sus entradas correspondientes en un espacio determinado de células embriónicas.
Se define la función de aptitud Fa(n) como la sumatoria del número de entradas encontradas
de cada multiplexor del árbol:
i ? n ?1
Fa (n ) ? ?e
i? 0
i
Donde n = número de multiplexores del árbol objetivo.

ei = número entradas encontradas para cada multiplexor.
La aptitud objetivo es la que indica cuando un cromosoma resuelve el enrutado, es
decir, cuando se han encontrado todas las entradas de los multiplexores del árbol objetivo en
el arreglo embriónico:
ao = eo x no
Donde no = número de multiplexores del árbol.

eo = entradas de cada multiplexor = 3.
La aptitud máxima para el circuito de la figura 3.7 es 9.
Para calcular la aptitud de un individuo de la población se necesita llenar la matriz de

conectividad mediante un cromosoma generado aleatoriamente como se mostró en la
sección anterior. Se debe ubicar cada multiplexor del árbol objetivo dentro del arreglo
embriónico, esto no quiere decir que los multiplexores del árbol objetivo deban contener
todas sus entradas correctas en un principio. La función de aptitud entonces se encarga de
calcular el número de entradas encontradas para cada multiplexor ubicado en el arreglo.
59
En la tabla 4.14 se muestra una matriz de conectividad parcial donde se ha decodificado

un cromosoma que no resuelve el enrutado. Se observa en la tabla 4.14 que el multiplexor
de la célula 00 contiene dos entradas iguales al multiplexor 0 de la tabla 3.12 (Sel = B y L =
0), pero el multiplexor 0 se le asigna esa posición por ser el lugar donde tiene un mayor
número de entradas en el arreglo. El multiplexor de la célula 02 contiene dos entradas
iguales al multiplexor 1 (Sel = B y L = A). El multiplexor de la célula 11 contiene las tres
entradas iguales al multiplexor 2. Sumando las entradas encontradas de cada multiplexor se
obtiene la aptitud de este cromosoma el cual es de 7.
En una primera evaluación de los individuos de la problación (primera generación) es

difícil encontrar un cromosoma con la aptitud objetivo, por lo que se deberá aplicar los
operadores genéticos (cruza y mutación) para producir nuevos individuos para mejorar la
aptitud real e igualarla a la ideal. La tabla 3.13 muestra la decodificación de un cromosoma
con aptitud 9 que presentado un enrutado para el árbol objetivo.
00 01 02 10 11 12
Nout y1 X01 y2 X10 y X12
Sel B C B X01 C 0
R (1) 1 1 0 1 y2 1
L (0) 0 1 A 1 y1 1
Tabla 3.14.- Matriz de conectividad parcial de un cromosoma que no resuelve el enrutado.
3.3.3 Selección por torneo
La selección es el proceso de determinar a los cromosomas que serán los progenitores

de los individuos que formarán a la siguiente generación. Se escogió la selección por torneo
porque toma en cuenta a todos los individuos de la población, la cual consiste en escoger
por lo menos dos cromosomas al azar y hacerlos competir de acuerdo a su aptitud, ganando
el cromosoma que tenga la mayor. A continuación se muestra la selección por torneo entre
dos cromosomas.
Si AC 1 > AC 2, entonces : Cs = C 1
Si AC 2 > AC 1, entonces : Cs = C 2
Si AC 1 = AC 2, entonces : Cs = C 1
Donde, AC1 = Aptitud del cromosoma 1
AC2 = Aptitud del cromosoma 2
C1 = Cromosoma 1
C2 = Cromosoma 2
Cs = Cromosoma seleccionado (ganador)
60
El número de cromosomas tomados al azar que competirán en el torneo (tamaño del

torneo) puede ser mayor a dos, esto dará como resultado una convergencia más rápida
(mayor velocidad) al resultado, pero no se asegura una mejor solución [Zbi96].
3.3.4 Cruza
La cruza consiste en combinar dos cromosomas de la población. Como se explicó en la

sección 3.3.1, cada cromosoma está formado por un conjunto de semiregistros. La cruza se
realiza a nivel de semiregistros de la siguiente manera: se determina un punto de cruza por
medio de un número aleatorio entre 1 y n-1 (n es el número de semiregistros).
Posteriormente se realiza la partición de los cromosomas en el punto determinado para crear
a los nuevos individuos. La cruza se lleva a cabo de acuerdo a una probabilidad de cruza
(Pc): se genera un número aleatorio entre cero y uno, si este número es menor a Pc se
realiza la cruza. La cruza puede tener más de un punto de cruza, esto dará al AGP una
mayor diversidad en la búsqueda de la solución y hará que el AGP pueda llegar al resultado
correcto, aunque se necesitará de un mayor número de generaciones [Zbi96]. En la figura
3.8 se muestra la cruza con dos puntos de cruza.
P1 P2
C1: SM1 SM2 SM3 SM4 SM5 SM6 C1’: SM1 SM2 SMC SMD SM5 SM6
C2: SMA SMB SMC SMD SME SMF

C2’: SMA SMB SM3 SM4 SME SMF
Donde C1, C2 = cromosomas padres

C1’, C2’ = cromosomas hijos
P1, P2 = puntos de cruza
SM (1-6), SM(A -F) = semiregistros de cada cromosoma
Figura 3.8- Generación de nuevos cromosomas mediante la cruza.
3.3.5 Mutación
Para cromosomas formados por cadenas de bits, la mutación se lleva a cabo a nivel de
bits y consiste en complementar un bit aleatoriamente de la siguiente manera: se genera un
número aleatorio entre 1 y n-1 (n es el número de semiregistros), para determinar el
semiregistro que sufrirá la mutación. Después se genera otro número aleatorio entre 0 y 7
que indica la posición del bit a mutar. La mutación se lleva a cabo de acuerdo a una
probabilidad de mutación (Pm), se genera un número aleatorio entre cero y uno, si este
61
número es menor a Pm se realiza la mutación. En la figura 3.9 se muestra la mutación de

un bit de un cromosoma.
C: SM1 SM2 SM3 SM4 SM5 SM6
SM2 1 0 1 0 1 1 1 0
SM2’ 1 0 1 0 1 0 1 0
bm
Donde C = cromosoma
SM2’ = semiregistro 2 mutado
bm = bit mutado
Figura 3.9.- Aplicación de la mutación a un cromosoma de la población.
3.4 Implementación del AGP
La figura 3.10 muestra el diagrama de flujo del AGP, en el se presentan los bloques
principales que realiza el programa escrito en lenguaje C. A continuación se presenta una
descripción de cada uno de los bloques que constituyen este programa.
Inicializa variables: Este bloque realiza la inicialización de las variables de entrada que
describen al árbol de multiplexores de la aplicación a enrutar a través de la lectura de tres
archivos de entrada.
a) Archivo en entrada 1: Por medio de este archivo se le indican al programa los siguientes
parámetros: porcentajes de cruza y mutación, tamaño del arreglo embriónico, número de
multiplexores del árbol, entradas de los multiplexores del árbol y tipo de salida de los
multiplexores (combinacional o secuencial). Para poder referenciar un multiplexor del árbol
dentro del AE es necesario otorgarle un número de acuerdo a la posición que guarda dentro
del árbol de multiplexores. La asignación del número se realiza de izquierda a derecha y de
abajo hacia arriba (ver figura 3.7a). El listado 3.1 muestra el archivo de entrada (en letras
negrillas y cursivas) que describe los parámetros del árbol de multiplexores para el circuito
votador que utilizará el AGP para realizar el enrutamiento:
0.8
0.15
2 3 3
2 2 1
0
1 2
Listado 3.1.- Archivo de entrada del AGP.
62
Inicializa variables
Lee archivos
de entrada
Genera población inicial
EVALUAR (1) h=0
Inicializa la MC
Carga las variables de entrada a la MC
Decodifica los Regs. de configuración

h=h+1
Propaga las vars. de entrada en la MC
Calcula la aptitud del cromosoma h
Si
h < tm
No
Ordena la población
e = 0, v = 0
Selecciona dos cromosomas
No
c < Pc
De donde: Si
MC = Matriz de conectividad Realiza la cruza
tm = tamaño de la población
Pc = Porcentaje de cruza
Pm = Porcentaje de mutación No
c, m = números entre 0 y 1 m < Pm e=e+1
generados aleatoriamente Si v=v+1
Realiza la mutación
EVALUAR (2)
Trata de insertar los nuevos cromosomas a la nueva población
(e < tm) y Si
(v < tm)
No
Completa la nueva población
¿Se alcanzó No
el CP?
Si Crea archivos
de salida
Imprime resultados
Figura 3.10.-Diagrama de flujo del AGP.
63
El significado de los valores mostrados en el listado 3.1 es el siguiente:

? Porcentaje de cruza: 0.8.
? Porcentaje de mutación: 0.15.
? Número de filas del AE: 2, número de columnas del AE: 2 y número de multiplexores
del árbol: 3.
? Número de niveles del árbol de multiplexores: 2 y número de multiplexores de cada
nivel: 2 1 1.
? Número de multiplexores con salida secuencial y posición de los mismos: 0 2.
? Número de multiplexores que tiene la función de salida y posición de los mismos
dentro del árbol de multiplexores: 2..
Notas:
1. El número de niveles del árbol de multiplexores se calcula contando los bloques de

multiplexores en forma vertical desde el multiplexor inferior hasta el multiplexor que tendrá la
función de salida. En caso de haber más de una función de salida, se considerará el árbol
con el mayor número de niveles. Para el circuito votador de la figura 3.7a se tienen dos
niveles, dos multiplexores en el nivel uno y un multiplexor en el nivel dos.
2. No todos los mutilplexores del árbol utilizarán a su salida el flip-flop de la arquitectura (ver
figura A.4 del apéndice) para retención de su valor. El flip-flop únicamente se utiliza en
aplicaciones secuenciales o que requieran almacenamiento.
b) Archivo en entrada 2: Este archivo contiene las tres entradas de cada multiplexor del
árbol de multiplexores. Estas entradas fuentes serán buscadas por el AGP dentro del arreglo
embirónico una vez que se ha realizado la propagación de las variables de entrada de la
función para determinar el enrutamiento de la aplicación. Las entradas de cada multiplexor
en este archivo siguen el siguiente orden: entrada de selección (sel), entrada uno (1),
entrada cero (0). El orden de los multiplexores depende de la numeración asignada para el
enrutamiento. En la figura 3.7a se muestra la numeración del árbol de multiplexores del
circuito votador. Así, para el árbol de multiplexores de la figura 3.7a, el archivo de entrada
debe contener: 'BA0B1ACba', donde BA0 (sel, 1, 0) son las entradas del multiplexor 0, B1A
las entradas del multiplexor 1 y Cba las entradas del multiplexor 2.
c) Archivo en entrada 3: Este archivo contiene las variables de entrada de la función. Estas
variables solo se pueden introducir por las entradas SIB y Sin de cada célula de la fila cero
del arreglo embriónico, como se explicó en la sección 3.2. El arreglo embriónico usado para
enrutar el árbol de multiplexores de la figura 3.7a es de 2x2. La fila cero contiene dos células
por las que se puede introducir las variables de la aplicación. Experimentalmente se logró
determinar la asignación de las variables de entrada de la función de la siguiente manera:
'BACA', donde la variable B se introduce por SIB de la célula 00, la A por la entrada Sin de la
64
célula 00, la C por SIB de la célula 01 y una copia de A por la entrada Sin de la célula 01. La
repetición de las variables de entrada (en este caso de A) le ayudan al AGP a encontrar el
mejor enrutado en menos tiempo.
Genera población inicial: Se generan números aleatorios de 8 bits (0-255) que representan
los ocho bits menos significativo del registro de configuración de una célula. Así un
cromosoma (un miembro de la población) consiste de “n” números creados aleatoriamente
(semiregistros), donde n es el número de células en el AE. El tamaño de la población (tm) se
tomó experimentalmente de 100 individuos.
EVALUAR (1): Consiste en aplicar la función de aptitud a cada cromosoma de la población

inicial para obtener su aptitud. En este bloque se utiliza la matriz de conectividad (MC)
explicada en la sección 3.2. Se realiza la conectividad entre las células mediante la
decodificación de cada cromosoma en la población y se propagan las variables de entrada
através de la MC . La función de aptitud es la encargada de contar el número de entradas del
árbol de multiplexores dentro del AE, como se explicó en la sección 3.3.2.
Ordena la población inicial: Ordena de mayor a menor a los cromosomas de acuerdo a su

aptitud. La tabla 3.15 muestra un ejemplo de la población ordenada. En algunos casos,
dependiendo de la complejidad del problema a resolver, los algoritmos genéticos requieren
miles de generaciones para encontrar una solución correcta. Existen dos criterios de paro en
el programa: uno es cuando se han evaluado un número determinado de generaciones y el
otro es hasta que se encuentra el valor máximo de la función de aptitud del problema
planteado [Zbi96].
Posición Aptitud
Cromosoma 1 8
Cromosoma 2 8
Cromosoma 3 6
… …
Cromosoma 100 3
Tabla 3.15.- Población ordenada de acuerdo con la mejor aptitud.
En la figura 3.10, o
l s bloques que se muestran después de ordenar la población
inicial, describen el cuerpo principal del algoritmo genético programado (AGP), el cual
consiste en un ciclo interno que se ejecuta “tm” veces (tm = tamaño de la población). Dentro
del ciclo se realiza lo siguiente: Se seleccionan dos cromosomas padres para producir a dos
nuevos individuos. Si un número aleatorio c (0<c<1) es menor que la probabilidad de cruza
Pc (normalmente de 0.8), se realizará la cruza entre los padres seleccionados. Si otro
65
número aleatorio m (0<m<1) es menor que la probabilidad de mutación Pm (elegido

experimentalmente de 0.15), se realizará la mutación de un bit de los padres seleccionados.
Estos dos nuevos cromosomas se evalúan y se insertan en una nueva población. Se cuenta
con un mecanismo que impide que un individuo sea incluido más de una vez en la nueva
población, de esta manera se garantiza que todos los individuos de la nueva población sean
diferentes entre sí. Al salir del ciclo, si no se completó la población nueva debido a que se
eliminaron individuos repetidos, se generan los cromosomas faltantes de manera aleatoria.
Imprime resultados: Una vez que se ha cumplido el criterio de paro (número de

generaciones o solución correcta encontrada) , se crea un archivo de salida que contiene el
conjunto de registros de configuración de cada célula que describen a la función dentro del
AE. Este archivo es utilizado para la simulación de la aplicación en Foundation de Xilinx. A
continuación se muestra el listado de este archivo VHDL de salida proporcionado por el
AGP.
library IEEE;
use IEEE.std_logic_1164.all;
entity Mem_votador is
port (
okaux: in STD_LOGIC;
xy: in STD_LOGIC_VECTOR (7 downto 0);
conf: out STD_LOGIC_VECTOR (16 downto 0) );
end Mem_votador;
architecture Mem_votador_arch of Mem_votador is
type REG is array (16 downto 0) of bit;
begin
process(okaux,xy)
begin
if ( okaux = '0' ) then
conf <= "01001000100000000";
else
case xy is
when "00000000" => conf <= "00010000000011001";
when "00000001" => conf <= "00001001000000011";
when "00010000" => conf <= "00000000011011011";
when "00010001" => conf <= "00010010011101011";
when others => conf <= "01001000100000000";
end case;
end if;
end process;
end Mem_votador_arch;
Listado 3.2.- Archivo de salida del AGP.
3.4.1 Ajuste de los parámetros del AGP
a) Porcentajes de cruza y de mutación.- Estos porcentajes representan la probabilidad de

llevar a cabo la cruza y la mutación, respectivamente. Dependen del tipo de problema que se
66
necesite resolver. Se ha tomado experimentalmente como porcentaje de cruza “Pc” igual a

0.8 y como porcentaje de mutación igual a 0.15 [Zbi96].
b) Tamaño de la población.- El número de cromosomas que forman la población, se eligió

de forma experimental. Se propone un tamaño de población de 100 cromosomas para todas
las aplicaciones utilizadas [Zbi96].
c) Número de generaciones.- El número de generaciones se determinó de forma

experimental. Se inicia tomando un número reducido de generaciones (por ejemplo 100), y
de acuerdo a la aptitud máxima obtenida en la generación final se incrementa el valor de
este parámetro. Al incrementar el número de generaciones es posible encontrar individuos
con mejor aptitud, pero se incrementa el tiempo de procesamiento.
d) Tamaño del AE.- El tamaño inicial del AE es el espacio bidimensional donde se desea
acomodar el árbol de multiplexores. Este tamaño depende de la forma del árbol de
multiplexores y se obtiene de la siguiente manera: el número de niveles del árbol de
multiplexores determina el número filas del AE, y el nivel con más multiplexores determina el
número de columnas del AE. Este tamaño puede ser reducido o aumentado para mejorar el
enrutamiento buscado por el AGP. El tamaño que utiliza el AGP para realizar el enrutamiento
de alguna aplicación no toma en cuenta a las células que servirán como repuestos en caso
de falla en el AE. Como durante la reconfiguración se utiliza la estrategia de eliminación por
filas, las células de repuesto se colocan en la parte superior del arreglo establecido, de esta
manera se puede simular la tolerancia a fallas en Foundation de Xilinx.
3.5 Resumen
En este capítulo se presentó una matriz de conectividad que representa la conexión

entre las células del arreglo embriónico. Esta matriz es utilizada para simular la propagación
de las variables de entrada a través de las conexiones habilitadas por el enrutador de E/S de
cada célula. Se demostró mediante un ejemplo que la matriz de conectividad propuesta es
una buena herramienta para solucionar el problema de enrutado entre células de un AE. Se
describieron las partes que constituyen el algoritmo genético programado. Mediante un
diagrama de bloques se describió el programa escrito en el lenguaje C que resuelve el
enrutado de arreglos Embriónicos. Finalmente se justificó la selección de los valores de los
parámetros usados por el algoritmo genético programado.
67
CAPÍTULO IV
4. RESULTADOS
Este capítulo presenta el diseño de circuitos digitales para probar el

enrutador de arreglos embriónicos descrito en el capítulo 3. Dentro de las
aplicaciones que se mostrarán se incluyen circuitos combinacionales y
secuenciales que siguen una metodología de diseño que va desde el
planteamiento del problema mediante su tabla de verdad hasta la simulación
en la plataforma de foundation de Xilinx.
4.1 Ambiente de desarrollo foundation de xilinx
Xilinx es uno de los líderes en el mercado mundial de dispositivos lógicos programables.

Su ambiente de desarrollo se llama Foundation. Esta herramienta permite realizar el diseño
de circuitos electrónicos para poder encapsularlos en Arreglos de Compuertas Programables
en campo o FPGA (por sus siglas en inglés). Para poder simular algún circuito en
Foundation es necesario proporcionar el diseño del mismo, que puede desarrollarse de tres
maneras: mediante un diagrama esquemático, mediante un archivo escrito en el lenguaje
descriptor de hardware VHDL o mediante diagramas de estados.
El proceso para desarrollar una aplicación es el siguiente:
1. Introducir el diseño (esquemático, archivo VHDL o diagrama de estados).

2. Sintetizar el diseño del paso 1.
3. Simulación funcional.
4. Implementación para simularlo en tiempo real.
5. Descargar el diseño a un dispositivo lógico programable.
CAPÍTULO IV Resultados
La arquitectura de la célula embriónica es la misma para cualquier aplicación. Lo que

hace particular a cada aplicación es el módulo de memoria que va dentro de cada célula
(equivalente al ADN de las células biológicas). Los diseños creados para el sistema
embriónico utilizan dos tipos de fuentes: para realizar la arquitectura de la célula se utilizó el
editor de esquemáticos de Foundation y para implementar el módulo de memoria se ha
utilizado como fuente un archivo VHDL, el cual es generado automáticamente por el
algoritmo genético programado.
El diseño de una aplicación digital basada en los arreglos embriónicos implica la

realización de los siguientes pasos:
1. Describir la aplicación mediante una tabla de verdad.

2. Obtener los árboles binarios de decisión ordenados de cada salida de la aplicación.
3. Transportar el árbol binario de decisión ordenado a un árbol de multiplexores.
4. Realizar el enrutamiento del árbol de multiplexores mediante el algoritmo genético
programado en un arreglo embriónico.
5. Comprobar los pasos anteriores mediante la simulación del diseño en Foundation de
Xilinx.
4.2 Reloj de 12 horas
El reloj propuesto se ha diseñado con base a contadores que indican los segundos,
minutos y horas (ver figura 4.1). Los contadores utilizados son: el contador 0-9, el contador
0-5 y el contador 0-11. El reloj se construye de la siguiente manera: se coloca un contador de
0-9 para llevar el conteo de las unidades de los segundos, cuando este llega a 9 genera una
señal (DR) que indica el rebose de la cuenta. Esta señal se utiliza como pulso de reloj para el
siguiente contador de 0-5 que lleva el conteo de las decenas de segundos. A continuación se
coloca otro contador de 0-9 para el conteo de las unidades de los minutos, después se
coloca otro contador de 0-5 para el conteo de las decenas de los minutos y por último se
coloca el contador 0-11 que registra el conteo de las horas. Cuando todos los contadores
llegan a su cuenta máxima el reloj se reinicia a cero para comenzar nuevamente la cuenta.
La figura 4.2 muestra el diagrama a bloques del reloj propuesto. La señal de salida DR
representa el detector de rebose para cada contador.
Figura 4.1.- Cuenta máxima del reloj de 0 a 12 horas.
69
Salidas Salidas Salidas Salidas Salidas

BCD BCD BCD BCD BCD
11
0- 0 -5 0 -9 0 -5 0 -9
clk clk clk clk clk
Pulso
DR DR DR DR DR de
reset reset reset reset reset reloj
Inicializar
Figura 4.2.- Estructura del reloj de 0 a 12 horas.
Para construir una aplicación basada en los arreglos embriónicos es necesario seguir la
serie de pasos descrita en la sección 4.1. Se presentará a detalle únicamente el diseño del
contador 0-9, de los demás diseños se mostrarán las partes más relevantes.
4.2.1 Contador 0-9
Este circuito es de tipo secuencial y es un contador cíclico de cero a nueve. La tabla 4.1
muestra la tabla de estados que lo describe. El estado actual del contador está representado
por DCBA (D es el bit más significativo) y el estado siguiente por D+C +B+A+. En la tabla 4.1 se
puede notar la generación de una salida DR para detectar la cuenta máxima del contador y
manejar el reloj de la siguiente etapa.
+ + + +
D C B A D C B A DR
0 0 0 0 0 0 0 1 1
0 0 0 1 0 0 1 0 1
0 0 1 0 0 0 1 1 1
0 0 1 1 0 1 0 0 1
0 1 0 0 0 1 0 1 1
0 1 0 1 0 1 1 0 1
0 1 1 0 0 1 1 1 1
0 1 1 1 1 0 0 0 1
1 0 0 0 1 0 0 1 1
1 0 0 1 0 0 0 0 0
Otras comb. 0 0 0 0 1
Tabla 4.1.- Tabla de verdad para el contador 0-9.
La figura 4.3 muestra los OBDD de cada función de salida del contador 0-9. La figura
4.4a muestra los árboles de multiplexores para cada función de salida del contador 0-9 (la
función DR se enrutó por separado, ver figura 4.b). En la figura 4.4a los rectángulos con
etiqueta FF significa la presencia de un flip flop tipo D para retener el valor de salida de la
función y actualizarse en cada pulso de reloj.
70
+
D +
C
D
D
0 1
0 1
C C
C 0
0 1 0 1
0 1
0 B B 0
B B
0 1 0 1
0 1 0 1
1 A 0 1 A
A
0 A
0 1 0 1
1 0 1 0
a) b)
DR
0 1
B+
D 1 C
0 1 0 1
B 0 B 1
0 1 0 1
A+
A A A A 1
0 1 0 1 0 1
1 0 1 0 1 0
c) d) e)
Figura 4.3.- OBDD para el contador 0-9.
C D
DR
FF FF
d
n o Out 3
B
Out 13 Out 14 0 s 1
0 s 1 0 s 1
FF
1 D
D 0 k l D m c
j Out 2
Out 10 Out 11 Out 12
Out 9 0 s 1 0 s 1 0 s 1 0 s 1
0 s 1
D 0 0 C C 0 C 1
C g h i b
e f
Out 4 Out 5 Out 6 A Out 7 Out 8 Out 1
0 s 1 0 s 1 0 s 1 0 s 1 0 s 1
0 s 1
FF
0 B A 1 B 0 B A B 0 B 1
A B
a b c d a
Out 1 Out 2 Out 3 Out 0
Out 0
0 s 1 0 s 1 0 s 1 0 s 1
0 s 1
1 A 0 1 A 0 1 A 0 1 A 0 1 A 0
a) b)
Figura 4.4.- Árboles de multiplexores del contador 0-9.

El listado 4.1 muestra el archivo de entrada 1 que describe al árbol de multiplexores de
la figura 4.4a para ser enrutado mediante el programa propuesto en el capítulo 3. La
71
explicación del archivo se presentó en la sección 3.4. El segundo archivo de entrada

contiene las entradas fuentes del árbol de multiplexores de la figura 4.4a las cuales son:
'c01c01c01c01kc1ka1kbckc0k0dnfeo0gnh0n0io0joml'. El tercer archivo de entrada que
contiene las variables de entrada es: '0000000000'. La colocación de ceros se debe a que
esta aplicación no contiene variables de entrada y depende de las salidas de la misma
función, por ser de tipo secuencial.
0.8
0.15
4 5 15
4 4 5 4 2
4 2 10 13 14
4 2 10 13 14
Listado 4.1.- Archivo de entrada para enrutar el contador 0-9.
Una vez creados los tres archivos de entrada del contador 0-9, se procede a ejecutar el
programa del algoritmo genético para que intente enrutar la aplicación. Se ejecuta el
programa un cierto número de generaciones. El programa no siempre logra enrutar la
aplicación en una ejecución. La tabla 4.2 muestra los resultados de las corridas del algoritmo
genético para enrutar las aplicaciones descritas en este capítulo.
TAMAÑO No. DE GENERS. GEN. CROMOS. PROB. DE

APLICACION TIPO
DEL AE MUXS. TOTALES MIN. BUENOS ENRUTAM.
Contador 0-9 Sec. 4x5 15 30000 6500 80 0.5
Contador 0-5 Sec. 3x5 10 50000 12000 78 0.4
Contador 0-11, 1a. parte Sec. 4x4 10 50000 42000 75 0.2
Contador 0-11, 2a. parte Sec. 4x4 11 50000 30000 80 0.3
Contador A/D Sec. 3x3 5 10000 250 85 0.7
Votador de 3 bits Com. 2x2 3 100 1 82 1
Sumador paralelo de 2 b. Com. 4x8 15 30000 8500 75 0.4
CRC-4 Com. 2X6 10 10000 80 78 0.5
Gen. paridad par de 4 b. Com. 4x8 15 30000 2500 80 0.9
Gen. paridad par de 5 b. Com. 5x6 11 20000 450 76 0.2
Tabla 4.2.- Resultados de las corridas del programa del algoritmo genético.
Donde:
a) TIPO: significa si la aplicación es combinacional o secuencial.

b) TAMAÑO DEL AE: indican las dimensiones del arreglo embriónico.
c) No. DE MUXS.: indica el número de multiplexores del árbol.
d) GENERS. TOTALES: indica el # de generaciones del algoritmo genético.
e) GEN. MIN.: indica la generación mínima donde se ha encontrado el primer
cromosoma bueno (cromosoma que resuelve el enrutado).
f) CROMOS. BUENOS: indica el número de cromosomas buenos cuando se logra
enrutar el problema.
g) PROB. DE ENRUTAM.: indica la probabilidad de encontrar soluciones buenas, es
decir, número de soluciones buenas por cada diez corridas.
72
El listado 4.2 corresponde al archivo VHDL creado por el algoritmo genético una vez que
ha enrutado el árbol de multiplexores de la figura 4.4a en un arreglo embriónico. El árbol de
multiplexores de la figura 4.4a se enrutó en un arreglo embriónico de 4x5. Contiene todos los
registros de configuración de cada célula del arreglo para utilizarlo como memoria de la
célula para la simulación en Foundation de Xilinx.
library IEEE;
use IEEE.std_logic_1164.all;
entity Mem_counter9 is
port (
okaux: in STD_LOGIC;
xy: in STD_LOGIC_VECTOR (7 downto 0);
conf: out STD_LOGIC_VECTOR (16 downto 0) );
end Mem_counter9;
architecture Mem_counter9_arch of Mem_counter9 is
type REG is array (16 downto 0) of bit;
begin
process(okaux,xy)
begin
if ( okaux = '0' ) then
conf <= "01001000100000000";
else
case xy is
when "00000000" => conf <= "01000000101000101";
when "00000001" => conf <= "00000000111100100";
when "00000010" => conf <= "00000100111010011";
when "00000011" => conf <= "00000000111000001";
when "00000100" => conf <= "00000000010110100";
when "00000101" => conf <= "10000000100101101";
when "00000110" => conf <= "11001011100100001";
when "00010000" => conf <= "01110000001110010";
when "00010001" => conf <= "00100000101010101";
when "00010010" => conf <= "00100001000100010";
when "00010011" => conf <= "00100000001110001";
when "00010100" => conf <= "00000010000000000";
when "00010101" => conf <= "00001001110001000";
when "00010110" => conf <= "00000000000101011";
when "00100000" => conf <= "00011001000100110";
when "00100001" => conf <= "01000101101110010";
when "00100010" => conf <= "00011000001110001";
when "00100011" => conf <= "00000001110000010";
when "00100100" => conf <= "00000000000111001";
when "00100101" => conf <= "00000000000110001";
when "00100110" => conf <= "00100000111111011";
when "00110000" => conf <= "01000101011111010";
when "00110001" => conf <= "00000000010011010";
when "00110010" => conf <= "00011101011110010";
when "00110011" => conf <= "00000000001100110";
when "00110100" => conf <= "00000000000011000";
when others => conf <= "01001000100000000";
end case;
end if;
end process;
end Mem_counter9_arch;
Listado 4.2.- Archivo VHDL que describe la memoria del reloj de 12 horas.
73
La figura 4.5 muestra el resultado de decodificar en forma manual los registros de

configuración para el enrutamiento del contador 0-9 realizado por el algoritmo genético en un
arreglo embriónico de 4x5.
C B D A
NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT
WI EO WI EO WI EO WI EO WI EO
WO EI WO EI WO EI WO EI WO EI
13 14
WIB 0 S 1 EOB WIB EOB WIB 0 S 1 EOB WIB EOB WIB EOB
WOB 0 EIB WOB EIB WOB EIB WOB EIB WOB EIB
SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
9 10 11 12
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB
EIB 0 EIB 0 EIB 0 EIB EIB

WOB WOB WOB WOB WOB
4 5 6 7 8
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB
0 EIB 1 EIB EIB EIB 0 EIB

WOB WOB WOB WOB 0 WOB
SIB SOB
0 SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
0 1 2 3
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB
1 0 1 0 1 0
WOB EIB WOB 1 0 EIB WOB EIB WOB EIB WOB EIB
SIB 1
SOB 0
SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
0 0 0 0 0 0 0 0 0 0
Figura 4.5.- Enrutamiento del contador 0-9.
La figura 4.6 muestra la simulación del contador 0-9 donde no existen células erróneas.
Se puede observar que el conteo se realiza de forma correcta y al llegar a 9 se produce un
cambio de alto a bajo en la señal DR que se utiliza como pulso de reloj para el contador
siguiente.
Figura 4.6.- Simulación del contador 0-9 con todas las células en buen estado.
74
Las variables mostradas en la figura 4.6 son las siguientes:
? CLRI.- Inicializa las células que utilizan salida secuencial.

? CLKI.- Proporciona el pulso de reloj para las células con salida secuencial.
? A … (hex)#4.- Salidas de contador (DCBA).
? DR.- Detector de rebose para indicar la cuenta máxima del contador.
? OKAA y OKBB.- Utilizados para simular un error en la célula AA o BB
respectivamente.
? X0EA. (hex)#5.- Coordenada X que proporciona la última célula.
? EIBUSAH. (hex).- Las entradas del arreglo embriónico por las que no se introducen
variables de entrada se ajustan a ceros.
La figura 4.7 muestra un error provocado en la célula AA cuando el contador está en la

cuenta de 7. Este error se provoca colocando la entrada OKAA en bajo. Después de un
tiempo corto de establecimiento de las señales de salida del contador (provocado por la
reconfiguración de las células) el contador sigue funcionando correctamente.
Figura 4.7.- Simulación del contador 0-9 con una fila dañada.
4.2.2 Contador 0-5
El contador 0-5 forma parte del reloj propuesto. Utiliza para su cuenta binaria 3 bits
representados por las letras CBA. Cuenta con su detector de rebose (DR) que indica la
cuenta máxima del contador. La tabla 4.3 muestra su tabla de verdad.
+ + +
C B A C B A DR
0 0 0 0 0 1 1
0 0 1 0 1 0 1
0 1 0 0 1 1 1
0 1 1 1 0 0 1
1 0 0 1 0 1 1
1 0 1 0 0 0 0
1 1 0 0 0 0 1
1 1 1 0 0 0 1
75
La figura 4.8 muestra el árbol de multiplexores para el contador 0-5. El listado 4.3
muestra el archivo de entrada necesario para enrutar el contador sobre un arreglo
embriónico.
FF DR
i j
C Out 8 Out 9 0.8
0 s 1 0 s 1
0.15
FF 3 5 10
C 0 1 C
f g 3 5 3 2
h
Out 5 Out 6 Out 7 3 2 5 8
A
0 s 1 0 s 1 0 s 1 4 2 5 8 9
C FF
A B B 1 Listado 4.3.-
a b c d e Archivo de
Out 2 Out 3 Out 4
0
Out 0
s 1 0
Out 1
s 1 0 s 1 0 s 1 0 s 1
entrada para
enrutar el
0 B A 1 A 0 1 A 0 1 A 0 1 A 0 contador 0-5.
La figura 4.9 muestra el resultado de decodificar los registros de configuración para el

enrutamiento del contador 0-5 realizado por el algoritmo genético en un arreglo embriónico
de 3x5.
C B DR A
8 9
WIB EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB WIB EOB
0 1
WOB EIB WOB EIB WOB EIB WOB EIB WOB EIB
5 6 7
WIB 0 S 1 EOB WIB EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB
EIB EIB EIB 1 EIB EIB

WOB WOB WOB WOB WOB
SIB SOB
1 0 2 3 4
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB
1 0 EIB 0 EIB 1 0 EIB 1 0 EIB 1 0 EIB
WOB WOB WOB WOB WOB
SIB SOB
1 SIN
0 SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
0 0 0 0 0 0 0 0 0 0
Figura 4.9.- Enrutamiento del contador 0-5.
76
La figura 4.10 muestra la simulación del contador 0-5. Las salidas CBA están agrupadas
en la etiqueta A. Durante la simulación se provocó un error en la célula BB colocando la
señal OKBB en bajo como se muestra la figura 4.10.
Figura 4.10.- Simulación del contador 0-5.
4.2.3 Contador 0-11
Este contador 0-11 también forma parte del reloj propuesto. Utiliza para su cuenta
binaria 5 bits representados por las letras EDCBA. Cuenta con su detector de rebose (DR)
que indica la cuenta máxima del contador. La tabla 4.4 muestra su tabla de verdad.
+ + + + +
E D C B A E D C B A DR
0 0 0 0 0 0 0 0 0 1 1
0 0 0 0 1 0 0 0 1 0 1
0 0 0 1 0 0 0 0 1 1 1
0 0 0 1 1 0 0 1 0 0 1
0 0 1 0 0 0 0 1 0 1 1
0 0 1 0 1 0 0 1 1 0 1
0 0 1 1 0 0 0 1 1 1 1
0 0 1 1 1 0 1 0 0 0 1
0 1 0 0 0 0 1 0 0 1 1
0 1 0 0 1 1 0 0 0 0 1
1 0 0 0 0 1 0 0 0 1 1
1 0 0 0 1 0 0 0 0 0 0
Otras comb. 0 0 0 0 0 1
La figura 4.11 muestra los árboles de multiplexores para el contador 0-11. El

enrutamiento de esta aplicación se realizó en dos partes (figura 4.11a y 4.11b), pero se
juntaron los dos archivos VHDL proporcionados por el AGP para su simulación en
Foundation de Xilinx.. Los listados 4.4a y 4.4b muestran los archivos de entrada para
enrutar las dos partes de esta aplicación en un arreglo embriónico.
77
B
a)
FF
j
Out 9
0 s 1
E 0
i
Out 8 E
0 s 1
FF
DR
D 0 g
f h
Out 6
Out 5 A Out 7
0 s 1
0 s 1
0 s 1
0.8
0.15
FF E
A B 1 E 4 4 11
a b c d e
Out 1 Out 4
5 2 4 2 2 1
Out 0 Out 2 Out 3
0 s 1 0 s 1 0 s 1 0 s 1 0 s 1 2 9 10
2 9 10
1 A 0 1 A 0 0 D A 1 A 0 1 A 0
a)
C
b)
FF 0.8
k 0.15
Out 10 D 4 4 10
0 s 1 4 5 3 11
FF 3 6 7 9
E 0
i j 4 1 6 7 9
Out 8 Out 9
0 s 1 0 s 1
b)
D 0 E 0
g h
Out 6 Out 7
0 s 1 0 s 1
Listado 4.4.-
Archivos de entrada
c C d e D f para enrutar el
Out 2 Out 3
0 s 1 0 s 1
Out 4 Out 5 contador 0-11.
0 s 1 0 s 1
0 B A 1 B 0 C 1 A 0
a b
Out 0 Out 1
0 s 1 0 s 1
1 A 0 0 B A
La figura 4.12 y 4.13 muestran la decodificación de los registros de configuración

para el enrutamiento de las funciones de salida de la figura 4.11a y 4.11b respectivamente
del contador 0-11 realizado por el algoritmo genético en un arreglo embriónico de 4x4 cada
uno.
78
DR A B E
NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT
WI EO WI EO WI EO WI EO
WO EI WO EI WO EI WO EI
9
WIB EOB WIB EOB WIB 0 S 1 EOB WIB EOB
EIB EIB 0 EIB EIB

WOB WOB WOB WOB
SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
7 8
WIB 0 S 1 EOB WIB EOB WIB 0 S 1 EOB WIB EOB
1 0
WOB EIB WOB EIB WOB EIB WOB EIB
4 5 6
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB
1 0
SIB SOB
0 SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
0 1 2 3
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB
1 0 1 0
EIB 1 0 EIB EIB EIB
WOB WOB WOB 0 WOB
SIB 1
SOB 0
SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
0 0 0 0 D 0 0 0
Figura 4.12.- Enrutamiento parcial del contador 0-11, primera parte.
C D
8 9
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB WIB EOB
0 EIB 0 EIB EIB EIB

WOB WOB WOB WOB
6 7
WIB EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB

NOB NIB NOUT NOB NIB NOUT NOB NIB NOU T NOB NIB NOUT
WI EO WI EO WI EO WI
WO EI WO EI WO EI WO
3 4 2 5
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1
1 0 0
WOB EIB WOB EIB WOB EIB WOB
SIB SOB
0 SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
10 0 1
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB
0
WOB EIB WOB 1 0 EIB WOB 0 EIB WOB EIB
SIB SOB
1 SIN
0 SIB SOB SIN SIB SOB SIN SIB SOB SIN
0 A E 0 A 0 B B
Figura 4.13.- Enrutamiento parcial del contador 0-11, segunda parte.
79
La figura 4.14 muestra la simulación del contador 0-11. La salidas están agrupadas en 2
conjuntos. Los cuatro bits menos significativos (DCBA) representan las unidades para este
contador. La salida E es el encargado de contar las decenas del contador. Cuando el
contador llega a 11 la salida DR genera la señal de rebose. En el siguiente ciclo de reloj se
ha producido un error en la célula AA al poner en bajo la señal OKAA. Después de un
pequeño tiempo de estabilización de las señales, el contador sigue funcionando.
Figura 4.14.- Simulación del contador 0-11.
4.3 Otras aplicaciones
4.3.1 Contador ascendente/descendente de 2 bits
Este contador es el último circuito secuencial diseñado. Utiliza para su cuenta binaria 2
bits representados por las letras BA. La cuenta la realiza de la siguiente manera: cuando la
variable de control C vale uno la cuenta es de forma ascendente (0 a 3) y para cuando C
vale cero la cuenta es de forma descendente (3 a 0). La tabla 4.5 muestra su tabla de
verdad. La figura 4.15 muestra los árboles de multiplexores para las salidas de este
contador.
B
FF
e
+ +
C B A B A Out 4
1 s 0
0 0 0 1 1
0 0 1 0 0 C
c d
0 1 0 0 1 Out 2 Out 3
A
0 1 1 1 0 0 s 1 0 s 1
1 0 0 0 1 FF
B A A B
1 0 1 1 0 a b
Out 0 Out 1
1 1 0 1 1 0 s 1 0 s 1
1 1 1 0 0
1 A 0 1 B 0
Tabla 4.5.- Tabla de verdad para el contador Figura 4.15.- Árboles de multiplexores del
ascendente/descendente de 2 bits. contador ascendente/descendente de 2 bits.
El listado 4.5 presenta el archivo de entrada para realizar el enrutamiento del contador
en un arreglo embriónico.
80
Listado 4.5.- Archivo de 0.8

entrada para enrutar el 0.15
4 4 11
contador 5 2 4 2 2 1
ascendente/descendente 2 9 10
de 2 bits. 2 9 10

enrutamiento del contador ascendente/descendente de 2 bits realizado por el algoritmo
genético en un arreglo embriónico de 3x3.
B A
NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT

WI EO WI EO WI EO
WO EI WO EI WO EI
4
WIB 0 S 1 EOB WIB EOB WIB EOB

SIB SOB SIN SIB SOB SIN SIB SOB SIN

WI EO WI EO WI EO
WO EI WO EI WO EI
2 3
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB

SIB SOB
0 SIN SIB SOB SIN SIB SOB SIN

WI EO WI EO WI EO
WO EI WO EI WO EI
0 1
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB
1 0 1 0
SIB SOB
1 SIN
0 SIB SOB SIN SIB SOB SIN
0 0 0 0 C 0
Figura 4.16.- Enrutamiento del contador ascendente/descendente de 2 bits.
Figura 4.17.- Simulación del contador ascendente/descendente de 2 bits.
La figura 4.17 muestra la simulación del contador ascendente/descendente de 2 bits. La

salidas B+ A+ se encuentran agrupadas en Y. La variable de control C determina si la cuenta
es de manera ascendente (C = 1) o de manera descendente (C = 0). Durante la simulación
se provocaron dos errores en filas diferentes (célula AA y célula BB). Al dañar dos filas del
arreglo embriónico se hizo necesario el uso de dos filas con células de repuestos contenidas
dentro del mismo arreglo.
81
4.3.2 Circuito votador de 3 bits
Este ejemplo es un circuito combinacional que realiza la función de votador. Los

votadores son utilizados en sistemas redundantes tolerantes a fallas para comparar la salida
de los elementos replicados y de esa manera detectar y enmascarar los errores. Un circuito
votador recibe n entradas y genera una salida. El valor de la salida es verdadera cuando
recibe por lo menos n/2 + 1 entradas verdaderas. En un circuito votador de 3 entradas, la
salida es alta o baja si por lo menos dos de las entradas son altas o bajas respectivamente.
La tabla 4.6 muestra su tabla de verdad. La figura 4.18 muestra el árbol de multiplexores que
describe la función del votador de 3 bits. El listado 4.6 presenta el archivo de entrada para
realizar el enrutamiento del votador en un arreglo embriónico.
C B A Y Y
0 0 0 0 c 0.8
0 0 1 0
Out 2 0.15
0 s 1
2 2 3
0 1 0 0
C
2 2 1
0 1 1 1 a b 0
1 0 0 0 Out 0 Out 1
1 2
0 s 1 0 s 1
1 0 1 1
1 1 0 1 0 B A A B 1
1 1 1 1
Listado 4.6.- Archivo de
Tabla 4.6.- Tabla de verdad Figura 4.18.- Árbol de entrada para enrutar el
para el circuito votador de 3 multiplexores del circuito votador circuito votador de 3 bits.
bits. de 3 bits.
La figura 4.19 muestra el resultado de decodificar los registros de configuración para

enrutamiento del circuito votador de 3 bits realizado por el algoritmo genético en un arreglo
embriónico de 2x2.
Y
NOB NIB NOUT NOB NIB NOUT

WI EO WI EO
WO EI WO EI
2
WIB EOB WIB 0 S 1 EOB
WOB EIB WOB EIB

SIB SOB
0 SIN SIB SOB SIN
NOB NIB NOUT NOB NIB NOUT

WI EO WI EO
WO EI WO EI
0 1
WIB 0 S 1 EOB WIB 0 S 1 EOB
0 1
WOB EIB WOB EIB
SIB 1
SOB 0
SIN SIB SOB
1SIN
B A C A
Figura 4.19.- Enrutamiento del circuito votador de 3 bits.
82
La figura 4.20 muestra la simulación del circuito votador. Las entradas C, B y A no se

encuentran agrupadas en esta ocasión para ver el valor de cada una de ellas. Se provocó un
error en la célula AA haciendo uso de una fila de repuesto del arreglo embriónico para que
siguiera trabajando correctamente el votador como se muestra en la figura 4.20.
Figura 4.20.- Simulación del circuito votador de 3 bits.
4.3.3 Sumador paralelo de 2 bits
Este circuito realiza la suma de dos números binarios de dos bits. Los números binarios
están representados por DC y BA, de donde D y B son los bits más significativos de cada
número. La salida XYZ contiene el resultado de la suma de los dos números binarios. La
tabla 4.7 muestra su tabla de verdad. La figura 4.21 muestra los árboles de multiplexores de
las salidas del sumador.
D C B A X Y Z
Y
0 0 0 0 0 0 0 m
0 0 0 1 0 0 1 Out 14
0 s 1
0 0 1 0 0 1 0 a X
0 0 1 1 0 1 1 k l
j D
0 1 0 0 0 0 1 Out 11 Out 12 Out 13
0 1 0 1 0 1 0 0 s 1 0 s 1 0 s 1
0 1 1 0 0 1 1 Z
B C C D
0 1 1 1 1 0 0 d e f g h i
Out 5 Out 6 Out 7 Out 8 Out 9 Out 10
1 0 0 0 0 1 0 0 s 1 0 s 1 0 s 1 0 s 1 0 s 1 0 s 1
1 0 0 1 0 1 1
1 0 1 0 1 0 0 A C B A
A B 1 B 0 0 C B C
a a a b c
1 0 1 1 1 0 1 Out 0 Out 1 Out 2 Out 3 Out 4
1 1 0 0 0 1 1 0 s 1 0 s 1 0 s 1 0 s 1 0 s 1
1 1 0 1 1 0 0
1 A 0 1 A 0 1 A 0 0 B A A B 1
1 1 1 0 1 0 1 A
1 1 1 1 1 1 0
Figura 4.21.- Árboles de multiplexores del sumador paralelo de
Tabla 4.7.- Tabla de 2 bits.
verdad para el sumador
paralelo de 2 bits.
El listado 4.7 muestra el archivo de entrada para enrutar el sumador en un arreglo

embriónico.
83
0.8
0.15
Listado 4.7.- Archivo de 4 8 15
entrada para enrutar el 4 5 6 3 1
sumador paralelo de 2 bits. 0
3 5 13 14

enrutamiento del sumador paralelo de 2 bits realizado por el algoritmo genético en un arreglo
embriónico de 4x8.
Y Z X
NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT
WI EO WI EO WI EO WI EO WI EO WI EO WI EO WI EO
WO EI WO EI WO EI WO EI WO EI WO EI WO EI WO EI
14
WIB EOB WIB EOB WIB EOB WIB 0 S 1 EOB WIB EOB WIB EOB WIB EOB WIB EOB
WOB EIB WOB EIB WOB EIB WOB EIB WOB EIB WOB EIB WOB EIB WOB EIB
SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NO UT NOB NIB NOUT
11 12 13
EOB EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB WIB 0 S 1 EOB WIB EOB WIB EOB
WIB WIB
EIB EIB EIB EIB EIB WOB EIB EIB EIB
WOB WOB WOB WOB WOB WOB WOB
WI EO WI EO WI EO WI EO WI EO WI WI EO WI
WO EI WO EI WO EI WO EI WO EI WO WO EI WO
5 6 7 EOB
8 9 10
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 WIB 0 S 1 EOB WIB EOB WIB 0 S 1 WIB 0 S 1 EOB WIB
1 0
WOB EIB WOB EIB WOB EIB WOB EIB WOB EIB WOB 0 WOB EIB WOB
SIB SOB
0 SIN SIB SOB SIN SIB SOB
0 SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
0 1 2 3 4
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB WIB EOB WIB EOB WIB 0 S 1 EOB WIB 0 S 1 EOB
1 0
WOB 1 0 EIB WOB 1 0 EIB WOB EIB WOB EIB WOB EIB WOB EIB WOB 0 EIB WOB 1 EIB
SIB 1
SOB 0SIN SIB SOB SIN SIB SOB
1 SIN
0 SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
C A A A B 0 D 0 D 0 D 0 C 0 B A
Figura 4.22.- Enrutamiento del sumador paralelo de 2 bits.
La figura 4.23 muestra la simulación sumador paralelo de dos bits. En la figura 4.23 los
numéros binarios (DC) y (BA) están agrupados en C y A respectivamente. Las salidas XYZ
estan agrupadas en Z. Se provocó durante la simulación un error en la célula AA. Se puede
notar en la figura 4.23, que la reconfiguración de las células al presentarse un error no
requirió un tiempo tan largo como en las aplicaciones secuenciales.
Figura 4.23.- Simulación del sumador paralelo de 2 bits.
84
4.3.4 Generador de Redundancia Cíclica de 4 bits (CRC-4)
Los errores son algo natural dentro de las comunicaciones de datos. Es posible
desarrollar metodologíaa de transmisión de datos que proporcionen un alto rendimiento de
detección y corrección de errores. Algunos métodos comunes para la detección de errores
son: la prueba de paridad, claves de relación constante y verificación por redundancia cíclica
[Hal92, Mor00]. Estos métodos son muy utilizados en la comunicación de datos para reducir
los errores en la trasmisión de datos. La Verificación por Redundancia Cíclica (CRC: cyclic
redundancy check) trabaja de la siguiente manera: por cada trama (cadena de caracteres)
transmitida se genera un conjunto único de dígitos de verificación, con base en el contenido
de la trama, y se añaden al final de la trama para su transmisión. El receptor a su vez, realiza
un cálculo similar con la trama completa y los dígitos de verificación. Si no se han inducido
errores, siempre se obtendrá un resultado conocido; si se obtiene una respuesta distinta, se
habrá detectado un error. [Hal92, Mor00].
El CRC-4 diseñado en esta sección genera un código de redundancia cíclica de una

trama de cuatro bits para la detección de errores. La tabla 4.8 muestra la tabla de verdad del
CRC-4. El listado 4.8 muestra el archivo de entrada para enrutar el CRC-4 en un arreglo
embriónico.
D C B A X Y Z W
0 0 0 0 0 0 0 0
0 0 0 1 0 0 1 1
0 0 1 0 0 1 1 0
0 0 1 1 0 1 0 1
0 1 0 0 1 1 0 0 0.8
0 1 0 1 1 1 1 1 0.15
0 1 1 0 1 0 1 0 2 6 10
0 1 1 1 1 0 0 1 3 4 5 1
0
1 0 0 0 1 0 1 1
4 4 5 8 9
1 0 0 1 1 0 0 0
1 0 1 0 1 1 0 1
1 0 1 1 1 1 1 0 Listado 4.8.- Archivo de entrada
1 1 0 0 0 1 1 1 para enrutar el CRC-4.
1 1 0 1 0 1 0 0
1 1 1 0 0 0 0 1
1 1 1 1 0 0 1 0
Tabla 4.8.- Tabla de verdad

del CRC-4.
La figura 4.24 muestra los árboles de multiplexores para cada salida de esta aplicación.
85
Z
j
Out 9
0 s 1
Y X W
D
e f g h i
Out 4 Out 5 Out 6 Out 7 Out 8
0 s 1 0 s 1 0 s 1 0 s 1 0 s 1
B C C D A B B A A D
a b c d
0 s 1 0 s 1 0 s 1 0 s 1
1 B 0 1 C 0 1 A 0 1 A 0
Figura 4.24.- Árboles de multiplexores del CRC-4.

enrutamiento del CRC-4 realizado por el algoritmo genético en un arreglo embriónico de 2x6.
Y X Z W
NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT
WI EO WI EO WI EO WI EO WI EO WI EO
WO EI WO EI WO EI WO EI WO EI WO EI
4 EOB 5 EOB
9 EOB EOB
8
WIB 0 S 1 WIB 0 S 1 EOB WIB WIB 0 S 1 WIB WIB 0 S 1 EOB
WOB EIB WOB EIB WOB EIB WOB EIB WOB EIB WOB EIB
SIB SOB
0 SIN SIB SOB
0 1 6 2 7 3
WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB
1 0 EIB 1 0 EIB EIB 1 0 EIB EIB 1 0 EIB
WOB WOB WOB WOB WOB WOB
SIB 1
SOB 0
SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
B 0 C B 0 A 0 B D A A B
Figura 4.25.- Enrutamiento del CRC-4.
La figura 4.26 muestra la simulación del circuito CRC-4. En la figura 4.26 las entradas
(DCBA) se encuentran agrupadas en A. Las salidas X, Y, Z, y W no están agrupadas para
notar el valor de cada una de ellas. Se provocó un error en la célula AA para verificar la
propiedad de tolerancia a fallas de la aplicación en el arreglo embriónico.
Figura 4.26.- Simulación del CRC-4.
86
4.3.5 Generador de paridad par de 4 bits
Este circuito combinacional genera el bit de paridad par de un número de cuatro bits
utilizados en la transmisión de datos [Hal92]. De forma general la paridad par se calcula
contando en cada número de n bits los unos que contenga. Si la cuenta de estos unos es
impar el circuito deberá generar un uno, pero si la cuenta es par el circuito deberá generar un
cero. La tabla 4.9 muestra su tabla de verdad. La figura 4.27 muestra el árbol de
multiplexores del generador de paridad par de 4 bits.
D C B A Y
0 Y
0 0 0 0
o
0 0 0 1 1
Out 14
0 0 1 0 1 0 s 1
0 0 1 1 0
0 1 0 0 1 m
D
n
0 1 0 1 0 Out 12 Out 13
0 s 1 0 s 1
0 1 1 0 0
0 1 1 1 1
C C
1 0 0 0 1 i j k l
1 0 0 1 0 0 s 1 0 s 1 0 s 1 0 s 1
1 0 1 0 0
1 0 1 1 1 B B B B
a b c d e f g h
1 1 0 0 0 Out 0 Out 1 Out 2 Out 3 Out 4 Out 5 Out 6 Out 7
1 1 0 1 1 0 s 1 0 s 1 0 s 1 0 s 1 0 s 1 0 s 1 0 s 1 0 s 1
1 1 1 0 1
0 A 1 1 A 0 1 A 0 0 A 1 1 A 0 0 A 1 0 A 1 1 A 0
1 1 1 1 0
Tabla 4.9.- Tabla de

verdad del generador de Figura 4.27.- Árbol de multiplexores del generador de paridad par
paridad par de 4 bits. de 4 bits.
El listado 4.9 muestra el archivo de entrada para enrutar el generador de paridad par de
4 bits en un arreglo embriónico.
Listado 4.9.- Archivo de 0.8

entrada para enrutar el 0.15
4 8 15
generador de paridad
4 8 4 2 1
par de 4 bits. 0
1 14

enrutamiento del generador de paridad par de 4 bits realizado por el algoritmo genético en un
87
NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NIB NOUT NOB NI B NOUT NOB NIB NOUT
14
WIB EOB WIB EOB WIB 0 S 1 EOB WIB EOB WIB EOB WIB EOB WIB EOB WIB EOB
12 13
WIB EOB WIB EOB WIB 0 S 1 EOB WIB EOB WIB EOB WIB 0 S 1 EOB WIB EOB WIB EOB
SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SI N
8 9 EOB
10 11 EOB
WIB EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB WIB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB
WOB EIB EIB EIB EIB WOB EIB EIB EIB WOB EIB
WOB WOB WOB WOB WOB
SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
WI WI EO WI EO WI EO WI EO WI EO WI EO WI EO
WO WO EI WO EI WO EI WO EI WO EI WO EI WO EI
0 1 2 3 4 5 6 7
WIB 0 S 1 WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB
0 1
WOB WOB 1 0 EIB WOB 1 0 EIB WOB 0 1 EIB WOB 1 0 EIB WOB 0 1 EIB WOB 0 1 EIB WOB 1 0 EIB
SIB 1
SOB 0
SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
B 0 C A B A D 0 D 0 B A C A B 0
Figura 4.28.- Enrutamiento del generador de paridad par de 4 bits.
La figura 4.29 muestra la simulación del generador de paridad par de 4 bits. Se provocó
un error en la célula AA y el circuito siguió trabajando correctamente.
Figura 4.29.- Simulación del generador de paridad par de 4 bits.
4.3.6 Generador de paridad par de 5 bits
Este circuito genera el bit de paridad par de un número de cinco bits utilizados en la
transmisión de datos [Hal92]. La tabla 4.10 muestra su tabla de verdad. La figura 4.30
muestra su árbol de multiplexores. El listado 4.10 muestra el archivo de entrada para enrutar
el generador de paridad par de 5 bits en un arreglo embriónico.
88
E D C B A Y Y
0 0 0 0 0 0 i
Out 10
0 0 0 0 1 1 0 s 1
0 0 0 1 0 1
0 0 0 1 1 0 E
g h
0 0 1 0 0 1
Out 8 Out 9
0 0 1 0 1 0 0 s 1 1 s 0
0 0 1 1 0 0
0 0 1 1 1 1 D D
0 1 0 0 0 1
0 1 0 0 1 0 e f
0 1 0 1 0 0 Out 6 Out 7
0 s 1 1 s 0
0 1 0 1 1 1
0 1 1 0 0 0
C C
0 1 1 0 1 1
0 1 1 1 0 1
0 1 1 1 1 0 Out 4 Out 5
0 s 1 0 s 1
1 0 0 0 0 1
1 0 0 0 1 0
B B
1 0 0 1 0 0 a b c d
1 0 0 1 1 1
0 s 1 0 s 1 0 s 1 0 s 1
1 0 1 0 0 0
1 0 1 0 1 1 0 A 1 1 A 0 1 A 0 0 A 1
1 0 1 1 0 1
1 0 1 1 1 0 Figura 4.30.- Árbol de multiplexores del generador de
1 1 0 0 0 0 paridad par de 5 bits.
1 1 0 0 1 1
1 1 0 1 0 1
0.8
1 1 0 1 1 0
0.15
1 1 1 0 0 1
5 6 11
1 1 1 0 1 0 5 4 2 2 2 1
1 1 1 1 0 0 0
}
1 1 1 1 1 1 1 10
Tabla 4.10.- Tabla de verdad del Listado 4.10.- Archivo de entrada para enrutar el
generador de paridad par de 5 bits. generador de paridad par de 5 bits.

enrutamiento del generador de paridad par de 5 bits realizado por el algoritmo genético en un
89
10
WIB EOB WIB EOB WIB 0 S 1 EOB WIB EOB WIB EOB WIB EOB
SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
EOB EOB
8 EOB
9 EOB EOB EOB
WIB WIB WIB 0 S 1 WIB 0 S 1 WIB WIB
EOB EOB
6 EOB
7 EOB EOB
WIB WIB WIB 0 S 1 WIB 0 S 1 WIB EOB WIB
EOB EOB
4 EOB
5 EOB EOB EOB
WIB WIB WIB 0 S 1 WIB 0 S 1 WIB WIB
WI SIB WI EO WI EO WI EO WI EO WI EO
SOB
WO SIN WO EI WO EI WO EI WO EI WO EI
EO 0 1 2 3
WIB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB 0 S 1 EOB WIB EOB
EI
1 0 1 0 0 1
WOB WOB 0 1 EIB WOB EIB WOB EIB WOB EIB WOB EIB
EOB
SIB SOB
1 SIN
0 SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN SIB SOB SIN
E 0 C 0 B A D A C 0 E 0
Figura 4.31.- Enrutamiento del generador de paridad de 5 bits.
La figura 4.32 muestra la simulación del generador de paridad de 5 bits. Se provocó un

error en la célula AA y el generador siguió trabajando correctamente.
Figura 4. 32.- Simulación del generador de paridad par de 5 bits.
90
4.4 Resumen
En este capítulo se presentó el diseño de circuitos digitales que fueron utilizados para
comprobar la eficacia del enrutador de arreglos Embriónicos desarrollado en esta tesis.
Nueve fueron los circuitos diseñados presentados en este capítulo de resultados.
Únicamente el contador de cero a nueve fue presentado en detalle. En el apéndice al final de
este documento se presentan los diagramas esquemáticos de la célula embriónica utilizada
para realizar la simulación en la plataforma Foundation de Xilinx. Para la simulación de los
ejemplos se necesitó de un arreglo bidimensional de células embriónicas con filas de
repuesto que se convirtieron en filas activas cuando se simuló una falla en una célula.
91
Conclusiones
Esta tesis presentó una nueva estrategia para resolver el problema de enrutamiento de
arreglos embriónicos. Los arreglos embriónicos, junto con los algoritmos genéticos, forman
parte de los sistemas bioinspirados al tomar los conceptos básicos de la biología como son:
evolución natural, adaptación y reproducción de las especies sobre un medio ambiente. La
hipótesis de la tesis ha sido probada a lo largo de este trabajo: Es posible resolver el
enrutado de un arreglo embriónico utilizando un algoritmo genético.
Los conceptos tomados de la embriología aplicados a los sistemas electrónicos dan una
nueva temática llamada arreglos embriónicos. La incorporación de las propiedades de
tolerancia a fallas en una arquitectura celular hacen aún más atractivo a este campo de
investigación.
Para implementar una aplicación en los arreglos embriónicos es necesario obtener los
siguientes elementos: tabla de verdad, árbol de decisión binaria ordenados, árbol de
multiplexores, trasladar el árbol de multiplexores en un arreglo embriónico.
Según la arquitectura del sistema embriónico usado [Ort00a], la conectividad limitada

entre las células del arreglo hace que a medida que crece la complejidad de la aplicación, se
vuelva más complicado el enrutamiento del diseño en un arreglo embriónico en forma
manual. Por tal motivo se propuso en este trabajo un enrutador automático para los arreglos
embriónicos utilizando los algoritmos genéticos.
La estrategia de la eliminación de una fila, cuando se daña una célula, fué elegida por
ser muy práctica su realización a través de la generación de las nuevas coordenadas del
arreglo y permitir con esto la reducción del uso de recursos en la implementación final de la
aplicación en los arreglos lógicos programables (FPGA).
Parte importante resultó el uso de los árboles binarios de decisión ordenados, formados
a partir de la tabla de verdad de la función, porque permitió un traslado muy fácil hacia los
árboles de multiplexores que describen a la aplicación. La facilidad estriba en que los árboles
binarios de decisión ordenados son muy parecidos en su forma estructural a los árboles de
multiplexores.
Conclusiones
A través de la realización de diversos ejemplos y de la ejecución de un cierto número de

corridas del algoritmo genético programado, se encontró que el ajuste adecuado de los
valores de los operadores genéticos, como la cruza y la mutación, permiten otra orientación
para la búsqueda de la solución.
La selección por torneo es muy sencilla de implementar y su capacidad para utilizar a

toda la población de individuos, le permite realizar una mejor selección obteniendo al
individuo con la mejor aptitud, provocando con esto que el algoritmo genético evolucione
hacia una mejor solución a través de las generaciones.
El número de generaciones usado por el algoritmo genético programado para enrutar

cada aplicación, fue tomado experimentalmente a través de diversas corridas, observando la
aptitud final del mejor individuo en cada ejecución del programa. Las aplicaciones con mayor
número de multiplexores necesitaron un mayor número de generaciones para lograr el
enrutamiento de los mismos.
El enrutador automático desarrollado es capaz de enrutar aplicaciones de tipo

combinacional y secuencial de una forma efectiva, práctica y considerablemente rápida con
respecto al enrutamiento en forma manual.
El arreglo embriónico donde el algoritmo genético realiza el enrutamiento de la función

puede ser de tamaño variable, es decir, se programó de manera general para poder utilizar
cualquier dimensión del arreglo embriónico con tan solo modificar el número de filas y
columnas del mismo.
Una de las principales características de la embriónica, es la aplicación de la tolerancia

a fallas a los sistemas evolutivos para su mejor desempeño ante condiciones desfavorables
en el funcionamiento del sistema. Esto implica la adición de células de repuesto al arreglo
embriónico para ser utilizadas cuando una célula esté dañada. Al llevar a cabo las
simulaciones de diversas aplicaciones en los arreglos embriónicos , mostradas en el capítulo
IV de resultados, se pudo comprobar que después de la reconfiguración de las células, al
presentarse una falla en una célula, el sistema seguió trabajando perfectamente dando los
valores de salida correctos. Con todo esto se pudo observar el manejo de la tolerancia a
fallas aplicado a los arreglos embriónicos.
El algoritmo genético que resuelve el enrutamiento de los arreglos embriónicos fue

programado en el lenguaje de programación C. El programa necesita de tres archivos de
entrada que describan las características del árbol de multiplexores de la aplicación y
93
Conclusiones
proporciona un archivo VHDL de salida que contiene los registros de configuración de las
células del arreglo. Este archivo VHDL es utilizado para la simulación en Foundation de
Xilinx.
Para simular una aplicación es necesario un arreglo bidimensional de células

embriónicas con un cierto número de células de repuesto para proporcionar la propiedad de
tolerancia a fallas de estos sistemas embriónicos. La arquitectura celular implementada se
muestra en el apéndice de este trabajo.
El futuro de la embriónica
Tal vez en los próximos años seamos testigos de la aplicación de nuevos sistemas que
puedan tomar decisiones a través del aprendizaje del medio ambiente en que se desarrollan.
La elaboración de nuevas máquinas con cierta inteligencia que puedan soportar cambios
bruscos de su entorno y poder desarrollarse a pesar de tener diversos factores en contra.
La embriónica no estará alejada de todos estos nuevos avances tecnológicos y seguirá

tomando cada día mas fuerza inspirándose en los sistemas biológicos. La perfección de la
naturaleza siempre será tomada como ejemplo para sistemas prácticos diseñados por el
hombre.
La capacidad de autoreparación, autoreproducción y autoconfiguración de los sistemas

embriónicos, serán motivos de nuevos intentos por lograr una mejor aplicabilidad hacia los
sistemas de alta disponibilidad.
Aportaciones
La aportación más importante obtenida en el presente trabajo es una nueva estrategia

para resolver el problema de enrutamiento de los arreglos embriónicos de tamaño variable.
La conectividad limitada que existe entre las células se hace más evidente a medida que
crece la complejidad de la aplicación. Resolver el enrutamiento de manera manual se vuelve
un proceso lento, tedioso y con posibles errores humanos. Ante todo esto, se propone un
enrutador automático basado en los algoritmos genéticos.
La inclusión de una matriz de conectividad entre las células, permite simular la

propagación de las variables de entrada a través del arreglo embriónico. La flexibilidad de la
matriz permite simular la propagación de las variables para cualquier tamaño de arreglo, tan
94
Conclusiones
solo agregando columnas a la derecha de la matriz de acuerdo con el número de células del
arreglo embriónico.
Propiedades como: velocidad, búsqueda paralela, robustez y la alta probabilidad de

encontrar la solución esperada, hacen muy atractivo el uso de los algoritmos genéticos a
problemas de enrutamiento. La representación de los registros de configuración del arreglo
embriónico en forma de cromosomas permitió el uso adecuado de los algoritmos genéticos
en la resolución del problema.
El enrutador automático desarrollado permite el enrutamiento de aplicaciones de tipo

combinacional y secuencial de una forma rápida, efectiva, y fácil de usar. La facilidad del uso
del enrutador automático va encaminada en que a partir del árbol de multiplexores de la
aplicación solo se necesitan tres archivos pequeños de entrada para poder realizar el
enrutamiento. Utilizando esta herramienta se evitan los posibles errores humanos al enrutar
una aplicación en forma manual.
El algoritmo genético desarrollado proporciona una gran número de soluciones de

enrutado (un promedio de 80 cromosomas útiles de una población de 100 individuos). Con
esta redundancia en las soluciones deseadas se puede cubrir aún mejor la propiedad de
tolerancia a fallas en una arquitectura celular, al poder implementar más de una solución de
enrutamiento para el arreglo embriónico en caso de que una solución deseada falle.
Trabajos futuros
El objetivo general de este trabajo fue lograr el enrutamiento de los arreglos embriónicos
mediante el uso de los algoritmos genéticos. Este objetivo se cumplió y se pudo resolver el
problema encontrando un gran número de soluciones diferentes deseadas. Uno de los
trabajos futuros que le pueden dar continuidad al presente es el realizar un análisis de las
soluciones deseadas y encontrar la solución óptima.
La optimización del problema puede ir encaminada a encontrar un enrutamiento que

permita un mejor acomodo de los multiplexores del árbol en el arreglo. Este acomodo puede
ser utilizando un menor número de filas en el arreglo embriónico, para así dejar un mayor
número de filas de repuestos para cuando falle una célula.
Realizar una interfaz gráfica a través de un lenguaje de programación que permita

mostrar de manera automática los resultados del enrutamiento encontrado por el algoritmo
95
Conclusiones
genético, donde se presente la ubicación de los multiplexores con sus entradas correctas en
las células asignadas.
Otro cuestionamiento por resolver en un futuro es de qué forma afecta la numeración

inicial del árbol de multiplexores para su enrutamiento. En algunos ejemplos mostrados se
presentan más de una función de salida, por lo que se complica la introducción de las
variables de entrada, y surje una pregunta ¿cúal será el mejor acomodo de las variables de
entradas para introducirlas al árbol?.
El empleo de los algoritmos genéticos para resolver el problema del enrutamiento de los
arreglos embriónicos resultó ser muy efectivo, pero aun existen otros mecanismos que
posiblemente puedan resolver el mismo problema, estas herramientas son: algoritmos
evolucionarios, recocidos simulados, lógica difusa, redes neuronales, etc.
Al poder resolver el problema de enrutamiento de los arreglos embriónicos mediante

alguno o algunos de los mecanismos antes mencionados, se podrá realizar un análisis
comparativo con el uso de los algoritmos genéticos.
96
APÉNDICE
Diagramas esquemáticos de una célula embriónica
Figura A.1.- Módulo de memoria.
98
Figura A.2.- Generador de coordenadas.
99
Figura A.3.- Enrutador de Entrada / Salida.
100
Figura A.4.- Elemento de procesamiento.
101
Figura A.5.- Arquitectura de una célula embriónica.
102
Figura A.6.- Símbolo creado a partir del esquemático de la figura A.5.
103
Figura A.7.- Arreglo embriónico de 5x8 para simular el contador 0-9 y su detector de rebose (DR).
104
Bibliografía y referencias
[Ahn95] Ahn H. I., Han S. K., Cho T. W., “Genrouter: A Genetic Algorithm for Channel
Routing Problems”, Microelectronics and VSLI, 1995, TENCON ’95., IEE Region
10 International Conference on, 1995.
[Ara01] Arabas J., “Applying an evolutionary algorithm to telecomunication network
design”, IEEE Transactions on evolutionary computation, August 2001.
[Ars96] Arslan T., D. H. Horrocks and E. Ozdemir, “Structural synthesis of cell-based
VLSI circuits using a multi-objective genetic algorithm”, Electronics Letters,
March 1996.
[Bak85] Baker J. E., “Adaptive Selection Methods for Genetic Algorithms”, Proceedings
of sirts ICGA, Lawrence Erlbaum Associates Publishers, pp 101-111, 1985.
[Bar91] Bartee T. C., Data communications, networks and systems, SAMS, 1991.
[Bel78] Bell D., “Decision Trees, Tables and Lattices”, in Batchelor B. (ed.), Patterm
recognition: ideas in practice, Plenum Press, 1978.
[Bli95] Blickle T., Thiele L., “A mathematical analysis of Tournament Selection”,
Proceeding of sixth ICGA, Morgan Kaufmann Publishers, pp 9-16, 1995.
[Bra02] Bradley D. and Tyrrell A., “Immunotronics- Novel finite-state-machine

architectures with buit-in self-test using self-nonself differentiation,” IEEE
Transactions on Evolutionary Computation, Vol.6-3, pp.227-238, June 2002.
[Car86] Carlson A. B., Communication systems, Mc Graw Hill, 1986.
[Cer79] Cerny E., “Synthesis of Minimal Binary Decision Trees”, IEEE Trans. On
Computers, Vol. 28-7, July 1979, pp. 472-482.
[Cha70] Chang H., Fault Diagnosis of Digital Systems, Wiley, 1970.
[Dei95] Deitel H. M., P. J. Deitel, Cómo programar en C/C++, Prentice Hall, 1995.
[Fit88] Fitzgerald J., Eason T. S., Fundamentos de Comunicación de Datos, Limusa,

1988.
[Fog00] Fogel D. B., “What is evolutionary computation?”, IEEE Spectrum, February
2000.
[Fog66] Fogel, L. J., Owens A. J., and Walsh M. J., Artificial Intelligence Through
Simulated Evolution, Jhon Wiley, Chichester, UK, 1966.
[Göc96] Göckel N., et al, “A hybrid Genetic Algorithm for the Channel Routing Problem”,
Circuits and Systems, 1996, ISCAS ’96., Connecting the World., 1996, IEEE
International Symposium on, Volume 4, 1996.
[Gol89] Goldberg D., Genetic Algorithms in search, optimization and machine learning,
Reading Massachusetts, 1989.
[Gon88] Gonzales N., Comunicaciones y Redes de Procesamiento de Datos, Mc Graw
Hill, 1988.
[Gon99] Goni B. M. and Arslan T., “An Evolutionary 3D Over-the-Cell Router”,
ASIC/SOC Conference, 1999, Twelfth Annual IEEE International, 1999.
[Hal92] Halsall F., Data communications, computer networks and open systems,
Addison Wesley Longman, 1992.
[Han77] Hanani M., “An Optimal Evaluation of Boolean Expresions in an online query
system”, Commun. ACM, Vol. 20-5, May 1977, pp. 344-347.
[Hem96] Hemmi H., et al, “Development and Evolution of Hardware Behaviors”, Lecture
Notes in Computer Science – Towards Evolvable Hardware, Vol. 1062,
Springer-Verlag, 1996.
[Hig96] Higuchi T., et al, “Evolvable Hardware and its Application to Pattern Recognition
and Fault-Tolerant Systems”, Lecture Notes in Computer Science – Towards
Evolvable Hardware, Vol. 1062, Springer-Verlag, 1996.
[Hol92] Holland J., Adaptation in natural and artificial systems, Cambridge
Massachusetts, 1992.
[Ina01] Inagaki J., Haseyama M., Kitajima H., “A New Genetic Algorithm for Routing the
Shortest Route Via Several Designated Points”, Circuits and Systems, 2001,
ISCAS 2001, The 2001 IEEE International Symposium on, Volume 2, 2001.
[Ina99] Inagaki J., Haseyama M., Kitajima H., “A Genetic Algorithm for Determining
Multiple Routes and its Applications”, Circuits and Systems, 1999, ISCAS ’99,
Proceedings of the 1999 IEEE International Symposium on, Volume 6, 1999.
[Jac01] Jackson A. and Tyrrell A., "Asynchronous Embryonics”, Proceedings of Third

NASA/DoD workshop on Evolvable Hardware, IEEE Computer Society, pp.201-
210, 2001.
[Jho96] Q. D. Jhonson, Sun R., “A genetic Algorithm for VLSI Channel Routing in the
Presence of Cyclic Vertical Constraints”, Circuits and Systems, 1996., IEEE 39th
Midwest symposium on, Volume 1, 1996.
[Ko97] Ko K., Tang K., Chan Ch., Man K., Kwong S., “Using genetic algorithms to
design mesh networks”, IEEE Computer, August 1997.
[Koz92] Koza J., Genetic Programming: on the programming of computers by means of
natural selection, Massachusetts, 1992.
[Kuo81] Kuo F. K., Protocols and techniques for data communication networks, Prentice
Hall, 1981.
[Kwo00] Kwong S., Wing D., Tang K., Man K., “Optimization of spare capacity in self-
106
healing multicast ATM network using genetic algorithm”, IEEE Transactions on
industrial electronics, December 2000.
[Laf89] Lafore R., Turbo C, Programming for the PC, The Waite Group, Inc., 1989.
[Leu98] Leung Y., Li G., Xu Z., “A genetic algorithm for the multiple destination routing
problems”, IEEE Transactions on evolutionary computation, November 1998.
[Lie96] Lienig J., “A Parallel Genetic Algorithm for two Detailed Routing Problems”,
Circuits and Systems, 1996, ISCAS ’96., Connecting the World., 1996, IEEE
International Symposium on, Volume 4, 1996.
[Lie97] Lienig J., “A Parallel Genetic Algorithm for Perfomance-Driven VLSI Routing”,
Evolutionary Computation, IEEE Transactions on, April 1997.
[Lim97] Lim Q. and Chew H., “Joining of compacted cells using genetic algorithm”,
Electronics Letters, Volume: 33 Issue: 23, November 1997.
[Lon01] Lones M.A., Tyrrell A.M., “Enzyme Genetic Programming”, in proceedings of the
Congress on Evolutionary Computation 2001 (CEC2001), Seoul, Korea, May
2001.
[Man96] Mange D., Goeke M., Madon D., et al. “Embrionics: a new family of coarse-
grained FPGA with self-repair and self-reproduction properties”, in towards
evolvable hardware: The evolutionary engineering approach, LNCS 1062, E.
Sanchez and M. Tomassini (eds.), Springer-Verlag: Berlin, pp. 197-220, 1996.
[Man97] Mani N., Srinivasan B., “Using Genetic Algorithm for Slicing Floorplan Area
Optimization in Circuit Design”, Systems, Man, and Cybernetics, 1997,
Computational Cybernetics and Simulation., 1997 IEEE International Conference
on, Volume: 3, 1997.
[Mar96] Marchal P., Nussbaum P., Piguet C., et al., “Embrionics: The birth of synthetic
life,” in towards evolvable hardware: The evolutionary engineering approach,
LNCS 1062, E. Sanchez and M. Tomassini (eds.), Springer-Verlag: Berlin, pp.
166-196, 1996.
[Mil99] Miller J. F. and Thompson P., “Evolving Circuits on Gate Arrays”, Reconfigurable
Systems (Ref. No. 1999/061), IEEE Colloquium on, 1999.
[Min78] Minieka E., Optimization Algorithms for Networks and Graphs, Marcel Dekker
Inc., 1978.
[Mor00] Moreno J. de J., Morales J., et al, “Implementación de un polinomio para la

evaluación del CRC16 utilizando un microcontrolador PIC1684”, 2º Congreso de
Ingeniería Eléctrica y Electrónica Aplicada, Instituto Tecnológico de Durango,
Durango 2000.
[Mor95] Moreno J. de J., “Sistema para la Automatización de la Iluminación en
Edificios”.(Tesis M.C.; Cuernavaca, Mor.: Centro Nacional de Investigación y
Desarrollo Tecnológico, Julio 95).
[Not96] Noteboom R. and Ali H. H., “A New Genetic Algorithm for Single Row Routing”,
Circuits and Systems, 1995, Proceedings., Proceedings of the 38th Midwest
107
Symposium on, Volume 2, 1996.
[Ort00a] Ortega Sánchez C., Embrionics: A bio-inspired fault-tolerant multicellular
system, The University of York, Department of Electronics Bio-inspired and Bio-
Medical Engineering Group, York, England, may 2000.
[Ort00b] Ortega Sánchez C., Mange D., Smith S. and Tyrrell A., “Embrionics: A bio-
inspired cellular architecture with fault-tolerant properties”, Genetic Programming
and Evolvable Machines, vol. 1-3, pp 187-215, Julio 2000.
[Paz99] Paz Ramos M. A., Control de un sistema MIMO por medio de técnicas difuso-
genéticas, Cenidet 1999.
[Pol01] Politécnico de Lausana, Lausana, Suiza, Página en internet,
http://diwww.epfl.ch/recherche/, 2001.
[Rec73] Rechenberg I., Evolutionsstrategie: Optimierung technischer System nach

Prinzipien der biologischen Evolution, Fromman-Holzboog Verlag, Stuttgart,
1973.
[Ron98] Ronald S. and Kirkby S., “Compund Optimisation. Solving Transport and Routing
Problems with a Multi-Chromosome Genetic Algorithm”, Evolutionary
Computation Proceedings, 1998, IEEE World Crongress on Computatuonal
Intelligence., The 1998 IEEE International Conference on, 1998.
[Sal99] Saltourus M., et al, “An Efficient Evolutionary Algorithm for (Near-) Optimal
Steiner Trees Calculation: an Aproach to Routing of Multipoint Connections”,
Computational Intelligence and Multimedia Aplications, 1999, ICCIMA ’99,
Proceedings, Third International Conference on, 1999.
[San97] Sanchez E., Mange D., Sipper M., et al, “Phylogeny, Ontogeny and Epigenesis:
Three Sources of Biological Inspiration for Softening Hardware”, en Proceedings
of 1st International Conference on Evolvable Systems: From Biology to Hardware
(ICES96), LNCS 1259, Springer-Verlag, 1997, pp.35-54
[Sch81] Schwefel, H.-P., Numerical Optimization for Computer Models, John Wiley,
Chichester, UK, 1981.
[Sch90] Schwartz M., Transmisión de información, modulación y ruido, Mc Graw Hill,
1990
[Sch95] Schnecke V., Vornberger O., “Genetic Design of VLSI-Layouts”, Genetic
Agorithms in Engineering Systems: Innovations and Applications, 1995,
GALESIA, First International Conference on, 1995.
[Sin01] Sinha K., et al, “Partitioning Routing Area into Zones with Distinct Pins”, VLSI
Design, 2001, 14th International Conference on, 2001.
[Sip00] Sipper M., Ronald E. M. A., “A new species of hardware”, IEEE Spectrum,
March 2000.
[Swa89] Swamy M. N. S., Thulasiraman K., Graphs, networks, and algorithms, Edit. John
Wiley & Sons, 1989.
108
[Tan97] Tanenbaum A. S., Redes de computadoras, Pearson, pp. 346-400, 1997.
[Tau98] Taubes G., “Tras una Máquina consciente”, Discover en Español, Julio 1998.
[Tom96] Tomasi W., Sistemas de comunicaciones electrónicas, Prentice may, 1996.
[Tyr01] Tyrrell A., Hollingworth G. and Smith S., “Evolutionary Strategies and Intrinsic
Fault Tolerance”, Proceedings of Third NASA/DoD workshop on Evolvable
Hardware, IEEE Computer Society, pp.98-106, 2001.
[Uni01] Universidad de York, York, Inglaterra, Página en internet, http://www.york.ac.uk/,
2001.
[Wei77] Weide B., “A Survey of Analysis Techniques for Discrete Algorithms”, ACM
computing surveys, Vol. 9-4, Dec. 1977, pp. 291-313.
[Wir76] Wirth N., Algorithms + Data Structures = programs, Prentice Hall, 1976.
[Wol96] Wolf H. G. and Mlynski D. A., “A New Genetic Single-Layer Routing Algorithm
for Analog Transistor Arrays”, Circuits and Systems, 1996, ISCAS ’96.,
Connecting the World., 1996, IEEE International Symposium on, Volume 4,
1996.
[You01] Youssef H., Sait S. M., Khan S. A., “, “An evolutionary Algorithm for Network
Topology Design”, Neural Networks, 2001, Proceedings, IJCNN ’01,
International Joint Conference on, Volume: 1, 2001.
[Zbi96] Zbigniew M., Genetic algorithms + Data structures = Evolution programs,
Springer, 1996.
[Zha99] Zhang Q., Leung Y., “An orthogonal genetic algorithm for multimedia multicast
routing”, IEEE Transactions on evolutionary computation, April 1999.
109

123MC JM

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

123MC JM

Cargado por

Copyright:

Formatos disponibles

SEP SNIT SEIT

CENTRO NACIONAL DE INVESTIGACIÓN Y

ACADEMIA DE LA MAESTRÍA EN ELECTRÓNICA

"ENRUTADOR DE ARREGLOS EMBRIÓNICOS

Director de Tesis: Dr. César Ortega Sánchez

Codirector de Tesis: Dr. José Torres Jiménez

Alumno Solicitante: Ing. Jorge Morales Cruz.

Cuernavaca Morelos, Agosto de 2002.

A Dios, por darme la oportunidad de existir.

Al Dr. César Ortega Sánchez y al Dr. José Torres Jiménez, por su

1.1 INTRODUCCIÓN ................................................................................................................... 18

2. ALGORITMOS GENETICOS Y ENRUTADORES .......................................................35

2.1 INTRODUCCIÓN ................................................................................................................... 35

3. ENRUTADOR PROPUESTO ...........................................................................................44

3.1 REPRESENTACIÓN DE LA CONECTIVIDAD ENTRE CÉLULAS DEL ARREGLO EMBRIÓNICO........... 44

4.1 AMBIENTE DE DESARROLLO FOUNDATION DE XILINX............................................................. 68

BIBLIOGRAFÍA Y REFERENCIAS ..................................................................................105

Figura 0.1.- Estructura de la tesis................................................................................................... 16

El incremento considerable en el poder computacional y más recientemente, la aparición

La evolución natural implica poblaciones de individuos, cada uno conteniendo una

El estudio de la vida en cualquier contexto requiere del entendimiento de los cuatro

INTELIGENCIA ARTIFICIAL (AI) VIDA ARTIFICIAL (ALIFE)

emular las propiedades de la naturaleza como lo son reproducción, sobrevivencia,

La idea primordial en embriónica es tomar los conceptos de la Biología para realizar un

La hipótesis a comprobar en esta tesis es que es posible

Diseñar, desarrollar y probar un enrutador automático basado en algoritmos genéticos

? Representar en forma abstracta de la conectividad del arreglo embriónico (enrutado

Al desarrollar el presente tema de tesis se propone obtener los siguientes alcances:

? Representación abstracta de la topología del arreglo de multiplexores y de la

? Algoritmo genético que resuelva el enrutado del arreglo de multiplexores en el arreglo

Aportación o contribución del trabajo

Con el presente trabajo de tesis se pretende obtener:

? Inicio del estudio de los arreglos embriónicos en México.

En la figura 0.1 se muestra la estructura de la tesis:

Figura 0.1.- Estructura de la tesis.

El capítulo I presenta los conceptos básicos tomados de la biología por la embriónica.

El capítulo III describe la forma de implementar a los elementos que constituyen al

En el capítulo IV, se presentan los resultados de la simulación en Foundation de Xilinx

Este capítulo presenta en la sección 1.1 los antecedentes y conceptos

Una de las instituciones dedicadas al estudio de la electrónica inspirada en la biología es la

? Embriónica: La embriónica propone una nueva familia de arreglos de procesadores

proyecto incluye la investigación de tolerancia a fallas como una propiedad implícita

Otra institución dedicada a la búsqueda de nuevas aplicaciones electrónicas inspiradas

El objetivo principal del grupo de investigación en el Politécnico de Lausana es el

? Aplicaciones que requieren muy alto nivel de confiabilidad, como la electrónica

Embriónica es un término adoptado para describir un hardware reconfigurable capaz de

1.1.3 Conceptos tomados de la biología

Las células se diferencían dentro de un embrión de acuerdo a la posición que guardan

Las arquitecturas embriónicas permiten emular algunos de los mecanismos observados

La función lógica de cada célula es determinada por uno de los registros de

Coordenadas únicas 12 Desde el vecino S

Figura 1.1.- Componentes básicos de un arreglo embriónico.

La arquitectura mostrada en la figura 1.1 presenta las siguientes ventajas:

? Es altamente regular, lo cual facilita su implementación en silicio. El elemento de

En un arreglo embriónico convencional se requiere tener en cada célula, memoria

El elemento de procesamiento de la célula requiere de 17 bits para su configuración. La

La figura A.1 del apéndice muestra el esquemático de la memoria implementada para

m,0 m,0 m,n Generador de

Figura 1.2.- Estructura de la memoria de un arreglo embriónico.

1.2.2 Generador de coordenadas

Si la célula está en malas condiciones de operación entonces se vuelve transparente, es

Al bloque de 0,0 0,1 0,n

Figura 1.3.- Generación de coordenadas para cada célula.