Embed Size (px)
Citation preview
Centro Universitário Positivo - UnicenP Núcleo de Ciências Exatas e Tecnológicas – NCET
Engenharia da Computação
Hamon Veloso da Silva
Interface para Arquitetura Paralela Reconfigurável Aplicada a Algoritmos Genéticos Usando Nios II
Curitiba 2006
Centro Universitário Positivo - UnicenP Núcleo de Ciências Exatas e Tecnológicas – NCET
Engenharia da Computação
Hamon Veloso da Silva
Interface para Arquitetura Paralela Reconfigurável Aplicada a Algoritmos Genéticos Usando Nios II
Monografia apresentada a disciplina de Projeto Final, como requisito parcial à conclusão do curso de Engenharia da Computação. Orientador: Prof. Edson Pedro Ferlin.
Curitiba 2006
TERMO DE APROVAÇÃO
Hamon Veloso da Silva
Interface para Arquitetura Paralela Reconfigurável Aplicada a Algoritmos Genéticos
Usando Nios II
Monografia aprovada como requisito parcial à conclusão do curso de Engenharia da
Computação do Centro Universitário Positivo, pela seguinte banca examinadora:
Prof. Edson Pedro Ferlin (Orientador) Prof. Alessandro Brawerman Prof. Mauricio Perretto
Curitiba, 11 de Dezembro de 2006
AGRADECIMENTOS
Quero agradecer a minha família, que sempre estiveram me guiando, apoiando,
confiando, ajudando a superar a todas as dificuldades até aqui.
Também quero agradecer aos amigos, professores, colegas de trabalho, todos que
fizeram parte desse período acadêmico, da minha vida.
SUMÁRIO
LISTA DE FIGURAS ............................................................................................................................................VIII
LISTA DE TABELAS ..............................................................................................................................................IX
LISTA DE SIGLAS ................................................................................................................................................... X
LISTA DE SÍMBOLOS............................................................................................................................................XI
RESUMO................................................................................................................................................................. XII
ABSTRACT............................................................................................................................................................. XII
1. INTRODUÇÃO..................................................................................................................................................... 13
1.2 VISÃO GERAL.................................................................................................................................................... 14 1.2 MOTIVAÇÃO ...................................................................................................................................................... 15 1.3 CONTEXTUALIZAÇÃO ........................................................................................................................................ 15 1.4 OBJETIVO.......................................................................................................................................................... 16
2. REVISÃO BIBLIOGRÁFICA............................................................................................................................. 17
2.1. COMPUTAÇÃO EVOLUTIVA E ALGORITMOS GENÉTICOS................................................................................... 17 2.2. COMPUTAÇÃO RECONFIGURÁVEL.................................................................................................................... 19 2.3. FPGA............................................................................................................................................................... 20 2.4. PROCESSAMENTO PARALELO ........................................................................................................................... 22 2.5. PLACA DE DESENVOLVIMENTO NIOS II - EDIÇÃO STRATIX ............................................................................... 23
3. DESCRIÇÃO......................................................................................................................................................... 24
3.1 DESCRIÇÃO DO SOFTWARE................................................................................................................................ 24 3.2 DESCRIÇÃO DO FIRMWARE................................................................................................................................ 24 3.3 DESCRIÇÃO DO HARDWARE .............................................................................................................................. 25
3.3.1 Configuração da FPGA............................................................................................................................ 25 3.3.2. Comunicação entre Hardware e o Software............................................................................................ 26
4. PROJETO.............................................................................................................................................................. 27
4.1 SOFTWARE........................................................................................................................................................ 27 4.1.1 Objetivos................................................................................................................................................... 27 4.1.2 Funções .................................................................................................................................................... 27 4.1.3 Atributos ................................................................................................................................................... 28 4.1.4 Descrição de Casos de Uso ...................................................................................................................... 28 4.1.5 Diagramas de Casos de Uso..................................................................................................................... 30 4.1.6 Prioridades dos Casos de Uso.................................................................................................................. 30 4.1.7 Telas do Sistema....................................................................................................................................... 31 4.1.8 Diagramas de Classes .............................................................................................................................. 32
4.2 FIRMWARE ........................................................................................................................................................ 33 4.2.1 Objetivos................................................................................................................................................... 33 4.2.2 Funções .................................................................................................................................................... 34 4.2.3 Funcionamento do Firmware ................................................................................................................... 35
4.3 HARDWARE....................................................................................................................................................... 36 4.3.1 Modelagem do CORE............................................................................................................................... 37 4.3.2 Melhor Cromossomo ................................................................................................................................ 38 4.3.3 Memória Temporária e de Cromossomos ................................................................................................ 39 4.3.4 Elemento Processador.............................................................................................................................. 39 4.3.5 Unidade de Resultado...............................................................................................................................41 4.3.6 Contador de Gerações.............................................................................................................................. 41 4.3.7 Máquina de Estados .................................................................................................................................41 4.3.8 HOST........................................................................................................................................................ 41 4.3.9 Seleção...................................................................................................................................................... 42 4.3.10 Crossover................................................................................................................................................ 43 4.3.11 Mutação.................................................................................................................................................. 43 4.3.12 MUX ....................................................................................................................................................... 43 4.3.13 Gerador de População ........................................................................................................................... 43
4.3.14 Estrutura do Cromossomo...................................................................................................................... 44
5. IMPLEMENTAÇÃO............................................................................................................................................ 45
5.1 SOFTWARE........................................................................................................................................................ 45 Classe de Comunicação ....................................................................................................................................45 Classe de Interpretação do Cromossomo.......................................................................................................... 46
5.2 FIRMWARE ........................................................................................................................................................ 46 Protocolo Firmware / Software......................................................................................................................... 47
6. FERRAMENTAS UTILIZADAS ........................................................................................................................ 48
6.1 AMBIENTE DE DESENVOLVIMENTO QUARTUS II ................................................................................................ 48 SOPC Builder .................................................................................................................................................... 48 RTL View ........................................................................................................................................................... 49
6.2 NIOS II IDE......................................................................................................................................................50
7. TESTES E RESULTADOS.................................................................................................................................. 51
8. CONCLUSÃO ....................................................................................................................................................... 53
9. REFERÊNCIAS.................................................................................................................................................... 54
ANEXOS.................................................................................................................................................................... 56
VIII
LISTA DE FIGURAS Figura 1 - Modelo de Execução de Algoritmos Genéticos.......................................................................................... 18 Figura 2 - Arquitetura de FPGA................................................................................................................................. 21 Figura 3 – O Processo de Paralelização .................................................................................................................... 22 Figura 4 - Diagrama em Blocos da Placa Stratix....................................................................................................... 23 Figura 5 – Blocos do Projeto...................................................................................................................................... 24 Figura 6 - Conexão JTAG........................................................................................................................................... 25 Figura 7 - Conector Serial.......................................................................................................................................... 26 Figura 8 - Casos de Uso ............................................................................................................................................. 30 Figura 9 - Diagramas de Classe 1.............................................................................................................................. 32 Figura 10 - Diagramas de Classe 2 ............................................................................................................................ 33 Figura 11 - Funcionamento do Firmware .................................................................................................................. 35 Figura 12 - Arquitetura do Projeto............................................................................................................................. 36 Figura 13 – Módulos do Core..................................................................................................................................... 38 Figura 14 – Elemento Lógico ..................................................................................................................................... 39 Figura 15 – Elemento Processador ............................................................................................................................ 40 Figura 16 – Fluxograma do Método de Seleção......................................................................................................... 42 Figura 17 – Estrutura do Cromossomo ......................................................................................................................44 Figura 18 - Estrutura do Gene.................................................................................................................................... 44 Figura 19 - Sistema Típico SOPC............................................................................................................................... 48 Figura 20 - RTL View ................................................................................................................................................. 49 Figura 21 - Nios II IDE............................................................................................................................................... 50
IX
LISTA DE TABELAS Tabela 1 - Funções do Software.................................................................................................................................. 27 Tabela 2 - Atributos do Software ................................................................................................................................ 28 Tabela 3 - Prioridades dos Casos de Uso................................................................................................................... 30 Tabela 4 - Funções do Firmware................................................................................................................................ 34
X
LISTA DE SIGLAS
AG - Algoritmo Genético.
CI - Circuito Integrado.
CLB - Configuration Logical Blocks.
DSP - Digital Signal Processor.
EP - Elemento processador.
EMI - Electromagnetic interference.
E/S - Entrada / Saída.
FPGA - Field-Programmable Gate Array.
IDE - Integrated Development Environment.
IOB - Input/Output Block.
LED - Light Emitting Diode.
LUT - Look-Up Table.
PLL - Phase-locked loops.
RAM - Random Acces Memory.
SDRAM - Synchronous Dynamic Random Access Memory.
VHDL - VHSIC Hardware Description Language.
VHSIC - Very-High-Speed Integrated Circuit.
XI
LISTA DE SÍMBOLOS MHz - Mega Hertz. Hz - Hertz. V - Volts.
XII
RESUMO
O projeto consiste no desenvolvimento de uma interface utilizando o processador
Nios II para uma arquitetura paralela reconfigurável aplicada a algoritmos genéticos. A
arquitetura realizará a síntese de circuitos digitais combinacionais. Os circuitos
possuem várias entradas e uma saída correspondente para cada combinação dessas
entradas. Esse projeto responderá qual expressão lógica nos fornece a saída desejada
para cada uma das entradas combinadas. Visando sempre minimizar a quantidade de
portas lógicas utilizadas.
Palavras-chave: VHDL, algoritmos genéticos, circuitos lógicos, Nios II, software
embarcado.
ABSTRACT
This project consists on the development of a interface using processor Nios II for a
architecture parallel and configurable applied the genetic algorithms. The architecture
will be able to perform the synthesis of digital circuits. The circuits possess some inputs
and a corresponding exit for each combination of these inputs. This project will be able
to answer which logical expression can supply the correct exit for each one of these
combined inputs, always aiming at minimizing the amount of logic gates used.
Key words: VHDL, genetic algorithms, logical circuits, Nios II, embedded software.
13
1. INTRODUÇÃO
Esse projeto teve sua proposta lançada a partir de outro projeto que estava sendo
desenvolvido no Centro Universitário Positivo – UnicenP, pelo Prof. Edson Pedro Ferlin
e pelo Eng. Ederson Cichazevszki.
A álgebra booleana é uma variação da álgebra fundamental desenvolvida no século
XIX pelo matemático inglês George Boole (1815-1864), cujas variáveis assumem
apenas dois únicos valores opostos, permitindo determinar se proposições lógicas são
verdadeiras ou falsas. Graças à essa característica binária, passou a ser utilizada em
computação nos circuitos lógicos combinacionais. É formada de operadores lógicos
básicos: AND, OR e NOT.
Um circuito combinacional é uma implementação de operadores lógicos na forma
de portas lógicas que representam uma equação lógica. Uma vez obtida a expressão
de um circuito combinacional, podemos ser capazes de reduzi-la a uma forma mais
simples, que contenha um número menor de termos ou variáveis em um ou mais
termos da expressão. Esta nova expressão pode ser usada para implementar um
circuito que é equivalente ao circuito original, mas que contém um menor número de
portas e conexões.
Existem dois métodos utilizados para simplificar circuitos lógicos. Um dos métodos
faz uso dos teoremas da álgebra booleana do séc. XIX e é bastante dependente da
inspiração e da experiência. O outro método é o de Karnaugh e tem uma abordagem
mais sistemática (TOCCI & WIDMER, 2003).
14
1.2 Visão Geral
Apesar do grande avanço na área de arquitetura de computadores, as arquiteturas
paralelas reconfiguráveis possuem um grande campo de atuação na engenharia e nas
ciências, pois existe uma necessidade crescente de poder computacional e flexibilidade
que a arquitetura paralela reconfigurável proporciona.
Entre todos os campos de estudo associados com projeto de sistemas embarcados,
as tecnologias de software e hardware, em particular dos processadores, são as que
têm experimentado a evolução mais rápida (FERLIN, 2004).
Em função desta acelerada evolução tecnológica, a idéia de se utilizar estruturas
abertas e reconfiguráveis que possam adaptar-se a novas demandas torna-se muito
atraente. Isto pode até ser um pré-requisito na consideração de um projeto de um
sistema embarcado. Sistemas de desenvolvimento baseados em computação
reconfigurável (sistemas de hardware reconfigurável) apresentam características
adequadas para uso nesta classe de projetos. Eles apresentam, dentre outras
vantagens, as características de baixo consumo, alta velocidade de operação,
capacidade de integração, flexibilidade, facilidade de programação e operação modular
(ITO & CARRO, 2000).
Esse projeto utiliza-se de uma arquitetura paralela reconfigurável, que emprega os
conceitos de Arquitetura de Computadores e de Processamento Paralelo, para obter
um desempenho escalável. Aliando-se com os conceitos de Computação
Reconfigurável, aproveita-se a flexibilidade e a adaptabilidade da arquitetura à
aplicação. Esta arquitetura permite uma rápida adequação do sistema para diversos
problemas e, em particular, neste trabalho estuda-se a aplicação de Algoritmos
Genéticos (AG) na otimização de circuitos combinacionais. Diferentemente da
computação seqüencial, a computação paralela de algoritmos genéticos aproveita os
Elementos Processadores disponíveis e sua especificidade para a aplicação. Assim, a
arquitetura proposta pode oferecer um alto desempenho, escalabilidade e soluções
particularizadas para problemas de otimização usando AG.
15
1.2 Motivação
O projeto possibilitará o embasamento técnico científico para o desenvolvimento de
novos projetos nas áreas de processamento paralelo, computação reconfigurável e
algoritmos genéticos.
Uma arquitetura poderosa capaz de suportar novos problemas a serem resolvidos
usando Algoritmos Genéticos estará formada.
Estudar e desenvolver uma arquitetura são tarefas desafiadoras que motivam a
busca pela solução que atenda as necessidades e objetivos.
1.3 Contextualização
Métodos convencionais de simplificação de expressões lógicas são empregados
ainda em alguns aplicativos desenvolvidos para arquiteturas convencionais de
computadores que não tiram o melhor proveito de processamento já que executam
sequencialmente apenas.
Atualmente existem estudos e conferências tratando de diferentes técnicas e
heurísticas para desenvolver circuitos combinacionais para circuitos digitais e o que
tem se percebido é que o processamento paralelo voltado a uma arquitetura
reconfigurável é o que apresenta maior desempenho e flexibilidade.
Arquiteturas de computadores são formadas de muitos circuitos combinacionais e a
eliminação de portas é algo que representa principalmente economia. Mas, as maiorias
das arquiteturas são fixas e uma vez definidas terão sempre as mesmas lógicas
combinacionais utilizadas. Porém, os hardwares evolutivos, reconfiguráveis estão
constantemente fazendo uma nova recombinação de seus circuitos e é por isso que
técnicas rápidas de simplificação de expressões são tão importantes hoje.
16
1.4 Objetivo
O principal objetivo desse projeto é a construção de uma interface de comunicação
utilizando o processador Nios II da Altera para uma arquitetura que implementa
Algoritmos Genéticos em hardware para obter a expressão lógica de uma dada tabela
verdade, reduzindo o número de operadores lógicos necessárias para representar uma
função.
Como objetivos secundários espera-se:
• Modificar a arquitetura para trabalhar com no mínimo sete bits de entradas
booleanas.
• Arquitetura com 20 elementos processadores (EPs) (aumentando o poder de
processamento).
• Reduzir o tempo de busca da solução, aproveitando-se do desempenho do
hardware e de uma arquitetura paralela.
17
2. REVISÃO BIBLIOGRÁFICA
2.1. Computação Evolutiva e Algoritmos Genéticos
A Computação Evolucionária compreende um conjunto de técnicas de busca e
otimização inspiradas na evolução natural das espécies. Desta forma, cria-se uma
população de indivíduos que vão se reproduzir e competir pela sobrevivência. Os
melhores sobrevivem e transferem suas características genéticas a novas gerações. As
técnicas atualmente incluem: Programação Evolucionária, Estratégias Evolucionárias,
Algoritmos Genéticos e Programação Genética (BANZHAF, 1998).
Os AGs possuem uma larga aplicação em muitas áreas científicas e de engenharia,
entre as quais podem ser citados problemas de otimização combinatória, aprendizado
de máquina, desenvolvimento de estratégias, análise de modelos econômicos, e
diversas aplicações na Biologia como simulação do comportamento de bactérias,
sistemas imunológicos, ecossistemas, descoberta de padrões e propriedades de
moléculas orgânicas (SILVA, 2002).
Esses algoritmos simulam processos naturais de sobrevivência e reprodução das
populações, essenciais em sua evolução. Na natureza, indivíduos de uma mesma
população competem entre si, buscando principalmente a sobrevivência, seja através
da busca de recursos como alimento, ou visando a reprodução. Os indivíduos mais
aptos terão um maior número de descendentes, ao contrário dos indivíduos menos
aptos.
A idéia básica de funcionamento dos algoritmos genéticos é a de tratar as possíveis
soluções do problema como "indivíduos" de uma "população", que “evoluirá" a cada
iteração ou "geração". Para isso é necessário construir um modelo de evolução onde
os indivíduos sejam soluções de um problema. A execução do algoritmo está
apresentada na Figura 1 e pode ser resumida nos seguintes passos:
• Inicialmente escolhe-se uma população inicial, normalmente formada por
indivíduos criados aleatoriamente;
• Avalia-se toda a população de indivíduos segundo algum critério,
determinado por uma função que avalia a qualidade do indivíduo (função de
aptidão ou "fitness");
18
• Em seguida, através do operador de "seleção", escolhem-se os indivíduos de
melhor valor (dado pela função de aptidão) como base para a criação de um
novo conjunto de possíveis soluções, chamado de nova "geração";
• Esta nova geração é obtida aplicando-se sobre os indivíduos selecionados as
operações que misturem suas características (chamadas "genes"), através
dos operadores de "cruzamento" ("crossover"), "mutação" e inversão;
• Estes passos são repetidos até que uma solução aceitável seja encontrada,
até que o número predeterminado de passos seja atingido ou até que o
algoritmo não consiga mais melhorar a solução já encontrada.
Figura 1 - Modelo de Execução de Algoritmos Genétic os
Os AGs são habitualmente considerados algoritmos implicitamente paralelos, sendo
esta característica um dos seus pontos fortes. Atualmente existe uma procura cada vez
maior por algoritmos que, além de resolver os problemas de forma aceitável, também
os resolvam de um modo que seja paralelizável, pois cada vez mais a tendência está
voltada para a utilização de sistemas paralelos. Os AGs possuem uma estrutura
computacional altamente paralelizável (CANTÚ-PAZ, 1997).
19
2.2. Computação Reconfigurável
A idéia da utilização de hardware reconfigurável para o desenvolvimento de
computadores reconfiguráveis surgiu na década de 60. Contudo, a primeira
demonstração prática só ocorreu na década de 80 com o advento dos dispositivos
reprogramáveis, como no caso os FPGAs (Field-Programmable Gate Array) (TOCCI &
WIDMER, 2003).
A Computação Reconfigurável, compartilha todas essas características de
"computador de uso geral", mas organiza a computação de maneira muito diferente. Ao
invés de computar uma função seqüencial através de um conjunto de instruções de
tempo, igual a um processador, as arquiteturas reconfiguráveis geralmente computam
a função através de unidades funcionais configuradas no espaço (unidades em
diferente blocos dentro dos FPGAs). Temos, portanto, computação paralela envolvendo
diferentes unidades funcionais que geram e consomem resultados intermediários. A
diferença, portanto está na computação totalmente temporal/seqüencial das tarefas
versus computação totalmente espacial/paralela. (DEHON, 96).
Na década de 90, a disponibilidade de grande densidade de interconexão e de
transistores nas FPGAs propiciou uma nova forma de elementos reconfiguráveis
denominados Reconfigurable Data Path (VEMURI & RANDOLPH, 2000).
20
2.3. FPGA
A computação reconfigurável vem sendo muito utilizada em projetos de
desenvolvimento de hardware. Como exemplo temos os dispositivos FPGAs, circuitos
de hardware que podem ser modificados praticamente em qualquer momento durante o
uso.
Um FPGA é um dispositivo semicondutor que é largamente utilizado para o
processamento de informações digitais. Foi criado pela Xilinx Inc., e teve o seu
lançamento no ano de 1985 como um dispositivo que poderia ser programado de
acordo com as aplicações do usuário (programador). O FPGA é composto basicamente
por três tipos de componentes: blocos de entrada e saída (IOB), blocos lógicos
configuráveis (CLB - Circuitos idênticos, construído pela reunião de flip-flops e a
utilização de lógica combinacional. Utilizando os CLBS, um usuário pode construir
elementos funcionais lógicos) e chaves de interconexão (Switch Matrix - Trilhas
utilizadas para conectar os CLBS e IOBS). Os blocos lógicos são dispostos de forma
bidimensional (matriz), as chaves de interconexão são dispostas em formas de trilhas
verticais e horizontais entre as linhas e as colunas dos blocos lógicos.
O FPGA é um chip que suporta a implementação de circuitos lógicos relativamente
grandes. Consiste de um grande arranjo de células lógicas ou blocos lógicos
configuráveis contidos em um único circuito integrado. Cada célula contém capacidade
computacional para implementar funções lógicas (and, nand, or, nor ou xor) e realizar
roteamento para comunicação entre elas. O primeiro FPGA disponível comercialmente
foi desenvolvido pela empresa Xilinx Inc, em 1983.
Um FPGA basicamente é constituído por blocos lógicos, blocos de entrada e saída,
e chaves de interconexão. Os canais de roteamento possuem chaves de interligação
programáveis que permitem conectar os blocos lógicos de maneira conveniente, em
função das necessidades de cada projeto.
No interior de cada bloco lógico do FPGA existem vários modos possíveis para
implementação de funções lógicas. O mais utilizado pelos fabricantes de FPGA é o
bloco de memória LUT. Esse tipo de bloco lógico contém células de armazenamento
que são utilizadas para implementar pequenas funções lógicas. Cada célula é capaz de
armazenar um único valor lógico: zero ou um.
Nos FPGAs disponíveis comercialmente como, por exemplo, da empresa Altera
Corp., os blocos lógicos LUTs possuem geralmente quatro ou cinco entradas, o que
permite endereçar 16 ou 32 células de armazenamento. Quando um circuito lógico é
21
implementado em um FPGA, os blocos lógicos são programados para realizar as
funções necessárias, e os canais de roteamento são estruturados de forma a realizar a
interconexão necessária entre os blocos lógicos.
A arquitetura de roteamento de um FPGA é a forma pela qual os seus barramentos
e as chaves de comutação são posicionados para permitir a interconexão entre as
células lógicas. Essa arquitetura deve permitir que se obtenha um roteamento completo
e, ao mesmo tempo, uma alta densidade de portas lógicas.
Cada fabricante de FPGA possui sua própria arquitetura, mas em geral elas são
uma variação da arquitetura apresentada na Figura 2. A arquitetura consiste de blocos
lógicos configuráveis, blocos de E/S configuráveis e interconexões programáveis.
(ZEIDMAN, 2006).
Figura 2 - Arquitetura de FPGA
22
2.4. Processamento Paralelo
O processamento paralelo é uma forma eficiente do processamento da informação
com ênfase na exploração de eventos simultâneos na execução de um software
(DONGARRA et al, 2003). A motivação para o processamento paralelo é a
possibilidade de aumentar a capacidade de processamento de uma única máquina.
Com a limitação tecnológica da velocidade das máquinas seqüenciais, a solução
empregada para aumentar o poder de processamento é a utilização de processadores
em paralelo (HENNESSY & PATTERSON, 2003).
A utilização do paralelismo nos projetos de arquitetura de computadores tem
possibilitado um aumento significativo na velocidade de processamento devido à
execução simultânea de diversas tarefas. Contudo, o fator limitador do paralelismo, em
um programa, é a dependência dos dados. Se não houvesse isto, todas as operações
poderiam ser executadas simultaneamente, visto que não haveria interdependência
entre elas. As dependências são próprias dos programas seqüenciais, pois as
operações têm uma ordem de precedência para execução, que são geradas pela
aplicação durante o desenvolvimento do programa.
O processo de paralelização dos programas seqüenciais, como mostrado na Figura
3, envolve três etapas distintas (FERLIN, 1998). Na primeira etapa detectam-se as
dependências de dados de um programa. Na segunda, eliminam-se as dependências
desnecessárias. Na terceira, particiona-se do espaço de iteração, utilizando um dos
métodos de paralelização apresentados em (FERLIN, 1997).
Figura 3 – O Processo de Paralelização
23
2.5. Placa de Desenvolvimento Nios II - edição Stra tix
A placa Nios II edição Stratix é projetada para o desenvolvimento de aplicações
embarcadas de alto desempenho e/ou complexidade.
Principais características:
• FPGA EP1S10F780C6.
• 8 Mbytes de memória FLASH.
• 1 Mbyte de RAM stática.
• 16 Mbytes de SDRAM.
• 2 conectores RS232 DB9 (portas seriais).
• 4 push – buttons conectados à pinos de E/S do Stratix.
• 8 LEDs conectados ao Stratix.
• Conector JTAG da Altera.
• Oscilador de 50 MHz.
Na Figura 4 tem-se o diagrama em blocos da placa.
Figura 4 - Diagrama em Blocos da Placa Stratix
24
3. DESCRIÇÃO
Nesse capítulo tem-se uma descrição dos principais módulos do projeto. São eles:
Software, Firmware e Hardware. Eles estão representados na Figura 5.
Figura 5 – Blocos do Projeto
3.1 Descrição do Software
O software é a principal interface do usuário. Nela, ele preencherá os parâmetros de
probabilidade de crossover, mutação, máximo de gerações a processar e a tabela
verdade da qual ele deseja obter a equação. Através da interface o usuário poderá
observar as equações obtidas a cada geração dentre outras informações. Os
parâmetros são passados ao firmware que devolverá os resultados sempre que
disponíveis até o final do processamento.
3.2 Descrição do Firmware
O firmware faz a ponte entre o software e o hardware. Ele controla o acesso a cada
dispositivo no sistema. O software possui acesso aos dispositivos e suas funções
através de um protocolo estabelecido e trocado por uma interface serial RS-232.
Escrito em linguagem de programação C é capaz de acessar dispositivos em
25
barramentos de 8, 16 e até 32 bits já que o processador para o qual foi construído é de
32 bits (Nios II da Altera corp).
3.3 Descrição do Hardware
O Hardware corresponde tanto aos componentes físicos presentes no kit de
desenvolvimento quanto aos componentes que serão configurados na FPGA. São
diversos componentes escritos em linguagem de descrição de hardware.
O principal componente de hardware construído em VHDL nesse projeto é chamado
de CORE. Sua estrutura implementa Algoritmos Genéticos(AG) para a resolução de
equações lógicas combinacionais com resposta em função de até sete operadores
lógicos.
Todos os componentes escritos linguagem de descrição de hardware (HDL) serão
configurados em uma única FPGA. Para se ter uma idéia além de todo o CORE capaz
de realizar AG (unidade de hardware de seleção, crossover, memória, processamento
etc) tem-se também um processador, interface de comunicação e diversos
controladores de dispositivos presentes no kit de desenvolvimento.
3.3.1 Configuração da FPGA
Para configurar a FPGA será utilizada a interface de comunicação JTAG e o cabo
Byte Blaster presente no kit de desenvolvimento conforme mostrado na Figura 6.
Figura 6 - Conexão JTAG
26
3.3.2. Comunicação entre Hardware e o Software
Para a comunicação entre o hardware e o software é utilizada a interface serial RS-
232. Com a seguinte configuração:
• Taxa de dados: 57600 (bps)
• Paridade: nenhuma
• Bits de dados: 8
• Bits de Parada: 1
A Figura 7 exibe o conector serial presente na placa de desenvolvimento e também
sua configuração.
Figura 7 - Conector Serial
27
4. PROJETO
4.1 Software
Esse sistema visa estabelecer uma comunicação com o hardware enviando o
problema do usuário e recebendo a solução. Parâmetros de configuração do hardware
e do problema serão inseridos pelo usuário e transferidos para que o hardware
processe e devolva as equações encontradas a cada geração.
4.1.1 Objetivos
Permitir que um usuário obtivesse respostas (equações lógicas) a cada geração
realizada pelo hardware para sua tabela verdade de entrada.
4.1.2 Funções
Na Tabela 1 tem-se as principais funções que foram implementadas no sistema.
Estejam elas de maneira clara ou não para o usuário.
Tabela 1 - Funções do Software Ref
#
Função Categoria
R1.1 Exibir gráfico de fitness por geração. Para cada geração processada
pelo hardware a aplicação irá exibir graficamente seu respectivo fitness
alcançado.
Evidente
R1.2 Exibir equação obtida em cada geração. Evidente
R1.3 Receber cromossomo da arquitetura. A aplicação deverá receber,
pela interface serial, o cromossomo sempre que disponível. Oculto
R1.4 Interpretar cromossomo. O cromossomo recebido a cada geração
precisa ser interpretado. Duas informações importantes precisam ser
extraídas da string de bits. Valor de fitness e a equação lógica.
Oculto
R1.5 Contar tempo decorrido em cada geração. Evidente
R1.6 Ajuda Evidente
28
4.1.3 Atributos
Na Tabela 2 tem-se os atributos do software. Detalhes e restrições que são
relevantes para o bom funcionamento do mesmo.
Tabela 2 - Atributos do Software Atributo Detalhes e Restrições de Limites
Plataforma de Sistemas Operacionais Windows 98/NT
Processador (mínimo) Pentium ou similar de 60MHz
Memória para Execução 1 MB de RAM
Necessário para Instalação 2 MB
4.1.4 Descrição de Casos de Uso
Na figura Figura 8 tem-se os casos de uso do sistema. Eles estão descritos nesse
capítulo.
Caso de Uso: Obter Nova Equação.
Atores: Usuário.
Tipo: Secundário.
Descrição: o usuário escolhe Obter Nova Equação e a arquitetura será
reinicializada cancelando qualquer operação de processamento atual. Ela estará
disponível para um novo processamento. Os campos da aplicação voltarão ao estado
inicial e o usuário poderá realizar uma nova configuração de parâmetros e realizar o
processamento.
Caso de Uso: Definir Parâmetros.
Atores: Usuário.
Tipo: Opcional.
Descrição: o usuário pode definir os parâmetros do problema. São eles:
probabilidade de crossover, de mutação, máximo de gerações e o preenchimento da
tabela verdade.
Caso de Uso: Iniciar Processamento.
Atores: Usuário.
29
Tipo: Primário.
Descrição: o software enviará todos os parâmetros para a arquitetura, começar a
receber e exibir as soluções sempre que disponíveis pelo hardware. Quando esse caso
de uso for utilizado praticamente todas as funções que o software deverá desempenhar
serão ativadas.
Caso de Uso: Ver Ajuda.
Atores: Usuário.
Tipo: Opcional.
Descrição: o usuário poderá escolher visualizar um documento de ajuda, que
explicará como o programa funciona, entre outros recursos. Esse documento trata-se
do manual do usuário.
Caso de Uso: Exibir Créditos.
Atores: Usuário.
Tipo: Opcional.
Descrição: exibe os créditos do desenvolvedor do sistema.
30
4.1.5 Diagramas de Casos de Uso
Figura 8 - Casos de Uso
4.1.6 Prioridades dos Casos de Uso
Na Tabela 3 tem-se uma classificação das prioridades dos casos de uso.
Tabela 3 - Prioridades dos Casos de Uso Nome Prioridade
Obter Nova Equação Médio
Definir Parâmetros Médio
Iniciar Processamento Alta
Ver Ajuda Baixa
Exibir Créditos Baixa
Justificativas para as prioridades julgadas de acordo com a Tabela 3:
31
Alta: foram classificados assim os casos de uso que possuem fundamental
importância para alcançar o objetivo do sistema.
Média: São importantes, no entanto, o sistema irá funcionar mesmo que o usuário
não utilize esses casos de uso. Esses casos de uso são opcionais.
Baixa: simplesmente opcionais e não influenciam no objetivo do sistema de forma
alguma.
4.1.7 Telas do Sistema
O software apresenta quatro painéis de visualização para o usuário. São eles:
• Configuração: nesse painel o usuário configura o problema que deseja
executar.
• Processamento: somente após o início de um processamento, as equações
serão listadas a cada geração já processada pelo hardware até o máximo de
gerações. Na tabela que será formada você verá três informações. Geração,
fitness (valor que representa o quanto a equação está correta), Equação.
• Gráfico de desempenho: nesse painel, um gráfico Fitness X Geração será
representado.
• Gráfico de Gerações: gráfico de Geração X Tempo (s).
Observação: consultar as imagens no anexo C – telas do sistema.
32
4.1.8 Diagramas de Classes
O software é constituído das classes apresentadas na Figura 9 e Figura 10.
• cComunicacao: classe responsável pela comunicação entre software e o
firmware para a resolução do problema de Algoritmo Genético.
• cSerial: classe utilizada para transmissão serial de dados. Deve ser
acessada somente pela classe de comunicação.
• cErro: classe utilizada para captura de erros que são lançados pelo software
em situações de erro, como por exemplo erro de comunicação.
• cInterpCromossomo: classe que interpreta um cromossomo. Fornecendo da
string de bits uma string de equação que a string binária representa. Para
isso utiliza a classe de Elemento Lógico (EL).
Figura 9 - Diagramas de Classe 1
33
Figura 10 - Diagramas de Classe 2
4.2 Firmware
O firmware realizará a integração do hardware com o software. Ele controla o
hardware através das requisições feitas pelo software, com operações especificadas
por um protocolo. Dessa forma, o hardware não é diretamente controlado pelo
programa de computador.
As trocas de mensagens são realizadas através do protocolo estabelecido. O
firmware além de controlar os dispositivos de hardware também faz o controle de E/S
de comandos e dados.
4.2.1 Objetivos
Permitir o acesso correto ao hardware da arquitetura. Enviando parâmetros para o
hardware e soluções para o software.
34
4.2.2 Funções
Na Tabela 4 tem-se as funções que o firmware deverá atender.
Tabela 4 - Funções do Firmware Ref # Função
R1.1 Contolar dispositivos. Cada dispositivo pode ser controlado pelo controlador
através de um endereço de memória. Cabe ao firmware receber os comandos e
ativar ou não um dispositivos. Exemplo: ativar um display, ativar/reiniciar/desativar
o CORE etc.
R1.2 Receber parâmetros de configuração provenientes do software e iniciar o
processamento com o CORE.
R1.3 Receber cromossomos obtidos pelo hardware e enviar à aplicação sempre que
requisitado.
35
4.2.3 Funcionamento do Firmware
O firmware fica constantemente realizando leitura no buffer da interface serial. De
acordo com o comando enviado pelo software ele realiza uma operação. Podendo essa
ser uma ativação de hardware e/ou ainda envolver algum retorno para o software. O
funcionamento está exemplificado na Figura 11.
Figura 11 - Funcionamento do Firmware
36
4.3 Hardware
O hardware utilizado nesse projeto inclui componentes presentes na Placa de
Desenvolvimento Nios II - edição Stratix e principalmente o hardware que será
configurado na FPGA, escrito em linguagem de descrição de hardware (HDL).
O principal bloco de hardware escrito em VHDL é chamado de CORE. Ele é
formado por unidades de memória, processamento e controle. Implementa a estrutura
de Algoritmos Genéticos e é capaz de achar a equação lógica que representa uma
tabela verdade passada como problema. O CORE, foi desenvolvido pelo Prof. Edson
Pedro Ferlin e pelo Eng. Ederson Cichazevszki em projetos anteriores no Centro
Universitário Positivo.
O hardware que será configurado na FPGA não é constituído somente do CORE,
mas também do processador Nios II, memória e controladores de dispositivos de
comunicação presentes no kit. O software embarcado (firmware) estará rodando nessa
arquitetura. É uma arquitetura completa, construída com a ferramenta SOPC Builder da
Altera. A Figura 12 representa em blocos os principais componentes dessa arquitetura
e o anexo B exemplifica o mesmo, porém, como esses componentes foram interligados
na prática.
Figura 12 - Arquitetura do Projeto
37
4.3.1 Modelagem do CORE
O CORE receberá parâmetros do software como probabilidade de mutação,
crossover, máximo de gerações e a uma tabela de onde se deseja obter a equação. A
cada geração do problema processado devolverá o melhor cromossomo obtido. Esse
cromossomo é uma representação da função lógica que está associada à tabela de
entrada.
A arquitetura implementa o método de Algoritmos Genéticos para a resolução do
problema. Nesse método a solução é buscada a cada geração partindo de uma
solução totalmente aleatória, contando então com um mecanismo de evolução genética
para alcançar a solução. Esse método de resolução pode ser muito eficiente, no
entanto requer muito processamento para alcançar, em alguns casos, à solução
correta. Portanto, justifica-se a construção da arquitetura paralela para obter o máximo
do poder computacional do chip.
Na Figura 13 temos uma modelagem do CORE comunicando-se com o software
Host. Cada bloco modelado (exceto o HOST) é uma unidade que será escrita em
linguagem de descrição de hardware e depois sintetizada pelo próprio Quartus II em
uma estrutura de hardware de acordo com o que foi projetado para a unidade.
Nos próximos capítulos, arquitetura do CORE será detalhada.
38
Figura 13 – Módulos do Core
4.3.2 Melhor Cromossomo
O cromossomo será avaliado quanto ao seu resultado que é o seu valor (fitness)
obtido. Dois critérios são fundamentais nessa avaliação:
- Quantidade de acerto (match): representa quantos valores de saída obtidos
correspondem com o valor de saída desejado.
- Quantidade de nulos: quantas das operações fornecidas pelo cromossomo são
nulas. Na prática esse fator implicará na redução do tamanho da equação.
O cromossomo de melhor fitness é transferido para unidade de resultado.
39
4.3.3 Memória Temporária e de Cromossomos
Na Memória Temporária e também na Memória de Cromossomos teremos uma
população de 100 cromossomos. As principais funções da Memória de Cromossomos é
alimentar o Elemento Processador e ao mesmo tempo armazenar os novos
cromossomos que vão chegando do processo de evolução (seleção, crossover e
mutação). O que se diferenciará em cada uma das memórias será o tamanho de cada
cromossomo. Na Memória Temporária o fitness e a quantidade de nulos são
armazenados juntamente com a equação e na memória cromossomo somente a
equação que representa o cromossomo é armazenada.
4.3.4 Elemento Processador
O Elemento Processador (EP) na Figura 15 é responsável pela geração de cinco
equações lógicas por geração. Ele é formado por 25 Elementos Lógicos (ELs) e
também por multiplexadores (EL representado na Figura 14).
A cada geração um cromossomo configura o EP. Cada gene do cromossomo irá
configurar um EL fornecendo 3 bits para o operador e 2 bits para a seleção do
operando A no multiplexador, 2 bits para a seleção do operando B.
Os EL são recombinados formando as cinco equações de saída (Y0 até Y4 na
Figura 15) com somente um cromossomo, portanto ele é intrinsecamente paralelo.
Cada Elemento Lógico constitui uma unidade que fornece parte da equação. Os
primeiros 4 elementos lógicos possuem suas entradas associadas com as variáveis ( A,
B, C e D) do problema e os demais são funções dos outros elementos lógicos
anteriores. Por exemplo, as entradas do multiplexador do EL4 na Figura 15 são
provenientes dos quatro Elementos Lógicos anteriores.
Figura 14 – Elemento Lógico
40
Figura 15 – Elemento Processador
41
4.3.5 Unidade de Resultado
Nessa unidade teremos disponível a contagem de gerações e fitness do
cromossomo da geração atual. O resultado será transmitido ao computador utilizando-
se a interface de comunicação serial.
4.3.6 Contador de Gerações
Essa unidade conta a quantidade de gerações decorridas. Essa informação é
importante para saber a evolução no tempo e também para ser utilizada como
referência em um dos critérios de parada que é o valor máximo de gerações. Sua
função é realizar uma contagem seqüencial que inicia-se na geração zero e vai até ao
máximo de gerações.
4.3.7 Máquina de Estados
Todo o funcionamento da arquitetura será controlado através de uma máquina de
estados. Cada estado é responsável pela ativação de uma pequena parte do CORE,
tornando-o funcional. A máquina de estados é quem realmente comanda e sincroniza a
arquitetura.
4.3.8 HOST
Representa o software principal que comunica-se com o hardware. Enviará os
dados de configuração como probabilidade de mutação, de crossover, quantidade de
gerações, dados de entrada da tabela e a resposta para aquela combinação. Receberá
e apresentará a resposta em um gráfico de gerações e respostas. A cada geração o
Host receberá um seqüência de dados que é o cromossomo. Nesse cromossomo
teremos: a resposta que é a equação, a quantidade de nulos e o resultado que é o
fitness para essa equação. O Host terá também que interpretar cada parte desse
cromossomo para exibir a equação e o fitness.
42
4.3.9 Seleção
Unidade responsável por aplicar uma técnica que em Algoritmos Genéticos é
chamada de seleção (MITCHELL, 1997). O método de seleção será por Torneio onde n
indivíduos serão escolhidos aleatoriamente para gerar uma sub-população temporária.
Sendo então o indivíduo selecionado através da taxa de entrada. A Figura 16
apresenta o fluxograma do mecanismo de seleção.
Figura 16 – Fluxograma do Método de Seleção
43
4.3.10 Crossover
Unidade responsável por aplicar uma técnica que em Algoritmos Genéticos é
chamada de crossover. O crossover fará com que as características dos cromossomos
sejam misturadas. A taxa de crossover será um dos parâmetros de entrada do usuário
e o ponto de troca adotado será na metade dos cromossomos.
4.3.11 Mutação
Unidade responsável por aplicar uma técnica que em algoritmos genéticos é
chamada de mutação (MITCHELL, 1997). Isso fará com que as características dos
cromossomos sejam modificadas de uma forma aleatória. Essa operação é baseada na
própria evolução das espécies, mas um valor muito elevado poderá fazer com que o
processo de evolução seja mais lento.
4.3.12 MUX
Essa unidade será um multiplexador que selecionará a população de cromossomos
de entrada. A seleção das entradas será efetuada então pelo valor da geração. Caso
seja a primeira geração o cromossomo é proveniente do Gerador de População caso
contrário utiliza-se cromossomo de gerações anteriores.
4.3.13 Gerador de População
Essa unidade produzirá aleatoriamente os cromossomos iniciais. Sendo assim o
sistema começa a funcionar a avaliar equações de cromossomos aleatórios e que
provavelmente não são respostas para o problema configurado. Então, o valor do
fitness para os cromossomos iniciais deverá ser praticamente nulo e com a sucessão
de gerações, aplicando-se operadores genéticos (seleção, crossover e mutação) as
novas populações serão obtidas. O gerador de população é utilizado somente na
primeira geração.
44
4.3.14 Estrutura do Cromossomo
O cromossomo é uma seqüência de bits que constituem 25 Genes. Cada Gene
possui 7 bits. Então, o cromossomo é formado por 175 bits. A estrutura do cromossomo
está representada na Figura 17.
Figura 17 – Estrutura do Cromossomo
Cada Gene é responsável pela configuração de um Elemento Lógico dentro do EP.
Como já comentado ele possui 7 bits. São eles:
• Endereço A (2 bits) – responsável pelo sinal de seleção da entrada A do
multiplexador que irá selecionar o primeiro operando.
• Endereço B (2 bits) – responsável pelo sinal de seleção da entrada B do
multiplexador que irá selecionar o segundo operando.
• Função (3 bits) – representa a função que o Elemento Lógico correspondente
deverá executar.
A estrutura do Gene está representada na Figura 18.
Figura 18 - Estrutura do Gene
Como o Endereço de seleção de cada operando é de 2 bits, o número máximo de
variáveis de entradas atualmente está limitado em quatro.
O campo Função (de 3 bits) corresponde as funções implementadas. Ou seja, as
funções que o Elemento Lógico é capaz de operar. São elas: and, or, xor, not a, not b,
transparente a (a), transparente b (b).
45
5. IMPLEMENTAÇÃO
Esse capítulo apresenta de fato como alguns blocos do sistema foram
implementados, partes consideradas importantes no projeto serão expostas. O objetivo
principal é exemplificar o projeto proporcionando maior esclarecimento sobre o sistema.
5.1 Software
O software foi implementado através da aplicação C++ Builder 6, da Borland. As
principais classes estão apresentadas a seguir:
Classe de Comunicação
Os principais métodos dessa classe são:
• Construtor não padrão cComunicacao(...): com ele os parâmetros são
configurados na classe cComunicacao.
• IniciarProcessamento(): transmitirá os parâmetros previamente configurados
pelo construtor e também o comando para que o firmware ative o
funcionamento do hardware.
• GetNewCromossomo(): esse método deverá ser chamado para receber o
novo cromossomo. Para que funcione corretamente deve ser chamado
somente após o retorno verdadeiro do método TemNovoCromossomo().
class cComunicacao{ private: bool m_EstaProcessando; bool m_EstaConcluido; int m_geracoes; float m_pcrossover; float m_pmutacao; short int m_tabela_verdade; unsigned char m_cromossomo[24]; bool CancelarProcessamento(); public: cComunicacao(); ~cComunicacao(); cComunicacao(int geracoes, float pcrossover, float pmutacao, short int TV); bool IniciarProcessamento(); bool ConcluiuProcessamento(); bool TemNovoCromossomo(); unsigned char* GetNewCromossomo(); };
46
Classe de Interpretação do Cromossomo
Essa classe é responsável por interpretar partes de um cromossomo. Os métodos
estão comentados do projeto. Os principais métodos dessa classe são:
• get_fitness(...): retorna o fitness para o cromossomo passado como
parâmetro.
• Get_equação(...): retorna como string a equação que o cromossomo,
passado como parâmetro, representa.
class cInterpCromossomo{ private: AnsiString m_equacao; void inicializa_matrixEL ( EL* mEL, unsigned char* cromossomo); int get_cod_operador(int gene); int get_cod_operando1(int gene); int get_cod_operando2(int gene); AnsiString get_operador(int operacao); char get_operando(int cod_operando); void get_equacao(EL* raiz); void converte_cromossomo(unsigned char* cromossomo, unsigned char*
novo_cromossomo); int get_bit(unsigned char* cromossomo, int pos); public: cInterpCromossomo(); ~cInterpCromossomo(); static int get_fitness(unsigned char cromossomo[24]); String get_equacao(unsigned char cromossomo[24]); };
5.2 Firmware
O firmware em sua função principal implementa exatamente o fluxograma da Figura
11 - Funcionamento do Firmware.
Sobre ele é realmente importante esclarecer o seguinte. Qualquer que seja a
interação com dispositivo de hardware, seja ele escrito em lógica de descrição de
hardware ou não, é realizada através de um endereço de memória. Endereço para o
qual o dado dispositivo está mapeado no processador Nios II. Exemplo:
IORD_16DIRECT(DEV_CORE, CTRLC_CROMOSSOMO);
O exemplo anterior realiza uma leitura de 16 bits no registro
CTRLC_CROMOSSOMO de endereço DEV_CORE. O registro que está sendo lido,
pertence ao dispositivo controlador do CORE.
47
O controlador do CORE, um display de 7 segmentos e um banco de leds são os
dispositivos atualmente controlados e estão definidos nos endereços:
#define DEV_CORE 0x00000C00 #define DEV_PIO_7SEG 0x00000860 #define DEV_PIO_LED 0x00810880
O firmware realiza operações de acordo com o protocolo estabelecido. Um código
de operação é recebido ou enviado pela serial. A seguir os códigos que foram
utilizados para que fosse possível a comunicação e iteração entre o firmware e o
software.
Protocolo Firmware / Software
#define CMD_INIT 0xA1 // comando para iniciar configuração #define CMD_REPLY_OK 0xF1 // confirmação de resposta #define CMD_CANCEL_PROCESS 0xF2 // cancelar processamento #define CMD_IS_PROCESSING 0xF3 // está processando? #define CMD_TEM_CROMOSSOMO 0xF4 // tem cromossomo? #define CMD_GET_CROMOSSOMO 0xF5 // retorna cromossomo da geração atual #define CMD_SET_TV 0xF6 // configura a tabela verdade
48
6. FERRAMENTAS UTILIZADAS
6.1 Ambiente de desenvolvimento Quartus II
Quartus II é uma ferramenta completa de desenvolvimento voltada para
computação reconfigurável. Através dele é possível criar, compilar e simular arquivos
de descrição de hardware. Possui um conjunto de ferramentas para auxiliar na
construção de projetos como SOPC, Simulator e o RTL Viewer.
SOPC Builder
O SOPC Builder é uma ferramenta exclusiva do software Quartus® II, com ela pode-
se construir uma arquitetura embarcada de uma maneira fácil e rápida.
Ele fornece os componentes customizáveis como o processador Nios® II,
memórias, barramentos, interfaces de comunicações e outros. Você pode também criar
seus próprios componentes através de um arquivo de definição de hardware e
adicionar tudo isso a sua arquitetura e gerar um sistema correspondente.
Posteriormente o seu sistema pode ser configurado em sua FPGA utilizando o
Quartus® II. Essa ferramenta foi utilizada para construção da arquitetura do meu
projeto. Como exemplo, consulte o anexo B – Arquitetura.
A possibilidade de integração é possível graças ao barramento Avalon que controla
tudo o que se passa pelo barramento. Existe todo um protocolo de definição e tráfego
de sinais escrito pela Altera. A Figura 19 representa um sistema gerado pelo SOPC.
Figura 19 - Sistema Típico SOPC
49
RTL View
O RTL View é mais uma ferramenta exclusiva que acompanha o software Quartus II.
Essa ferramenta fornece a visualização esquemática de todos os componentes de seu
projeto. Mostrando a forma como cada um deles foi sintetizado em hardware. Na Figura 20
um exemplo de esquemático representado nesta ferramenta.
Figura 20 - RTL View
50
6.2 NIOS II IDE
O ambiente de desenvolvimento Nios II é uma ferramenta de integrada para a
família de processadores embarcados. Com ela é possível criar, editar e depurar
programas. Os softwares desenvolvidos podem ser executados ou depurados na
arquitetura que foi projetada através do Quartus II ou até mesmo por meio de
simulação no próprio computador. O programa é transferido serialmente para a FPGA
através de um cabo chamado JTAG.
O Nios II IDE é baseado principalmente no Eclipse C/C++ Development
Tools (CDT) Project. Portanto, é possível escrever softwares para programas
embarcados (firmware) utilizando as linguagens de programação C e C++. Na Figura
21 tem-se uma imagem desse ambiente de desenvolvimento.
Figura 21 - Nios II IDE
Através do Nios II IDE será escrito o firmware que integrará a arquitetura com o
Software. Ele controlará dispositivos, receberá os parâmetros iniciais e enviará
serialmente as soluções que serão encontradas a cada geração.
51
7. TESTES E RESULTADOS
Como o projeto pode ser dividido nos três principais blocos (software, firmware e
hardware) cada um deles foi testado individualmente conforme foram desenvolvidos.
Na primeira etapa, o hardware do sistema foi validado através de simulações feitas
no ambiente de desenvolvimento Quartus II. Entretanto, os resultados nesse modo de
simulação mostraram apenas que o AG produzia os cromossomos como esperado,
mas, a complexidade do problema e o tempo necessário de simulação impossibilitaram
as traduções manuais dos diversos cromossomos que eram fornecidos.
Na segunda etapa, o firmware foi submetido a testes. Recebendo dados via serial,
escrevendo nos devidos registros e endereços de hardware. Devolvendo os sinais pela
serial. Controlando dispositivos como leds, display de sete segmentos e principalmente
o CORE. O firmware funcionou corretamente, ativando os controles como esperado.
Na terceira etapa, o software foi validado. Na maioria dos testes participaram
firmware e software. Para assegurar do funcionamento do software neste ponto, foi
construído um software embarcado que emulava o funcionamento do CORE, isolando
dessa forma o hardware CORE dos testes. O software recebeu os cromossomos e os
interpretou.
Na quarta etapa, faltava validar o sistema completo. Parte desse teste já havia sido
realizada em outras ocasiões. No entanto, o CORE não executava todas as suas
operações. Por exemplo: todo o sistema foi simulado com apenas algumas unidades
do CORE, responsáveis por gerar os cromossomos, realizar seleção, cruzamento e
retornar um melhor pré-estabelecido. Isso foi feito quando se tentava validar
comunicação e não o funcionamento e por isso justificava-se desligar varias outras
unidades funcionais do CORE simplificando seu funcionamento e validando a
comunicação de todo o sistema. De qualquer forma apresentava bons sinais de seu
funcionamento. Porém, quando de fato todo o sistema foi unido e submetido aos testes,
o hardware não funcionara. Após investigar a fonte do problema, foi descoberto que o
núcleo do CORE apresentava-se fora da conformidade, não realizando suas funções
na seqüência de operações programadas, perdido. Devido a suspeita de uma
freqüência de operação muito alta, seu clock principal foi reduzido de 50 Mhz para 20
MHz, mas, ainda assim, não funcionou corretamente. O problema apresentado ocorre
na transição de estados, por diversos momentos o hardware muda para estados
52
incorretos e dessa forma não chegava até o estado que permite o envio de um novo
cromossomo para o software.
O problema ainda não fora corrigido, mas restam diversos testes que ainda
precisam ser executados. Desvios na máquina de estados do CORE, por exemplo,
podem servir para validar as transições. Redução de lógica total do dispositivo já que
esse está ocupando muitos elementos lógicos. Alterar a freqüência de operação e
verificar onde são os caminhos críticos dos sinais.
53
8. CONCLUSÃO
Já na primeira etapa de testes, (com o hardware) percebeu-se a necessidade de
uma interface de comunicação para avaliar o funcionamento do projeto, devido o tempo
necessário em simulações e a própria complexidade de interpretar os cromossomos
era inviável tal prática.
O software embarcado funcionou aparentemente muito bem. Com grande
desempenho, não apresentou nem problemas de comunicação com a interface serial.
Ativa cada unidade de hardware como demandado.
O software principal que faz a interface do projeto com o usuário ainda pode ser
melhorado, mas, seu funcionamento está de acordo com o necessário. Envia os
parâmetros, recebe os cromossomos sempre que possíveis, interpreta e exibe ao
usuário junto com os gráficos.
Todos os testes sugeridos para correção do problema requerem tempo. Vale
lembrar que cada compilação demora aproximadamente doze minutos somente para o
CORE. Alguns dos testes requerem principalmente o kit de desenvolvimento.
Com esse projeto percebe-se o potencial que a computação reconfigurável oferece
no desenvolvimento de sistemas embarcados desde os mais simples aos mais
complexos.
54
9. REFERÊNCIAS
ALTERA CORPORATION, Stratix Device Handbook disponível na WWW por http://www.altera.com/literature/hb/stx/stratix_handbook.pdf (pesquisa realizada em 01 de abril de 2006). ALTERA CORPORATION, Introduction to Quartus II. Disponível na WWW por www.altera.com/literature/manual/intro_to_quartus2.pdf (pesquisa realizada em 02 de abril de 2006). ALTERA CORPORATION, Quartus II Development Software Handbook v5.1 (Complete Five-Volume Set) disponível na WWW por http://www.altera.com/literature/hb/qts/quartusii_handbook.pdf (pesquisa realizada em 01 de abril de 2006). ZEIDMAN, Introduction to CPLD and FPGA Design disponível na WWW por www.pldworld.com/html/ technote/intro.cpld.fpga.design.pdf (pesquisa realizada em 01 de abril de 2006). BANZHAF, W., et al. Genetic programming: an introduction. Morgan Kaufmann, 1998. DONGARRA, J., et al. Sourcebook of parallel computing. San Francisco-USA: Morgan Kaufmann Publishers, 2003. A. DEHON. Reconfigurable Architecture for General-Purpose Computing, Massachusetts Institute of Technology, 1996. FERLIN, E.P. Avaliação de Métodos de Paralelização Automática. Dissertação (Mestrado em Física Computacional), Instituto de Física de São Carlos, USP, São Carlos-SP, 1997. FERLIN, E.P. O Processo de paralelização automática de programas seqüenciais em programas paralelos. In: IV Simpósio de Pesquisa e Extensão em Tecnologia. Anais ... Natal, 1998, p. 188-190. FERLIN, E.P. O Avanço tecnológico dos processadores e sua utilização pelo software. Revista “da Vinci” , V.1, n. 1. Curitiba: UnicenP, 2004, p. 43-60. HENNESSY, J.L., PATTERSON, D.A. Arquitetura de computadores: uma abordagem quantitativa . 3. ed. Rio de Janeiro: Campus, 2003. ITO, S.A., CARRO, L. A comparison of microcontrollers targeted to FPGA-based embedded applications. In: IEEE 13th Symposium on Integrated Circuits and Systems Design. Proceedings … 2000, p. 397–402. LOPES, H. S. Algoritmos Genéticos em Projetos de Engenharia: Aplicações e Perspectivas Futuras. In: IV Simpósio Brasileiro de Automação Inteligente. Anais ... 1999, p. 64–74. MITCHELL, M. An introduction to genetic algorithms. Cambridge: MIT Press. 207p, 1997. SILVA, P.A. Tutorial Genetic Algorithms. Learning and Nonlinear Models. Revista da Sociedade Brasileira de Redes Neurais. nº 1, vol 1., 2002, p. 45–60.
55
TOCCI, R. J., WIDMER, N.S. Sistemas digitais: princípios e Aplicação. 8. ed. São Paulo: Pearson, 2003. VEMURI, R., RANDOLPH, E. Configurable computing: technology and applications. IEEE Computer Magazine, v. 33, n. 4, 2000, p. 39–40.
56
ANEXOS
Anexo A – Cronograma Anexo B – Arquitetura Anexo C – Telas do Sistema Anexo D – Artigo Anexo E – Manual do Usuário Anexo F – Manual Técnico
![Replicação Máquina de Estados Paralela e Reconfigurável · 2017. 5. 16. · na implementação de sistemas distribuídos tolerantes a falhas [18, 26, 8]. Basicamente, esta técnica](https://img.pdfslide.tips/doc/110x75/5fddb361c7d7003a6076ab1c/replicao-mquina-de-estados-paralela-e-reconfigurvel-2017-5-16-na-implementao.jpg)
