ALGORITMO GENÉTICO IMPLEMENTADO EM FPGA PARA EVOLUÇÃO DE ... · NÚCLEO DE CIÊNCIAS EXATAS E...

CENTRO UNIVERSITÁRIO POSITIVO

NÚCLEO DE CIÊNCIAS EXATAS E TECNOLÓGICAS

ENGENHARIA DA COMPUTAÇÃO

ALGORITMO GENÉTICO IMPLEMENTADO EM FPGA PARA

EVOLUÇÃO DE HARDWARE

Tiago Carvalho Oliveira

Monografia apresentada à disciplina de Projeto Final como requisito parcial à conclusão

do Curso de Engenharia da Computação, orientada pelo Prof. Valfredo Pilla Júnior

UNICENP/NCET

Curitiba

2007

TERMO DE APROVAÇÃO

Tiago Carvalho Oliveira

Algoritmo genético implementado em FPGA para evolução de hardware Monografia aprovada como requisito parcial à conclusão do curso de Engenharia da Computação

do Centro Universitário Positivo, pela seguinte banca examinadora:

Prof. Valfredo Pilla Júnior (Orientador) Prof. Maurício Perretto Prof. Edson Pedro Ferlin

Curitiba, 15 de Dezembro de 2007.

AGRADECIMENTOS Há muitas pessoas que contribuíram diretamente ou indiretamente para a finalização e sucesso

deste projeto de conclusão de curso. Entretanto, para registrar o devido reconhecimento a quem

mais contribuiu, deixo meus agradecimentos para aqueles que se esforçaram durante anos para

me proporcionar o que eles mesmos não tiveram a oportunidade de ter, meus pais.

RESUMO

O projeto consiste no em um sistema capaz de evoluir um circuito eletrônico através de um

algoritmo genético. Este sistema é composto por três módulos principais: algoritmo genético

(embarcado em FPGA), módulo evolutivo (simulado no software SMASH) e módulo de

avaliação (software desenvolvido em C++). Os módulos de avaliação e simulação operam em

um computador comum e se comunicam com o algoritmo genético (AG) embarcado em uma

FPGA.

O objetivo principal do projeto é embarcar uma variante de um algoritmo genético específico

(Algoritmo Genético Compacto) em FPGA. A evolução do hardware é utilizada como validação

da capacidade de busca de solução do AG embarcado com um problema complexo.

O circuito simulado (circuito evoluído) é um amplificador de baixo ruído (LNA – Low Noise

Amplifier) que usa tecnologia de circuitos integrados CMOS e modelagem de transistores

MOSFET do tipo enriquecimento com base em corrente. Valores e dimensões de componentes

são utilizadas como variáveis no projeto do circuito a fim de obter um desempenho adequado do

amplificador para a freqüência central de operação. Foram determinados quatro parâmetros para

avaliação de desempenho: impedância do circuito, potência dissipada, diferença de fase e

linearidade de operação.

Palavras-chave: Hardware evolutivo, Computação Evolutiva, Algoritmo Genético, Algoritmo

Genético Compacto (CGA), Algoritmo Evolutivo, Field Programmable Array (FPGA),

Computação Reconfigurável, Hardware Reconfigurável, Amplificador de baixo ruído (LNA).

Genetic Algorithm implemented on FPGA for Evolvable Hardware applications

ABSTRACT

The project consists on a system capable of evolving (through the use of Genetic Algorithms) a

circuit. This system is formed by three main modules: genetic algorithm (embedded on FPGA),

evolvable module (simulated on SMASH software) and assessment module (C++ developed

software). The assessment module runs on a personal computer and has an interface with the

genetic algorithm (GA) embedded on a FPGA.

The project main objective is to embed a variation of a specific GA (the compact genetic

algorithm) on a FPGA. The hardware evolution is used to validate the search power of the

embedded GA to solve a complex problem.

The simulated circuit (evolvable circuit) is a Low Noise Amplifier (LNA) based on CMOS

integrated circuit technology and MOSFET transistor modeling. Values and dimensions of

components are used as variables on circuit design project to obtain an amplifier adequate

performance on a central operation frequency. Four parameters are used to assess performance:

circuit impedance, dissipated power, phase difference and operating linearity.

Key words: Evolvable Hardware, Evolutionary Computation, Genetic Algorithm, Compact

Genetic Algorithm (CGA), Evolutionary Algorithm, Field Programmable Array (FPGA),

Reconfigurable Computing, Low Noise Amplifier (LNA).

SUMÁRIO

Capítulo 1 - Introdução ....................................................................................................... 10

1.1 Motivação................................................................................................................................ 10

1.2 Definição do Trabalho.................................................................................................................. 11

Capítulo 2 – Fundamentação Teórica .................................................................................. 12

2.1 Dispositivos Lógicos Programáveis............................................................................................. 12

2.1.1 Field Programmable Gate Arrays (FPGA)................................................................................ 12

2.2 Computação Evolutiva................................................................................................................. 13

2.2.1 Algoritmos Genéticos................................................................................................................ 14

2.2.2 Algoritmo Genético Compacto ................................................................................................. 16

2.3 Hardware Evolutivo ..................................................................................................................... 18

Capítulo 3 – Especificação do Projeto ................................................................................. 20

3.1 Especificação do Hardware.......................................................................................................... 20

3.1.1 Separação Física........................................................................................................................ 20

3.1.2 Separação Lógica ...................................................................................................................... 20

3.2 Especificação do Software ........................................................................................................... 21

Capítulo 4 – Desenvolvimento e Implementação .................................................................. 23

4.1 Hardware...................................................................................................................................... 23

4.1.1 Diagrama em blocos.................................................................................................................. 23

4.1.2 Materiais.................................................................................................................................... 26

4.2 Software ....................................................................................................................................... 28

4.2.1 Diagrama de fluxo de dados do Controlador do AGC.............................................................. 28

4.2.2 Diagrama de fluxo de dados do software avaliador .................................................................. 32

4.2.3 Diagrama de Estados do Controlador do AGC......................................................................... 34

4.2.4 Diagrama de Estados do componente de comunicação ............................................................ 35

Capítulo 5 – Validação e Resultados.................................................................................... 37

5.1 – Simulação do AGC ................................................................................................................... 37

5.2 – Validação do AGC e comunicação com o computador ............................................................ 38

5.3 – Validação do AGC para evolução de hardware ........................................................................ 39

Capítulo 6 - Conclusão ........................................................................................................ 43

Capítulo 7 - Referências Bibliográficas ............................................................................... 44

LISTA DE FIGURAS

Fig. 1 - Módulos do projeto.............................................................................................. 11

Fig. 2 - Estrutura de Algoritmo Evolutivo ........................................................................ 14

Fig. 3 - Pseudocódigo do Algoritmo Genético Compacto ................................................. 18

Fig. 4 - Separação dos módulos de hardware................................................................... 20

Fig. 5 - Blocos funcionais do projeto e fluxo de dados...................................................... 21

Fig. 6 - Diagrama em blocos do AGC .............................................................................. 23

Fig. 7 - Placa DE2 da Altera............................................................................................ 26

Fig. 8 - Cabo de conexão entre a porta paralela e a placa DE2 ....................................... 27

Fig. 9 - Conexão entre a placa DE2 e o cabo que liga à porta paralela ........................... 28

Fig. 10 - Diagrama de fluxo de dados do AGC................................................................ 31

Fig. 11 - Código-fonte de configuração de arquivos e chamada de execução do SMASH 32

Fig. 12 - Diagrama de fluxo de dados do software de cálculo do fitness.......................... 33

Fig. 13 - Código da função de comunicação do computador com a FPGA...................... 36

Fig. 14 - Esquemático do circuito do LNA ...................................................................... 40

LISTA DE SIGLAS

AG – Algoritmo Genético

AGC – Algoritmo Genético Compacto

CE – Computação Evolutiva

EA – Algoritmo Evolutivo

FPGA – Field Programmable Gate Array

HE – Hardware Evolutivo

LNA – Low noise amplifier

NCET- Núcleo de Ciências Exatas e Tecnológicas

PC – Computador Pessoal

PLD – Programmable logic device

UNICENP – Centro Universitário Positivo

LISTA DE TABELAS

TABELA 1 Características da família Cyclone II de FPGAs ........................................... 26

TABELA 2 Estados da máquina do controlador do AGC................................................. 34

TABELA 3 Estados da máquina do componente de comunicação.................................... 35

