FACULDADE DE TECNOLOGIA DE INDAIATUBA
GUILHERME CAVASSAN
Paralelização do Algoritmo de Agrupamento de Formiga
Indaiatuba
Novembro/2012
CENTRO ESTADUAL DE ENSINO TECNOLÓGICO PAULA SOUZA
FACULDADE DE TECNOLOGIA DE INDAIATUBA
GUILHERME CAVASSAN
Paralelização do Algoritmo de Agrupamento de Formiga
Trabalho de Graduação apresentado por Guilherme Cavassan como pré-requisito para a conclusão do Curso Superior de Tecnologia em Informática com ênfase em banco de dados, da Faculdade de Tecnologia de Indaiatuba, elaborado sob a orientação da Profa. Mestre Maria das Graças J. M. Tomazela.
Indaiatuba
Novembro/2012
FACULDADE DE TECNOLOGIA DE INDAIATUBA
GUILHERME CAVASSAN
Banca avaliadora
Profª. Me. Maria das Graças J. M. Tomazela
Orientadora
Profª. Me. Rosana Veroneze
Avaliadora externa –
Unicamp
Prof. Me. Sérgio Furgeri
Avaliador interno – Fatec
Indaiatuba
AGRADECIMENTOS
Agradeço primeiramente a Deus, por permitir que eu alcançasse essa vitória.
Agradeço aos meus pais, que me incentivaram nas minhas decisões e me apoiaram para que eu conseguisse meus objetivos durante essa caminhada.
Agradeço à professora Maria das Graças J. M. Tomazela pelas orientações, disponibilidade e paciência durante a elaboração desse trabalho.
Agradeço à Rosana Veroneze pelos direcionamentos de grande valia no início dessa pesquisa.
Agradeço aos meus amigos, pela amizade, ajuda e companheirismo durante essa etapa de minha vida.
A mineração de dados é uma importante ferramenta para descoberta e análise de padrões em um conjunto de dados. Uma das tarefas da mineração é o agrupamento de dados, que consiste em separar os elementos, de tal forma que os elementos similares fiquem em um grupo e os elementos dissimilares fiquem em grupos distintos. O objetivo desse trabalho é apresentar uma proposta de otimização de desempenho para o algoritmo de agrupamento de formiga conhecido como ACA, utilizando técnicas que aproveitam o processador gráfico para realizar tarefas de propósito gerais. A metodologia utilizada foi a realização de um estudo sobre o algoritmo e técnicas usadas em inteligência de enxames e sobre a linguagem CUDA desenvolvida pela empresa NVIDIA usada na aplicação desenvolvida neste trabalho. Foram criadas duas aplicações semelhantes, mas utilizando técnicas de processamento diferentes, uma executada pelo processador e outra pela placa de vídeo, para comparação do tempo de processamento dos algoritmos. Os resultados do trabalho apontaram que as técnicas de processamento usando a placa de vídeo obtiveram menor tempo de processamento quando utilizando grande volume de dados, sendo que em situações nas quais houve maior quantidade de instruções executadas ao mesmo tempo foram também as que apresentaram maior diferença de tempo entre o modelo de aplicação tradicional e o paralelo. O algoritmo implementado neste trabalho se destacou pela escalabilidade considerando o tempo de processamento final obtido.
Palavras-chave: Inteligência de enxames, Algoritmo de Agrupamento de Formiga, ACA,
LISTA DE FIGURAS
Figura 1: Representação das rotas disponíveis do ninho até a fonte de alimento ... 14
Figura 2: Representação das duas possíveis rotas do ninho até a fonte de alimentos, sendo uma consideravelmente maior ... 14
Figura 3: Em um primeiro momento os dois caminhos são explorados, mas com o tempo, a trilha com menor comprimento, tende a acumular mais feromônio, sendo mais interessante para o enxame ... 15
Figura 4: Ilustração do desenvolvimento do agrupamento de corpos de formigas em um ninho, no decorrer do processo aplica-se uma quantidade de feromônio proporcional ao tamanho do grupo, onde os corpos se encontram ... 16
Figura 5: Criando um projeto CUDA após a instalação do programa Nsight Visual Studio pelo Microsoft Visual Studio 2010 ... 25
Figura 6: Esquema dos principais componentes e barramentos envolvidos na execução de um programa no computador ... 26
Figura 7: Matriz com oito posições, os números representam seu índice ... 28
Figura 8: Simulando a matriz a partir do vetor, com a mesma quantidade de posições ... 28
Figura 9: Matriz com oito posições, os números representam seu índice ... 29
Figura 10: Simulando a matriz a partir do vetor, com a mesma quantidade de posições ... 29
Figura 11: Representação visual da implementação da arena, com base na Figura 12 ... 30
Figura 12: Representação visual da arena, com os agentes e dados ... 30
Figura 13: Opções de locomoção de um agente a partir do número aleatório escolhido ... 32
Figura 14: Movimentação de um agente quando ele se encontra nas bordas laterais da arena ... 32
Figura 15: Movimentação de um agente quando ele se encontra na borda superior da arena, onde ocorre a situação de índex menor que zero se não tratado ... 33
Figura 16: Movimentação de um agente quando ele se encontra na borda inferior da arena, onde ocorre a situação de índex maior que a quantidade de posições disponíveis se não tratado ... 33
Figura 17: Tela de configurações para exibição do gráfico ... 34
Figura 18: Tela para exibição do gráfico usando a ferramenta desenvolvida. Pontos com a distância dentro da tolerância informada são colocados no mesmo grupo... 35
Figura 19: Distribuição dos dados antes da execução do algoritmo de agrupamento... 38
Figura 20: Distribuição dos dados após o processo de agrupamento realizado pelo algoritmo ACA simples ... 38
Figura 21: Campo de visão do agente, sendo a área verde, sempre analisada pela Equação
e a área vermelha, analisada somente quando o agente está diante de um grupo de dados ... 41
Figura 22: Distribuição dos dados após o processo de agrupamento realizado pelo algoritmo
ACA melhorado, usando a placa de vídeo ... 42
Figura 23: Distribuição dos dados após o processo de agrupamento realizado pelo algoritmo
ACA melhorado, usando o processador ... 42
Figura 24: Tempo de execução do algoritmo ACA melhorado usando a placa de vídeo e o
LISTA DE EQUAÇÕES
Equação 1: Probabilidade de um agente que não está carregando um item pegá-lo ... 17
Equação 2: Probabilidade de um agente carregado soltar o item ... 18
Equação 3: Define a distância dos itens da vizinhança, utilizada para calcular a probabilidade de um agente pegar ou deixar um item. ... 19
Equação 4: Cálculo da distância euclidiana. ... 19
Equação 5: Probabilidade de um agente que não está carregando um item pegá-lo. ... 19
Equação 6: Probabilidade de um agente carregado soltar um item. ... 19
Equação 7: Representação da queda do valor de . ... 20
Equação 8: Representação do aumento do campo de visão do agente. ... 20
Equação 9: Probabilidade de um agente que não está carregando um item pegá-lo, considerando o fator de feromônio na grade onde o item se encontra. ... 21
Equação 10: Probabilidade de um agente carregado soltar o item, considerando o fator de feromônio na grade onde a formiga está. ... 21
INTRODUÇÃO ... 9
CAPÍTULO I ... 11
Inteligência de enxames... 11
1.1 Estudo sobre o comportamento coletivo das formigas ... 12
1.1.1 Procura e coleta de alimentos. ... 13
1.1.2 Agrupamento de corpos e larvas ... 15
1.2 Algoritmos que usam o conceito de inteligência de enxames ... 16
1.2.1 Algoritmo de agrupamento de formiga ... 17
CAPÍTULO II ... 23
A plataforma usada e desenvolvimento do projeto ... 23
2.1 Conceitos sobre unidade de processamento gráfico de propósito geral ... 25
2.2 Desenvolvimento da aplicação ... 28
2.2.1 Tarefas de um agente ... 31
2.3 Desenvolvimento da ferramenta de visualização dos dados ... 34
CAPÍTULO III ... 36
Testes e resultados do algoritmo ... 36
3.1 Algoritmo de agrupamento de formiga simples... 37
3.2 Algoritmo de agrupamento de formiga melhorado ... 40
CONSIDERAÇÕES FINAIS ... 46
INTRODUÇÃO
O crescimento da rede mundial de computadores facilitou a disseminação das informações e atualização dos profissionais. Na última década, apenas no Brasil o número de usuários ativos da internet passou de 5,1 milhões no ano de 2000 para 42,1 milhões em 2012 segundo a pesquisa IBOPE (Instituto Brasileiro de Opinião Pública e Estatística, 2012). Neste período a estrutura desta rede se tornou mais robusta para suportar a crescente quantidade de acessos. Os sistemas de gerenciamento de banco de dados também ocupam um papel importante no crescimento da internet, seus mecanismos de segurança e consistência das informações estão em constante melhoria, alem disso o volume de informações consultadas e alteradas é cada vez maior.
Não é difícil perceber o aumento da capacidade de processamento dos computadores, especialmente é possível destacar as placas dedicadas ao processamento gráfico, que possuem um enorme poder computacional, maior inclusive que qualquer processador comercial, essa capacidade pode ser um aliado na busca de respostas.
Baseando-se no sucesso do comportamento coletivo de algumas espécies de animais, esse trabalho monográfico propõe aperfeiçoar o algoritmo de agrupamento de formiga usando técnicas de processamento paralelo, para se possível melhorar a experiência de outros pesquisadores da área de mineração de dados.
O trabalho se justifica pelo crescimento no campo de atuação dos algoritmos bioinspirados baseados em populações e metaheurísticas. Estes algoritmos vêm sendo usados para resolver problemas de busca e otimização em vários domínios de problemas para os quais soluções robustas são difíceis ou impossíveis de encontrar usando abordagens tradicionais como a programação matemática (SERAPIÃO, 2009).
As perguntas que norteiam essa pesquisa monográfica são:
1. O Algoritmo de agrupamento de formiga apresenta um ganho de desempenho considerável com as modificações propostas utilizando o equipamento disponível? 2. As modificações realizadas afetam a qualidade do grupo criado, comparando com a
versão tradicional do algoritmo?
O objetivo principal deste trabalho é apresentar uma proposta de otimização de desempenho para o algoritmo de agrupamento de formiga, aplicando o mesmo em uma placa de processamento gráfico e analisando os tempos obtidos dessa versão com a que usa apenas o processador do computador. Outro objetivo do trabalho é verificar se a qualidade dos grupos criados se mantém com a utilização do algoritmo desenvolvido.
A primeira etapa desse trabalho foi definir qual algoritmo seria aplicado na otimização e se o processo era possível, analisando o ambiente de desenvolvimento integrado fornecido e a complexidade da linguagem.
Na próxima etapa foi realizada a busca por referências bibliográficas. Foram utilizados principalmente os conceitos de Castro (2006) por descrever completamente o algoritmo padrão utilizado como base para esse trabalho e todo o processo biológico em que o algoritmo foi inspirado.
Na terceira etapa foi realizada a elaboração do algoritmo para os testes, este foi escrito de duas maneiras diferentes, uma em C e a outra em C/CUDA a fim de obter a diferença de tempo entre eles. Também foi preparado um programa com o objetivo de visualizar os dados em um primeiro momento espalhados na arena e após o processo de agrupamento, este escrito na linguagem Java.
A última etapa consistiu em aplicar os testes e analisar os resultados obtidos com o modelo proposto, se o mesmo apresentou qualidade no agrupamento e se houve melhora de desempenho.
O trabalho está dividido em três capítulos.
Capítulo I – Inteligência de Enxames
Esse capítulo apresenta os fundamentos dos algoritmos de inteligência de enxames e apresenta o algoritmo usado como base para o trabalho.
Capítulo 2 – A plataforma usada e desenvolvimento do projeto
O capítulo tem como objetivo apresentar a linguagem usada para o desenvolvimento de uma parte da aplicação, no qual esse trabalho tem foco, e apresentar o modelo de código desenvolvido.
Capítulo 3 – Testes e resultados do algoritmo
O capítulo mostra os resultados obtidos por esse trabalho com um conjunto de dados para teste.
CAPÍTULO I
Inteligência de enxames
Algumas espécies de insetos, como os cupins, as formigas e as abelhas, são conhecidas na biologia como insetos sociais por viverem em colônias. Esse tipo de comportamento facilita uma série de tarefas, entre elas podemos citar: coleta de alimentos, reprodução e defesa de possíveis predadores.
Analisando essas vantagens e adaptando-as ao ambiente virtual, com o propósito de aperfeiçoar uma série de tarefas, surgiu uma nova área de estudos ligada à inteligência computacional, conhecida como Swarm Intelligence ou Inteligência de Enxames.
O termo Inteligência de Enxames foi proposto no final da década de 1980 (CASTRO, 2006). No início, esse termo estava fortemente ligado a sistemas robóticos e, mais recentemente, com algoritmos de otimização e agrupamento, mostrando ser eficiente e altamente adaptável a tarefas como:
Coleta de objetos em uma arena, utilizados em sistemas robóticos;
Otimização de rotas, para solução de problemas como o caixeiro viajante1
; Mineração de dados, mais especificamente em algoritmos de agrupamento2
.
A definição de Inteligência de Enxames é formada a partir dos termos enxame – conjunto de abelhas de uma colmeia3, o qual pode ser adaptado e comparado à sistema similar, como
1
O caixeiro viajante, é um problema de otimização bastante conhecido estudado por várias áreas, apesar de parecer simples, sua solução apresenta crescimento exponencial de processamento computacional.
2
Berry e Linoff (2004) definem que agrupamento é a tarefa de segmentar uma população heterogênea em um número de subgrupos mais homogêneos ou clusters. O agrupamento trabalha com funções de similaridade, baseando-se na distância entre os dados.
3
Dicionário Houaiss da Língua Portuguesa, versão online, disponível em <http://houaiss.uol.com.br/busca.jhtm?verbete=colmeia&stype=k> acesso em 05/09/2011
um enxame de formigas onde os agentes são formigas. – e Inteligência Coletiva – nome usado para identificar sistemas composto de agentes com pouca ou nenhuma inteligência, mas que em conjunto conseguem realizar tarefas de forma coletiva e apresentando inteligência (WHITE; PAGUREK, 1998).
A Inteligência de Enxames inclui qualquer tentativa de projetar algoritmos ou dispositivos distribuídos de solução de problemas inspirados no comportamento coletivo de insetos sociais e outras sociedades de animais (BONABEAU et al., 1999).
Millonas (1994) descreveu cinco comportamentos que um sistema de inteligência de enxames apresenta:
Proximidade: Os agentes necessitam interagir entre si, para manter a organização e o foco nos interesses coletivos;
Qualidade: O agente deve ser capaz de entender os fatores de ambiente e a tarefa em que se encontra (avaliar seu comportamento);
Diversidade: Permite ao enxame a capacidade de flexibilidade, para trabalhar com situações inesperadas e também desconhecidas;
Estabilidade: O sistema não deve permitir que todas as variações ambientais afetem o comportamento do agente;
Adaptabilidade: capacidade do enxame de se adequar a variações ambientais.
1.1 Estudo sobre o comportamento coletivo das formigas
Algumas espécies de formigas possuem características comuns. A comunicação entre os agentes é realizada através de uma substância estimulante, conhecida como feromônio, liberada pelos mesmos. Através do feromônio, os agentes da colônia conseguem reconhecer a rota para coletar alimentos, alertar um aos outros sobre predadores e realizar a limpeza do ninho.
As formigas possuem inteligência individual limitada, eles conseguem apenas analisar as necessidades locais e atuais da colônia, seguindo o princípio que um agente tende a agir onde há maior intensidade de feromônio e garantindo o princípio de qualidade sugerido por Millonas (1994).
Em um enxame, não existe um grupo de agentes capaz de gerenciar projetos e medir a necessidade da colônia para alocar recursos a uma determinada tarefa, além disso, cada agente
13
realiza uma tarefa sem que nenhuma outra supervisione suas atividades, elas são altamente adaptáveis às necessidades da colônia.
1.1.1 Procura e coleta de alimentos.
Apesar de existir muitas espécies de formigas, a maneira que elas usam para explorar território em busca de comida é semelhante.
Os tipos de recrutamento usado por elas, para coleta de alimentos são:
Recrutamento em massa: uma fonte de alimentos é descoberta por um agente, que retorna ao ninho liberando uma trilha de feromônio, assim outras formigas passam a conhecer o caminho e depositar mais feromônio;
Recrutamento em grupo: um agente recruta outros agentes formando um grupo e os guia até a fonte de alimento descoberta. Após o grupo recrutado voltar ao formigueiro, é criado novos grupos a fim de explorar a fonte de alimento. Esse processo utiliza uma trilha de feromônio de curto alcance;
Recrutamento em linha: um agente convida outro para segui-lo, a principal característica desse tipo de recrutamento é que apenas um companheiro de ninho é recrutado por vez e não é utilizado trilha de feromônio nesse processo.
Um estudo realizado por Deneubourg et al. (1990), revelou algumas características, que hoje são utilizadas no algoritmo de otimização de rota, conhecido como Ant Colony Otimization ou Otimização por colônia de formigas, e suas variações. Para realização do estudo foi usada uma colônia de formigas da espécie Linepithema humile, que usa recrutamento em massa para coleta de alimentos.
Em um primeiro momento, foi colocado o ninho e a fonte de alimento, separado por um espaço e criando dois caminhos diferentes, mas do mesmo tamanho, como ilustra a Figura 1. Depois de observar o comportamento das formigas nesse teste diversas vezes, o pesquisador constatou que inicialmente ambos os caminhos eram usados pelas formigas, mas que no decorrer da exploração da fonte de alimento um dos caminhos recebeu mais formigas que o outro.
Com este teste também foi possível observar que as formigas tendiam a escolher uma das duas rotas disponíveis de maneira aleatória, com probabilidade de 50% para cada caminho.
Figura 1: Representação das rotas disponíveis do ninho até a fonte de alimento
Fonte: Gonçalves (2011, p. 4) 4
Após a primeira análise, foi realizada uma mudança no trajeto do formigueiro até a fonte de alimento, deixando um dos caminhos ligeiramente maior, como ilustra a Figura 2. O pesquisador, depois de diversas tentativas usando esse modelo, constatou então, que assim como no primeiro caso (usando as trilhas com tamanhos idênticos) as formigas inicialmente exploravam a fonte de alimento usando as duas rotas, mas depois de algum tempo, o caminho menor era escolhido na maioria das vezes, esse evento pode ser observado na Figura 3. Isso acontece porque existe dispersão (evaporação) do feromônio e a trilha maior é menos reforçada pelas formigas, consequentemente, o menor caminho possuí maior quantidade de feromônio e as formigas, por questões biológicas, tendem a seguir a trilha com maior depósito de feromônio.
Figura 2: Representação das duas possíveis rotas do ninho até a fonte de alimentos, sendo uma
consideravelmente maior Fonte: Gonçalves (2011, p. 4) 4
4
GONÇALVES, André Ricardo. Inteligência de Enxames disponível em: <http://www.dca.fee.unicamp.br/~andreric/arquivos/pdfs/enxames.pdf> acesso em: 08/09/2011
15
A trilha formada pelas formigas seguindo o feromônio não é perfeita, isto é, existem agentes que se dispersam. Esse fator não é considerado ruim para o enxame, pois é assim que outras possíveis fontes de alimento ou caminhos, talvez melhores (menores) são encontrados.
Figura 3: Em um primeiro momento os dois caminhos são explorados, mas com o tempo, a trilha com
menor comprimento, tende a acumular mais feromônio, sendo mais interessante para o enxame Fonte: Castro, 2006, p 212
Com esse experimento, alguns pontos que devem ser considerados na construção de um algoritmo de otimização, baseado em colônias de formigas, puderam ser identificados:
A probabilidade de um caminho menor ser escolhido aumenta com a diferença de comprimento entre os caminhos, pois menos feromônio a trilha maior irá receber; Se o caminho mais curto for apresentado muito depois do caminho mais longo, ele não
será selecionado, a não ser que o feromônio evapore muito rapidamente. Se a trilha maior já estiver com uma grande quantidade de feromônio, dificilmente o agente que apresentar o melhor caminho conseguirá atrair as demais formigas para aquela rota.
1.1.2 Agrupamento de corpos e larvas
Algumas espécies de formigas utilizam uma técnica similar à coleta de alimentos para manter o formigueiro organizado, são montados grupos de larvas e corpos dentro do ninho, utilizando técnicas com feromônio, dessa maneira os grupos de corpos mortos recebem depósito de feromônio, que são controlados pelas formigas, quanto maior o grupo, maior é a intensidade do feromônio na área onde o mesmo se encontra.
Considerando que as formigas se movimentam livremente por uma arena onde atuam e podem realizar dois possíveis eventos – pegar um item e soltar um item – a função delas é: se um corpo é encontrado em uma região com bastante feromônio, ele não se torna interessante, isto é, um agente não o pega; se o agente está carregando um corpo e encontra uma região com feromônio, essa região se torna interessante para que o corpo seja deixado. Esse fato ocorre porque as formigas não se interessam em tirar corpos de locais que possuem níveis altos de feromônio, com isso formam-se agrupamentos de corpos cada vez maiores, a Figura 4 ilustra essa reação.
Figura 4: Ilustração do desenvolvimento do agrupamento de corpos de formigas em um ninho, no
decorrer do processo aplica-se uma quantidade de feromônio proporcional ao tamanho do grupo, onde os corpos se encontram
Fonte: Castro, 2006, p 224
O número de grupos formados durante o processo de agrupamento é aleatório, não é possível prever ou pré-definir quantos grupos serão formados quando o processo estiver concluído.
1.2 Algoritmos que usam o conceito de inteligência de enxames
O objetivo dos algoritmos que usam o conceito de inteligência de enxames é solucionar problemas complexos utilizando idéias simples, que podem ser simuladas em um ambiente virtual.
17
Os tipos de algoritmos mais conhecidos encontrados atualmente são Castro (2006):
Ant Colony Optimization ou Otimização por Colônias de Formigas – simula um ambiente que utiliza o recrutamento em massa (técnica usada por algumas espécies de formigas) para solucionar problemas relacionados a caminhos, por exemplo, o problema do caixeiro viajante;
Particle Swarm Optimization ou Otimização baseada em partículas – o sistema é iniciado com soluções aleatórias conhecidas como partículas e tenta achar a melhor solução usando o conceito de atualização de gerações;
Ant Clustering Algorithm (ACA) ou Algoritmo de agrupamento de formiga – compreende em formar uma arena com dados e criar grupos utilizando o conceito de agrupamento de corpos e larvas, essa técnica é inspirada no comportamento das formigas.
1.2.1 Algoritmo de agrupamento de formiga
Partindo de como funciona a organização dos formigueiros, especificamente de como as formigas trabalham com corpos e larvas, surgiu um modelo de algoritmo denominado Ant Clustering Algorithm ou Algoritmo de agrupamento de formiga.
Seu objetivo é que um agente (formiga) se movimente randomicamente em uma arena bidirecional, podendo pegar um item ou soltá-lo, de acordo com a proximidade do item que o agente carrega com os demais itens da área onde o mesmo se encontra. Outro fator relevante para o processo é a quantidade de itens ao seu redor. A área de percepção da formiga com o ambiente é limitada em sxs células, sendo que o agente se encontra no centro dessas células.
Para pegar um item pode-se assumir a Equação 1, onde é uma constante e é a equação que determina a proximidade dos itens na região onde o agente está. Quanto menor o valor de , maior a possibilidade de um agente pegar o item.
{
}
Equação 1: Probabilidade de um agente que não está carregando um item pegá-lo
Para soltar um item assume-se a Equação 2, onde é uma constante e é a quantidade de itens observados no ambiente. Quanto menor o valor de , maior a possibilidade de um agente soltar o item.
{
}
Equação 2: Probabilidade de um agente carregado soltar o item
Fonte: Jafar; Sivakumar, 2010, p790
Lumer e Faieta (1994) aplicaram o algoritmo de agrupamento de formiga padrão em uma análise de dados exploratória. O algoritmo foi desenvolvido usando uma matriz bidirecional, simulando uma arena, onde os dados e os agentes são inseridos, ambos de forma randômica. Depois de criado esse cenário, é realizado iterações, até a quantidade máxima estabelecida pelo usuário. Para cada iteração é realizado um trabalho com os agentes, seja pegar um item ou soltá-lo e mover o agente de forma randômica novamente para uma das células vizinhas. O Pseudocódigo 1 representa o algoritmo de agrupamento de formiga padrão.
procedure [] = ACA(max_it,N,k1,k2)
projete cada item (i) em uma célula randômica na matriz projete cada formiga (k) em uma célula randômica na matriz não ocupada pelas formigas
t 1
enquanto t < max_it faça,
para i = 1 até N faça, //para cada formiga calcule ( ) // Eq. 3
se formiga livre E célula ocupada por um item , então calcule ( ) //probabilidade para carregar um item senão se formiga carregada E célula vazia, então
calcule ( ) //probabilidade para deixar um item fim se
mova a formiga para uma célula vizinha selecionada aleatoriamente que esteja desocupada
fim para t t + 1 fim enquanto
escreva a localização dos itens
Pseudocódigo 1: Algoritmo de agrupamento de formiga padrão. Fonte: Castro (2006, p 229)
19
A Equação 3 é responsável por calcular a proximidade do item que a formiga carrega com os itens percebidos no ambiente, onde s é a quantidade de células vizinhas ao redor da célula atual r, α é um parâmetro que define a dependência entre os dados e ( ) é a distância euclidiana do item que a formiga está carregando para o item na arena.
( ) { ∑ * ( ) + ( )( )
Equação 3: Define a distância dos itens da vizinhança, utilizada para calcular a probabilidade de um
agente pegar ou deixar um item. Fonte Castro, 2006, p 230
O cálculo da distância não deve utilizar a distância dos dados projetados na arena, e sim a distância real dos mesmos, ele deve ser realizado antes de começar o processo de agrupamento. A Equação 4 apresenta a distância euclidiana deve ser calculada.
√∑( )
Equação 4: Cálculo da distância euclidiana.
A Equação 5 decide se o agente pega o item ou não, quanto mais alto o valor de , maior a possibilidade do agente pegar o item, assim como na Equação 1, é uma constante.
( ) {
( )}
Equação 5: Probabilidade de um agente que não está carregando um item pegá-lo.
Fonte Castro, 2006, p 230
A Equação 6 decide se o agente deixa o item ou não, quanto mais alto o valor de , maior a possibilidade do agente deixar o item na região que se encontra, assim como na Equação 2, é uma constante.
( ) { ( ( ) ( ) )
Equação 6: Probabilidade de um agente carregado soltar um item.
O Algoritmo de agrupamento de formiga simples apresenta dois problemas conhecidos: Não é possível estabilizar um grupo, isto é enquanto o algoritmo é executado ele
forma e destrói várias vezes os grupos, cada momento com elementos diferentes; O número de grupos formados pelo algoritmo pode ser maior do que a quantidade de
grupos que os dados realmente apresentavam.
Para diminuir esses efeitos Vizine et al. (2005) propuseram três mudanças para o algoritmo inicial, a primeira é realizar uma redução do valor de , a cada ciclo, definido por 10.000 passos de formiga, representado na Equação 7. O objetivo da mudança é evitar que o agente pegue e deixe os itens frequentemente após um período, visando a estabilizar os grupos já formados.
←
Equação 7: Representação da queda do valor de . Fonte: Vizine et el, (2005, p145)
Outra mudança sugerida pelo pesquisador é aumentar o campo de visão do agente quando o mesmo percebe que está diante de um grupo grande de dados, representado na Equação 8. Os valores sugeridos pelo pesquisador é de 0,6 para e 7 x 7 para . Seu objetivo é reduzir a formação de pequenos grupos espalhados na arena.
( ) ←
Equação 8: Representação do aumento do campo de visão do agente.
Fonte: Vizine et el, 2005, p145
A última mudança proposta é fazer com que os itens carregados pelos agentes tenham uma quantidade de feromônio, e que o mesmo pode ser transferido para a arena, o objetivo é diminuir o estímulo do agente a tirar itens de onde existe mais feromônio, para conservar os grupos já formados, aumentando a estabilidade do grupo e diminuindo a quantidade de pequenos grupos formados na arena. A Equação 9 e a Equação 10 definem respectivamente a probabilidade de um agente pegar e deixar um item, implementando o conceito de feromônio.
21
( ) ( ) ( ( ))
Equação 9: Probabilidade de um agente que não está carregando um item pegá-lo, considerando o
fator de feromônio na grade onde o item se encontra. Fonte: Vizine et el, 2005, p146
( ) ( ) ( ( ) ( ))
Equação 10: Probabilidade de um agente carregado soltar o item, considerando o fator de feromônio
na grade onde a formiga está. Fonte: Vizine et el, 2005, p146
O pseudocódigo 2 apresenta o algoritmo de agrupamento de formiga modificado com a proposta de diminuir os problemas conhecidos usando os conceitos propostos pelo pesquisador. As partes realçadas do pseudocódigo são as que necessitam de mudança comparado ao pseudocódigo 1.
procedure [] = ACA(max_it,N,k1,k2)
projete cada item (i) em uma célula randômica na matriz projete cada formiga (k) em uma célula randômica na matriz não ocupada pelas formigas
t 1
qtd_passos 0
enquanto t < max_it faça,
para i = 1 até N faça, //para cada formiga
se qtd_passos 10000 então, calcule k1 qtd_passos = 0 fim se calcule ( ) se ( ) > e então,
aumente o campo de visão da formiga e recalcule ( )
senão se ( ) < e então,
diminua o campo de visão da formiga e recalcule ( )
fim se
se formiga livre E célula ocupada por um item , então
calcule ( ) //probabilidade para carregar um item senão se formiga carregada E célula vazia, então
calcule ( ) //probabilidade para deixar um item fim se
mova a formiga para uma célula vizinha selecionada aleatoriamente que esteja desocupada
qtd_passos qtd_passos + 1
fim para t t + 1 fim enquanto
escreva a localização dos itens
Pseudocódigo 2: Mudanças propostas por Vizine et el, (2005) ajustadas no algoritmo de agrupamento de formiga simples. As partes realçadas são as que apresentam alterações.
CAPÍTULO II
A plataforma usada e desenvolvimento do projeto
A princípio, para o desenvolvimento do algoritmo ACA simples foi avaliado o uso de algumas tecnologias semelhantes, que tornam o algoritmo possível de ser executado de forma paralela.
Dentre as tecnologias avaliadas, podemos citar o OpenMP, uma API (Application Programming Interface ou Interface de Programação de Aplicativos) preparada para ser utilizada na paralelização de programas, mas seu objetivo é otimizar a aplicação na unidade central de processamento ou CPU e nesse caso, devido ao equipamento disponível, o tempo ganho na execução do projeto em paralelo na CPU poderia ser muito limitado ou até mesmo inexistente, comprometendo o objetivo do trabalho.
Considerando também a motivação pela inovação do pesquisador, o desafio do projeto foi desenvolver a aplicação usando a unidade de processamento gráfico, conhecidas como GPU – Graphics Processing Unit, ou Unidade de Processamento Gráfico –. Esta, por ser uma arquitetura dividida muitas vezes em centenas de pequenos núcleos simples (com menos instruções que os processadores x865) consegue realizar um maior número de operações no mesmo intervalo de tempo, tornando-a mais rápida.
O desempenho por watt de energia gasto em um sistema que utiliza a base de GPU é muito superior que as CPU e apesar de ser uma tecnologia recente, apresenta uma base sólida e pode ser usada desde workstations simples até supercomputadores.
Mas, para que uma aplicação aproveite a capacidade de processamento de uma placa de vídeo dedicada da melhor forma, é necessário que a tarefa a ser realizada possa ser dividida em várias partes menores e que uma não dependa da outra, para que ambas sejam executadas ao mesmo tempo, no caso do algoritmo em estudo, isso é possível, pois os agentes são independentes.
5
Atualmente, o mercado oferece duas arquiteturas que suportam a escrita do código para que a GPU interprete as instruções, são elas o CUDA e o OpenCL, cada uma com suas particularidades oferecendo vantagens e desvantagens, a plataforma escolhida nesse caso foi o CUDA.
Para executar um programa escrito nessa linguagem é necessário que o computador tenha ao menos uma placa de vídeo dedicada do fabricante NVIDIA instalado no computador e devidamente configurado com o driver correto, disponibilizado pelo fabricante gratuitamente.
As primeiras placas de vídeo que o processador gráfico suporta realizar tarefas de propósito gerais, termo conhecido como GPGPU – do inglês General Purpose Graphics Processing Unit – foi lançada em 2007, conhecida como geração 8000. Desde então todas as placa de vídeos da linha GeForce (voltadas para o mercado popular e focada em processamento gráfico) e da linha Tesla (direcionadas para o uso exclusivo de aplicações GPGPU, no segmento profissional) podem utilizar dessa tecnologia.
O ambiente de desenvolvimento oferecido pode ser configurado por um instalador disponível no site do fabricante, conhecido como Nsight Visual Studio. O objetivo desse programa é oferecer as opções de criar um projeto pré-configurado no Visual Studio 2008 ou 2010, sem que haja necessidade de alterar o compilador padrão do Visual C++ para o compilador NVIDIA's CUDA Compiler, conhecido como NVCCmanualmente, esse processo envolve a configuração de vários parâmetros de compilação, que muitas vezes podem facilmente causar erro, ou ainda perca de desempenho na execução da aplicação.
25
Figura 5: Criando um projeto CUDA após a instalação do programa Nsight Visual Studio pelo
Microsoft Visual Studio 2010
O fabricante também possui uma biblioteca com exemplos de projetos já desenvolvidos e com o código disponível para estudo, conhecida como NVIDIA GPU Computing SDK.
Outras facilidades oferecidas pelo programa incluem o poder de depurar o código CUDA C/C++ diretamente no hardware da GPU e o uso de breakpoints, para depuração do código escrito. Recursos importantes e usados no decorrer do desenvolvimento do projeto.
2.1 Conceitos sobre unidade de processamento gráfico de propósito geral
Um programa de computador, ao ser executado, utiliza a memória principal para manter o valor das variáveis e o processador para executar as instruções, o papel do chipset, mais especificamente a ponte norte, conforme Figura 6, é de manter a comunicação entre os dois. Ele possui o controlador de memória, além das comunicações com a ponte sul e barramentos de alta velocidade, como por exemplo, o PCI- Express, com 16 linhas, utilizado normalmente nas placas de vídeo dedicadas.
Figura 6: Esquema dos principais componentes e barramentos envolvidos na execução de um
programa no computador
Quando a placa de vídeo é usada para o processamento de instruções, esse fluxo é alterado. Os dados são copiados da memória principal para a memória da placa de vídeo, passando pelo barramento PCI-Express. Essa transferência é bastante demorada e não é recomendado realizá-la dentro de laços, com vetores grandes, pois a perda de desempenho é considerável.
Depois dos dados estarem alocadas na placa de vídeo o processamento e transferência das informações entre processador gráfico e memória dedicada da placa é mais rápido, elas trabalham com a frequência e a largura de transferência de dados mais elevada que os processadores. Essa velocidade de transferência pode chegar a mais de 190 GB/s, enquanto que um processador moderno trabalha a 2x12 GB/s, no caso do equipamento usado a velocidade de transferência dos dados na placa de vídeo atinge 57,73GB/s, enquanto a transferência entre a memória principal e o processador é de apenas 2x 6,4GB/s.
A quantidade de memória de cada placa deve ser respeitada, se o limite for atingido, ocorrerá um erro em tempo de execução do programa, diferente de um sistema operacional, que tem recursos de paginação de memória em disco, conhecido como swap. Essas técnicas
27
não são utilizadas para a GPU implicitamente, geralmente cada placa de vídeo fornece de 1 GB até 4 GBs de memória.
Os núcleos da GPU são gerenciados implicitamente pela API conforme a tarefa é dividida em threads, é alocado um núcleo para cada thread, se forem alocados mais threads que a quantidade de núcleos, as threads esperam a disponibilidade de um núcleo para que suas instruções possam ser realizadas. Dessa forma, para trabalhar com a placa de vídeo o pesquisador não necessita conhecer detalhes do modelo utilizado, como a quantidade de núcleos, deixando a implementação desenvolvida independente da placa usada.
Ao desenvolver uma aplicação usando a linguagem CUDA, é comum o uso das palavras reservadas __global__, __device__ e __host__ na frente das funções, ela indica onde o código será executado, sendo:
__global__: chamado de dentro de código de host (CPU), não pode ser chamado de código do dispositivo (GPU) e deve retornar void;
__device__: chamada de outras funções GPU, não pode ser chamado de código central (CPU);
__host__: só pode ser executado pela CPU, conhecido como hospedeiro.
As threads alocadas em uma chamada, geralmente usado para substituir um laço, são divididas em blocos e threads, onde um bloco pode conter várias threads, esse conceito é importante para o trabalho, pois deve haver equilíbrio na quantidade de threads por bloco. Esse item influencia no tempo de execução do programa.
Sua chamada é feita da seguinte forma: // Codigo para device
__global__ void add(...) { ...
}
// Código para host void main() {
...
add<<<blocos, threads>>>(...); ...
}
2.2 Desenvolvimento da aplicação
O algoritmo ACA pode ser dividido em dois grandes laços de repetição, um deles, o mais interno representa o número de agentes e o externo, a quantidade de iterações, que é a quantidade de passos que os agentes terão que realizar durante o processo de agrupamento. Implementando esse algoritmo para um modelo paralelo, o laço mais interno será dividido em threads, sendo assim, cada agente será representado por um núcleo da placa de vídeo, e todos agentes compartilham o mesmo ambiente, sendo representado pela arena, onde irão se movimentar.
Inicialmente, a arena é alocada na memória principal do computador, ela é representada por apenas um vetor, e apesar de possuir o conceito de matriz, com índices X e Y esse comportamento é simulado usando um vetor. Isso é possível quando o número de posições que representam as colunas está definido. As Figuras 7 e 8 ilustram como essa divisão lógica é realizada usando uma matriz de 2 linhas e 4 colunas de exemplo.
0x0 0x1 0x2 0x3 1x0 1x1 1x2 1x3
0 1 2 3 4 5 6 7
Figura 7: Matriz com oito posições, os
números representam seu índice
Figura 8: Simulando a matriz a partir do
vetor, com a mesma quantidade de posições
Nesse caso, quando for necessário acessar a posição 1x1 da matriz, se ela for representada por um vetor será necessário realizar a seguinte operação:
Posição = Quantidade de posições por linha X linha desejada + Coluna desejada
Logo:
Posição = 4 X 1 + 1 Posição = 5
A Figura 9 representa o acesso ao índice desejado usando a matriz e a Figura 10 apresenta a mesma posição sendo acessada no vetor usando o calculo realizado.
29
0x0 0x1 0x2 0x3 1x0 1x1 1x2 1x3
0 1 2 3
4 5 6 7
Figura 9: Matriz com oito posições, os
números representam seu índice
Figura 10: Simulando a matriz a partir do
vetor, com a mesma quantidade de posições
Para começar o processo de agrupamento os dados e os agentes precisam ser colocados na arena, ambos de forma aleatória, os números que representam o índice, ou sua posição na arena são calculados na placa de vídeo. A função escrita para o desenvolvimento da pesquisa para esse fim utiliza um mecanismo já desenvolvido nas bibliotecas da linguagem de forma nativa. Os parâmetros necessários para executar a função são um vetor para receber os resultados, o tamanho máximo dos números, a quantidade de números desejados e uma semente para que a partir dela os demais números sejam calculados.
Para gerar a semente inicial é usada a função rand disponível na linguagem C, oferecido pela biblioteca stdlib. Ela é limitada a 32.767 possíveis números aleatórios, que oferece uma quantidade satisfatória de sementes, mas não o suficiente para ser usado diretamente, como valor determinante para o índice da arena.
Caso fosse usada essa função diretamente para o índice da arena, o algoritmo seria limitado, pois a área de atuação dos agentes e dos dados não seria maior que o número máximo oferecido pela função. O tamanho máximo da arena seria um número próximo de 160 linhas, com 200 colunas cada linha, totalizando um vetor com 32.000 posições.
A função usada para calcular os valores aleatórios realiza as seguintes etapas: Aloca um vetor com a quantidade de números desejados na placa de vídeo; Atribui valor zero nos índices do vetor;
Realiza o cálculo do número aleatório para atribuí-lo ao vetor;
Copia o vetor com os resultados da placa de vídeo para o vetor de retorno da função. Para o cálculo do número aleatório é utilizado a biblioteca curand_kernel, nativa da linguagem CUDA, essa biblioteca é específica apenas para geração de números aleatórios.
Após a execução da função, os números gerados pela placa de vídeo passam por uma etapa de validação que consiste em analisar se o número representa um índice válido na arena, caso represente, nessa posição é colocado um item que faz parte do processo de agrupamento, entretanto, se a posição já estiver ocupada por um item, não é possível colocar outro.
Se algum número está duplicado, então a função é chamada novamente para o cálculo de novos valores, com uma semente diferente da anterior. Esse cálculo é realizado sempre em grandes quantidades, independente de qual quantidade de números foi repetido, o objetivo nesse caso é diminuir o número de chamadas e alocação de vetores na placa de vídeo, tornando a aplicação mais eficiente.
Apesar da forma de cálculo dos números aleatórios ser igual para os agentes e dados, eles são colocados na arena de forma diferente, enquanto um dado é um valor inteiro, variando entre 1 e 999.999, um agente é representado por um valor negativo fixo, -1.000.000. No final dessa etapa a arena está semelhante à Figura 11.
4
-1000000
4
-2
-1000000 -2
Figura 11: Representação visual da implementação da
arena, com base na Figura 12
Figura 12: Representação visual da arena, com os
agentes e dados
Nesse processo ainda é mantido outro vetor auxiliar na memória, com a posição de todos os agentes, que será utilizado nas próximas etapas.
Antes de realizar a carga desses vetores na placa de vídeo, os resultados obtidos são gravados em um arquivo de texto, que depois é interpretado por outro programa responsável
31
por gerar um gráfico indicando como está a posição atual dos dados. Esse programa será descrito em detalhes na Seção 2.3.
No próximo passo, os vetores que representam a arena e a posição de cada agente são passados para uma função responsável por alocá-los na memória da placa de vídeo, também é alocado um novo vetor diretamente na placa de vídeo, para manter os itens que estão sendo carregados no momento pela formiga. A quantidade de espaços desse vetor depende da quantidade de formigas utilizadas.
Após todos os dados estarem alocados, são criadas N threads, onde N é um valor maior ou igual ao número de formigas definido no começo do algoritmo. O objetivo é que cada thread seja uma formiga. O processo de alocação das threads se repetem até ser atingido a quantidade de iterações determinada por parâmetro.
2.2.1 Tarefas de um agente
Logo no início da execução da thread, é realizado o cálculo da equação ( ), representada na Equação 3 da Seção 1.2.1.
Depois de obtido a proximidade dos itens da região onde o agente está localizado é verificado se o mesmo está vazio ou carregando um item.
A partir desse resultado é calculado se a formiga pegará o item, caso esteja vazia ou deixará o item, caso esteja carregada. Esses cálculos são representados nas Equações 5 e 6 respectivamente, conforme apresentado na Seção 1.2.1.
A ação de pegar o item é representada pelas seguintes etapas:
O item que está na arena é passado para o vetor que representa o que o agente está carregando;
A posição que o item se encontrava na arena é marcada com o valor -1.000.000, para representar que o local está ocupado por um agente apenas.
Para soltar um item, os seguintes passos são realizados:
O elemento do vetor que representa o item que o agente está carregando é passado para a arena, mas com um valor negativo;
A posição do vetor com o elemento recebe valor 0.
Para finalizar a execução da thread, o agente deve se mover para uma área vizinha, de forma aleatória, para isso é gerado um número entre 1 e 8, representando suas opções de
locomoção ilustrado pela Figura 13. Caso a célula escolhida já esteja ocupada por outro agente, não é possível movê-lo, sendo obrigatória a escolha de outra posição para se movimentar.
1 2 3
4 5
6 7 8
Figura 13: Opções de locomoção de um agente a partir do número
aleatório escolhido
Um fator considerado no desenvolvimento da movimentação do agente é a possibilidade dele estar nas bordas da arena, sendo assim é uma característica desejável que ele possa andar sem se preocupar com as limitações do espaço do vetor, logo o movimento nessas condições são tratados como descrito na Figura 14.
1 2
3 4
5 6 7
8
Figura 14: Movimentação de um agente quando ele se encontra nas bordas
laterais da arena
O deslocamento do agente no final de uma sequência de posições na arena que representa uma linha para outra é tratado de forma simples, pois a arena é representada por um vetor e se o agente está localizado no final da linha, a próxima posição será no começo da linha imediatamente abaixo.
Essa questão não prejudica o agrupamento, pois não afeta a proximidade dos itens no decorrer do processo, apenas apresenta benefícios simplificando seu desenvolvimento e complexidade.
33
As soluções para manter o agente na mesma linha quando estivesse caminhando nas extremidades da arena poderiam precisar de uma grande quantidade de condições para tratar ou o uso de uma estrutura mais complexa, onde cada posição seria um objeto e cada objeto seria ligado com as demais posições vizinhas. Nesse caso, o único tratamento que precisou ser realizado é se caso o agente tivesse um valor de índex do vetor inválido ele seja deslocado para um válido. Essa situação pode ocorrer em dois casos:
Quando o agente está na primeira linha e deseja se movimentar para uma posição acima. Então o índex desejado atinge um valor menor que 0 e o agente é colocado para a última linha da arena, representado na Figura 15;
Quando o agente está na última linha e deseja se movimentar para uma posição abaixo. Nesse caso o índex desejado atinge um valor maior do que o disponível na arena, e o agente é colocado na primeira linha da arena, representado na Figura 16.
4 5 6 7 8 1 2 3 6 7 8 1 2 3 4 5
Figura 15: Movimentação de um agente
quando ele se encontra na borda superior da arena, onde ocorre a situação de índex menor
que zero se não tratado
Figura 16: Movimentação de um agente
quando ele se encontra na borda inferior da arena, onde ocorre a situação de índex maior
que a quantidade de posições disponíveis se não tratado
Depois de concluídas as iterações é realizada a cópia dos valores do vetor da placa de vídeo para a memória principal do computador e liberada a memória usada na placa de vídeo.
Na próxima etapa são gravados os dados da arena e suas respectivas posições em um segundo arquivo de texto, para que depois essas informações possam ser analisadas.
2.3 Desenvolvimento da ferramenta de visualização dos dados
A ferramenta de visualização foi criada a partir da necessidade de visualizar os resultados do agrupamento de forma clara e objetiva.
O programa foi desenvolvido utilizando a linguagem de programação Java, em conjunto com a biblioteca JFreeChart, para criação de gráficos.
Ele é composto por duas telas, a primeira de configurações e a segunda para exibição do gráfico. A tela de configurações possui dois campos, um para a escolha do local do arquivo de texto que contém a posição X, posição Y e o valor de cada dado e um segundo campo para ser informada a tolerância de valores para definição do grupo. A Figura 17 mostra a tela de configurações criada.
Figura 17: Tela de configurações para exibição do gráfico
Após as configurações estarem preenchidas e a opção para criar o gráfico ser selecionada, os dados são carregados em uma lista na memória. Depois de carregados, a lista é ordenada pelo valor dos dados, que é representada por um número inteiro.
No próximo passo, os dados são distribuídos em grupos, considerando o valor de tolerância informado. Caso a diferença de valor dos dados seja maior que a tolerância, então é criado um novo grupo.
O resultado final do processo é uma estrutura de dados no formato de árvore, em que cada nó possui uma lista de dados que serão os pontos, formando um gráfico de dispersão.
A última etapa consiste na montagem do gráfico e apresentação do mesmo, como mostra a Figura 18.
35
Figura 18: Tela para exibição do gráfico usando a ferramenta desenvolvida. Pontos com a distância
CAPÍTULO III
Testes e resultados do algoritmo
Para o cenário de testes, o algoritmo foi escrito nas linguagens C/CUDA e C apenas, ambas implementações ficaram bastante semelhantes, o cálculo das funções, vetores e estrutura do código foi preservado de uma versão para outra.
Uma observação é que, por limitação da função rand nativa da linguagem C, no início do código foi mantido o cálculo de números aleatórios utilizando o processamento da placa de vídeo. Foi considerado que diferentes implementações de funções aleatórias, oferecidas por outras bibliotecas poderia influenciar o tempo final de execução e prejudicar os resultados.
A IDE usada durante o desenvolvimento foi o Visual Studio 2008 e para compilar as duas implementações foi usado NVCC, versão 4.1. O sistema operacional usado foi o Windows Seven.
A configuração da máquina onde foram obtidos os resultados é:
Processador: Intel Core 2 Duo, com dois núcleos físicos, utilizando a frequência interna de 2,33 GHz;
Memória: 2x2 GBs de memória, sendo sua comunicação com o processador limitada a 10,6 GB/s pela ponte norte do chipset (ver Seção 2.1, Figura 6);
Placa de vídeo: NVIDIA GeForce GTS 450, com 192 núcleos simples – conhecidos como CUDA Core –. Cada núcleo trabalha na frequência de 1,566GHz. Sua memória interna tem 1GB de capacidade e se comunica com o processador gráfico a 57,7 GB/s. A transferência de dados entre o processador gráfico e a placa de vídeo é limitada a 8GB/s pelo barramento PCI-Express 16x, onde cada linha suporta até 500MB/s, obtendo o total de 16x500MB/s.
Apesar do programa ser escrito em CUDA, o processador também é bastante usado durante a execução do programa, isso foi notado pelo gerenciador de tarefas do sistema operacional, portanto um conjunto de processador e placa de vídeo não alinhados pode causar gargalos.
37
Os dados usados no teste são sintéticos e formam três grupos claros. A distância entre os dados do mesmo grupo é menor que um, enquanto a distância para os demais grupos é maior que cinco. A quantidade de dados usada para cada grupo pode ser definida através de constante e conforme os testes seu valor foi alterado.
3.1 Algoritmo de agrupamento de formiga simples
A primeira implementação do algoritmo utilizado foi baseada no Pseudocódigo 1. Ela apresenta o algoritmo de agrupamento de formiga simples. Os parâmetros usados na execução do algoritmo foram:
Tamanho da arena horizontal: 80 posições; Tamanho da arena vertical: 60 posições; Quantidade de iterações: 80.000;
Quantidade de agentes: 250; K1: 0,8;
K2: 0,25.
A quantidade de itens em cada grupo foi de 250, 280 e 320, somando 850 itens na arena. Com esses parâmetros foram realizados dois testes para cada implementação do algoritmo.
As Figuras 19 e 20 mostram como os dados estavam distribuídos antes e depois da execução do segundo teste realizado usando as linguagens C/CUDA.
Figura 19: Distribuição dos dados antes da execução do algoritmo de agrupamento
Figura 20: Distribuição dos dados após o processo de agrupamento realizado pelo algoritmo ACA simples
39
A Tabela 1 exibe o tempo de execução dos algoritmos em segundos.
Tabela 1: Tempo de execução do algoritmo ACA simples nas linguagens C e C/CUDA com um conjunto de dados pequeno
Número do teste Linguagem C Linguagem C/CUDA Tempo total (segundos) Tempo total (segundos)
1ª Execução 2,561 12,988
2ª Execução 2,573 13,146
Média 2,667 13,067
Os resultados obtidos no primeiro teste indicam que o desempenho do processador foi de aproximadamente 5x mais rápido que a placa de vídeo. Esse resultado é devido a pequenas transferências de dados pelo barramento PCI-Express, que possuí uma latência elevada e ao baixo paralelismo da aplicação, considerando apenas 250 agentes se movimentando pela arena.
Foi realizado um novo teste, com um volume de dados aproximadamente 375 vezes maior, os parâmetros usados foram:
Tamanho da arena horizontal: 2.000 posições; Tamanho da arena vertical: 1.000 posições; Quantidade de iterações: 150.000;
Quantidade de agentes: 30.000; K1: 0,8;
K2: 0,25.
Dessa vez, a quantidade de itens em cada grupo foi de 80.000, 100.000 e 120.000, somando um total de 300.000 itens na arena.
A Tabela 2 mostra o tempo de execução dos algoritmos em segundos.
Tabela 2: Tempo de execução do algoritmo ACA simples nas linguagens C e C/CUDA com um conjunto de dados grande
Número do teste Linguagem C Linguagem C/CUDA Tempo total (segundos) Tempo total (segundos)
1ª Execução 936,436 165,662
2ª Execução 910,670 164,755
Diferente do primeiro, esse novo teste mostra que a solução baseada na placa de vídeo obteve um tempo de execução 5x menor que o processador do computador. O principal fator que influenciou essa diferença foi o gerenciamento das threads e blocos pela placa de vídeo.
3.2 Algoritmo de agrupamento de formiga melhorado
Para melhorar a qualidade do grupo apresentado na Figura 20 existem três mudanças propostas por Vizine et al (2005), apresentadas na Seção 1.2.1 que são:
1. Decaimento da taxa de ;
2. Aumento no campo de visão do agente ao chegar a um grupo grande;
3. Programar uma matriz de feromônio, para estimular os agentes a pegar e deixar os itens em determinadas regiões.
Uma segunda versão do algoritmo foi criada usando as duas primeiras mudanças propostas com o objetivo de diminuir a fragmentação dos grupos.
Para implementar a primeira mudança é necessário acumular a quantidade de passos de formiga por iteração, e quando a mesma for maior que N, então decrementar o valor de .
O código usado para desenvolver a mudança é semelhante ao apresentado:
... double currentK1 = K1; while(currLoop <= nLoopsTotal) { if (qtdPassosFormiga > N) { currentK1 = currentK1 * 0.98; if (currentK1 < 0.001) {
currentK1 = 0.001; //valor minimo aceito }
qtdPassosFormiga = 0; }
...
qtdPassosFormiga = qtdPassosFormiga + numeroAnt; }
...
A segunda mudança se localiza onde é realizado o cálculo da equação ( ) e consiste em verificar o valor a ser retornado pela equação. A princípio o cálculo é realizado nas células mais próximas do agente, em uma área de 3x3 posições na arena, caso esse valor seja menor que , então o campo de visão do agente aumenta para 5x5 posições na arena e o cálculo de ( ) é realizado novamente. A área considerada está representada na Figura 21.
41
Figura 21: Campo de visão do agente, sendo a área verde, sempre analisada pela Equação ( ) e a
área vermelha, analisada somente quando o agente está diante de um grupo de dados
Quanto menor o valor da função ( ), mais próximo é o item que ele está analisando para pegar ou deixar com os demais de sua região. O valor usado para durante os testes foi de 0,8.
Com essas mudanças foram realizados dois novos testes para cada implementação do algoritmo. Os valores dos parâmetros usados foram propositalmente idênticos ao primeiro teste do algoritmo de agrupamento de formiga simples, para análise do tempo de execução com as mudanças e alteração nos grupos formados. Os parâmetros são:
Tamanho da arena horizontal: 80 posições; Tamanho da arena vertical: 60 posições; Quantidade de iterações: 80.000;
Quantidade de agentes: 250; K1: 0,8;
K2: 0,25.
Foram usados 850 itens na arena divididos em três grupos de 250, 280 e 320 itens. As Figuras 22 e 23 mostram como os dados estavam distribuídos depois da execução do segundo teste realizado usando as linguagens C/CUDA e C.
Figura 22: Distribuição dos dados após o processo de agrupamento realizado pelo algoritmo ACA
melhorado, usando a placa de vídeo
Figura 23: Distribuição dos dados após o processo de agrupamento realizado pelo algoritmo ACA melhorado, usando o processador
43
A Tabela 3 mostra o tempo de execução dos algoritmos em segundos.
Tabela 3: Tempo de execução do algoritmo ACA melhorado nas linguagens C e C/CUDA com um conjunto de dados pequeno
Número do teste Linguagem C Linguagem C/CUDA Tempo total (segundos) Tempo total (segundos)
1ª Execução 3,354 13,346
2ª Execução 3,515 13,325
Média 3,4345 13,335
Nessa etapa de testes, os resultados indicaram que o processador do computador foi em média 4x mais rápido que a placa de vídeo, mas as melhorias desenvolvidas no algoritmo se mostraram mais robustas sobre a placa de vídeo. Com uma quantidade pequena de agentes a diferença no tempo de execução médio da placa de vídeo foi de 0,268 segundos e do processador foi de 0,7675 segundos comparando a Tabela 3 com a Tabela 1.
Também foi realizado um novo teste, com um volume de dados maior que a primeira execução, com o mesmo valor dos parâmetros usados no segundo teste do algoritmo de agrupamento de formiga simples. Os parâmetros são:
Tamanho da arena horizontal: 2.000 posições; Tamanho da arena vertical: 1.000 posições; Quantidade de iterações: 150.000;
Quantidade de agentes: 30.000; K1: 0,8;
K2: 0,25.
A quantidade de itens em cada grupo foi de 80.000, 100.000 e 120.000, somando 300.000 itens na arena.
A Tabela 4 mostra o tempo de execução dos algoritmos em segundos.
Tabela 4: Tempo de execução do algoritmo ACA melhorado nas linguagens C e C/CUDA com um conjunto de dados grande
Número do teste Linguagem C Linguagem C/CUDA Tempo total (segundos) Tempo total (segundos)
1ª Execução 1046,346 258,633
2ª Execução 1010,685 262,164
Analisando a amostra de testes realizada e comparando com a Tabela 2, o tempo médio gasto na execução do algoritmo, tanto no processador como na placa de vídeo, houve um aumento de 100 segundos com as mudanças realizadas. No tempo total de execução, a placa de vídeo foi aproximadamente 4 vezes mais rápida quando comparada com o processador.
Outro teste realizado foi variando apenas o parâmetro de quantidade de agentes, que é o número de threads criadas em uma iteração no código em C/CUDA. Os valores dos parâmetros usados foram:
Tamanho da arena horizontal: 800 posições; Tamanho da arena vertical: 600 posições; Quantidade de iterações: 50.000;
K1: 0,8; K2: 0,25.
A quantidade de itens na arena para cada grupo foi de 28.000, 34.000 e 38.000, totalizando 100.000 itens.
A Figura 24 exibe um gráfico com a escalabilidade do algoritmo ACA melhorado usando a solução baseada em um processador gráfico para sua execução.
Figura 24: Tempo de execução do algoritmo ACA melhorado usando a placa de vídeo e o processador em função do parâmetro de número de agentes
Enquanto uma solução tradicional apresenta um aumento de tempo linear na execução do algoritmo em decorrer da variável de número de agentes, a implementação usando a placa
5000 agentes 10000 agentes 15000 agentes 20000 agentes 25000 agentes 30000 agentes Placa de vídeo 53,864 62,894 69,969 71,192 72,864 73,248 Processador 59,567 93,008 120,856 150,384 177,925 205,561 0 50 100 150 200 250 Tem p o (e m se gu n d o s)
Execução do algoritmo usando o processador e a placa de
vídeo
45
de vídeo para processamento geral mostrou-se escalável considerando que o número de agentes dobrou de 15.000 para 30.000 e o tempo de execução praticamente não se alterou.
Verificamos dessa forma que o algoritmo ACA executado paralelamente, apresenta um tempo menor de execução quando o volume de dados é grande. Considerando que o ambiente de teste possuí recursos limitados e que um conjunto de dados real pode ser muitas vezes maior que o usado, o ganho de tempo com a melhora no algoritmo é significativo, sendo em alguns casos 5 vezes mais rápido que o algoritmo tradicional.