TABELA 4 Estados do AGC e ciclos de clock.................................................................. 38

TABELA 5 Restrições dos parâmetros do LNA................................................................ 41

TABELA 6 Resultados das simulações ............................................................................ 41

10

CAPÍTULO 1 - INTRODUÇÃO

O crescimento acelerado nas últimas décadas da utilização de circuitos e componentes

eletrônicos nos mais diversos tipos de equipamentos e instalações fez com que surgissem novas

necessidades além do desenvolvimento e implementação dos circuitos. Entre elas podemos citar

a preocupação com o consumo de energia, disponibilidade de espaço físico e acesso à

manutenção. Algumas aplicações eletrônicas requerem um pequeno consumo de energia e

pequeno espaço físico, como por exemplo, dispositivos portáteis alimentados por bateria. Alguns

desses dispositivos podem ainda ter finalidades cuja localização ou funcionamento impeçam

manutenções regulares, seja por custo ou ininterruptibilidade das operações.

Para estes circuitos eletrônicos são pesquisadas diversas formas de manutenção remota visando

minimizar o problema de acesso. Entretanto, há aplicações em que não é possível prever ou

calcular as alterações necessárias em um circuito eletrônico, como o desgaste de componentes

em satélites artificiais devido às oscilações térmicas e tempo de utilização.

Motivado pela necessidade específica destas aplicações eletrônicas este trabalho tem por objetivo

embarcar um algoritmo genético em um dispositivo de hardware de baixo consumo de energia.

Este algoritmo através de variáveis pré-definidas irá evoluir um circuito para que sua

funcionalidade esteja dentro do esperado. Através de soluções de computação evolutiva como

esta (algoritmos genéticos), soluções de hardware evolutivo podem ser criadas de forma que

circuitos eletrônicos não precisem de monitoramento de variáveis, cálculos de otimização ou

intervenção humana para sua manutenção (TETSUYA HIGUCHI, et al, 1999).

1.1 Motivação

A principal motivação para o desenvolvimento deste projeto é a pesquisa em uma área

relativamente nova (evolução de hardware). O hardware evolutivo se adapta para a realização de

novas funcionalidades ou a alterações no ambiente durante seu funcionamento, reconfigurando

sua própria estrutura de hardware automaticamente.

11

1.2 Definição do Trabalho

O projeto consiste no desenvolvimento de um circuito eletrônico capaz de evoluir por meio de

um algoritmo genético um. Este sistema (Figura 1) é composto por três módulos principais:

algoritmo genético (embarcado em FPGA), módulo evolutivo (simulado no software SMASH) e

módulo de avaliação (software desenvolvido em C++). O módulo avaliador opera em um

computador comum que se comunica com o algoritmo genético (AG) implementado em uma

FPGA.

O objetivo principal do projeto é embarcar uma variante de um algoritmo genético específico

(Algoritmo Genético Compacto) em FPGA. A evolução do hardware é utilizada como validação

da capacidade de busca de solução do AG embarcado com um problema complexo.

Fig. 1 - Módulos do projeto

12

CAPÍTULO 2 – FUNDAMENTAÇÃO TEÓRICA

O projeto consiste na implementação de um algoritmo genético específico (algoritmo genético

compacto apresentado por GOLDBERG, et al., 1999) em um dispositivo lógico programável

(PLD) do tipo FPGA. A utilização deste AG para a solução de um problema de HE foi escolhida

porque problemas de hardware evolutivo (HE) são relativamente complexos e podem demonstrar

a robustez e aplicabilidade do AG.

A fundamentação teórica está divida em três partes, de forma a abranger estes três tópicos

fundamentais do projeto (PLD, AG e HE) e suportar as escolhas tomadas para a utilização de um

tipo específico de cada tecnologia.

2.1 Dispositivos Lógicos Programáveis

Um dispositivo lógico programável ou PLD é um componente eletrônico usado para construir

circuitos digitais. Diferente de uma porta lógica, que tem uma função fixa, um PLD tem uma

função indefinida no momento da fabricação. Antes que um PLD possa ser usado em um circuito

ele deve ser programado.

Quando soluções inovadoras para problemas difíceis de projeto de hardware são necessárias,

programação com algoritmos genéticos pode ser usada para criar projetos de hardware em

termos de linguagem de descrição de hardware. A estrutura de um dispositivo de hardware

reconfigurável pode ser alterada quantas vezes forem necessárias realizando no dispositivo o

download de string de bits, chamado de bits de configuração. FPGAs são um exemplo típico de

dispositivos reconfiguráveis de hardware (HIOGUCHI et al, 1999).

Entretanto, o objetivo de utilização de FPGAs neste circuito não é a evolução e reconfiguração

lógica de um dispositivo de hardware digital. A utilização de FPGA está relacionada à facilidade

de programação e testes para fins didáticos, como também o baixo consumo de energia e alta

velocidade de processamento para que o AG seja embarcado.

2.1.1 Field Programmable Gate Arrays (FPGA)

As FPGAs são uma classe específica de PLDs. Uma FPGA é um dispositivo semicondutor que

contém componentes de lógica programável e interconexões programáveis. Os componentes de

13

lógica programável podem ser configurados para duplicar a funcionalidade de portas lógicas

básicas como AND, OR, XOR, NOT ou funções combinacionais mais complexas como decoders

ou funções matemáticas simples. Na maioria das FPGAs estes elementos lógicos programáveis

(ou blocos lógicos, na linguagem de FPGA) também incluem elementos de memória, que podem

ser simples flip-flops ou blocos de memória mais completos.

A hierarquia das interconexões programáveis permite que blocos lógicos de uma FPGA estejam

interconectados conforme necessário de acordo com o sistema de elaboração de projeto. Estes

blocos lógicos e interconexões podem ser programados após a fabricação pelo cliente /

desenvolvedor (por isto o termo field programmable, de programável em campo) de forma que a

FPGA possa realizar qualquer função lógica necessária.

2.2 Computação Evolutiva

A computação evolutiva (CE) é uma área de desenvolvimento e pesquisa da ciência da

computação. Ela abrange a construção, aplicação e estudo de algoritmos baseados na seleção

natural. A CE é conduzida com a ajuda de algoritmos evolutivos.

Um algoritmo evolutivo (AE) utiliza alguns mecanismos inspirados na evolução biológica como:

reprodução, mutação, recombinação, seleção natural e sobrevivência do mais apto. Soluções

candidatas para o problema de otimização fazem o papel de indivíduos em uma população e a

função de custo determina o ambiente em que a solução “vive” (VAN ZUBEN, 2000).

Os sistemas baseados em computação evolutiva mantêm uma população de soluções potenciais,

aplicam processos de seleção baseados na adaptação de um indivíduo e também empregam

outros operadores “genéticos”. Diversas abordagens para sistemas baseados em evolução foram

propostas, sendo que as principais diferenças entre elas dizem respeito aos operadores genéticos

empregados (VAN ZUBEN, 2000). Segundo ZUBEN as principais abordagens propostas na

literatura são:

• algoritmos genéticos;

• estratégias evolutivas;

• programação evolutiva.

Uma extensão dos algoritmos genéticos, denominada programação genética, foi introduzida por

Koza (1992), e tem por objetivo básico evoluir programas de computador usando os princípios

14

da evolução natural. Atualmente a programação genética tem sido aplicada a uma grande

variedade de problemas, como na síntese de circuitos elétricos analógicos e na definição de

arquiteturas de redes neurais artificiais (VAN ZUBEN, 2000).

A estrutura de um algoritmo evolutivo pode ser dada na forma apresentada na Figura 2.

Fig. 2 - Estrutura de Algoritmo Evolutivo

O algoritmo evolutivo mantém uma população de indivíduos },...,{)( 1t

n

t xxtP = na iteração

(geração) t. Cada indivíduo representa um candidato à solução do problema em questão e, em

qualquer implementação computacional, assume a forma de alguma estrutura de dados S. Cada

solução t

ix é avaliada e produz alguma medida de adaptação, ou fitness.

Uma nova população é formada na iteração t + 1 pela seleção dos indivíduos mais adaptados.

Alguns indivíduos da população são submetidos a um processo de alteração por meio de

operadores genéticos para formar novas soluções. Após um número de gerações, a condição de

parada deve ser atendida, a qual geralmente indica a existência, na população, de um indivíduo

que represente uma solução aceitável para o problema, ou quando o número máximo de gerações

foi atingido (VAN ZUBEN, 2000).

2.2.1 Algoritmos Genéticos

Os AGs foram introduzidos por Holland em 1975 com o objetivo de formalizar

matematicamente e explicar rigorosamente processos de adaptação em sistemas naturais e

desenvolver sistemas artificiais (simulados em computador) que retenham os mecanismos

15

originais encontrados em sistemas naturais. Os algoritmos genéticos utilizam os operadores de

crossover e mutação.

A terminologia adotada em AGs é originada da teoria da evolução natural e da genética. Um

indivíduo da população é representado por um único cromossomo, o qual contém a codificação

(genótipo) de uma possível solução do problema (fenótipo). Cromossomos são usualmente

implementados na forma de listas de atributos ou vetores, onde cada atributo é conhecido como

gene. Os possíveis valores que um determinado gene pode assumir são denominados alelos.

O processo de evolução executado por um algoritmo genético corresponde a um procedimento

de busca em um espaço de soluções potenciais para o problema. Como enfatiza

MICHALEWICZ (1996), esta busca requer um equilíbrio entre dois objetivos aparentemente

conflitantes: o aproveitamento das melhores soluções e a exploração do espaço de busca

(exploitation × exploration). Este equilíbrio está muito longe de ocorrer quando se considera

outras técnicas de busca:

• métodos de otimização clássicos, como o método do gradiente, são exemplos de

métodos que apenas aproveitam a melhor solução na busca de possíveis

aprimoramentos, sem realizar uma exploração do espaço de busca;

• métodos de busca aleatória, por sua vez, são exemplos típicos de métodos que

exploram o espaço de busca ignorando o aproveitamento de regiões promissoras do

espaço.

Algoritmos genéticos constituem, assim, uma classe de métodos de busca de propósito geral que

apresentam um balanço notável entre aproveitamento de melhores soluções e exploração do

espaço de busca. Embora apresentem etapas não-determinísticas em seu desenvolvimento, os

algoritmos genéticos não são métodos de busca puramente aleatórios, pois combinam variações

aleatórias com seleção, polarizada pelos valores de adequação (fitness) atribuídos a cada

indivíduo. Outra propriedade importante dos algoritmos genéticos (assim como de todos os

algoritmos evolutivos) é que eles mantêm uma população de soluções candidatas enquanto que

os métodos alternativos processam um único ponto no espaço de busca a cada instante (VAN

ZUBEN, 2000).

O processo de busca é, portanto, multi-direcional, através da manutenção de soluções candidatas,

e encorajando a troca de informação entre as direções. A cada geração, soluções relativamente

16

“boas” se reproduzem, enquanto que soluções relativamente “ruins” são eliminadas. Para fazer a

distinção entre diferentes soluções, é empregada uma função de avaliação ou de adaptabilidade

(fitness) que simula o papel da pressão exercida pelo ambiente sobre o indivíduo (VAN ZUBEN,

2000).

Um algoritmo genético para um problema particular deve ter os seguintes componentes:

• uma representação genética para soluções candidatas ou potenciais (processo de

codificação);

• uma maneira de criar uma população inicial de soluções candidatas ou potenciais;

• uma função de avaliação que faz o papel da pressão ambiental, classificando as soluções

em termos de sua adaptação ao ambiente (ou seja, sua capacidade de resolver o

problema);

• operadores genéticos;

• valores para os diversos parâmetros usados pelo algoritmo genético (tamanho da

população, probabilidades de aplicação dos operadores genéticos, etc.)

2.2.2 Algoritmo Genético Compacto

O objetivo principal deste trabalho é a implementação em hardware (no caso, FPGA) de um

algoritmo genético. Diversos AEs baseados em hardware têm sido propostos nos últimos anos.

Cada um é uma variação do algoritmo genético simples (simple genetic algorithm, SGA)

adaptado para implementação em hardware, e cada um proporciona aumento de desempenho

sobre o mesmo algoritmo implementado em um computador.

Uma maneira em que memória significativa (e, portanto, potência e espaço) pode ser

economizada em AEs baseados em hardware é representar populações de soluções candidatas

como vetores de probabilidade ao invés de grupos de strings de bits. Um AG padrão representa

uma população candidata como um grupo de genomas de string de bits, necessitando de espaço

de memória RAM embarcada proporcional a LN onde L é o comprimento do genoma e N é o

número de candidatos da população. Um método baseado em vetor de probabilidades representa

a população como um único vetor de probabilidades em que cada bit em cada string de bits de

um candidato teria o valor de zero ou um. Adotando a interpretação da freqüência relativa de

probabilidade, cada elemento no vetor de probabilidades representa a proporção de membros de

uma população simulada que tem um ou zero na posição do bit correspondente. Presumindo uma

17

representação de probabilidade binária de precisão fixa seria necessário )(log2 NL bits de

memória para representar uma população de tamanho L com strings de N bits. Para genomas de

mesmo tamanho, AGs padrão iriam precisar memória de )(NO , enquanto um AG baseado em

vetor de probabilidades precisaria de )(log2 NO .

Pelo menos dois AE que empregam codificação de população em vetores de probabilidade têm

sido explorados na literatura. Destes, o algoritmo genético compacto (AGC) é de interesse

particular porque ele simula algumas propriedades do SGA e porque já há na literatura uma

implementação em hardware elegante (GALLAGHER et al. 2004).

Segundo GALLAGHER et al (2004), o AGC simples não tem poder de busca suficiente para uso

em diversos projetos de HE. Portanto, para solucionar o problema do circuito evolutivo no

presente trabalho foi utiliza-se uma variável de uma família de AGC proposta por JOHN

GALLAGHER et al (2004) e a implementação de hardware também proposta no mesmo artigo.

Os fundamentos deste AGC são encontrados no modelo original de GOLDBERG et al. (1999).

Este modelo é descrito na Figura 3.

18

Fig. 3 - Pseudocódigo do Algoritmo Genético Compacto

A família de AGC proposta por GALLAGHER et al. (2004) sobre o modelo de GOLDBERG et

al. (1999) e utilizada neste projeto possui duas modificações em relação ao AGC padrão:

elitismo e mutação.

2.3 Hardware Evolutivo

Hardware evolutivo é uma área de pesquisa que objetiva construir, por exemplo, circuitos

eletrônicos cujo modelamento ou operação são definidos através de um processo de evolução.

Hardware evolutivo é um novo campo que relaciona hardware reconfigurável, inteligência

artificial e sistemas autônomos e tolerantes a falhas. Hardware evolutivo se refere ao hardware

que pode mudar sua arquitetura e comportamento dinamicamente e autonomamente pela

interação com seu ambiente.

Na sua forma fundamental um AE manipula uma população de indivíduos onde cada indivíduo

descreve como construir um circuito candidato. A cada circuito é associado um fitness, que

indica quão bem o circuito candidato satisfaz a especificação de projeto. O AE usa operadores

aleatórios para evoluir novas configurações de circuitos a partir de configurações existentes.

Feito corretamente, o AE irá ao longo do tempo evoluir uma configuração de circuito que exibe

comportamento desejável.

Cada candidato pode ser tanto simulado quanto fisicamente implementado em um dispositivo

reconfigurável. Dispositivos reconfiguráveis típicos são FPGAs (para projetos digitais) ou field

programmabel analog arrays (FPAAs, para projetos analógicos).

Há diversas razões para evoluir circuitos. Em muitos casos os métodos convencionais (ex.

fórmulas) de projeto podem ser utilizados para desenhar circuitos. Mas em outros casos a

especificação de projeto não fornece informação suficiente para permitir o uso de métodos

convencionais. Por exemplo, a especificação pode somente estabelecer o comportamento do

hardware em questão. Em outros casos o circuito deve adaptar-se (ex: modificar sua

configuração) para compensar falhas ou talvez uma mudança operacional no ambiente.

19

Hardware evolutivo é um novo conceito no desenvolvimento de máquinas adaptativas on-line.

Em contraste com o hardware convencional onde a estrutura é irreversivelmente fixada no

processo de desenho, HE é designado para se adaptar a mudanças nos requisitos das tarefas ou

mudanças no ambiente através da sua habilidade de reconfigurar sua própria estrutura de

hardware on-line (dinamicamente) e autonomamente. Esta capacidade de adaptação, atingida por

AEs (como os AGs) tem grande potencial para desenvolvimento de aplicações industriais

inovadoras (HIGUCHI et al. 1999).

Apesar do conceito de HE ser relativamente novo, algumas aplicações de HE já estão sendo

avaliadas para uso comercial. Há na literatura artigos sobre aplicações reais de HE analógico e

digital. HIGUCHI et al (1999) apresenta cinco chips de HE e suas aplicações práticas,

demonstrando a aplicabilidade comercial de HE.

O fitness de um circuito evoluído pode ser medido através do quão bem ele está de acordo com a

especificação do projeto. O fitness em problemas de HE é determinado por dois métodos:

• Evolução extrínseca: todos os circuitos são simulados para avaliar seu desempenho;

• Evolução intrínseca: testes físicos são realizados em hardware.

Na evolução extrínseca apenas a melhor solução final da população final do AE é fisicamente

implementada enquanto que na evolução intrínseca todos os indivíduos em cada geração do AE

são fisicamente implementados e testados.

20

CAPÍTULO 3 – ESPECIFICAÇÃO DO PROJETO

3.1 Especificação do Hardware

3.1.1 Separação Física

O hardware do projeto é composto por dois módulos principais: kit didático da FPGA e

computador pessoal. A Figura 4 ilustra a separação entre o os módulos do hardware.

Fig. 4 - Separação dos módulos de hardware

3.1.2 Separação Lógica

O módulo de avaliação dos indivíduos (desenhos de circuitos) gerados pelo algoritmo genético

está implementado em um computador. Apenas o processamento do AG é realizado na FPGA,

conforme diagrama em blocos do projeto (Figura 5).

21

Algoritmo genético implementado em FPGA para evolução de hardware - Blocos funcionais

Geração de indivíduos Avaliação dos indivíduos Apresentação do Resultado

Circuito Evolutivo (PC)

Algoritmo Genético (FPGA)

Módulo Avaliador (PC)

Início

Gerador de

números

aleatórios

Recebimento dos

dados (indivíduo)

Conversão dos dados

para formato texto

padrão dos

parâmetros

Software Smash

Arquivo

texto com

parâmetros

do indivíduo

Arquivo com

resultado da

simulação

Identificação e

extração dos

parâmetros.

Cálculo do fitness.

Envio de dados

(fitness)

Incremento/

decremento do

vetor de

probabilidades

Comparação com

o vetor de

probabilidades e

geração do novo

inivíduo

Número de

indivíduos

atingido?

Não

Recebimento dos

dados (indivíduo)

Conversão dos

dados para

formato texto

padrão dos

parâmetros

Arquivo

texto com

parâmetros

do indivíduo

Fim

Sim

Geração do

indivíduo

final

Fig. 5 - Blocos funcionais do projeto e fluxo de dados

3.2 Especificação do Software

O software do projeto é responsável por realizar a comunicação de interface entre a FPGA e o

programa SMASH e calcular o fitness dos indivíduos. Conforme ilustrada na Figura 5, a

simulação e geração de dados de resposta do circuito são realizados pelo software de projeto e

simulação SMASH (DOLPHIN INTEGRATION, www.dolphin.fr). O software desenvolvido

para este projeto recebe os dados do indivíduo gerado na FPGA, configura os arquivos (.nsx e

.pat) que descrevem o circuito e sinais de entrada de acordo com o indivíduo, executa o SMASH

22

com comando de simulação, recebe a resposta por meio de arquivo de simulação do SMASH,

calcula o fitness e o envia para a FPGA.

Não há interação do usuário com o software do projeto. A simulação e evolução de hardware são

simuladas em software para facilitar a implementação e substituir o hardware que realizaria estas

funções.

A comunicação entre a FPGA e o software é realizada por meio da porta paralela do PC. O

software foi desenvolvido na linguagem de programação C++ e o computador pessoal utiliza o

sistema operacional Windows XP.

23

CAPÍTULO 4 – DESENVOLVIMENTO E IMPLEMENTAÇÃO

4.1 Hardware

Com exceção do módulo de avaliação, todo o algoritmo genético está implementado em FPGA.

Para elaborar o circuito foi utilizado o software Quartus II da Altera. Os blocos elaborados, suas

funções e equipamentos utilizados estão descritos nos próximos tópicos.

4.1.1 Diagrama em blocos

Todo os blocos do algoritmo genético compacto foram desenvolvidos em linguagem de

descrição de hardware da Altera (AHDL). Cada componente foi compilado individualmente e

gerado o arquivo de inclusão de símbolo.

A Figura 6 relaciona os blocos e seus pinos. A estrutura representada do AGC é para um

indivíduo de n bits com fitness de y bits.

MUX2x1

MUX4x1

Fig. 6 - Diagrama em blocos do AGC

Os componentes do AGC da Figura 6 e seus pinos estão descritos abaixo:

Gerador de números aleatórios (RNG): O RNG é um gerador de números pseudoaleatórios do

tipo LFSR (Logical Feedback Shift Register). O pino <load> é ativado na inicialização do AGC.

24

A cada ciclo de clock o RNG gera um novo número aleatório, seja ele utilizado ou não no fluxo

de dados do AGC. O número aleatório do diagrama é composto por 8 bits para uma

representação de um número entre 0 e 1 com ponto fixo.

Registrador de probabilidade (B_PBR): O registrador de probabilidades armazena um valor entre

0 e 1 em uma representação em ponto fixo. Este valor é a probabilidade de um indivíduo na

população possuir o bit em 0 ou 1 em uma determinada posição do genoma. Quando o pino

<b_clear> é ativado o registrador é configurado para 0x80, indicando que a probabilidade é

iniciada em 50% para 0 ou para 1. Os pinos <b_inc> e <b_dec> respectivamente incrementam e

diminuem o valor da probabilidade de acordo com o valor configurado no desenho do

componente.

Registrador de mutação (M_PBR): O registrador de mutação é muito semelhante ao registrador

de probabilidade com a diferença da ativação do pino <m_clear> que zera o valor do registrador.

Com o registrador de mutação zerado não há mutação, desta forma, no processo de inicialização

do AGC o pino de incremento (<m_inc>) é ativado quantas vezes for necessário para determinar

a probabilidade de mutação desejada.

Buffer (BUF): O buffer possui apenas 2 registradores de armazenamento, acessados através de

duas saídas. A gravação é permitida através dos pinos <b_write> (para ativar a gravação) e

<i_sel> (para selecionar o registrador). Um multiplexador simples é utilizado para determinar

qual valor de registrador está disponível no barramento de saída.

Módulo de Ajuste (INC/DEC): O Módulo de ajuste faz alterações no registrador de

probabilidades todas as vezes que o pino <p_fix> é ativado. Comparando os bits presentes no

buffer e contendo a informação do registrador E (registrador do bit de elite) o módulo de ajuste

através de um circuito combinacional determina se a probabilidade de cada bit deve ser

incrementada ou diminuída, ou ainda, se não deve ser alterada. A probabilidade de um bit só

deve ser alterada se o indivíduo avaliado possui o bit diferente do indivíduo apontado como

campeão. O incremento ou decremento da probabilidade ocorre na direção do valor do bit do

indivíduo campeão.

Registrador do bit de elite (E_REG): O registrador do bit de elite indica qual registrador do

buffer contém o bit de elite (indivíduo campeão). Este componente do AGC é compartilhado por

todos os bits do genoma, ou seja, há apenas um registrador “E”. O pino <e_bit> é configurado

25

pelo módulo de avaliação, que após calcular o fitness, altera o valor do pino de acordo com o slot

em que se encontra o indivíduo melhor avaliado. O pino <e_load> é controlado pela unidade de

controle do AGC.

Comparador (CMP_2_1): O comparador desta estrutura de AGC possui duas entradas e uma

saída. As entradas são de 8 bits, utilizando a mesma representação de número com ponto fixo do

RNG e B_PBR. Se o valor da entrada do RNG é maior que a entrada do B_PBR (ou M_PBR) o

valor de saída é 0, caso contrário o valor de saída é 1.

Função de fitness (FUNCAO): O módulo de função de fitness é o componente que a partir dos

dados do barramento com os bits do indivíduo calcula o fitness. Sua saída <fitness> possui

largura y, dependendo de qual resolução se deseja do valor do fitness. O pino <r_write> indica

para o módulo quando o indivíduo já está disponível no barramento para que seja calculado seu

fitness. O pino <fit_ready> indica para o módulo controlador da avaliação que o resultado do

fitness do indivíduo já foi calculado e está disponível no barramento <fitness>.

Controlador de avaliação (FEV): A versão do AGC implementada contempla o elitismo do

indivíduo e para que não seja necessário em todas as rodadas de comparação de indivíduos

calcular novamente o fitness do atual campeão se faz necessário um registrador para seu

armazenamento. Este módulo possui dois registradores de largura y para armazenar o fitness do

indivíduo campeão e do competidor. Em cada rodada de avaliação apenas o fitness do

competidor é calculado. Após o cálculo pelo módulo FUNCAO e a gravação do fitness no

registrador do competidor (de acordo com o pino <i_sel>) o registrador que indica o indivíduo

campeão (E_REG) é ajustado de acordo com o registrador de fitness que possui maior valor.

Para realizar estes passos o componente possui uma máquina de estados que é iniciada pela

ativação do pino <p_eval>.

Controlador do AGC (CTRL): O componente foi omitido na Figura 6 por possuir muitas

conexões com os demais módulos, o que poderia poluir visualmente o diagrama. Ele é

responsável por gerenciar todo o fluxo de informações através dos demais componentes por meio

da ativação dos pinos de controle dos módulos. Este módulo possui uma máquina de estados

para determinar as ativações dos pinos de controle. Os estados, pinos de entrada e pinos de saída

do controlador do AGC estão descritos no capítulo 4 no tópico 4.2.3 (diagrama de estados do

controlador do AGC).

26

Outros componentes: A estrutura do AGC ainda é composta por dois multiplexadores (um de

quatro entradas e outro de duas entradas) e uma porta XOR simples.

4.1.2 Materiais

Os componentes do AGC foram desenvolvidos em AHDL e integrados através de esquemático

no software Quartus II da Altera. Para a implementação em hardware foi utilizada uma FPGA da

Altera disponível em um kit didático. O kit didático utilizado (Placa DE2, Figura 7) é para

desenvolvimento de aplicações com o processador NIOS. Ele possui uma FPGA Altera da

família Cyclone II, modelo EP2C35.

Fig. 7 - Placa DE2 da Altera

FONTE: ALTERA CORPORATION (WWW.ALTERA.COM)

Da família de FPGAs de baixo custo Cyclone II, o modelo EP2C35 é um modelo intermediário e

contêm 33216 blocos lógicos, 105 blocos de RAM e máximo de 475 pinos utilizáveis pelo

usuário (Tabela 1). Este kit foi o escolhido para desenvolvimento do projeto porque facilita a

configuração da FPGA e sua comunicação com o PC por meio dos barramentos de expansão.

TABELA 1 Características da família Cyclone II de FPGAs

Característica \ Modelo EP2C5 EP2C8 EP2C20 EP2C35 EP2C50 EP2C70

Elementos Lógicos 4.608 8.256 18.752 33.216 50.528 68.416

M4K RAM blocks (4 Kbits mais 512 parity bits) 26 36 52 105 129 250

Total RAM bits 119.808 165.888 239.616 483.84 594.432 1.152.000

Máximo pinos de E/S (usuário) 158 182 315 475 450 622

FONTE: Altera DE2 Development and Education Board User Manual

27

Não foi utilizado nenhum componente já disponível no kit para comunicação ou mesmo o

processador NIOS. Apenas a porta USB Blaster foi utilizada para a configuração da FPGA. Toda

a arquitetura do AGC e comunicação com o PC foram implementadas diretamente no chip

através de lógica desenvolvida em linguagem de descrição de hardware da Altera (AHDL).

A comunicação entre a FPGA e o computador através da porta paralela foi estabelecida através

de um cabo (Figura 8) montado para realizar esta ligação.

Fig. 8 - Cabo de conexão entre a porta paralela e a placa DE2

Foram utilizados os oito pinos de dados da porta paralela e os pinos wait, write e ground,

totalizando onze pinos. A conexão do cabo com a porta paralela do computador foi realizada por

meio do conector padrão DB25. A conexão entre o cabo e a placa DE2, conforme exibido pela

Figura 9, foi realizada por meio dos conectores do cabo ao barramento de pinos de expansão da

placa.

28

Fig. 9 - Conexão entre a placa DE2 e o cabo que liga à porta paralela

4.2 Software

O software relacionado diretamente ao AGC é apenas o firmware do componente controlador do

AGC. Nele está a máquina de estados que controla todo o fluxo de informações entre os demais

componentes do AGC.

O software no computador tem o objetivo de comunicar-se com a FPGA para obter os valores

dos indivíduos, simular o circuito no software SMASH, calcular o fitness e enviar o valor para a

FPGA.

4.2.1 Diagrama de fluxo de dados do Controlador do AGC

A Figura 10 representa o diagrama de fluxo de dados do componente controlador do AGC

(CTRL). Os números do diagrama estão relacionados com a descrição dos passos. Os passos

contêm a descrição dos procedimentos realizados e sua relação com o algoritmo genético

utilizado (algoritmo genético compacto padrão com variação de elitismo e mutação). Eles estão

relacionados também com os estados da máquina do controlador.

Passo 1) Todos os registradores recebem o sinal de clear. Apenas os registradores que

representam o vetor de probabilidades são iniciados em 0,5 (0x80 em uma representação já

comentada de ponto fixo de 8 bits). Estas ações são realizadas no estado i00 do CTRL. Em

29

seguida, no estado i01, os registradores do gerador de números aleatórios são inicializados com

um valor pré-definido no gerador e os registradores de probabilidade de mutação são

inicializados de acordo com um valor definido de mutação (valores configurados no código em

AHDL).

Passo 2) Um indivíduo é gerado pelo comparador utilizando números aleatórios do RNG e

probabilidades do B_PBR. Este indivíduo é gravado no slot campeão do buffer. Este passo

corresponde ao estado g00 do CTRL.

Passo 3) O módulo de avaliação dos indivíduos (FEV) recebe sinal para avaliar o indivíduo do

slot campeão do buffer. O FEV envia sinal para o módulo FUNCAO iniciar o cálculo do fitness

do indivíduo. Ao fim deste processo o FEV recebe um sinal indicando o término da avaliação e

armazena o resultado no registrador interno indicado pelo bit de campeão. Este passo

corresponde aos estados g01 e g02 do CTRL.


probabilidades do B_PBR. Este indivíduo é gravado no slot competidor do buffer. Este passo

corresponde ao estado g03 do CTRL.


slot competidor do buffer. O FEV envia sinal para o módulo FUNCAO iniciar o cálculo do

fitness do indivíduo. Ao fim deste processo o FEV recebe um sinal indicando o término da

avaliação e armazena o resultado no registrador interno diferente do bit indicador de campeão.

Este passo corresponde aos estados a00 e a01 do CTRL.

Passo 6) O FEV gera o bit correspondente ao slot do buffer que contém o indivíduo de melhor

fitness e o CTRL envia o sinal para o registrador E atualizar seu valor. Este passo corresponde ao

estado a01 do CTRL.

Passo 7) As linhas de ajuste de B_PBR (<b_inc> e <b_dec>) são ativadas de acordo com as

necessidades de ajuste calculadas pelo módulo INC/DEC. Este módulo é um circuito

combinacional e realiza ajuste no vetor de probabilidade fazendo com que ele sofra uma

alteração na direção do indivíduo campeão em um determinado bit caso ele seja diferente entre o

campeão e o competidor. Este passo corresponde ao estado c00 do CTRL.

30


probabilidades do M_PBR. Os bits desse indivíduo passam por uma porta lógica XOR com os

bits do indivíduo do slot campeão do buffer. O indivíduo resultante é gravado no slot de

competidor do buffer. Este passo corresponde ao estado m00 do CTRL.


slot competidor do buffer. O FEV envia sinal para o módulo FUNCAO iniciar o cálculo do

fitness do indivíduo. Ao fim deste processo o FEV recebe um sinal indicando o término da

avaliação e armazena o resultado no registrador interno diferente do bit indicador de campeão.

Este passo corresponde aos estados m01 e m02 do CTRL.

Passo 10) O FEV gera o bit correspondente ao slot do buffer que contém o indivíduo de melhor

fitness e o CTRL envia o sinal para o registrador E atualizar seu valor. Este passo corresponde ao

estado m02 do CTRL.

Após o passo 10 é verificado se o processo de evolução chegou ao fim. Podem existir diversas

condições de parada como, por exemplo: número de gerações, convergência parcial do vetor de

probabilidades, convergência total do vetor de probabilidades, fitness mínimo atingido, etc.

Caso seja verificado que o processo de evolução não chegou ao fim o controlador executa

novamente o processo a partir do passo três. Nos casos descritos como teste do CGA a condição

de parada (quantidade de indivíduos desejada) foi determinada em software.

31

BUF[0], BUF[1], E ← 0

RNG(load)

B_PBR ← 0,5

M_PBR ← Taxa de Mutação

BUF[E] ← CMP(RNG, B_PBR)

BUF[!E] ← CMP(RNG, B_PBR)

E ← FEV(BIT_E)

B_PBR ← INCDEC(E, BUF[0], BUF[1])

BUF[!E] ← XOR(CMP(RNG, M_PBR), BUF[E])

E ← FEV(BIT_E)

Fim do processo?

Não

Início

Fim

Sim

FEV(E) ← FUNCAO(BUF[E])

FEV(!E) ← FUNCAO(BUF[!E])

FEV(!E) ← FUNCAO(BUF[!E])

1

2

3

4

5

6

7

8

9

10

Fig. 10 - Diagrama de fluxo de dados do AGC

32

4.2.2 Diagrama de fluxo de dados do software avaliador

O software responsável pelo cálculo do fitness dos indivíduos gerados pelo AGC na FPGA foi

completamente desenvolvido em linguagem de programação C++ com o uso do compilador

Borland C++ Builder 6.0. O programa não possui interface com o usuário e não é orientado a

objetos. Antes de executar o software o usuário já deve ter ligado a placa com a FPGA contendo

a programação do AGC. Ao chamar o programa de cálculo do fitness o mesmo já inicia a

comunicação com o AGC conforme o diagrama da Figura 12. Não há indicadores do andamento

do processo. Ao final das avaliações dos indivíduos (o programa está configurado para avaliar

301 indivíduos por execução) o programa é encerrado automaticamente e gera um arquivo texto

de log contendo as informações dos indivíduos gerados e dos fitness calculados na execução.

Fig. 11 - Código-fonte de configuração de arquivos e chamada de execução do SMASH

O software de simulação de circuitos SMASH é utilizado devido à complexidade dos cálculos

envolvidos. Para se comunicar com o software SMASH são utilizados dois arquivos de texto

33

contendo as configurações do circuito (arquivo .nsx) e os sinais de entrada (arquivo .pat). O

SMASH é chamado por linha de comando utilizando estes dois arquivos como parâmetros para

simulação e retorna dois arquivos com os resultados (arquivos com extensões .op e .dat). A

Figura 11 contém trechos de código do software com funções de configuração dos arquivos e

chamada do software SMASH com os parâmetros necessários para a simulação com os arquivos

configurados.

Fig. 12 - Diagrama de fluxo de dados do software de cálculo do fitness

34

4.2.3 Diagrama de Estados do Controlador do AGC

A máquina de estados que controla o fluxo de informações entre os componentes do AGC está

no controlador do AGC. A Tabela 2 lista e descreve todos os estados, suas entradas e saídas. O

processo de evolução do AGC está dividido em 4 etapas: inicialização, geração de indivíduos,

avaliação dos indivíduos, ajustes no vetor de probabilidades e mutação.

TABELA 2 Estados da máquina do controlador do AGC

all_clear

rng_load

mux4_1

mux4_0

b_sel

b_write

mux2_sel

f_evaluate

incdec_fix

e_load

S9 S8 S7 S6 S5 S4 S3 S2 S1 S0

i00 X X 1 0 0 1 0 0 0 0 0 0 0 i01

Todos os registradores são "zerados". Apenas os registradores

do vetor de probabilidades assumem o valor 0xH0.

i01 X X 0 1 0 1 0 0 0 0 0 0 VCC i02

Os registradores do gerador de números aleatórios são inciados

com um valor pré-definido. Os registradores de probabilidade de

mutação são incrementados uma vez.

i02 X X 0 0 0 1 0 0 0 0 0 0 0 i03 Estado para aguardar o funcionamento normal do RNG.



i05 X X 0 0 0 1 0 0 0 0 0 0 0 g00 Estado para aguardar o funcionamento normal do RNG.

g00 X X 0 0 0 1 0 1 0 0 0 0 0 g01 Gera indivíduo e grava no slot campeão do buffer.

g01 X X 0 0 0 1 0 0 0 1 0 0 0 g02 Envia para avaliação indivíduo do slot campeão do buffer.

g02 X 0 0 0 0 1 0 0 0 0 0 0 0 g02 Aguarda FEV responder com sinal de término da avaliação.

g02 X 1 0 0 0 1 0 0 0 0 0 0 0 g03 Aguarda FEV responder com sinal de término da avaliação.

g03 0 X 0 0 0 1 1 1 0 0 0 0 0 a00 Gera indivíduo e grava no slot competidor do buffer.

g03 1 X 0 0 0 1 0 1 0 0 0 0 0 a00 Gera indivíduo e grava no slot competidor do buffer.

a00 0 X 0 0 0 1 0 0 1 1 0 0 0 a01 Envia para avaliação indivíduo do slot competidor do buffer.

a00 1 X 0 0 0 1 0 0 0 1 0 0 0 a01 Envia para avaliação indivíduo do slot competidor do buffer.

a01 0 0 0 0 0 1 0 0 1 0 0 0 0 a01 Aguarda FEV responder com sinal de término da avaliação.

a01 1 0 0 0 0 1 0 0 0 0 0 0 0 a01 Aguarda FEV responder com sinal de término da avaliação.

a01 X 1 0 0 0 1 0 0 0 0 0 1 0 c00

Ajusta registrador E conforme slot do indivíduo com melhor

fitness .

Corrige c00 X X 0 0 0 1 0 0 0 0 1 0 0 m00 Ajusta vetor de probabilidades.

m00 0 X 0 0 1 0 1 1 0 0 0 0 0 m01

Gera mutação do indivíduo campeão e grava no slot competidor

do buffer.

m00 1 X 0 0 1 0 0 1 1 0 0 0 0 m01

Gera mutação do indivíduo campeão e grava no slot competidor

do buffer.

m01 0 X 0 0 0 1 0 0 1 1 0 0 0 m02 Envia para avaliação indivíduo do slot competidor do buffer.

m01 1 X 0 0 0 1 0 0 0 1 0 0 0 m02 Envia para avaliação indivíduo do slot competidor do buffer.

m02 0 0 0 0 0 1 0 0 1 0 0 0 0 m02 Aguarda FEV responder com sinal de término da avaliação.

m02 1 0 0 0 0 1 0 0 0 0 0 0 0 m02 Aguarda FEV responder com sinal de término da avaliação.

m02 X 1 0 0 0 1 0 0 0 0 0 1 0 g03

Ajusta registrador E conforme slot do indivíduo com melhor

fitness.

Entradas

m_inc[]

Estado

Comentários

Avalia

Muta

e_bit

f_finished

Estado

Processo

Saídas

Inicializa

Gera

35

4.2.4 Diagrama de Estados do componente de comunicação

Uma máquina de estados controla a comunicação entre a FPGA e o PC. Toda a comunicação é

feita um byte por vez. Todos os parâmetros do projeto são de um byte, inclusive o fitness. Desta

forma a FPGA envia n bytes para a o PC, no qual n é o número de parâmetros do indivíduo, e

recebe um byte relativo ao fitness do indivíduo avaliado. Os estados e suas descrições estão

comentados na Tabela 3.

TABELA 3 Estados da máquina do componente de comunicação

estado

write

r_write

rd_end

wait

tri_estate

reg_read

reg_write

ct_en

estado

i00 0 0 X 0 0 0 0 0 i00

Espera sinal indicando que valor a ser enviado para o PC já está

disponível no barramento.

i00 0 1 X 0 0 1 0 0 r00

Sinal r_write ativo indicado que o valor para envio ao PC já está

disponível no barramento. O pino reg_read é ativado, habilitando o

registrador para gravação.

r00 0 X X 1 0 0 0 0 r00

Ativação do pino wait indicando ao computador que se a transmissão

dos dados está para iniciar.

r00 1 X X 1 1 0 0 1 r01

O computador responde com a ativação do pino write que está pronto

para receber o valor. Neste instante o pino tri_state é ativado, permitindo

que a saída do registrador seja conectada ao barramento.

r01 1 X X 0 1 0 0 0 r01

Enviado sinal para o PC através da desativação do pino wait indicando

que o valor para leitura já está disponível.

r01 0 X 0 0 0 0 0 0 r00

O PC responde que finalizou a leitura através da destaivação do pino

write. Caso rd_end seja zero o processo de envio para o PC é realizado

novamente.

r01 0 X 1 0 0 0 0 0 w00

O PC responde que finalizou a leitura através da destaivação do pino

write. Caso rd_end seja um indica que todos os parâmetros foram

passados para o PC e assim a comunicação pode prosseguir para o

recebimento de dados.

w00 0 X X 1 0 0 0 0 w00

O pino wait é ativado indicando que a FPGA está disponível para

receber o valor do PC.

w00 1 X X 1 0 0 1 1 w01

O pino write é ativado pelo PC indicando que o valor já se encontra

disponível no barramento. Nesta condição o pino reg_write é habilitado

permitindo a gravação do valor no registrador.

w01 1 X X 0 0 0 0 0 w01 O pino wait é desativado comunicando ao PC que o valor foi recebido.

w01 0 X X 0 0 0 0 0 i00

Estado de espera da desativação do pino write quando o PC comunica

que recebeu a mensagem de término do processo de gravação do valor

enviado. Após este estado todo o processo é iniciado novamente com o

recebimento dos valores do barramento do CGA.

Envio dos

parâmetros do

indíviduo ao

PC

Gravação do

fitness do

indivíduo

avaliado pelo

PC

ComentáriosProcesso

Entradas Saídas

Gravação dos

dados do

barramento

do CGA

O trecho do código da Figura 13 é a função de comunicação implementada em C++ e contém os

comentários relacionados a máquina de estados de comunicação. A função wait_value deixa o

programa em um laço infinito até que o valor passado como parâmetro seja lido no pino wait na

porta paralela. A função set_write envia para o pino write da porta paralela o valor passado como

parâmetro. As demais funções lêem e enviam dados pela porta de dados da porta paralela

(inportb e outportb) e configuram os registradores da porta que indicam seu modo de operação

(leitura ou gravação).

36

Fig. 13 - Código da função de comunicação do computador com a FPGA

37

CAPÍTULO 5 – VALIDAÇÃO E RESULTADOS

Todos os módulos e componentes dos módulos do projeto foram testados e avaliados

individualmente para garantir o funcionamento correto antes de serem integrados. As etapas

descritas de validação do projeto estão divididas entre simulação do AGC, validação do AGC e

comunicação e validação dos resultados para evolução de hardware. Cada etapa testou parte do

AGC e apresentou resultados relevantes para a validação do projeto e análise do funcionamento

do algoritmo genético.

5.1 – Simulação do AGC

Uma simulação do AGC foi realizada no software Quartus II para validar seu funcionamento e

convergência para busca do indivíduo ótimo de um problema simples. Foi elaborada uma função

em linguagem de descrição de hardware que possui entrada de doze bits e conta a quantidade de

bits 1. A saída da função possui largura de quatro bits, pois o menor resultado possível é zero

(indivíduo com todos os doze bits iguais a zero) e o maior resultado possível é doze (indivíduo

com todos os doze bits iguais a um).

Conforme descrito no tópico 4.1.1 o componente FUNCAO do diagrama em blocos da Figura 6

é o responsável pelo cálculo da função de fitness. A função para contar a quantidade de bits 1 foi

compilada em um componente no formato do FUNCAO e colocado no seu lugar. Devido ao fato

desta ser uma função simples ela é completamente formulada por lógica combinacional, desta

forma, a saída com o resultado é atualizada “instantaneamente” com a mudança da entrada.

Com esta configuração do AGC para avaliação do fitness foi simulada no Quartus II a sua

execução para verificar se o algoritmo convergia para um indivíduo com todos os bits iguais a

um. Na simulação realizada o algoritmo obteve um indivíduo com todos os bits iguais a um no

quadragésimo segundo indivíduo gerado (somando indivíduos gerados a partir do vetor de

probabilidades e mutações) e convergiu o vetor de probabilidades após 95 indivíduos avaliados.

Para correção no vetor de probabilidades após as avaliações foi utilizado um valor igual a 32

para incremento ou decremento. O vetor de probabilidades possui um byte de resolução para

cada bit, permitindo 256 níveis diferentes de probabilidade para cada bit. Com ajuste de valor 32

o AGC possuiu oito níveis diferentes de probabilidade para cada bit do indivíduo.

38

A Tabela 4 relaciona cada estado do AGC (descritos no tópico 4.2.3) e quantidade de ciclos de

clock observada na simulação. Para cada processo inteiro de geração de indivíduo a partir do

vetor de probabilidades até a mutação e avaliação da mutação são necessários nove ciclos.

TABELA 4 Estados do AGC e ciclos de clock

Estado Qtd de Ciclos

g03 1

a00 1

a01 2

c00 1

m00 1

m01 1

m02 2

Total 9

5.2 – Validação do AGC e comunicação com o computador

O objetivo final de validação da implementação do AGC é a sua utilização para a solução de

problemas de evolução de hardware. Entretanto, não é possível assim como na simulação do

AGC implementar uma função de fitness na própria FPGA devido à sua alta complexidade. Para

resolver este problema foi necessário desenvolver uma interface de comunicação com um

computador para que este calculasse o fitness. Esta etapa de testes teve o objetivo de validar o

funcionamento do AGC para um problema de complexidade maior do que o descrito no tópico

5.1 e também avaliar se a interface de comunicação com o PC estava funcionando

adequadamente.

O componente FUNCAO do AGC exibido no diagrama em blocos da Figura 6 foi substituído

por um componente que realiza a comunicação com o computador. Os estados deste componente

já foram descritos no tópico 4.2.4. Um software no computador foi elaborado para realizar o

cálculo de uma função de segundo grau (f(x,y) = -4x² +20x -3y² +15y +50) com duas variáveis

para obter seu resultado. O AGC foi configurado para que cada indivíduo fosse formado por 16

bits, permitindo que cada variável da equação fosse representada por um byte. O fitness foi

ajustado para também ser representado por um byte.

Para cada avaliação de indivíduo gerado pela FPGA os valores de x e y foram recebidos no PC e

normalizados. Após a normalização o cálculo do resultado da função foi realizado, foi

39

normalizado e enviado para a FPGA. O objetivo das simulações realizadas foi verificar que o

AGC encontraria o indivíduo com o valor máximo da equação.

Para as diversas simulações realizadas uma grande parte encontrou o indivíduo ótimo (f(x,y)

igual a 93) com sessenta ou menos indivíduos gerados. Para as demais simulações os resultados

obtidos eram próximos ao ideal, entretanto, identificamos um problema devido a forma de

codificação do indivíduo. Como os valores das variáveis estavam em representação binária cada

bit representava o dobro de valor do bit a sua direita. Quando um indivíduo com fitness quase

ótimo era gerado pelo AGC e com valores de x e y muito próximos aos da representação dos bits

(ex.: 127, 128, 64) o mesmo encontrava dificuldades para convergir para o indivíduo ótimo. Isto

ocorreu porque para haver a mudança de um valor de 127 para 128, por exemplo, é necessário

que todos os bits sejam alterados, contrariando a tendência do vetor de probabilidades que

convergia para um determinado valor de acordo com os últimos indivíduos gerados e avaliados.

Em algumas situações o indivíduo ótimo não era obtido por causa deste problema da

representação do indivíduo, mas ocorreram também algumas situações em que a mutação

conseguiu gerar o indivíduo com as modificações necessárias para que este fosse melhor que o

anterior e não convergir prematuramente.

Para estas simulações foi utilizado incremento e decremento do vetor de probabilidades igual a

32 (possibilitando oito níveis de probabilidade) e mutação também igual a 32 (probabilidade de

um de cada oito bits sofrer mutação).

5.3 – Validação do AGC para evolução de hardware

O software descrito no tópico 5.2 foi substituído pelo software final (conforme descrito no tópico

4.2.2) para validar o AGC com um problema de evolução de hardware. O objetivo desta

simulação é validar se o AGC é capaz de encontrar uma solução ótima para um problema

complexo, que neste caso é a evolução de um circuito. Esta evolução pode ser classificada como

off-line pois cada indivíduo (configuração de circuito) não é implementada, apenas a versão final

com a melhor configuração do circuito seria implementada.

O circuito escolhido para ser evoluído é um projeto de um amplificador de baixo ruído (LNA –

Low Noise Amplifier). Para saber o quanto o circuito evoluído está perto do circuito ótimo e

também para definir a função de fitness foi utilizada a metodologia proposta por BARONCINI e

40

GOUVEIA FILHO (2004) que usa tecnologia de circuitos integrados CMOS e modelagem de

transistores MOSFET do tipo enriquecimento com base em corrente. Foram utilizados os

resultados do relatório de PILLA JR. (2006), que contém os passos e valores obtidos para

desenho do circuito de acordo com a metodologia de BARONCINI, para comparação com os

resultados obtidos do AGC.

O circuito do LNA (Figura 14) possui diversos componentes eletrônicos, entretanto, de acordo

com a metodologia utilizada apenas alguns parâmetros são configuráveis e os resultados do

circuito devem respeitar algumas restrições.

Fig. 14 - Esquemático do circuito do LNA

Foram utilizados quatro parâmetros para a configuração do circuito. O primeiro parâmetro é a

largura (W) dos transistores M1 e M2. O segundo e terceiro parâmetros são as indutâncias dos

indutores Lg e Ls. O último e quarto parâmetro é o valor da fonte de sinal (Vs). Os valores

obtidos das simulações devem respeitar as condições da Tabela 5.

41

TABELA 5 Restrições dos parâmetros do LNA

Parâmetro Descrição Restrição

Pdc Potência dissipada no LNA Menor que 30 mW

IIP3 Linearidade de resposta em 1GHz Maior que -10dB

ZMI Impedância do circuito Mais próximo possível de 50 ohms

ZFI Diferença de fase em 1GHz Mais próximo possível de zero graus

A fórmula de fitness do software no computador considerou os quatro parâmetros de resultado

do LNA. Cada parâmetro de configuração do circuito e o fitness foram representados por oito

bits, desta forma, o AGC foi configurado para largura de 32 bits. O valor de incremento do vetor

de probabilidades utilizado foi igual a 8, possibilitando 32 níveis de probabilidade. O valor de

probabilidade de mutação configurado para todos os bits foi de 64, estabelecendo uma

probabilidade de um quarto para mutação de cada bit.

A Tabela 6 apresenta os resultados obtidos nas 14 simulações realizadas e os valores de

configuração obtidos com a metodologia de BARRONCINI e GOUVEIA FILHO extraídos do

relatório de PILLA JR.

TABELA 6 Resultados das simulações

Entradas Saídas Simulação Indivíduos Melhor

W Lg Ls Vs Pdc IIP3 ZMI ZFI

Relatório - - 1900,000 20,000 1,700 0,518 0,012 7,541 42,462 9,397

1 201 144 1521,961 22,596 1,773 0,540 0,013 11,654 52,541 0,127

2 401 320 2751,765 18,663 2,582 0,573 0,034 7,991 48,029 3,728

3 1001 176 2713,333 19,125 4,896 0,458 0,007 0,649 33,963 0,160

4 301 193 1618,039 29,653 6,169 0,461 0,004 0,896 56,689 0,281

5 301 186 1714,118 26,761 5,012 0,458 0,004 0,637 50,350 0,162

6 301 194 2886,275 13,110 1,310 0,617 0,052 5,664 48,084 1,367

7 301 232 1387,451 27,571 2,814 0,477 0,005 2,521 46,505 0,211

8 301 280 2444,314 20,629 3,276 0,543 0,021 20,817 49,716 0,654

9 301 282 1675,686 24,794 3,276 0,480 0,006 2,812 50,176 1,964

10 301 232 1752,549 29,190 7,557 0,447 0,004 -0,375 49,488 0,578

11 301 176 2175,294 24,100 3,624 0,568 0,025 11,723 57,544 1,185

12 301 288 1349,020 23,869 1,425 0,557 0,014 18,061 49,488 1,282

13 301 278 2002,353 28,843 10,912 0,450 0,004 -0,124 38,327 0,706

14 301 244 2943,922 15,655 2,351 0,524 0,020 11,112 40,041 0,913

A primeira simulação realizada obteve um indivíduo com parâmetros de configuração do circuito

muito próximos ao do relatório utilizado como referência. Esta simulação foi realizada com 201

indivíduos (segunda coluna da Tabela 6) e o melhor indivíduo obtido foi o de número 144

(terceira coluna da Tabela 6). Alguns indivíduos obtidos nas simulações tiveram resultados

superiores aos resultados do relatório, por exemplo, o indivíduo da oitava simulação. Apenas

42

algumas simulações geraram indivíduos com parâmetros não aceitáveis conforme descrito na

Tabela 5.

Apesar da alta velocidade de geração e mutação de indivíduos pela FPGA o processo de

avaliação no computador com o uso do software SMASH em modo batch se mostrou lento,

sendo este o gargalo de tempo no processo. O tempo médio para geração, avaliação e

comunicação do indivíduo entre o computador e a FPGA foi de aproximadamente seis segundos.

O sistema funcionou adequadamente conforme esperado convergindo para configurações de

circuito que atendem aos requisitos estabelecidos dentro de um espaço de 4.294.967.296 (quatro

parâmetros com 256 valores possíveis cada) soluções possíveis.

43

CAPÍTULO 6 - CONCLUSÃO

Os resultados obtidos a partir das simulações realizadas foram satisfatórios e demonstraram o

correto funcionamento do algoritmo genético compacto implementado na FPGA. Além de

concluir sobre o funcionamento do AGC foi verificado que a modificação do AGC básico

implementada possui poder de busca suficiente no espaço de soluções possíveis para resolver

problemas complexos, por exemplo, evolução de hardware.

Devido à avaliação dos indivíduos ser realizada no computador (ao invés da FPGA ou outro

circuito) o tempo necessário para o sistema encontrar uma solução aceitável de configuração de

circuito não permite que o mesmo seja utilizado para aplicações que exijam respostas rápidas.

Para utilização prática do sistema em aplicações reais e on-line de evolução de hardware se faz

necessário o desenvolvimento de um circuito com interfaces digitais de configuração de

parâmetros e um circuito de avaliação com tempo de resposta mínimo para que o sistema inteiro

opere em tempo real, se adequando instantaneamente a mudanças de operação que possam

surgir.

Melhorias podem ser realizadas no AGC implementado com modificações que ajudem no

refinamento das soluções encontradas, por exemplo, mudanças individuais nas taxas de mutações

dos bits ou taxas de mutação diferentes de acordo com o progresso da execução das simulações.

44

CAPÍTULO 7 - REFERÊNCIAS BIBLIOGRÁFICAS

GOLDBERG, D. E.; HARIK, G. R.; LOBO, F. G. The Compact Genetic Algorithm. IEEE

Transactions on Evolutionary Computation. VOL. 3, N. 4, November of 1999.

HIGUCHI, T., et al. Real-World Applications of Analog and Digital Evolvable Hardware. IEEE

Transactions on Evolutionary Computation. VOL. 3, N. 3, September of 1999.

ZUBEN, F. J. V. Computação Evolutiva: Uma Abordagem Pragmática. DCA/FEEC/Unicamp,

2000.

GALLAGHER, J. C.; VIGRAHAM, S.; KRAMER, G. A Family of Compact Genetic

Algorithms for Intrinsic Evolvable Hardware. IEEE Transactions on Evolutionary

Computation. VOL. 8, N. 2, April of 2004.

Altera DE2 Development and Education Board User Manual, Altera Corporation, 2006.

BARONCINI, V. H. V.; GOUVEIA FILHO, O. C.. Design of RF CMOS Low Noise Amplifiers

Using a Current Based MOSFET Model. Proceedings of 17th Symposium on Integrated

Circuits and Systems Design. Porto de Galinhas. New York: ACM press, 2004. v. 1, p. 82-87.

PILLA JR., VALFREDO. Projeto de um amplificador de baixo ruído (LNA – Low noise

amplifier). Programa de pós-graduação em engenharia elétrica, Universidade Federal do Paraná.

Curitiba, Brasil, 2006.

ALGORITMO GENÉTICO IMPLEMENTADO EM FPGA PARA EVOLUÇÃO DE ... · NÚCLEO DE CIÊNCIAS EXATAS E...

Documents

Transcript of ALGORITMO GENÉTICO IMPLEMENTADO EM FPGA PARA EVOLUÇÃO DE ... · NÚCLEO DE CIÊNCIAS EXATAS E...