Dissertação de Mestrado§ao... · Primeiramente gostaria de agradecer a Deus por ter me guiado...
112
Pós-Graduação em Ciência da Computação “EVOLUÇÃO DIFERENCIAL APLICADA AO PROBLEMA DE EXPLORAÇÃO DE ARQUITETURAS DE MEMÓRIA CACHE VISANDO DESEMPENHO E REDUÇÃO DE ENERGIA” Por Leonardo José Corrêa Nunes Dissertação de Mestrado Universidade Federal de Pernambuco [email protected] www.cin.ufpe.br/~posgraduacao RECIFE, AGOSTO/2013
Transcript of Dissertação de Mestrado§ao... · Primeiramente gostaria de agradecer a Deus por ter me guiado...
Pós-Graduação em Ciência da Computação
“EVOLUÇÃO DIFERENCIAL APLICADA AO PROBLEMA DE
EXPLORAÇÃO DE ARQUITETURAS DE MEMÓRIA CACHE
VISANDO DESEMPENHO E REDUÇÃO DE ENERGIA”
Por
Leonardo José Corrêa Nunes
Dissertação de Mestrado
Universidade Federal de Pernambuco
www.cin.ufpe.br/~posgraduacao
RECIFE, AGOSTO/2013
UNIVERSIDADE FEDERAL DE PERNAMBUCO
CENTRO DE INFORMÁTICA
PÓS-GRADUAÇÃO EM CIÊNCIA DA COMPUTAÇÃO
LEONARDO JOSÉ CORRÊA NUNES
“EVOLUÇÃO DIFERENCIAL APLICADA AO PROBLEMA DE EXPLORAÇÃO
DE ARQUITETURAS DE MEMÓRIA CACHE VISANDO DESEMPENHO E
REDUÇÃO DE ENERGIA”
ESTE TRABALHO FOI APRESENTADO À PÓS-GRADUAÇÃO EM CIÊNCIA DA COMPUTAÇÃO DO CENTRO DE INFORMÁTICA DA UNIVERSIDADE FEDERAL DE PERNAMBUCO COMO REQUISITO PARCIAL PARA OBTENÇÃO DO GRAU DE MESTRE EM CIÊNCIA DA COMPUTAÇÃO.
ORIENTADOR: ABEL GUILHERMINO DA SILVA FILHO
RECIFE, AGOSTO/2013
Dissertação de Mestrado apresentada por Leonardo José Corrêa Nunes à Pós-Graduação em
Ciência da Computação do Centro de Informática da Universidade Federal de Pernambuco, sob
o título “Evolução Diferencial Aplicada ao Problema de Exploração de Arquiteturas de
Memória visando Desempenho e Redução de Energia” orientada pelo Prof. Abel
Guilhermino da Silva Filho e aprovada pela Banca Examinadora formada pelos professores:
______________________________________________
Prof. Manoel Eusebio de Lima
Centro de Informática / UFPE
______________________________________________
Prof. Wellington Pinheiro dos Santos
Departamento de Engenharia de Biomédica / UFPE
_______________________________________________
Prof. Abel Guilhermino da Silva Filho
Centro de Informática / UFPE
Visto e permitida a impressão.
Recife, 29 de agosto de 2013
___________________________________________________
Profa. Edna Natividade da Silva Barros Coordenadora da Pós-Graduação em Ciência da Computação do
Centro de Informática da Universidade Federal de Pernambuco.
Dedicatória
Dedico àqueles que mais incentivaram e me ajudaram durante toda a realização deste
trabalho, minha família
Eliane Corrêa Nunes, Joaquim Nunes Filho e Mariana Corrêa Nunes.
vi
Agradecimentos
Primeiramente gostaria de agradecer a Deus por ter me guiado neste caminho de
sucesso na minha vida profissional.
Agradeço ao meu orientador Prof. Dr. Abel Guilhermino da Silva Filho por ter me dado a
oportunidade de realizar este trabalho, por ter me orientado de uma forma bastante paciente,
demonstrando sempre entusiasmo a cada passo dado e me incentivando nos momentos de
dificuldade.
Agradeço aos meus pais e a minha irmã por todo o apoio dado ao longo deste trabalho e
por terem me ajudado sabiamente em cada momento de decisão da minha carreira
profissional.
Agradeço a professora Edna Barros, pessoa que tenho profunda admiração, não só pelo
trabalho que ela realiza no Centro de Informática, mas pelo suporte que ela me deu durante a
graduação, por ter me incentivado a ingressar no mestrado acadêmico no CIn, por ter me dado
a oportunidade de ter trabalhado no LINCS, lugar que me permitiu realizar este trabalho e que
me permitiu crescer rapidamente na vida profissional.
Agradeço a todos os meus amigos, em especial a Gustavo, Raso, Dani, Adelma, Luciano,
Bopp, Milena, Fornari, Bruno, Carol, Aline, George, Marcus e Igino que me inspiraram e me
ajudaram nesta jornada.
Finalmente, agradeço a minha namorada, Silvana, que esteve comigo e me deu bastante
força na reta final deste trabalho.
vii
Resumo
Impulsionado pelo crescimento do mercado de dispositivos móveis, diversos estudos
têm sido realizados com o intuito de diminuir a energia consumida destes dispositivos. No
entanto, aplicações que exigem alto poder de processamento estão sendo cada vez mais
utilizadas nestes tipos de dispositivos. Logo, encontrar o melhor compromisso entre capacidade
de processamento e energia consumida tem se tornado um desafio em projetos de hardware.
Este trabalho apresenta uma nova metodologia para avaliar a energia consumida e o
desempenho de hierarquias de memória com três níveis de cache. Adicionalmente, uma
adaptação do algoritmo de evolução diferencial para otimização multiobjetivo no domínio
discreto é proposta para o problema de exploração de hierarquias de memória cache, visando
reduzir a energia consumida e aumentar o desempenho para processar uma aplicação
embarcada. A exploração de arquiteturas foi baseada em ajustes de parâmetros das caches
presentes em hierarquias compostas por três níveis de memórias cache. Um modelo de
memória DDR3L foi adotado para simular a memória principal, e um modelo de memória cache
recente baseado na tecnologia de transistores de 32n foi utilizado. Para a realização dos
experimentos, o algoritmo proposto foi aplicado a nove diferentes aplicações dos benchmarks
Mibench e MediaBenchII. Além disto, o desempenho da técnica proposta foi comparada com as
técnicas de otimização SPEA2 e NSGAII. As métricas selecionadas para comparar a qualidade
das frentes de Pareto encontrados por cada um destes algoritmos foram os indicadores de
hipervolume e de distância generacional. Os resultados mostraram que a estratégia de
otimização proposta, baseada no algoritmo de evolução diferencial, aplicada ao problema de
exploração de hierarquias de memória, obteve melhores resultados para ambos os indicadores,
alcançando uma melhoria de 100% e 78% dos casos estudados para ambas as métricas de
hipervolume e distância generacional.
Palavras-chave: exploração de memória; cache L3; evolução diferencial; otimização
multiobjetivo.
viii
Abstract
Driven by the growth of the mobile devices market, several studies were performed in
order to reduce the energy consumption of these devices. However, applications that require
high performance are being increasingly used in these types of devices. Then, to find the best
compromise between performance and energy consumption has become a big challenger in
hardware projects. This work presents a new methodology to evaluate the energy consumption
and performance for the three level cache memory hierarchies. Furthermore, an improved
differential evolution (DE) algorithm for multi-objective optimization in the discrete domain is
proposed to a cache memory hierarchy exploration problem, aiming to reduce the energy
consumption and to increase the performance to process an embedded application. The
architecture exploration was based on cache parameters adjustments inserted on memory
hierarchies composed of three levels of cache memory. A model of DDR3L memory was
adopted to simulate the main memory and a recent cache memory model based on 32 nm
transistor technology was used. In these experiments, the proposed algorithm was applied to
nine different applications from the MiBench and the MediaBenchII suites. Furthermore, the
performance of the proposed strategy was compared with those of SPEA2 and NSGAII
optimization mechanisms. The metrics selected to compare the quality of the Pareto front
found for each of those algorithms were the hypervolume and the generational distance. The
results show that the proposed strategy based on DE optimization algorithm applied to memory
hierarchy exploration problem obtained better results for both indicators, achieving
improvements in 100% and 78% of cases in both metrics, hypervolume and the generational
distance.
Keywords: memory exploration; L3 cache; differential evolution; multi-objective optimization.
ix
Sumário
1 INTRODUÇÃO ............................................................................................................................................... 1
1.1 MOTIVAÇÃO E CONTEXTO ..................................................................................................................................... 2 1.2 OBJETIVO GERAL ................................................................................................................................................. 3 1.3 OBJETIVOS ESPECÍFICOS ........................................................................................................................................ 3 1.4 ESTRUTURA DA DISSERTAÇÃO ................................................................................................................................. 4
2 HIERARQUIA DE MEMÓRIA .......................................................................................................................... 5
2.1 INTRODUÇÃO ...................................................................................................................................................... 6 2.2 MEMÓRIA CACHE ................................................................................................................................................ 8 2.3 ESTRUTURA DE UMA CACHE ................................................................................................................................... 8 2.4 ELEMENTOS DE PROJETO DA CACHE ...................................................................................................................... 10
2.4.1 Tamanho da Linha ............................................................................................................................... 10 2.4.2 Tamanho da Cache .............................................................................................................................. 10 2.4.3 Associatividade .................................................................................................................................... 11 2.4.4 Número de memórias cache ................................................................................................................ 13
2.5 SIMPLESCALAR .................................................................................................................................................. 14 2.6 CACTI ............................................................................................................................................................. 15 2.7 SIMULADOR DE MEMÓRIA MICRON ...................................................................................................................... 16
3 PROBLEMAS DE OTIMIZAÇÃO MULTI-OBJETIVO ......................................................................................... 17
3.1 CONCEITOS BÁSICOS .......................................................................................................................................... 18 3.1.1 Classes de Problemas .......................................................................................................................... 18 3.1.2 Problemas de Otimização .................................................................................................................... 19
3.1.2.1 Problemas de Otimização Mono-objetivo .................................................................................................. 20 3.1.2.2 Problemas de Otimização Multiobjetivo .................................................................................................... 20
3.1.3 Dominância ......................................................................................................................................... 21 3.1.4 Pareto .................................................................................................................................................. 21
3.2 ALGORITMOS EVOLUCIONÁRIOS............................................................................................................................ 22 3.2.1 Componentes de Algoritmos Evolucionários ....................................................................................... 23
3.2.1.1 Indivíduo ..................................................................................................................................................... 23 3.2.1.2 Função de Aptidão...................................................................................................................................... 23 3.2.1.3 População ................................................................................................................................................... 23 3.2.1.4 Mecanismo de Seleção de Pais ................................................................................................................... 24 3.2.1.5 Operadores de Variação ............................................................................................................................. 24 3.2.1.6 Mecanismo de Seleção de Sobreviventes .................................................................................................. 25
3.2.2 Algoritmos Genéticos .......................................................................................................................... 25 3.2.3 Estratégias Evolucionárias .................................................................................................................. 26 3.2.4 Evolução Diferencial ............................................................................................................................ 28
3.3 TÉCNICAS DE OTIMIZAÇÃO MULTI-OBJETIVOS ......................................................................................................... 30 3.3.1 NSGAII ................................................................................................................................................. 31 3.3.2 SPEA2 .................................................................................................................................................. 33
3.4 MÉTRICAS DE AVALIAÇÃO .................................................................................................................................... 35 3.4.1 Distância Generacional ....................................................................................................................... 36 3.4.2 Hipervolume ........................................................................................................................................ 37 3.4.3 Cobertura ............................................................................................................................................ 38
4 TRABALHOS RELACIONADOS ....................................................................................................................... 39
4.1 ESTUDO REALIZADO ........................................................................................................................................... 40 4.2 CONCLUSÃO ..................................................................................................................................................... 43
5 METODOLOGIA PROPOSTA ......................................................................................................................... 44
5.1 INTRODUÇÃO .................................................................................................................................................... 45 5.2 DEFINIÇÃO DO MODELO DE CÁLCULO DE CICLOS E ENERGIA TOTAL ............................................................................. 46
5.2.1 Cálculo do Número Total de Ciclos ...................................................................................................... 46 5.2.2 Cálculo da Energia Total Consumida ................................................................................................... 48
x
5.3 ADAPTAÇÃO DE FERRAMENTAS ............................................................................................................................. 50 5.3.1 Adaptação do Sim-Cache .................................................................................................................... 51 5.3.2 Adaptação do CACT 6.5 ....................................................................................................................... 52 5.3.3 Adaptação do Simulador de Memória Principal .................................................................................. 52
5.4 DEFINIÇÃO DO AMBIENTE EXPERIMENTAL ............................................................................................................... 52 5.4.1 Especificação da Arquitetura............................................................................................................... 53 5.4.2 Benchmarks ......................................................................................................................................... 54 5.4.3 Extração dos Parâmetros de Desempenho .......................................................................................... 55 5.4.4 Extração dos Parâmetros do Modelo de Energia ................................................................................ 57 5.4.5 Mecanismo de Cálculo de Energia e Ciclos Total ................................................................................. 60
5.5 MECANISMO DE EXPLORAÇÃO .............................................................................................................................. 61 5.6 INTEGRAÇÃO DE FERRAMENTAS ............................................................................................................................ 62 5.7 SIMULAÇÃO DOS ALGORITMOS DE OTIMIZAÇÃO....................................................................................................... 64
6 EVOLUÇÃO DIFERENCIAL APLICADA AO PROBLEMA DE EXPLORAÇÃO ........................................................ 67
6.1 INTRODUÇÃO .................................................................................................................................................... 68 6.2 MAPEAMENTO DAS SOLUÇÕES ............................................................................................................................. 68 6.3 MAPEAMENTO DO ESPAÇO DE EXPLORAÇÃO ........................................................................................................... 69 6.4 EVOLUÇÃO DIFERENCIAL APLICADA A EXPLORAÇÃO DE ARQUITETURAS ........................................................................ 70 6.5 EXEMPLO DE EXECUÇÃO DO MECANISMO DE OTIMIZAÇÃO PROPOSTO ......................................................................... 73
6.5.1 Inicialização ......................................................................................................................................... 73 6.5.2 Seleção de Primeiro Indivíduo ............................................................................................................. 74 6.5.3 Seleção de Pais .................................................................................................................................... 74 6.5.4 Mutação .............................................................................................................................................. 75 6.5.5 Recombinação ..................................................................................................................................... 77 6.5.6 Avaliação ............................................................................................................................................. 77 6.5.7 Seleção de Sobreviventes .................................................................................................................... 79
7 RESULTADOS ............................................................................................................................................... 81
7.1 INTRODUÇÃO .................................................................................................................................................... 82 7.2 AMBIENTE DE SIMULAÇÃO ................................................................................................................................... 82 7.3 ANÁLISE DE ABORDAGEM PROPOSTA ..................................................................................................................... 83
7.3.1 Impacto do Tamanho da População Inicial ......................................................................................... 83 7.3.2 Convergência das Soluções ................................................................................................................. 86 7.3.3 Desempenho da Abordagem Proposta................................................................................................ 87
7.4 COMPARAÇÃO COM OUTROS MECANISMOS DE OTIMIZAÇÃO ..................................................................................... 90
8 CONCLUSÕES E TRABALHOS FUTUROS ........................................................................................................ 94
8.1 CONSIDERAÇÕES FINAIS E CONTRIBUIÇÕES.............................................................................................................. 95 8.2 TRABALHOS FUTUROS ......................................................................................................................................... 96
REFERÊNCIAS BIBLIOGRÁFICAS ............................................................................................................................. 97
xi
Lista de Figuras FIGURA 1. HIERARQUIA DE MEMÓRIA TRADICIONAL .................................................................................................................. 7 FIGURA 2. ESTRUTURAS DE MEMÓRIAS: (A) CACHE; (B) MEMÓRIA PRINCIPAL ................................................................................. 9 FIGURA 3 CACHE COM MAPEAMENTO ASSOCIATIVO COM CONJUNTOS ..................................................................................... 11 FIGURA 4. ARQUITETURA DE UMA CACHE COM MAPEAMENTO ASSOCIATIVO POR CONJUNTO DE K LINHAS .......................................... 12 FIGURA 5. ORGANIZAÇÃO DE MEMÓRIA CACHE COM TRÊS NÍVEIS .............................................................................................. 14 FIGURA 6. CLASSIFICAÇÃO DE PROBLEMAS EM ANÁLISE DE SISTEMAS .......................................................................................... 18 FIGURA 7. DIAGRAMA DE FLUXO DO PRINCÍPIO DE FUNCIONAMENTO DE UM AG .......................................................................... 26 FIGURA 8. OPERADOR DE CROWNDING DISTANCE ................................................................................................................... 32 FIGURA 9. PROCESSO DE ORDENAÇÃO UTILIZADO NO NSGAII .................................................................................................. 32 FIGURA 10. COMPARAÇÃO ENTRE ALGORITMOS: (A) POSSÍVEL CONCLUIR QUAL O MELHOR ALGORITMO E (B) DIFÍCIL DE DECIDIR QUAL O
MELHOR ALGORITMO ............................................................................................................................................... 35 FIGURA 11. INDICADOR DE DISTÂNCIA GENERACIONAL ............................................................................................................ 36 FIGURA 12. INDICADOR HIPERVOLUME ................................................................................................................................ 37 FIGURA 13. INDICADOR DE COBERTURA ............................................................................................................................... 38 FIGURA 14. FLUXO DE DESENVOLVIMENTO DO TRABALHO ....................................................................................................... 45 FIGURA 15. EXEMPLO DE SISTEMA BASEADO EM PROCESSOR MIPS COM HIERARQUIA DE MEMÓRIA ................................................ 46 FIGURA 16. FLUXO DE DESENVOLVIMENTO DA EXPANSÃO DO SIM-CACHE .................................................................................... 51 FIGURA 17. FLUXO PARA EXTRAÇÃO DOS PARÂMETROS DE DESEMPENHO DE UMA ARQUITETURA ..................................................... 55 FIGURA 18. FLUXO PARA EXTRAÇÃO DOS PARÂMETROS DE ENERGIA ........................................................................................... 58 FIGURA 19. PROCESSO DO MECANISMO DE CÁLCULO DE ENERGIA E CICLOS TOTAL......................................................................... 60 FIGURA 20. FLUXO DO MECANISMO DE EXPLORAÇÃO .............................................................................................................. 61 FIGURA 21. ESTRUTURA DO CAETO .................................................................................................................................... 62 FIGURA 22. PROCESSO DE SIMULAÇÃO EXAUSTIVA .................................................................................................................. 64 FIGURA 23. PROCESSO DE SIMULAÇÃO DO ALGORITMO DE OTIMIZAÇÃO PROPOSTO ...................................................................... 65 FIGURA 24. REPRESENTAÇÃO DE UM INDIVÍDUO .................................................................................................................... 68 FIGURA 25. ETAPAS DE UM CICLO DO MECANISMO DE OTIMIZAÇÃO PROPOSTO ............................................................................ 73 FIGURA 26. POPULAÇÃO INICIAL ......................................................................................................................................... 74 FIGURA 27. INDIVÍDUO SELECIONADO .................................................................................................................................. 74 FIGURA 28. ESPAÇO OBJETIVO DA POPULAÇÃO INICIAL ............................................................................................................ 75 FIGURA 29. VETOR DIFERENCIAL ......................................................................................................................................... 76 FIGURA 30. VETOR MUTADO .............................................................................................................................................. 76 FIGURA 31. INDIVÍDUO RESULTANTE DA MUTAÇÃO ................................................................................................................. 76 FIGURA 32. INDIVÍDUO GERADO PELA RECOMBINAÇÃO ............................................................................................................ 77 FIGURA 33. COMPARAÇÃO DA SOLUÇÃO GERADA COM OUTROS INDIVÍDUOS ............................................................................... 78 FIGURA 34. ORDENAÇÃO DOS INDIVÍDUOS BASEADO NOS VALORES DOS OBJETIVOS....................................................................... 79 FIGURA 35. VALOR DE CROWDING DISTANCE PARA CADA OBJETIVO ............................................................................................ 80 FIGURA 36. FRONT ORDENADO POR VALOR DE CROWDING DISTANCE ......................................................................................... 80 FIGURA 37. NÚMERO DE SIMULAÇÕES X GERAÇÕES, CONSIDERANDO DIFERENTES POPULAÇÕES INICIAIS (10, 20, 30, 40, 50 INDIVÍDUOS)
E APLICAÇÃO H263ENC ............................................................................................................................................ 83 FIGURA 38. EVOLUÇÃO DO MENOR VALOR DA ENERGIA CONSUMIDA POR UMA POPULAÇÃO EM RELAÇÃO AO NÚMERO DA GERAÇÃO PARA A
APLICAÇÃO H263ENC .............................................................................................................................................. 84 FIGURA 39. EVOLUÇÃO DO MENOR VALOR TOTAL DE CICLOS DE UMA POPULAÇÃO EM RELAÇÃO AO NÚMERO DA GERAÇÃO PARA A
APLICAÇÃO H263ENC .............................................................................................................................................. 85 FIGURA 40. EVOLUÇÃO DO PARETO EM FUNÇÃO DO NÚMERO DE GERAÇÕES PARA A APLICAÇÃO H263ENC E POPULAÇÃO INICIAL DE 20
INDIVÍDUOS ........................................................................................................................................................... 86 FIGURA 41. EDDE X SIMULAÇÃO EXAUSTIVA PARA AS APLICAÇÕES DOS BENCHMARKS MEDIABENCHII E MIBENCH. (A) BITCOUNT. (B)
CRC. (C) DIJKSTRA. (D) DJPEG. (E) H263ENC. (F) MPEG2DEC. (G) MPEG2ENC. (H) SHA. (I) SUSAN. ................................ 88 FIGURA 42. NÚMERO DE SIMULAÇÕES NECESSÁRIAS PARA CADA TÉCNICA, PARA CADA APLICAÇÃO ................................................... 91
xii
Lista de Tabelas TABELA 1. PARÂMETROS DA ARQUITETURA DE CONTROLE DE UMA CACHE ................................................................................... 12 TABELA 2. COMPARAÇÃO DAS TÉCNICAS DE OTIMIZAÇÃO ESTUDADAS. ........................................................................................ 43 TABELA 3. TEMPO DE ACERTOS DE CADA NÍVEL DE CACHE ......................................................................................................... 47 TABELA 4. VALORES DE PENALIDADE POR ACESSO A MEMÓRIA PRINCIPAL .................................................................................... 48 TABELA 5. ESPAÇO DE EXPLORAÇÃO DOS PARÂMETROS DA HIERARQUIA DE MEMÓRIA CACHE .......................................................... 53 TABELA 6. APLICAÇÕES SELECIONADAS DO MEDIABENCHII ...................................................................................................... 54 TABELA 7. APLICAÇÕES SELECIONADAS DO MIBENCH .............................................................................................................. 55 TABELA 8. PARÂMETROS DE CONFIGURAÇÃO DE UMA CACHE .................................................................................................... 56 TABELA 9. PARÂMETROS DE ESPECIFICAÇÃO DA MEMÓRIA PRINCIPAL ......................................................................................... 59 TABELA 10. AVALIAÇÃO DA POPULAÇÃO INICIAL ..................................................................................................................... 74 TABELA 11. VALORES DE ENERGIA E CICLOS PARA O INDIVÍDUO GERADO E O INDIVÍDUO ALVO.......................................................... 78 TABELA 12. TEMPO DE EXPLORAÇÃO EXAUSTIVA X TEMPO DE EXPLORAÇÃO OTIMIZADA ................................................................. 89 TABELA 13. RESULTADOS DA MÉTRICA DE HIPERVOLUME ......................................................................................................... 92 TABELA 14. RESULTADOS DA MÉTRICA DE DISTÂNCIA GENERACIONAL ......................................................................................... 93
1
Capítulo
1 1 Introdução
Este capítulo tem como objetivo apresentar as principais motivações para realização
deste trabalho, assim como a contextualização do problema atual na exploração de
configurações de arquiteturas de memórias caches em até três níveis de hierarquia visando à
redução de energia e o aumento do desempenho de sistemas embarcados. Em seguida são
apresentados os objetivos gerais e específicos da dissertação. Por fim, será apresentada a
estrutura geral do documento.
2
1.1 Motivação e Contexto
Sistemas operacionais complexos, jogos 3D, gravadores e reprodutores de vídeo em
alta definição são exemplos de sistemas que exigem alto poder de processamento e que estão
cada vez mais presentes no mercado de sistemas embarcados, principalmente através de
smartphones e tablets. Aumentar a capacidade de processamento, no entanto, significa
diminuir a vida útil da bateria e aumentar os custos de refrigeração. Logo, encontrar o
equilíbrio entre consumo de energia e desempenho tem sido o principal problema em projetos
de sistemas embarcados [1]. Portanto, ferramentas e técnicas que visam otimizar o consumo
de energia e o desempenho tendem a ser cada vez mais visadas pelos projetistas de hardware
que lidam com este tipo de sistemas.
Estudos têm mostrado que a memória cache é responsável pelo consumo de até
metade da energia total utilizada por um processador [2], o que a torna ela a principal
contribuinte da energia consumida pelo sistema. Logo, a memória cache tem sido o principal
alvo das técnicas de redução de energia em sistemas embarcados. A escolha da hierarquia de
memória cache é, portanto, o principal exemplo da busca para encontrar o equilíbrio entre
consumo de energia e desempenho. Memórias caches grandes tendem a reduzir o tempo para
o tráfego de informações entre a memória principal e o processador, o que proporciona um
aumento no desempenho do sistema. Por outro lado, como a tecnologia de memória cache usa
muitos transistores para armazenar a informação, utilizar caches grandes implica em dissipar
bastante energia.
Neste trabalho, será apresentado um novo mecanismo de exploração de configurações
de memória cache em hierarquias com até três níveis, assim como uma nova abordagem para
explorar estas hierarquias baseada em um algoritmo evolucionário multiobjetivo chamado
Evolução Diferencial, visando reduzir o consumo de energia e aumentar o desempenho de
sistemas embarcados. Para este trabalho, serão consideradas configurações de hierarquias de
memória cache com três níveis, sendo o primeiro nível com a cache de dados e instruções
separadas e o segundo e terceiro nível com caches unificadas.
3
1.2 Objetivo Geral
O objetivo principal deste trabalho é apresentar uma metodologia denominada EDDM
para estimar o desempenho e a energia total consumida de configurações de memórias caches
considerando hierarquias com os três níveis baseada em evolução diferencial. Neste trabalho,
esta metodologia será aplicada em problemas de exploração de configurações de memórias
caches visando otimizar a relação entre energia consumida e desempenho em aplicações
específicas de sistemas embarcados.
1.3 Objetivos Específicos
Para alcançar o objetivo principal deste trabalho, será necessário realizar os seguintes
objetivos específicos:
1. Estudar ferramentas que possibilitem estimar o consumo de energia de
memórias cache com tecnologia presente no estado da arte da fabricação
deste tipo de componente;
2. Propor metodologia para calcular a energia total consumida e o desempenho
de configurações de hierarquias de memória com três níveis de cache, sendo o
primeiro nível com caches separadas para dados e instruções, e o segundo e o
terceiro nível com caches unificadas;
3. Estudar algoritmos de otimização multiobjetivo e métricas comparativas destes
algoritmos;
4. Adaptar os algoritmos de otimização estudados ao problema de exploração de
configurações de memória cache com três níveis de hierarquia;
5. Estudar benchmarks que reúnam aplicações simples e complexas utilizadas em
sistemas embarcados;
6. Estudar configurações de memórias caches com três níveis disponíveis no
mercado para definir o tamanho do espaço de exploração que será considerado
neste trabalho;
4
7. Realizar simulações das diferentes técnicas de otimização para as aplicações e
espaço de exploração definidos;
8. Fazer análise comparativa dos resultados das simulações.
1.4 Estrutura da Dissertação
Esta dissertação encontra-se estruturada da seguinte forma: no capítulo 2 são
apresentados os conceitos relacionados com hierarquias de memória, descrevendo seus
componentes e apresentando as ferramentas de simulação utilizadas para simular o
comportamento da hierarquia. No capítulo 3 são apresentados os conceitos relacionados a
problemas multiobjetivo, descrevendo também os algoritmos mais utilizados para resolver este
tipo de problema. No capítulo 4 é feito o estudo do estado da arte associado ao problema de
exploração de arquiteturas de sistemas visando redução de energia e desempenho. No capítulo
5 é apresentada a metodologia de desenvolvimento deste trabalho. Cada etapa da metodologia
é detalhada em uma subseção deste capítulo. No capítulo 6, um algoritmo de otimização
baseado em evolução diferencial é apresentado e mapeado no problema de exploração de
configurações de hierarquias de memória com três níveis de cache. No capítulo 7 são
apresentados os resultados das simulações do algoritmo de otimização proposto, assim como é
feita uma comparação dele com outros algoritmos já aplicados para este mesmo problema de
exploração de arquiteturas em outros trabalhos. No capítulo 8 são apresentadas as conclusões
e trabalhos futuros. E finalmente, há uma lista dos trabalhos que serviram de base para o
desenvolvimento desta dissertação.
5
Capítulo
2
2 Hierarquia de Memória
Este capítulo apresenta uma visão geral sobre a importância de hierarquias de
memórias e caches em sistemas computacionais, assim como relata a fundamentação teórica
relacionada a este tipo de memória.
6
2.1 Introdução
A velocidade de processamento de um sistema computacional não depende
inteiramente da velocidade do processador. Não adianta ter um processador rápido se ele não
receber as informações no mesmo ritmo do seu processamento. O componente do sistema que
é responsável tanto por fornecer estas informações ao processador, quanto por armazenar o
resultado do processamento é chamado de memória. A velocidade de um sistema, portanto, é
definida pelo conjunto composto por processador e memórias. Entretanto, a velocidade de
acesso de uma memória não é o único fator importante para o cálculo da velocidade do
sistema. É preciso, também, levar em consideração a capacidade de armazenamento desta
memória. No entanto, devido a limitações da tecnologia utilizada na fabricação de memórias,
aumentar o seu tamanho significa aumentar o seu tempo de acesso. A solução encontrada para
minimizar o impacto deste problema de objetivos conflitantes foi a criação da hierarquia de
memória.
Estruturar as informações do sistema em uma hierarquia de memória permite a
exploração do princípio da localidade, que ajuda a aumentar a velocidade com que as
informações chegam ao processador. Este princípio da localidade se subdivide em dois tipos:
localidade espacial e localidade temporal. O princípio da localidade espacial explora a ideia de
que os dados armazenados próximos ao dado que está sendo utilizado pelo processador têm
uma probabilidade maior de serem acessados em um futuro próximo. O outro princípio, da
localidade temporal, explora a ideia de que um dado utilizado recentemente pelo processador
tende a ser utilizado novamente dentro de um espaço de tempo curto. A hierarquia de
memória explora ambos os princípios alocando os dados que são mais acessados em memórias
mais rápidas e mais próximas ao processador, o que possibilita criar a ilusão de que o
processador pode acessar um grande espaço de armazenamento com uma velocidade de
acesso elevada. A Figura 1 ilustra uma hierarquia de memória tradicional composta por
registradores, três níveis de memória cache, memória principal, disco de estado sólido e disco
de estado magnético. Níveis mais altos na hierarquia de memória possuem maior velocidade de
acesso aos dados armazenados, maior custo por bit e menor capacidade de armazenamento.
Os níveis mais altos, portanto, possuem apenas as cópias das informações dos níveis mais
baixos que têm uma maior probabilidade de serem requisitadas pelo processador.
7
Figura 1. Hierarquia de memória tradicional
Como as memórias dos níveis mais altos não podem armazenar todos os dados
requisitados pelo processador, elas precisam estabelecer uma troca intensa de informações
com os níveis mais baixos da hierarquia de memória. No momento que um bloco de dados é
solicitado para um nível mais baixo da hierarquia e este nível já tiver o bloco disponível, então é
dito que ocorreu um acerto (hit). Entretanto, caso o bloco de dados não seja encontrado no
nível procurado, é dito que houve uma falta (miss). Uma forma de medir o desempenho de
diferentes hierarquias de memória é analisando a taxa de faltas (miss rate). Esta taxa é a fração
de acessos à memória que resultaram em uma falta, ou seja, é número de faltas dividido pelo
número total de acessos. Outra forma de medir o desempenho é analisando a taxa de acerto
(hit rate), que pode ser calculada pelo número de acertos dividido pelo número total de
acessos. Na medida em que a capacidade de armazenamento da memória aumenta, a taxa de
acertos também aumenta. Portanto, os níveis mais altos na hierarquia possuem uma taxa de
acerto menor, pois têm uma capacidade de armazenamento menor. Então, tanto o número de
níveis da hierarquia de memória, quanto a configuração de cada nível influenciam diretamente
no desempenho de um sistema. Identificar qual a configuração ideal para o sistema exige
bastante esforço, devido ao grande número de configurações que podem existir. Para este
trabalho serão analisadas configurações de hierarquias de memória com três níveis cache. Nas
seções a seguir será apresentada uma revisão sobre os conceitos relacionados a memória
cache.
Registrador
Cache L1
Cache L2
Cache L3
Memória Principal
Disco de Estado Sólido
Disco Magnético
8
2.2 Memória Cache
Cache é o nome dado para os níveis da hierarquia de memória que estão logo abaixo
dos registradores do processador. O objetivo da utilização deste tipo de memória é explorar o
princípio da localidade da hierarquia de memória. Para tanto, no caso da ocorrência de uma
falta gerada por uma requisição do processador, a memória cache requisita ao nível superior
não apenas a palavra referente à falta, mas um conjunto de dados com tamanho fixo, chamado
de bloco ou linha, que encapsula esta palavra. Portanto, para determinar o tempo de uma falta
em uma memória cache, é preciso saber qual a sua latência e sua largura de banda. A latência
determina o tempo para receber a primeira palavra do bloco, que normalmente é a palavra
requerida pelo processador, já a largura de banda determina o tempo de recepção do restante
do bloco. Então, para avaliar o desempenho da memória cache é fundamental conhecer a sua
estrutura e seus elementos de projetos, pois eles determinarão qual sua latência e sua largura
de banda e consequentemente, definirão como hierarquia de memória do sistema é capaz de
explorar os princípios da localidade espacial e temporal.
2.3 Estrutura de uma Cache
A memória cache armazena os dados da memória principal que são utilizados com
mais frequência, dessa forma ela permite aumentar o desempenho reduzindo o tempo de
acesso aos dados. A estrutura da memória cache, portanto, está diretamente relacionada com
a estrutura da memória principal. A Figura 2 apresenta as estruturas destes dois tipos de
memória. A memória principal é composta de até 2n palavras endereçáveis, onde cada palavra
tem um endereço único composto por n bits. Para fazer o mapeamento entre as memórias, a
memória principal pode ser dividida em blocos de tamanho fixo compostos por K palavras.
Logo, a memória principal possui blocos. A estrutura da memória cache, por sua
vez, é formada por m blocos chamados de linhas. Diferente do bloco da memória principal,
cada linha da cache é composta por K palavras com dados, mais alguns bits para rotular a linha,
um bit para controle e um bit para indicar quando a linha sofreu algum tipo de modificação
desde que foi carregada na cache. No entanto, o tamanho da linha de uma cache não inclui os
bits de rótulo nem de controle.
9
Figura 2. Estruturas de memórias: (a) cache; (b) memória principal
Quando uma palavra de um bloco da memória principal é lida, o bloco acessado é
transferido para uma das linhas da memória cache. Como existem muito mais blocos do que
linhas de cache, uma linha não pode ficar unicamente dedicada para um bloco em particular.
Então cada linha inclui um rótulo para identificar que bloco em particular está sendo
armazenado. O valor deste rótulo é calculado a partir de um endereço da memória principal.
O fluxo de leitura de uma palavra é inicializado através de uma requisição do
processador, que gera um endereço de leitura da palavra. Este endereço é, então, comparado
com os rótulos da cache. Se ocorrer um acerto, ou seja, o endereço foi encontrado em um dos
rótulos da cache, a palavra é apanhada e enviada para o processador. Caso ocorra uma falta, o
bloco que contém a palavra é carregado na cache e a palavra é enviada para o processador. Em
algumas arquiteturas estas duas operações podem ocorrer em paralelo para aumentar o
desempenho.
Blocos Rótulo Nº da Linha
0
1
2
𝑪 − 𝟏
Tamanho do bloco (K Palavras)
Bits de controle
Endereço de memória
Bloco (K palavras)
Bloco
𝟐𝒏 − 𝟏
0
1
2
3
(a) Estrutura da memória cache
(b) Estrutura da memória principal
10
2.4 Elementos de Projeto da Cache
Esta seção apresenta um resumo dos parâmetros de projeto de uma memória cache.
Embora haja um grande número de configurações de memórias cache, existem apenas alguns
elementos básicos de projeto que servem para classificar e diferenciar as arquiteturas de cache
quanto ao desempenho e consumo de energia. Para este trabalho, portanto, os principais
elementos de projeto de uma cache são: tamanho da linha, tamanho da cache, associatividade
e número de memórias cache.
2.4.1 Tamanho da Linha
O tamanho da linha de uma cache é considerado um dos principais parâmetros que
influenciam o desempenho e a energia consumida de uma cache, pois ele está diretamente
relacionado com a capacidade de exploração do princípio da localidade espacial. Quando um
programa que está sendo executado tem muita localidade espacial, então uma cache com linha
grande conseguiria diminuir a taxa de faltas. Entretanto, se o programa não possuir esta
característica, um tamanho de linha grande obriga a cache a buscar muitos dados que não são
necessários para preencher toda a linha. O resultado de se trabalhar com linhas grandes,
portanto, pode não só aumentar o tempo para carregar os blocos da memória principal, mas
também pode substituir dados mais importantes para execução da aplicação, o que aumentaria
o número de acessos à memória principal.
2.4.2 Tamanho da Cache
A decisão do tamanho da cache envolve três principais variáveis: custo, desempenho e
energia dissipada. Existem diversas razões para querer minimizar o tamanho da cache. As
caches grandes possuem um número grande de portas envolvidas no endereçamento da cache.
Portanto, caches grandes tendem a ser um pouco mais lentas do que as pequenas, assim como
têm um custo por bit maior e dissipam mais energia devido a esta lógica excessiva
implementada em hardware, ainda que sejam produzidas com a mesma tecnologia. No
entanto, assim como o tamanho da linha, o tamanho da cache é muito sensível ao tipo de
aplicação que será executada pelo sistema. Caches maiores tendem a explorar mais o principio
da localidade, o que pode aumentar o desempenho do sistema.
11
2.4.3 Associatividade
Como a memória cache possui um número de linhas bem inferior ao número de blocos
da memória principal, um algoritmo é necessário para fazer o mapeamento destes blocos nas
linhas da cache. A principal técnica para resolver este problema é fazer um mapeamento
associativo por conjunto. Neste método a cache é dividida em conjuntos, onde cada conjunto é
composto por linhas, conforme as equações a seguir:
onde representa número de linhas total da cache, é o número de conjuntos, é número
de linhas por conjunto, é o número de conjuntos da cache e representa o número de blocos
da memória principal. Então, de forma genérica, diz-se que é um mapeamento associativo por
conjunto de linhas. Através deste mapeamento associativo por conjunto um bloco pode
ser mapeado em qualquer uma das linhas do conjunto . A Figura 4 ilustra este mapeamento
para os primeiros blocos da memória principal, onde no mapeamento associativo, cada
palavra é mapeada em múltiplas linhas de cache. No entanto, para o mapeamento associativo
por conjunto, cada palavra é mapeada em todas as linhas de um conjunto específico. Portanto,
um bloco seria mapeado no conjunto 0. Então, no mapeamento associativo por conjunto
uma cache pode ser fisicamente projetada como caches associativas.
Figura 3 Cache com mapeamento associativo com conjuntos
k linh
as
𝑳𝟎
𝑳𝒌−𝟏
𝑩𝟎
𝑩𝒗−𝟏
Memória cache – Conjunto 0
Memória cache – Conjunto 𝒗 − 𝟏
Primeiro conjunto 𝒗 de blocos da memória principal (igual ao
número de conjuntos)
12
Para o mapeamento associativo por conjunto, o controle lógico da cache interpreta o
endereço da memória como sendo três campos: rótulo, conjunto e palavra. O conjunto de
bits especifica um dos conjuntos. Os bits do rótulo e conjunto especificam um dos
blocos da memória principal. A Figura 4 ilustra a lógica de controle de uma cache deste tipo. Em
um mapeamento completamente associativo, o rótulo no endereço de memória é um pouco
grande e precisa ser comparado com o rótulo de cada linha da cache. Já em um mapeamento
associativo por conjuntos de linhas, o rótulo no endereço de memória é bem menor e precisa
ser comparado com apenas os rótulos de um único conjunto.
Figura 4. Arquitetura de uma cache com mapeamento associativo por conjunto de k linhas
Na Tabela 1 são apresentados resumidamente os parâmetros de controle envolvidos.
Alguns deles relacionados com a variável p que representa o tamanho de uma palavra.
Tabela 1. Parâmetros da arquitetura de controle de uma cache Tamanho do endereço ( ) Número de blocos Linhas da cache
Unidades endereçáveis Linhas por conjunto Tamanho da cache
Tamanho do bloco Número de conjuntos Tamanho do rótulo ( − )
𝑭𝟎
𝑭𝟏
𝑭𝒌−𝟏
𝑭𝒌
𝑭𝒌 𝒊
𝑭𝟐𝒌−𝟏
𝑩𝟎
𝑩𝟏
𝑩𝒋
Co
nju
nto
0 C
on
jun
to 1
Dados Rótulo
Comparador
Rótulo Conjunto Palavra
Endereço de memória
(acerto)
(falta)
Cache Memória
Principal
𝒔 𝒑
𝒔 𝒑 𝒔− 𝒅
𝒔− 𝒅 𝒅 𝒑
13
Então, o parâmetro de projeto da memória cache chamado de associatividade se refere
ao número de linhas por conjunto de memória cache ( ). A variação deste parâmetro tem
grande impacto no desempenho da cache, pois ele influencia diretamente na taxa de acerto,
apesar de gerar atrasos devido ao uso de multiplexadores e só fornecer o dado após a decisão
de acerto/falta, assim como ter de aguardar a seleção do conjunto.
2.4.4 Número de memórias cache
Normalmente, a camada de cache da hierarquia de memória de um computador está
dividida em vários níveis. O primeiro nível está mais próximo ao processador e é chamada de
L1. Ele está localizado no mesmo chip que o processador, o que permite garantir o máximo de
desempenho na busca por instruções e dados. O segundo e terceiro nível são chamados de L2 e
L3, respectivamente. Estes níveis superiores têm uma capacidade de armazenamento maior e,
portanto, um tempo de acesso maior.
Além de quebrar a camada de cache da hierarquia de memória em vários níveis de
cache, é possível que cada um destes níveis seja dividido em cache de dados e cache de
instruções. A maioria dos sistemas embarcados comerciais tem o primeiro nível de memória
cache baseado na arquitetura de Harvard [37]. Esta arquitetura propõe que as memórias de
instruções e dados sejam separadas e possuam barramentos independentes para se comunicar
com o processador, o que permite um acesso simultâneo aos dois tipos de memória. No
entanto, a grande vantagem desta arquitetura está relacionada a capacidade de se permitir ler
novas instruções ao mesmo tempo em que se está executando uma outra. Isto permite ao
processador ficar executando instruções o tempo todo, acarretando em um aumento
significativo de velocidade no processamento. Esse processo é chamado de pipelining. Além
disto, esta arquitetura é conhecida por ter um repertório de instruções reduzido (RISC), o que
permite ao processador executá-las em um único ciclo de relógio. Então, dividir a camada de
cache em vários níveis permite aumentar a largura de banda do processador, utilizando uma
estrutura mais complexa no primeiro nível e simplificar o projeto dos níveis inferiores para
obter um melhor custo-benefício. A Figura 5 apresenta uma hierarquia de memória típica de
sistemas comerciais. O nível L1 foi subdivido em cache de instruções (IC1) e cache de dados
(DC1), os demais níveis apresentam caches unificadas.
14
Figura 5. Organização de memória cache com três níveis
2.5 SimpleScalar
O SimpleScalar [1] é um conjunto de ferramentas de código aberto que fornece a
infraestrutura necessária para simular arquiteturas de diversos tipos de processadores. Dessa
forma, é possível reproduzir o comportamento de aplicações em dispositivos ainda em tempo
de projeto do hardware. Para tanto, o SimpleScalar possui um conjunto de oito simuladores
que permitem fazer uma análise de desempenho de aplicações, modelar detalhadamente a
arquitetura do sistema e fazer co-verificação de hardware-software. São eles: sim-fast, sim-
safe, sim-profile, sim-cache, sim-cheetah, sim-eio, sim-bpred e o sim-outorder.
O mais rápido e menos detalhado simulador é o sim-fast. Ele não leva em consideração
o tempo, pois trabalha apenas com a simulação funcional. Dessa forma, este simulador executa
cada instrução serialmente, sem trabalhar com cache, nem com checagem de instruções. Outro
simulador que derivou do sim-fast, e que também realiza simulação funcional é o sim-safe. Este
último, no entanto, se diferencia por fazer uma verificação da permissão de acesso para cada
referência de memória. Associados a estes dois simuladores, pode ser utilizado o sim-profile,
que gera o perfil detalhado da simulação funcional. Já o sim-outorder é o mais complexo e
detalhado simulador. Ao contrário do sim-fast e do sim-safe, o sim-outorder é capaz de simular
o despacho e a execução de instruções fora de ordem, o que torna o tempo a variável mais
importante da simulação.
O SimpleScalar disponibiliza dois simuladores funcionais de cache: sim-cache e sim-
chetaah. Estes simuladores são ideais para a realização de uma simulação rápida de caches, se
os efeitos do desempenho da cache em tempo de execução não são necessários. O sim-chetaah
é capaz de gerar resultados para várias configurações de cache em uma única execução da
simulação. Ele também é capaz de simular diferentes tipos de associatividade de cache, bem
IC1
DC1 L3 L2 MEM CPU
15
como políticas de substituição. Para executar a simulação em apenas uma execução, o sim-
chetaah utiliza uma abordagem chamada Simple-Pass Simulation [2]. Este método baseia-se em
traces para realizar a simulação, o que pode exigir uma grande quantidade de memória quando
são simuladas aplicações mais complexas. Traces de acesso à memória para caches de apenas
um nível são fáceis de serem obtidos, mas quando a hierarquia de memória aumenta, torna-se
mais complicado o gerenciamento deste método.
O sim-cache é o outro simulador fornecido para análise de cache. Neste simulador o
tamanho da cache, o tamanho da linha, a associatividade, a política de substituição, o número
de caches e o tipo de caches são passados como parâmetro de entrada para simulação. O
número de caches, no entanto, está limitado a dois níveis, sendo eles unificados ou separados
para instruções e dados. Além destes parâmetros, é preciso definir qual será a aplicação
executada. Uma vez configurado o simulador, é possível obter um arquivo de resultado com as
informações sobre acertos e faltas de cada nível da hierarquia de memória. Então, a partir
destas informações, é possível calcular o desempenho da arquitetura através do número total
de ciclos necessários para executar a aplicação simulada.
2.6 CACTI
O CACTI é uma ferramenta para modelar memórias caches. Ela é capaz de modelar
características de uma cache, como o tempo de acesso, o ciclo, a área, a energia estática e
dinâmica. Integrando todos estes parâmetros, o usuário consegue fazer uma análise precisa
sobre o tempo, potência e área de diferentes arquiteturas de memórias cache, o que ajuda na
escolha da configuração de memória mais adequada de um sistema.
O modelo proposto pela ferramenta CACTI pode ser configurado através de um arquivo
com uma série de parâmetros de uma memória cache. Dentre eles estão o tamanho da
memória, o tamanho da linha, a associatividade, a tecnologia de transistor e o nível em que a
cache simulada se encontra. A versão 6.5 do CACTI [3] permite realizar a simulação de
memórias com tecnologia de fabricação de até 32nm, além de permitir modelar até o terceiro
nível de cache. Uma vez feita a modelagem da cache e a simulação, um arquivo de saída é
gerado contendo informações sobre a energia dinâmica por acesso e a energia estática
consumida pela arquitetura. Estas informações, então, podem ser utilizadas como base para o
cálculo do consumo total de energia de uma hierarquia de memória.
16
2.7 Simulador de Memória Micron
A Micron Technology desenvolveu uma serie de simuladores de memória capazes de
estimar a potência de determinados tipos de memórias DDR [16]. Um destes simuladores é o
DDR3L Power Calc, capaz de estimar a potência media consumida por memórias DDR3L. Este
tipo de memória tem sido utilizado em sistemas embarcados pelas suas características de alto
desempenho e baixo consumo de energia. O simulador de potência Power Calc da Micron foi
elaborado baseado em quatro planilhas do Microsoft Excel. A primeira planilha (DDR3 Config)
corresponde à especificação da memória que se deseja simular. A segunda (System Config)
permite que o usuário faça a configuração do sistema no qual a memória será inserida. Nesta
configuração o usuário colocará as informações sobre a utilização da memória, inserindo o
percentual de leituras e escritas, a tensão de entrada e a frequência de operação da memória.
A terceira planilha (Power Calcs) contém todas as fórmulas necessárias para estimar as diversas
potências consumidas pela memória. São levadas em consideração as potências consumidas
por leituras e escritas, assim como as potências associadas ao modo de espera, no qual a
memória não está sendo utilizada, mas ainda continua consumindo energia para manter as
informações. A última planilha (Summary) apresenta o resumo e os gráficos relacionados ao
consumo de energia da memória.
17
Capítulo
3
3 Problemas de Otimização Multi-
Objetivo
Neste capítulo serão apresentados os conceitos básicos relacionados a problemas de
otimização multi-objetivos. Depois, será feito um estudo sobre algoritmos evolucionários
aplicados a este tipo de problemas. Em seguida, serão descritas algumas técnicas de otimização
utilizadas para tentar solucionar estes problemas. Por fim, serão apresentados alguns
indicadores que medem o desempenho destas técnicas para um determinado problema de
otimização.
18
3.1 Conceitos Básicos
3.1.1 Classes de Problemas
Na perspectiva de análise de sistemas, automatizar a solução de um problema envolve
três componentes básicas: entradas, saídas e a modelagem interna que conecta estes dois.
Conhecer o modelo significa conhecer como o sistema funciona. Neste caso é possível
computar qualquer resposta do sistema (saídas) para um valor de entrada. Baseado nisto, é
possível distinguir três tipos de problemas, dependendo de qual das três componentes do
sistema é desconhecida. Em um problema de otimização, representado na Figura 6 (a), o
modelo do problema já é conhecido, junto com as saídas que são desejadas, ou apenas uma
descrição do que se deseja destas saídas (Ex.: minimização ou maximização). O problema,
então, se resume a encontrar as entradas que fornecem estas saídas. Em um problema de
modelagem, representado na Figura 6 (b), o conjunto de entradas e saídas já é conhecido.
Então, deseja-se encontrar um modelo que consiga mapear as saídas em cada uma das
entradas conhecidas. Em um problema de simulação, representado na Figura 6 (c), o modelo do
sistema já é conhecido, bem como algumas entradas. Neste caso, é preciso aplicar estas
entradas no modelo para encontrar as saídas.
Figura 6. Classificação de problemas em análise de sistemas
Neste trabalho, serão exercitados os três tipos de problemas. Primeiramente será feita a
modelagem do sistema, seguida de simulações e então otimizações. No entanto, para um
melhor entendimento dos problemas de otimização, será preciso detalhar mais a sua
composição, bem como entender seus diferentes tipos.
Conhecido Entrada Saída
Modelo
? Especificada
Entrada Saída
Modelo
Conhecida Conhecida ? Conhecido
Entrada Saída
Modelo
? Conhecida
(a) Problema de otimização (b) Problema de modelagem (c) Problema de simulação
19
3.1.2 Problemas de Otimização
Para conseguir formular um problema de otimização é importante conhecer alguns
conceitos relacionados a ele. Os três conceitos principais são: variáveis de decisão, restrições e
função objetivo.
As variáveis de decisão são as quantidades numéricas que representam os valores de
entrada que deverão ser escolhidos em um problema de otimização, ou seja, são as variáveis
que se pode decidir. Estas quantidades pode ser representadas como , onde
definirá o número de dimensões do problema. Então o vetor composto por variáveis de
decisão é representado por:
[
] (1)
Por convenção, o vetor pode ser escrito como:
[ ] ( )
Na maioria dos problemas de otimização, existem sempre restrições impostas por
características particulares do ambiente ou recursos disponíveis relacionados ao problema.
Estas restrições têm que ser satisfeitas para que uma solução seja considera aceitável. Estas
restrições podem ser representadas matematicamente na forma de inequações ou de
equações:
( ) ( ) ( ) ( )
Para determinar o quão boa é uma solução, é necessário ter alguns critérios de
avaliação dela. Estes critérios de avaliação são expressos como funções das variáveis de decisão
e são chamados de funções objetivo. Estas funções podem apresentar conflitos entre elas, e
algumas podem ser minimizadas, enquanto outras podem ser maximizadas. As funções objetivo
podem ser representadas matematicamente como: ( ) ( ) ( ), onde é o número
de funções objetivo. Então, as funções objetivo formam um vetor de funções ( ) que pode
ser representado por:
( ) [ ( ) ( ) ( )] ( )
20
Uma vez definidos os conceitos relacionados à formulação de um problema de
otimização, é possível apresentar os seus diferentes tipos.
3.1.2.1 Problemas de Otimização Mono-objetivo
Em um problema de otimização mono-objetivo, assim como o nome sugere, existe
apenas um único objetivo a ser alcançado, que é a busca por uma solução ótima. Embora o
espaço de busca desta solução possa ter várias soluções ótimas locais, o objetivo é sempre
encontrar a solução ótima global. Em um algoritmo de otimização mono-objetivo, quando uma
nova solução encontrada tem um melhor valor da função objetivo, então a última melhor
solução encontrada pode ser descartada.
Matematicamente, um problema de otimização mono-objetivo, pode ser definido de
forma genérica como a minimização ou maximização de ( ) sujeita às restrições ( )
e ( ) com . A solução, então, minimiza ou maximiza
o valor escalar ( ) onde é um vetor de variáveis de decisão de dimensão , ( ),
de um universo . Este vetor de decisão pode conter variáveis contínuas ou discretas, bem
como pode ser uma função contínua ou discreta.
3.1.2.2 Problemas de Otimização Multiobjetivo
O problema de otimização multiobjetivo pode ser entendido como a extensão de um
problema mono-objetivo, onde não existe apenas uma função objetivo para ser otimizada, mas
várias funções. Então, o problema deixa de ter uma única solução e passa a ter um conjunto de
soluções. Este conjunto de soluções pode ser encontrado através do uso de uma técnica
chamada Pareto Optimality Theory [4]. Mais precisamente, problemas de otimização
multiobjetivo são aqueles onde o objetivo é otimizar funções objetivo simultaneamente. Isto
pode envolver a maximização de todas as funções, a minimização de todas as funções, ou a
combinação de maximização e minimização destas funções.
Um problema de otimização multiobjetivo pode ser definido matematicamente, de
forma genérica, como sendo a minimização ou maximização de ( ) ( ( ) ( ) ( ))
sujeita às restrições ( ) e ( ) com . Uma
solução para o problema corresponde a minimização ou maximização das componentes de um
21
vetor ( ) onde é um vetor de variáveis de decisão de dimensão , ( ), de um
universo .
A formulação e resolução deste tipo de problema de otimização estão diretamente
relacionadas com os objetivos deste trabalho, uma vez que o estudo está fundamentado no
problema de exploração de arquiteturas de memória cache visando otimizar dois objetivos
naturalmente conflitantes, maximizar o desempenho e minimizar o consumo de energia.
3.1.3 Dominância
O conceito de dominância é bastante utilizado em problemas multiobjetivos e serve
para indicar e comparar o grau de qualidade de uma solução em relação à outra. Diz-se que
uma solução domina , se, e somente se, para todos os objetivos envolvidos no domínio da
função forem melhor ou igual aos objetivos de . Então, considerando que possui
objetivos, como um vetor de dimensões. Usando o símbolo para indicar a dominação, a
definição formal de pode ser descrita da seguinte forma:
, e ( )
Para objetivos conflitantes, não existe uma única solução que domina todas as outras.
Uma solução é dita não dominada se ela não for dominada por nenhuma das outras. Todas as
soluções não dominadas possuem um atributo que não pode ser melhorado, com relação a
qualquer uma das funções objetivo, sem que outros atributos sejam afetados.
3.1.4 Pareto
Em problemas de otimização multiobjetivo, como existem várias funções objetivo, a
noção do que é “ótimo” ganha uma conotação um pouco diferente, uma vez que as soluções
que têm destaque neste tipo de problema são as soluções que tem um bom compromisso
entre os objetivos. A noção de “ótimo” mais adotada neste tipo de problema, portanto, foi
originalmente proposta por Francis Ysidro Edgeworth, posteriormente generalizada por
Vilfredo Pareto [5], e finalmente chamada de Pareto Ótimo. Formalmente, uma solução
é chamada de Pareto Ótimo com respeito a , se e somente se não existe uma solução
onde ( ) ( ( ) (
)) domine ( ) ( ( ) ( )). Em outras
palavras, o Pareto Ótimo pode ser definido como sendo o conjunto de soluções não dominadas,
22
levando em consideração todo o espaço de busca. Então, para um problema de otimização
multiobjetivo, ( ) é possível definir o conjunto de Pareto, , da seguinte forma:
( ) ( ) ( )
Este conjunto, quando mapeado no espaço objetivo, forma uma superfície conhecida
como frente de Pareto ( ). Então, é possível definir formalmente a frente de Pareto da
seguinte forma:
( ) ( )
3.2 Algoritmos Evolucionários
Algoritmos evolucionários (AE) imitam os princípios de evolução natural para definir
mecanismos de busca e otimização. Algoritmos Evolucionários diferem dos métodos clássicos
de busca e otimização em vários aspectos. A maioria dos algoritmos clássicos utiliza um
procedimento determinístico para buscar soluções ótimas. Esta abordagem, no entanto, pode
apresentar um serie de dificuldades para encontrar os resultados desejados. Algumas destas
dificuldades são:
A convergência para uma solução ótima depende fortemente da escolha da
solução inicial;
Os algoritmos tendem a ficarem travados em solução ótimas locais;
Os algoritmos não são eficientes em lidar com problemas que possuem um
espaço de busca discreto;
Os algoritmos não são eficientes para serem usados em computadores que
exploram o paralelismo.
A utilização de algoritmos evolucionários, portanto, pode ser uma alternativa para
contornar estas dificuldades encontradas pelos algoritmos clássicos de busca e otimização. Nas
subseções a seguir, serão apresentados alguns conceitos básicos relacionados aos AE, assim
como serão apresentados alguns tipos de AE que serão relevantes para o entendimento deste
trabalho.
23
3.2.1 Componentes de Algoritmos Evolucionários
3.2.1.1 Indivíduo
O indivíduo representa uma solução do problema a ser tratado. Ele consiste no conjunto
de configurações que define uma possibilidade de solução para o problema. Em técnicas
baseadas em algoritmos genéticos, o indivíduo também é chamado de cromossomo. Diz-se que
o cromossomo é constituído de um conjunto de genes, onde cada gene representa um
parâmetro de configuração da solução.
3.2.1.2 Função de Aptidão
O papel da função de aptidão é representar os requisitos necessários para que a
adaptação ocorra. Ela forma a base do processo de seleção de indivíduos. Mais precisamente, é
a função que atribui uma medida de qualidade para um indivíduo.
Frequentemente, o problema a ser resolvido através de um algoritmo evolucionário está
relacionado com otimização. Neste caso, o nome função objetivo é utilizado no contexto do
problema, e a função de aptidão pode ser idêntica ou uma simples transformação de uma
função objetivo.
3.2.1.3 População
O papel da população é representar as possíveis soluções de um problema. Ela é
composta por vários indivíduos. A população forma a unidade de evolução. A capacidade de
mudança e adaptação não está relacionada com indivíduos, ela está relacionada com a
população. Em abordagens baseadas em algoritmos evolucionários, a população de uma
iteração é substituída por novos indivíduos mais interessantes para a solução de um
determinado problema, dando a ideia de que a população evolui com o tempo. A população
normalmente é iniciada de forma aleatória e na maioria dos algoritmos tem tamanho fixo ao
longo das iterações. O tamanho da população pode influenciar o desempenho da técnica,
influenciando na velocidade de convergência e qualidade dos resultados.
24
3.2.1.4 Mecanismo de Seleção de Pais
A seleção de pais tem como objetivo fazer uma distinção entre os indivíduos de uma
população em relação ao valor da sua função de aptidão. Esta seleção permite destacar os
melhores indivíduos que serão utilizados para criação da uma nova população. Um indivíduo é
dito pai se ele foi selecionado para gerar os indivíduos da próxima geração. Juntamente com a
seleção de sobreviventes, a seleção de pais visa punir os indivíduos que têm uma qualidade
menor quando avaliados pela função de aptidão. Como este mecanismo é normalmente
probabilístico, estes indivíduos com menor aptidão ainda podem se tornarem pais, evitando
que o algoritmo fique preso em ótimos locais.
3.2.1.5 Operadores de Variação
O papel dos operadores de variação é criar novos indivíduos a partir dos antigos. Estes
operadores estão divididos em dois tipos: mutação e cruzamento.
O operador de mutação visa garantir a diversidade da população. Seu conceito consiste
em mutar aleatoriamente um indivíduo existente de forma que um novo indivíduo seja criado.
Ao aplicar o operador de mutação em um indivíduo, cada gene (parâmetro da solução) tem
uma probabilidade de ser mutado. Quando um gene é mutado ele pode assumir qualquer valor
dentro do intervalo de possíveis valores daquele parâmetro. A mutação permite criar novas
soluções com parâmetros não existentes na população atual, permitindo que a população saia
de mínimos locais e explore outras regiões.
A recombinação ou cruzamento é o operador que possibilita a criação de novos
indivíduos a partir de outras já existentes. A ideia do operador de cruzamento é criar novos
indivíduos combinando as características dos indivíduos de origem. O tipo de cruzamento pode
variar dependendo da representação do problema, alternando entre número de pontos de
corte e forma como os genes são trocados. Uma das formas mais básicas de cruzamento é o
cruzamento de -pontos, onde representa o número de divisões que o cromossomo terá no
momento do cruzamento. O funcionamento de um cruzamento com corte de dois pontos é
descrito a seguir. Inicialmente são escolhidos dois indivíduos da população para serem os pais.
Após isso, em cada indivíduo escolhido são definidos pontos de corte onde haverá troca de
dados entre as características genéticas dos indivíduos. Uma vez realizada a troca, dois novos
25
indivíduos são gerados carregando informações misturadas de ambos os indivíduos que
iniciaram a operação de cruzamento.
3.2.1.6 Mecanismo de Seleção de Sobreviventes
De forma similar a seleção de pais, a seleção de sobreviventes visa distinguir os
indivíduos baseado em suas qualidades. No entanto, a seleção de sobreviventes é utilizada em
um momento diferente do ciclo evolucionário. O mecanismo de seleção de sobreviventes é
chamado após a criação da prole gerada pelos indivíduos escolhidos pela seleção de pais.
Normalmente, a seleção de sobreviventes é um processo determinístico, onde os indivíduos
são ordenados por aptidão e apenas os melhores indivíduos são selecionados para compor a
próxima geração.
3.2.2 Algoritmos Genéticos
Algoritmos genéticos (AG) são conjuntos de procedimentos utilizados para busca e
otimização que são motivados por princípios da genética e seleção natural. Algumas ideias
fundamentais da genética são utilizadas artificialmente para construir algoritmos de busca
robustos e que requerem o mínimo de informações sobre o problema. O princípio de
funcionamento de um algoritmo genético, ilustrado na Figura 7, é bem diferente da maioria das
técnicas de otimização clássicas. Ao contrário dos métodos de busca e otimização clássicos, o
AG inicia a busca com um conjunto aleatório de soluções, ao invés de apenas uma. Uma vez
que a população inicial é gerada aleatoriamente, cada um dos indivíduos é avaliado
individualmente e sua aptidão é atribuída. Avaliar um indivíduo significa calcular o valor da
função objetivo e as violações de restrições. Entretanto, uma métrica precisa ser definida
baseada na função objetivo e nas violações de restrições para atribuir um valor relativo de
aptidão para o indivíduo. Uma condição de término é, então, verificada. Se a condição não é
satisfeita, a população é modificada por três principais operadores e uma nova população é
criada. O contador de gerações é incrementado para indicar que uma geração (ou iteração), do
AG foi finalizada.
26
Figura 7. Diagrama de fluxo do princípio de funcionamento de um AG
Os três principais operadores utilizados em AG são: reprodução, cruzamento e mutação.
O operador de reprodução, também chamado de operador de seleção, é utilizado para fazer
cópias das soluções boas e eliminar as soluções ruins da população, enquanto mantém o
tamanho da população fixa. Existem várias formas de executar estas tarefas. Os métodos mais
comuns são: seleção por torneio, seleção proporcional e seleção por classificação. O operador
de reprodução, portanto, não tem o objetivo de criar novos indivíduos. Esta tarefa é realizada
pelos operadores de cruzamento e mutação. Assim como o operador de recombinação, existe
várias forma de implementar a operação de cruzamento e mutação em algoritmos genéticos,
no entanto, todas seguem os princípios citados na sessão 3.2.1.5.
3.2.3 Estratégias Evolucionárias
As estratégias evolucionárias (EE) são bastante parecidas com os algoritmos genéticos.
No início, eles se diferenciavam pelo fato de que as estratégias evolucionárias originalmente
não possuíam o operador de recombinação. Estudos recentes, no entanto, introduziram este
tipo de operador nas estratégias evolucionárias, o que dividiu está técnica em dois tipos.
Início
Inicializa a População
gen = 0
Avaliação Atribuição da Aptidão
Cond?
Fim
Reprodução
Cruzamento
Mutação gen = gen + 1
Não
Sim
27
As estratégias evolucionárias sem recombinação são baseadas na criação de uma prole
utilizando um operador de mutação gaussiano. O processo definido pelas estratégias
evolucionárias, aplicado a problemas de busca e otimização, pode ser dividido em cinco etapas.
O detalhamento destas etapas é apresentado no Quadro 1.
Quadro 1. Etapas de uma estratégia evolucionária sem recombinação
Nas estratégias evolucionárias com recombinação, um conjunto de pais selecionados
são primeiramente recombinados para encontrar uma nova solução. Então, o operador de
mutação é aplicado na nova solução, conforme a estratégia anterior. No entanto, ao invés de
escolher dois pais ou todos os pais para a recombinação, um conjunto de pais é escolhido
aleatoriamente, onde é um valor entre 1 e . Portanto, o passo-a-passo desta estratégia é
bastante similar ao da estratégia anterior conforme o processo apresentado no Quadro 2.
Etapa 1: Uma população inicial de soluções ( ) é escolhida, assim como o
fator de mutação .
Etapa 2: São criadas soluções:
( ) ( ) ( ), (9)
onde ( ) é um vetor criado utilizando uma distribuição normal com desvio
padrão de . Para criar o -ésimo elemento da prole, o pai é escolhido
aleatoriamente do conjunto de soluções.
Etapa 3: É criada uma população através da combinação do conjunto de elementos de
pais com o conjunto de elementos da prole.
(⋃ { ( )} )⋃(⋃ { ( )}
) ( )
Etapa 4: As soluções presentes em são ordenadas por valor de aptidão e as melhores
soluções são escolhidas para compor a nova população.
Etapa 5: O critério de parada é verificado e caso ele não seja satisfeito volte para a segunda etapa.
28
Quadro 2. Etapas de uma estratégia evolucionária com recombinação
A etapa 3 poderia sofrer uma mudança fazendo com que apenas os elementos da prole
fossem utilizados para criar a nova população.
3.2.4 Evolução Diferencial
Evolução diferencial é um algoritmo evolucionário relativamente novo, proposto no
meio da década de 90 por Kenneth Price e Rainer Storn [10]. Inicialmente, a heurística foi
desenvolvida para otimização de problemas de domínio contínuo, no entanto, diversos estudos
recentes apresentam a utilização deste algoritmo aplicado em problemas discretos [11][12]. O
funcionamento do algoritmo é baseado principalmente no operador de mutação diferencial.
Ele é capaz de realizar mutações baseadas na distribuição das soluções de uma população
atual. Desta forma, as direções de busca e os possíveis tamanhos dos passos dependem da
localização dos indivíduos selecionados para calcular os valores da mutação.
Etapa 1: Uma população inicial de soluções ( ) é escolhida, assim como o
vetor de fatores de mutação .
Etapa 2: São criadas soluções mutadas, cada uma usando pais selecionados
aleatoriamente, da seguinte forma:
1. A solução é calculada a partir da recombinação dos pais selecionados.
2. O operador de mutação é aplicado na solução gerada pela recombinação:
( ) (11)
Etapa 3: É criada uma população através da combinação do conjunto de elementos de
pais com o conjunto de elementos da prole.
(⋃ { ( )} )⋃(⋃ { ( )}
) ( )
Etapa 4: As soluções presentes em são ordenadas por valor de aptidão e as melhores
soluções são escolhidas para compor a nova população.
Etapa 5: O critério de parada é verificado e caso ele não seja satisfeito volte para a segunda etapa.
29
O algoritmo inicia com a criação de vetores, gerados aleatoriamente. A evolução
diferencial utiliza vetores de parâmetros -dimensionais como
população em cada geração . A geração de novos vetores de parâmetros é realizada através
da diferença ponderada entre dois vetores de parâmetros e um terceiro indivíduo da
população. Esta operação é chamada de mutação. Os vetores de parâmetros mutados são
então combinados com outros vetores pré-determinados, denominados de target vectors, a fim
de gerar os trial vectors. Esta combinação de parâmetros é referida como crossover. Cada vetor
presente na população atual deve ser usado uma vez como trial vector. Caso o trial vector
forneça um valor de aptidão melhor que aquele associado ao respectivo target vector, este
último dará lugar ao primeiro na próxima geração. Esta operação corresponde a etapa de
seleção.
Na etapa de mutação, cada target vector , um novo vetor é gerado
por meio da seguinte relação:
( − ), (13)
Os valores de representam índices mutuamente distintos e
também são diferentes do índice . A constante “ ” é um fator que determina a influência do
conjunto de pares de soluções selecionadas no cálculo do valor da mutação, ou seja, ela
determina o tamanho do passo a ser dado na direção definida pelo vetor − .
Após a mutação, um procedimento similar ao de cruzamento é utilizado com a
finalidade de aumentar a diversidade dos vetores de parâmetros mutados. Para tanto, um
terceiro vetor ( ), trial vector, é gerado a partir do target
vector e do vetor sob análise :
{
(14)
onde , ( ), [ ] e é um índice escolhido
aleatoriamente, o que garante que recebe pelo menos um parâmetro de .
No processo de cruzamento, portanto, a constante “ ” é definida pelo usuário e se
destaca pela capacidade de controlar a influência dos pais, ou do target vector, na geração da
prole (trial vector). Valores altos para esta constante significam menos influência dos pais.
30
Após a etapa de mutação e cruzamento, nas quais todos os vetores serviram como
target vector, a seleção dos vetores que serão preservados para próxima geração é feita usando
um critério de seleção guloso, escolhendo os vetores que parecem ser melhores no momento.
Se ( ) ( ), então (maximização), caso contrário .
Existe um padrão de nomenclatura desenvolvido para referenciar as diferentes
configurações uma evolução diferencial. A notação pode ser generalizada da seguinte forma:
DE/x/y/z. Nela a letra “x” especifica o vetor a ser mutado, “y” determina o número de vetores
diferença utilizados na etapa de mutação e “z” o esquema de crossover adotado. A proposta
clássica é chamada de “DE/rand/1/bin”, onde a palavra “rand” indica que o vetor a ser mutado
será escolhido aleatoriamente, “1” indica que será considerado apenas um vetor diferença na
mutação e, finalmente, “bin” significa que uma recombinação binomial será utilizada. O
algoritmo correspondente a está configuração é apresentado no Quadro 3.
Quadro 3. Algoritmo “DE/rand/1/bin”
3.3 Técnicas de Otimização Multi-Objetivos
Nesta sessão serão apresentadas algumas técnicas de otimização que serão
posteriormente aplicadas ao problema de exploração de arquiteturas de memória visando à
redução de energia e desempenho.
1. begin
2.
3. Cria uma população inicial aleatória
4. Avalia ( )
5. while critério de parada não for satisfeito do
6. for até do
7. ( )
8. ( )
9. end for
10. for até do
11. if ( ) ( ) then
12.
13. else
14.
15. end if
16. end for
17.
18. end while
19. end
31
3.3.1 NSGAII
O algoritmo NSGA, proposto em [6] [7], foi um dos primeiros algoritmos evolucionários
desenvolvidos. Porém, ao longo dos anos foi alvo das seguintes críticas: alta complexidade
computacional do algoritmo de ordenação baseado em não dominância, ausência de elitismo e
necessidade de especificar o parâmetro . Posteriormente, foi proposto o algoritmo
NSGAII (Nondominated Sorting Genetic Algorithm II) [8], que apresentava melhoras em relação
ao anterior, implementando elitismo, reduzindo complexidade computacional e retirando a
necessidade de especificar o parâmetro , que era um parâmetro utilizado para verificar a
diversidade de soluções equivalentes.
O NSGAII baseia-se no conceito de não dominância para selecionar indivíduos, assim
como na métrica crowding distance, que é utilizada para selecionar os melhores indivíduos de
um conjunto de soluções não dominadas. O passo-a-passo para o cálculo do crowding distance
é mostrado no Quadro 4.
Quadro 4. Passo-a-Passo para o cálculo do crownding distance
Conforme mostrado no Quadro 4, inicialmente é feita a ordenação da população em
fronts de não dominância. Para cada front é calculado o valor de crowding distance dos
Passo 1: Classificar a população e identificar os fronts não dominados . Para
cada , repetir os passos 2 e 3.
Passo 2: Para cada função objetivo , ordene as funções em em ordem crescente. Seja
| | e [ ] a representação da -ésima solução na lista ordenada, com respeito
ao objetivo e o valor deste objetivo. Atribua ( [ ]) e ( [ ])
. Para − atribua
( [ ]) ( [ ])− ( [ ])
−
. (15)
Passo 3: Para encontrar o crownding distance total ( ) de uma solução , some os
crownding distances das soluções com respeito a cada objetivo. ( ) ∑ ( )
32
elementos. O cálculo do crowding distance de cada elemento é baseado na distância entre uma
solução e as soluções vizinhas, conforme apresentado na Figura 8.
Figura 8. Operador de crownding distance
A distância entre as soluções vizinhas é calculada para cada um dos objetivos ( e )
da solução . O O cálculo final do crowding distance, de acordo com a Figura 8, é dado pelo
somatório entre ( ) e ( ), conforme a equação presente no Quadro 4.
No NSGAII, o operador de crowding distance é utilizado como critério de desempate no
processo de seleção dos melhores indivíduos. Um esquema do processo de ordenação e
seleção utilizado no NSGAII é mostrado na Figura 9.
Figura 9. Processo de ordenação utilizado no NSGAII
Inicialmente, tem-se um conjunto de soluções formado por (gerado através de
operadores de seleção, mutação e cruzamento) e (população inicial da iteração t). Em
𝑐𝑑 (𝑥)
𝑐𝑑 (𝑥)
𝑧
𝑧
Rejeitado
𝑷𝒕 𝟏 𝑷𝒕
𝑸𝒕
𝑭𝟏
𝑭𝟐
𝑭𝟑
Ordenação por não dominância Ordenação por crownding distance
33
seguida é feita a ordenação das soluções de acordo com o grau de não dominância. Com isso,
as soluções são divididas em fronts, onde aquelas contidas nos melhores fronts (com menos
soluções dominadas) são selecionadas para a próxima iteração. Então, a métrica crowding
distance deverá ser utilizada como critério de desempate para selecionar indivíduos do último
front escolhido. Para apresentar melhor o funcionamento do NSGAII, o Quadro 5 apresenta o
pseudocódigo do algoritmo.
Quadro 5. Pseudocódigo do NSGAII
De acordo com o Quadro 5, inicialmente é gerada uma população , que é ordenada
com base em não dominância e posteriormente dividida em fronts. A nova população é então
obtida selecionando os indivíduos baseados nos melhores fronts e no crowding distance. A
partir dessa população aplicam-se os operadores de seleção, mutação e cruzamento. Caso o
critério de parada seja atingido, o algoritmo termina, caso contrário é feita uma nova
ordenação por fronts e o processo se repete.
3.3.2 SPEA2
O SPEA2 (Strength Pareto Evolutionary Algorithm 2) [9] é um algoritmo que utiliza um
arquivo externo para armazenar as melhores soluções encontradas entre as gerações. Ele se
baseia no conceito de dominância e densidade de vizinhos para avaliar a aptidão. Pela
1. Gera população aleatória inicial de tamanho
2. Ordena com base em não dominância
3. População de tamanho é obtida a partir de através da aplicação dos
operadores de seleção, cruzamento e mutação.
4. Repetir − vezes, onde é o número de gerações
5. , onde é a iteração atual
6. ordenar por não dominância
7. ( ), todos os fronts de
8. enquanto
9. atribuir crownding distance para cada solução em
10.
11. ordenar com base em não dominância e crownding distance
12. [ ]
13. População de tamanho é obtida a partir da aplicação dos operadores de
seleção (crownding operator), cruzamento e mutação sobre a população
14.
34
densidade de vizinhos é possível observar quais indivíduos são mais representativos para o
conjunto de solução final. Desta forma, a densidade é utilizada como critério de decisão entre
indivíduos com mesmo grau de dominância. A densidade é calculada através da seguinte
equação:
( )
(16)
onde
√ ( )
para igual a -ésima solução para a qual se está calculando a densidade, igual ao tamanho
da população inicial da iteração , igual ao tamanho do arquivo externo de soluções não
dominadas e igual à distância Euclidiana entre a solução e a -ésima solução mais próxima.
O pseudocódigo do SPEA2 é apresentado no Quadro 6.
Quadro 6. Pseudocódigo do SPEA2
Como pode ser visto no Quadro 6, inicialmente é gerada uma população inicial e um
arquivo externo vazio . Em seguida é calculada a função de aptidão, onde é possível ter uma
1. Entrada: (Tamanho da população)
2. (Tamanho do arquivo)
3. (Número máximo de gerações)
4. Saída: (Soluções não dominadas)
5. Inicialização: Gere população inicial e crie um arquivo externo vazio .
6. Seta .
7. Atribuição da aptidão: Calcule a aptidão de e .
8. Seleção: Copie os indivíduos não dominados de e para .
9. Se
10. Teste condição de parada.
11. Senão se então
12. Aplique o truncamento a
13. Senão
14. Complete o arquivo com elementos dominados de e .
15. Condição de parada: se ou outro critério for satisfeito, atribua e pare
16. Cruzamento: Seleção por torneio direto (binário) em . Aplique cruzamento em
até completar o mating pool (conjunto de pais selecionados).
17. Diversidade: Aplique o operador de mutação ao mating pool e sete a população
resultante em . Incremente o contador de geração e volte para linha 7.
35
percepção melhor do relacionamento entre as soluções envolvidas. Posteriormente, os
indivíduos não dominados do conjunto de soluções são copiados para compor o arquivo
externo da próxima iteração. Baseado no tamanho do arquivo externo pode haver nessa etapa
a necessidade de truncamento ou de completar o novo arquivo externo com elementos
dominados. Caso a condição de parada não seja atingida, é realizado seleção, cruzamento e
mutação. Desta forma, é gerada uma nova população e esse processo se repete até que a
condição de parada seja atingida.
3.4 Métricas de Avaliação
Métricas são bastante utilizadas a fim de mensurar características de algoritmos multi-
objetivo, ajudando a entender seu comportamento no domínio do problema e permitindo uma
avaliação mais concreta do desempenho do algoritmo. As métricas também são um importante
parâmetro de comparação entre algoritmos, uma vez que muitas vezes é difícil perceber qual
algoritmo apresenta um melhor conjunto de soluções para o problema. A Figura 10 ilustra essa
característica.
Figura 10. Comparação entre algoritmos: (a) Possível concluir qual o melhor algoritmo e (b) Difícil de decidir qual o melhor algoritmo
Conforme mostra a Figura 10, na situação (a) é possível concluir que o conjunto de
soluções do algoritmo A é mais apropriado do que o do algoritmo B, uma vez que para cada
solução encontrada em B existe pelo menos uma solução em A que seja melhor ou igual à de B
em todos os objetivos. Mas ainda assim é difícil dizer o quanto o algoritmo A é melhor que B.
B
A
A B
𝒇𝟏 𝒇
𝟏
𝒇𝟐 𝒇
𝟐
(a) (b)
36
Na situação (b) já não se pode assegurar qual algoritmo é melhor, pois no conjunto das
melhores soluções encontradas na união dos resultados de A e B, algumas soluções pertencem
a A e outras a B. Dessa forma, as melhores soluções que pertencem ao algoritmo A podem
apresentar características que sejam boas para um tipo de aplicação, enquanto que as de B
podem ser boas apenas para outros tipos de aplicações. Sendo assim, a asserção de que os
resultados de um algoritmo são melhores do que de outro algoritmo dependerá de quais
características são importantes para o usuário. Em [13], Fonseca et al. também chegam a
mesma conclusão e observam que métricas podem ser combinadas a fim de se buscar um
conjunto de características mais apropriadas para análise comparativa entre os algoritmos.
Duas das principais métricas utilizadas são apresentadas a seguir. Elas serão utilizadas para
validação dos resultados deste trabalho.
3.4.1 Distância Generacional
Distância generacional é uma métrica simples, no entanto, bastante utilizada para
comparação de algoritmos. O seu princípio consistem em representar a o quão distante um
Pareto Front está do Pareto Ótimo. Para tanto, a métrica é calculada através do somatório da
distância Euclidiana entre cada solução obtida e o Pareto Ótimo, conforme ilustrado na Figura
11. A distância Euclidiana é representa pela menor distância entre uma solução obtida na
frente de Pareto e uma solução do Pareto Ótimo.
Figura 11. Indicador de distância generacional
A definição formal deste indicador foi proposta por Van Heldhizen em [14] e é calculada
pela seguinte equação:
𝒇𝟏
𝒇𝟐
Frente de Pareto
Pareto Ótimo
Distância Euclidiana
37
√∑
, (18)
onde, é o número de soluções não dominadas no Pareto Front e é a menor distância entre
a solução e o Pareto Ótimo.
3.4.2 Hipervolume
O indicador de Hipervolume foi originalmente proposto por Zitzler et al. [15] para
comparar o resultado final de diferentes Algoritmos Evolucionários Multi-Objetivo. O
hipervolume corresponde ao cálculo de uma fração de área do espaço de busca que é
dominada pelo Pareto Front e não dominada por um ponto de referência. Matematicamente,
para cada solução pertencente ao Pareto Front , é construído um hipercubo com
referência a um ponto , conforme apresentado na Figura 12.
Figura 12. Indicador Hipervolume
O ponto de referência pode ser definido construindo-se um vetor com os piores valores
de função objetivo. Esse ponto é apenas uma referência para o cálculo do volume em relação
ao Pareto Front, sendo normalmente representado por um ponto onde contém os piores
valores das funções objetivo. O resultado da métrica é a união de todos os hipercubos
encontrados. Nessa métrica, quanto maior o valor do hipervolume melhor, pois um alto valor
de hipervolume indica que houve um elevado espalhamento entre as soluções extremas do
Pareto encontrado e indica também que houve uma maior convergência, pois quanto mais o
algoritmo convergir maior será o volume calculado nessa métrica. Apesar de ser
𝒇𝟏
𝒇𝟐
W
Hipervolume
𝒔𝟏
𝒔𝟐
𝒔𝟑
𝒔𝟒 𝒔𝟓
𝒔𝟔
38
conceitualmente intuitiva, essa métrica apresenta um elevado custo computacional. Essa
métrica é calculada através de
(
) (19)
onde representa a solução do Pareto Front e representa o hipercubo daquela solução.
3.4.3 Cobertura
A métrica de cobertura [19] é capaz de mensurar quanto um determinado conjunto de
soluções domina outro conjunto. Essa relação é exemplificada na Figura 13.
Figura 13. Indicador de Cobertura
O valor ( ) na Figura 13 indica a porcentagem de elementos em B que são
fracamente dominados por elementos de A. No caso da figura, apenas um quarto das soluções
de B são dominados por alguma solução do conjunto A. Por essa razão, diz-se que a cobertura
de A em relação a B é de 25%. De forma análoga, a coberta de B em relação a A, expressa por
( ), é de 75%, pois três quartos das soluções de A são dominadas por alguma solução de B.
A equação que representa a métrica de cobertura é calculada através de
( )
, (20)
onde b e a representam soluções do conjuntos de solução B e A, respectivamente. O
termo indica que é fracamente dominado pela solução . O valor da métrica
( ) significa que todos os membros de B são fracamente dominados por A.
𝒇𝟏
𝒇𝟐
𝒃𝟏
𝒃𝟐
𝒃𝟑
𝒃𝟒
𝒂𝟏
𝒂𝟐
𝒂𝟑 𝒂𝟒
39
Capítulo
4
4 Trabalhos Relacionados
Neste capitulo são apresentadas os principais trabalhos que deram um
embasamento teórico para o desenvolvimento desta dissertação.
40
4.1 Estudo Realizado
Com o crescimento da utilização de dispositivos móveis, o problema de redução de
energia se tornou alvo de diversos estudos científicos. O problema de exploração de
hierarquias de memória visando otimizar a energia consumida pela arquitetura se mostrou
bastante promissor, haja vista que apenas as memórias cache de um sistema são responsáveis
por quase metade de toda energia consumida [2].
Em 2004, Zhang e Vahid [23] apresentaram um estudo sobre o impacto da escolha da
memória cache em sistemas embarcados. Eles mostraram que a memória cache precisa ser
projetada considerando os requerimentos dos tipos de aplicações que serão executadas no
sistema, caso contrário, este sistema desperdiçará energia. Muitas metodologias foram
propostas para explorar arquiteturas de memórias cache visando à redução da energia
consumida e o aumento do desempenho, a maioria delas manipulando o tamanho da cache, o
tamanho da linha e a associatividade. Entretanto, outras soluções como o uso de victim buffer,
a codificação de dados e instruções, controlar a largura de barramento, também são objetos de
estudos para o problema de redução de energia em sistemas embarcados.
Inicialmente, Platune [24] apresentou um ambiente de trabalho para plataformas de
system-on-a-chip (SOC) configuráveis, que permitia a utilização de um método exaustivo para
buscar a configuração de cache que atendesse aos requisitos relacionados com a energia
consumida pelo sistema projetado. Este trabalho, no entanto, considerou um espaço de
exploração muito restrito, baseado apenas em configurações de caches com apenas um nível.
Então, este método de exploração é aceito apenas quando o número de possíveis
configurações é pequeno, caso contrário o tempo necessário para a busca exaustiva pode ser
infactível. Portanto, tentando evitar o processo de busca exaustiva e consequentemente
reduzir o tempo de exploração, métodos baseados em técnicas inteligentes, como algoritmos
evolucionários, começaram a serem aplicadas. Estas técnicas são utilizadas para encontrar um
conjunto de soluções ótimas explorando uma pequena fração do espaço de busca. Então, Palesi
et al. [25] apresentaram uma metodologia baseada em algoritmos genéticos para reduzir o
tempo de exploração, estendendo o trabalho realizado por Platune.
41
Após o trabalho apresentado por Palesi, uma heurística foi desenvolvida por Zhang et al.
[27] para exploração de configurações de memórias cache baseada no tamanho da cache, no
tamanho da linha e na associatividade. Nesta heurística, os parâmetros da cache são
examinados individualmente e um conjunto de possíveis configurações de cache é gerado
visando à redução da energia consumida para uma determinada aplicação. No entanto, assim
como o trabalho de Platune, esta técnica foi aplicada apenas para hierarquias com um nível de
memória cache. Apesar desta limitação, os resultados alcançados com a aplicação da heurística
mostraram uma redução de até 40% da energia consumida. Em seguida, Gordon-Ross [26]
estendeu esta heurística, apresentada por Zhang, e propôs uma nova heurística chamada TCaT,
que conseguiu atingir resultados ainda mais expressivos, reduzindo em até 53% a energia
consumida pelo sistema.
Finalmente, Silva-Filho et al. propuseram uma série de mecanismos de otimização para
hierarquias de memória com dois níveis de cache. Dentre estes mecanismos desenvolvidos
estão: TECH [28], TECH-CYCLES [29] e TEMGA [30]. Entretanto, estes novos mecanismos foram
criados visando reduzir a energia consumida e aumentar o desempenho de um sistema. Os
resultados apresentados pelo mecanismo TECH-CYCLES mostraram uma redução média de até
41% da energia consumida pela cache de instruções quando comparada com a heurística TCaT.
Além disto, o mecanismo apresentado é capaz de encontrar soluções ótimas explorando
apenas 2% do espaço de busca. Entretanto, para a cache de dados o mecanismo não obteve
bons resultados. A melhoria deste tipo de cache só foi obtida no mecanismo TEMGA, onde os
resultados indicaram uma redução média de aproximadamente 15% para energia consumida
por caches de dados, quando comparados com os resultados obtidos pelo TECH-CYCLES e pela
heurística TCaT. Além disto, o mecanismo TEMGA foi capaz de reduzir em cinco vezes o número
de ciclos necessários para executar doze aplicações do benchmark MiBench.
Todos estes trabalhos apresentados foram baseados em hierarquias de memória com
um ou com dois níveis de cache, que são os tipos de memórias que normalmente já eram
integradas com o chip do processador. Entretanto, as hierarquias de memória precisaram
acompanhar o rápido crescimento da capacidade de processamento dos novos processadores.
Logo, nos últimos anos, um terceiro nível de memória cache (L3) com alta capacidade de
armazenamento virou alvo de estudos [33]. Como resultado destes estudos, memórias caches
L3 passaram a ser integradas e se tornaram um dos principais elementos de processadores com
multi-thread e multi-core [34].
42
Processadores com o terceiro nível de memória cache já estão disponíveis no mercado,
normalmente em processadores de alto desempenho, devido a grande quantidade de energia
requerida pela cache. Entretanto, processadores com a cache L3 já começaram a aparecer no
mercado de sistemas embarcados [35], em decorrência de resultados de estudos recentes que
permitiram a redução do consumo de energia deste tipo de arquiteturas. Barth et al. [32], em
2011, apresentaram uma nova tecnologia de memória cache baseada em DRAM (Dynamic
random-access memory) que permitiu a utilização da cache L3 embarcada no chip do
processador. Quando comparada com a tecnologia de um processador típico, que dedica cerca
de 40-50% da área do chip para a cache L3, esta nova tecnologia de memória consome apenas
11% da área total do chip, o que reduz drasticamente o consumo de energia do processador.
Recentemente, em 2012, Huang et al. [31], representando a corporação Intel,
apresentou uma nova arquitetura de cache L3 projetada para ter baixo consumo de energia.
Para atingir os requisitos de baixa potência, três estratégias avançadas de projeto foram
apresentadas. A primeira permitiu projetar a cache L3 em pequenas partes independentes.
Depois, foram criados novos tipos de sinais de controle de acesso especulativo para ativar e
desativar partes da memória que não estavam sendo utilizadas. A partir destas duas primeiras
estratégias, foi possível fazer a ativação dinâmica da memória SRAM (Static random-access
memory), colocando as partes que não estavam sendo utilizadas em um modo de espera sem
prejudicar o desempenho. Portanto, aplicando estas estratégias, a cache L3 apresentada obteve
uma redução de energia de 20% quando estava operando em altas frequências e de 40%
quando foi submetida a baixas frequências.
Outras técnicas de redução de energia de cache L3 podem ser encontradas na literatura,
no entanto, a maioria delas é baseada em novas tecnologias de fabricação ou na proposição de
novas arquiteturas para esta memória, seguindo a linha de estudo apresentada por [31] e [32].
Entretanto, para o trabalho apresentado nesta dissertação, o problema de redução de energia
de hierarquias com três níveis de cache é abordado como uma extensão do problema de
exploração de arquiteturas baseadas em um ou dois níveis de cache, conforme visto no início
desta seção. Contudo, devido ao grande número de configurações presente em hierarquias de
memória com três níveis de cache, um mecanismo inteligente visando à redução do tempo de
exploração será apresentado nos próximos capítulos, assim como visto em [25][28][29][30].
43
4.2 Conclusão
A fim de comparar as técnicas de otimização estudadas no estado da arte, assim como
direcionar a pesquisa realizada neste trabalho, a Tabela 2 apresenta um resumo de algumas
características destas técnicas aplicadas ao problema de exploração de arquiteturas de
memória cache.
Tabela 2. Comparação das técnicas de otimização estudadas.
Tecnologia Simuladores Processador Velocidade Multi-
Objetivo
Benchmarks
TCaT 0.18µm CACTI 2.0 MIPS 6.5% Não MediaBench
TECH 0.18µm CACTI 2.0 MIPS 1.7% Não MediaBench
TECH-
CYCLES
0.08µm eCACTI
SimpleScalar
MIPS 2.0% Sim MiBench
TEMGA 0.08µm eCACTI
SimpleScalar
MIPS 5.8% Sim MiBench
NSGAII 0.08µm CACTI 5.0
SimpleScalar
MIPS 11% Sim Mibench
A partir da análise comparativa das técnicas estudadas foi possível concluir que a
tecnologia utilizada na fabricação de transistores diminuiu na medida em que novas técnicas
foram surgindo. Esta diminuição foi acompanhada pela evolução dos simuladores de
arquiteturas de cache utilizados para estimar a energia consumida, haja vista que a
componente estática da energia se torna cada vez mais relevante quando se diminui o tamanho
do transistor. Outro ponto verificado foi a utilização de modelos de processadores simples,
baseados no processor MIPS, que se tornaram mais relevantes quando os algoritmos
começaram otimizar tanto a energia consumida pela arquitetura, como o desempenho dela
para executar aplicações de diversas áreas representadas pelos benchmarks suites MediaBench
e MiBench. Por fim, foi constatado que as velocidades com que as técnicas de otimização
conseguiram encontrar soluções ótimas, normalmente, foram inferiores a exploração de 10%
do espaço total de busca.
No segundo momento do estudo do estado da arte, foi possível concluir que a memória
cache de terceiro nível começou a ser embarcada nos chip dos processadores, devido ao
avanço da tecnologia de fabricação e ao surgimento de novas estratégias para projetar estes
componentes da hierarquia de memória.
44
Capítulo
5
5 Metodologia Proposta
Neste capítulo será detalhada a metodologia utilizada para criação deste trabalho.
Nesta metodologia serão descritos o modelo de cálculo de energia e ciclos de configurações de
hierarquias de memória, as adaptações realizadas em ferramentas utilizadas para simular
componentes de memória, o ambiente experimental, a ferramenta utilizada para integrar todos
os elementos envolvidos neste trabalho e, finalmente, o processo de simulação realizado.
45
5.1 Introdução
A metodologia utilizada para o desenvolvimento deste projeto foi quebrada em nove
etapas. A Figura 14 ilustra estas nove etapas da metodologia através do fluxo de
desenvolvimento do trabalho. As duas primeiras etapas, correspondentes ao estudo
bibliográfico e ao estado da arte, já foram apresentadas nos capítulos anteriores e, portanto,
não serão exploradas novamente. Então, neste capítulo serão apresentadas as demais etapas
realizadas para o desenvolvimento deste trabalho. As etapas que estão em destaque na cor
laranja, referentes à modelagem da evolução diferencial para o problema da exploração de
hierarquias de memória e a análise de resultados, serão tratadas em capítulos separados.
Figura 14. Fluxo de Desenvolvimento do trabalho
Estudo Bibliográfico Estudo do Estado da Arte Definição do Modelo de
Cálculo de Ciclos e Energia Total
Adaptação de Ferramentas
Definição do Ambiente Experimental
Modelagem de Evolução Diferencial para Problema
de Exploração de Hierarquias de Memória
Integração de Ferramentas
Simulação dos Algoritmos de Otimização
Análise dos Resultados
46
5.2 Definição do Modelo de Cálculo de Ciclos e Energia Total
O modelo de cálculo de ciclos e energia total de uma hierarquia de memória foi
desenvolvido com base no trabalho realizado por Silva Filho et al. [29]. Para um melhor
entendimento do mecanismo, será levado em consideração um sistema baseado em
processador MIPS com uma hierarquia de memória com três níveis de cache conforme
ilustrado na Figura 15. O primeiro nível de cache foi dividido em duas caches, uma dedicada
para o armazenamento de dados e outra para instruções. O segundo e o terceiro nível foram
utilizados como modelos de cache unificada.
Figura 15. Exemplo de sistema baseado em processor MIPS com hierarquia de memória
Para facilitar o entendimento do cálculo de ciclos e energia total, o mecanismo será
dividido em duas etapas. A primeira corresponde ao cálculo do número total de ciclos
necessários para executar uma aplicação, e a segunda ao cálculo da energia total consumida
pela hierarquia de memória. Estas duas etapas serão apresentadas nas subseções a seguir.
5.2.1 Cálculo do Número Total de Ciclos
O número total de ciclos necessários para executar uma aplicação será considerado
como as soma do número ciclos de cada nível da hierarquia, conforme apresentado a seguir:
(21)
Cada componente desta equação será tratada separadamente, devido às
particularidades de cada nível. No entanto, para realizar este cálculo de ciclos será preciso levar
em consideração os tempos de acertos de cada nível de cache. Neste trabalho serão
considerados os tempos de acertos apresentados na Tabela 3. Estes valores foram definidos
baseados nas latências de caches apresentadas em [36].
IC1
DC1
L3 L2 MEM MIPS
47
Tabela 3. Tempo de acertos de cada nível de cache
Nível e Tipo da Cache Tempo de acerto (ciclos)
Cache de instruções de nível 1 (IC1) 2
Cache de dados de nível 1 (DC1) 3
Cache de instruções de nível 2 (IC2) 13
Cache de dados de nível 2 (DC2) 9
Cache de instruções de nível 3 (IC3) 40
Cache de dados de nível 3 (DC3) 38
Para calcular o número total de ciclos do primeiro nível de cache ( ) é
necessário calcular o número de ciclos das caches de instruções e dados separadamente.
, (22) , (23)
onde as variáveis e representam o número de acertos no primeiro nível
de cache de instruções e dados. Estes números são, então, multiplicados pelo tempo de acerto
nas caches de primeiro nível. Entretanto, como as caches do nível L1 são acessadas em
paralelo, para calcular o valor total de ciclos da cache L1 é preciso levar em consideração o
maior valor de ciclos calculado.
Apesar do segundo nível de memória cache ser unificado, os tempos de acerto para
instruções e dados são diferentes. Portanto, para calcular o número de ciclos total do segundo
nível de cache ( ) será considerada a soma dos ciclos totais decorrentes de acertos
de instruções e de acertos de dados na cache, conforme apresentado na equação a seguir:
( ) ( ) , ( )
onde representa o número de acertos de instruções na cache unificada de nível 2 e
representa o número de acerto de dados. O tempo de acerto de uma instrução em
L2 ( ), determinado na Tabela 3, corresponde a soma do tempo de uma falta
no primeiro nível da cache de instruções mais o tempo de acesso à informação na cache do
segundo nível. De forma similar o é definido pela soma do tempo de uma
falta de dados no primeiro nível com o tempo de acesso ao dado no segundo nível.
Para o terceiro nível de cache, a forma de calcular o número de ciclos total
( ) corresponde a uma extensão das regras definidas para o segundo nível.
Portanto, o número total de ciclos da cache L3 será a soma dos ciclos totais decorrentes de
acertos de instruções e de acertos de dados na cache, conforme mostrado na equação a seguir:
48
( ) ( ) , (25)
onde e representam o número de acertos de instruções e dados na
cache unificada de nível três, respectivamente. A regra utilizada para definição do valor do
tempo de acerto, tanto para instruções quanto para dados, corresponde a soma do tempo de
uma falta no primeiro nível, mais o tempo de uma falta no segundo nível, somadas ao tempo
de acesso a informação no terceiro nível, uma vez que para ocorrer um acerto no terceiro nível
foi preciso ocorrer uma falta nos níveis inferiores.
A forma de calcular o número total de ciclos da memória principal ( ), no
entanto, difere um pouco da forma como foi calculado para memórias caches. A variável
principal neste calculo será o número de faltas que ocorrem no nível três de cache, pois cada
uma destas faltas ocasiona um acesso à memória principal. Dessa forma, define-se o número
total de ciclos da memória principal como sendo:
, (26)
onde , representa a penalidade em ciclos ocasionada por acessar a memória
principal do sistema. O valor desta penalidade, no entanto, depende do tamanho da linha de
que está sendo acessada. Os valores de penalidade considerados para este trabalho estão
apresentados na Tabela 4 e foram definidos segundo [37].
Tabela 4. Valores de penalidade por acesso a memória principal
Tamanho da linha Penalidade em ciclos
16 Bytes 82
32 Bytes 84
64 Bytes 88
5.2.2 Cálculo da Energia Total Consumida
Partindo de um nível mais alto, a energia total consumida pela hierarquia de memória
pode ser considerada como sendo a soma das contribuições da energia consumida por cada
elemento que compõe a arquitetura. Logo, a equação que define a energia total consumida
pelo o sistema apresentando na Figura 15 pode ser defina da seguinte forma:
( )
49
Na equação 27 a componente representa a energia consumida pela memória
principal, corresponde a energia consumida pela cache de instruções do nível 1,
corresponde a energia consumida pela cache de dados de nível 1, e representam as
energias consumidas pelo segundo e terceiro nível de cache, respectivamente.
A forma de calcular a energia consumida de qualquer uma as componentes da energia
total ( ) é igual, com exceção da componente que tem o seu próprio modelo.
Portanto, o cálculo destas componentes será explicado de forma genérica, levando em
consideração uma variável , onde representa o nível da hierarquia de memória cache.
A energia total consumida por um nível de memória cache ( ) é formada por duas
componentes, a energia dinâmica e a energia estática. A componente dinâmica está
relacionada com a potência dissipada da carga/descarga dos capacitores, assim como durante a
subida/descida de uma transição decorrente de um acesso realizado a memória. O número de
acessos à memória cache, portanto, está diretamente ligada com a energia dinâmica dissipada.
Já a componente estática da energia corresponde as correntes de fuga que estão associadas à
tecnologia dos componentes eletrônicos que compõem a memória. Logo, é possível definir
da seguinte forma:
, ( )
onde corresponde a componente dinâmica e corresponde a componente estática
de uma memória cache de nível .
O cálculo desta componente dinâmica da energia pode ser realizado da seguinte forma:
, (29)
onde a variável corresponde a energia dinâmica por acesso ao nível da hierarquia
de memória e corresponde ao número total de acessos a esta memória.
O cálculo da componente estática é realizado através da potência dissipada pelo
componente de memória e do tempo de utilização ( ) da memória. Então, a
é definida da seguinte forma:
, (30)
50
onde, é a potência dissipada por um componente de cache de nível e
é uma variável obtida a partir do número total de ciclos necessários para
executar uma aplicação.
A última variável necessária para estimar a energia total de uma hierarquia de memória
corresponde à energia dissipada pela memória principal ( ). Esta energia pode ser
generalizada pela potência média estimada da memória multiplicada pelo tempo total de
utilização da memória.
(31)
A potência média consumida pela memória principal pode ser obtida através um
simulador de memória, onde é levada em consideração a tecnologia de memória de um modelo
específico, assim como o número de acessos de leitura da memória, decorrentes de faltas no
nível inferior, e o número de acessos de escrita, decorrentes de write-backs realizados pelo
nível inferior.
5.3 Adaptação de Ferramentas
Para realização do cálculo do número total de ciclos e da energia consumida de uma
hierarquia de memória, conforme visto na seção anterior, foi preciso utilizar e adaptar três
ferramentas de simulação de arquiteturas de memória. A primeira delas corresponde ao pacote
de ferramentas de simulação de arquiteturas apresentado na seção 2.5, o SimpleScalar, mais
particularmente da ferramenta chamada sim-cache que está disponível neste pacote. A
segunda corresponde a ferramenta para estimar a energia dinâmica por acesso e a energia
estática de memórias cache. A terceira e última ferramenta, corresponde a um modelo que
simula uma memória principal, disponibilizado pela Micron [16], capaz de estimar a potência de
uma memória DDR3L.
Nas subseções a seguir será detalhado o que foi realizado em cada uma destas
ferramentas para viabilizar a criação de um mecanismo unificado para estimar a energia e
desempenho de hierarquias de memória com três níveis de cache. No entanto, a forma de
utilização destas ferramentas será apresentada apenas na seção 5.4, onde será definido o
ambiente experimental deste trabalho.
51
5.3.1 Adaptação do Sim-Cache
O sim-cache foi concebido baseado em hierarquias de memória com até dois níveis de
cache, conforme visto anteriormente. No entanto, como a proposta deste trabalho é explorar
hierarquias de memórias mais complexas com três níveis de cache, foi necessário adaptar a
ferramenta para calcular o número de faltas e acertos para esta nova hierarquia. Para tanto, foi
necessário alterar o arquivo “sim-cache.h” disponível no pacote de ferramentas do
SimpleScalar. O fluxo de desenvolvimento das alterações realizadas no simulador está ilustrado
na Figura 16.
Figura 16. Fluxo de desenvolvimento da expansão do sim-cache
Em um primeiro momento, foi necessário adaptar o formato de entrada dos parâmetros
de configuração da hierarquia de memória, e expandir o formato para suportar o terceiro nível
de memória cache. O formato de entrada permite configurar uma cache L3 tanto com as caches
de instrução e dados unificadas, quanto separadas.
No segundo momento, foi preciso expandir o simulador para criar o modelo de cache
L3, conforme especificado nos parâmetros de entrada, assim como validar a configuração da
hierarquia em geral. Logo, nesta etapa, foi necessário expandir as regras de validação de uma
hierarquia de memória para suportar o terceiro nível de cache unificado ou separado.
Na etapa seguinte, foi desenvolvida a lógica de acesso a cache do terceiro nível. Para
tanto, foi necessário expandir o tratamento das informações de faltas no nível inferior (L2), que
consequentemente geram um acesso no nível L3, assim como tratar as escritas decorrentes de
L2 para manter a coerência das caches através da política de write-back. Além do tratamento
dos acessos realizados ao terceiro nível de cache, nesta etapa foi necessário criar um método
1.Configuração do simulador
2.Criação dos modelo de memória
3.Criação de gerenciador de acesso a cache L3
4.Geração de resultados
52
para tratamento de faltas em L3. Então, foram criadas variáveis para monitorar todo o processo
de gerenciamento do terceiro nível de cache.
Finalmente, através das variáveis de monitoramento criadas na etapa anterior, o
arquivo de saída do simulador foi expandido para exibir as informações relacionadas a uma
hierarquia de memória com três níveis de cache.
5.3.2 Adaptação do CACT 6.5
A versão do CACT 6.5 apresentada na seção 2.6 já possui o suporte necessário para
simular caches de terceiro nível. No entanto, a ferramenta precisou ser alterada para permitir
uma interface de configuração por linha de comando, uma vez que só era possível utilizar a
ferramenta mediante a configuração de arquivo de parâmetros. A interface por linha de
comando foi escolhida para simplificar a execução da ferramenta, focando apenas nos
parâmetros de memória cache explorados neste trabalho: tamanho da cache, o tamanho da
linha, associatividade, tecnologia de transistor e nível da cache.
5.3.3 Adaptação do Simulador de Memória Principal
O modelo criado para estimar a potência da memória principal foi desenvolvido com
base na planilha fornecida pela Micron, descrita na seção 2.7. A partir das especificações da
memória e das fórmulas presentes no simulador foi possível criar um modelo em software
capaz de estimar a potência da memória recebendo como entrada o número de leituras e
escritas realizadas nesta memória. A criação deste modelo foi necessária para a integração do
simulador da Micron com o restante do ambiente que será apresentado na seção a seguir.
5.4 Definição do Ambiente Experimental
Nesta seção será apresentado o ambiente experimental criado neste trabalho. Nele será
especificado o espaço de exploração das arquiteturas de memória cache, os benchmarks que
foram escolhidos para simulação, o detalhamento do mecanismo de cálculo de ciclos e energia
total, assim como as etapas preliminares deste mecanismo.
53
5.4.1 Especificação da Arquitetura
Para este trabalho serão estudadas arquiteturas de memória baseadas em três níveis de
cache, sendo o primeiro nível dividido em cache de instruções (IC1) e cache de dados (DC1), o
segundo nível unificado (L2), o terceiro nível também unificado (L3) e uma memória principal
baseada no modelo DDR3L. Para cada uma destas caches serão explorados os seguintes
parâmetros: associatividade, tamanho da linha e tamanho da cache. No entanto, para definir os
intervalos de variação destes parâmetros, foi realizada uma pesquisa com processadores de
mercado. O resultado desta pesquisa, apresentado na Tabela 5, permitiu definir o espaço de
exploração das configurações de arquiteturas de memória cache.
Tabela 5. Espaço de exploração dos parâmetros da hierarquia de memória cache
Parâmetro Cache de
Instruções L1 Cache de Dados L1
Cache L2 Cache L3
Tamanho da Cache
4KB 8KB
16KB 32KB 64KB
4KB 8KB
16KB 32KB 64KB
256KB 512KB 1MB 2MB
4MB 8MB
16MB
Tamanho da Linha 32B 64B
32B 64B
32B 64B
32B 64B
Associatividade 2 4
2 4 8
8 16
16 64
O total de combinações destes parâmetros de cache corresponde a 115.200 diferentes
configurações de hierarquias de memória cache. No entanto, muitas destas configurações não
são factíveis e, portanto, precisam ser descartadas. Logo, para validação de uma configuração
foram adotadas as três regras apresentadas a seguir:
1. Uma cache de nível superior não pode ter o tamanho menor que uma cache de
nível inferior;
2. O tamanho da linha de uma cache de nível superior não pode ser menor do que
o tamanho da linha de uma cache de nível inferior;
3. A associatividade de uma cache de nível superior não pode ser menor do que a
associatividade de uma cache de nível inferior.
54
Então, aplicando as regras de validação de uma configuração de hierarquia de memória,
o número de combinações válidas cai para 28.800 configurações. Este valor, portanto,
representa o espaço de exploração de arquiteturas adotado para este trabalho.
5.4.2 Benchmarks
Os Benchmarks representam conjuntos de aplicações específicas utilizadas para simular
aplicações de diferentes áreas. A utilização de benchmarks permite analisar o comportamento
de uma arquitetura de sistema embarcado para executar diferentes tipos de aplicações. Dessa
forma, através de simulações destas aplicações para diferentes arquiteturas, é possível
encontrar as arquiteturas mais adequadas para realizar uma atividade específica, como
processar de imagens, sons e cálculos matemáticos em geral.
Os comportamentos dos sistemas embarcados que serão analisados neste trabalho são
desempenho e energia consumida pelo sistema. Para tanto, dois benchmarks foram escolhidos
visando explorar aplicações de baixa, média e alta complexidade. O primeiro foi o Mibench
[17], que contém aplicações que não exigem alto poder computacional, mas que estão
presentes em diversas áreas. O segundo benchmark escolhido foi o MediaBenchII [18], pois ele
é composto por aplicações que exigem maior capacidade de processamento, porém são mais
específicas para a área de processamento de imagens. O conjunto de aplicações de ambos os
benchmarks totalizam nove aplicações, detalhadas separadamente nas Tabelas 6 e 7 seguir.
Tabela 6. Aplicações selecionadas do MediaBenchII
Aplicação Categoria Descrição
djpeg Processamento de
Imagens
Algoritmo mais utilizado para compressão e descompressão de imagens. Está presente na maioria dos sistemas embarcados que lidam com imagens, como câmeras digitais, celulares, etc.
h263enc Processamento de
Vídeo
Compressor de vídeo padrão. Originalmente desenvolvido para comprimir vídeos com alta taxa de compressão para viabilizar a utilização dele em videoconferências.
mpeg2enc Processamento de
Vídeo Padrão de compressão de imagens associadas ao áudio.
mpeg2dec Processamento de
Vídeo Padrão de descompressão de imagens associadas ao áudio.
55
Tabela 7. Aplicações selecionadas do Mibench
Aplicação Categoria Descrição
Bitcount Controle Automotivo
e Industrial Realiza testes de habilidade de manipulação de bits de um processador, contando o número de bits em um vetor de inteiros.
CRC32 Redes Realiza a checagem de bits para detectar erros de transmissão de dados.
Dijkstra Redes Constrói um grande grafo em uma representação de matriz adjacência e calcula o menor de todos os caminhos entre todos os pares de nós usando o algoritmo Dijkstra repetidas vezes.
SHA Segurança Algoritmo de criptografia que produz uma mensagem de 160 bits.
Susan Controle Automotivo
e Industrial
Faz parte de um pacote de reconhecimento de imagem. Foi desenvolvido para reconhecimento de bordas e curvas em uma Imagem de Ressonância Magnética de cérebro.
5.4.3 Extração dos Parâmetros de Desempenho
A extração dos parâmetros de desempenho de uma configuração de memória cache é
realizada através do simulador sim-cache. O processo completo para extração destes
parâmetros está ilustrado na Figura 17.
Figura 17. Fluxo para extração dos parâmetros de desempenho de uma arquitetura
sim-cache
Especificação da hierarquia de
memória cache
Arquivo com os resultados
Interpretação dos resultados
Faltas Acertos Acessos
Write-backs
Extração dos parâmetros de desempenho
Aplicação
56
O processo inicia com a definição das entradas do simulador. São duas as entradas que
devem ser escolhidas: a especificação da hierarquia de memória cache e a aplicação que será
simulada. Estes parâmetros de entradas são passados através de linha de comando. O formato
padrão para configuração da hierarquia é definido da seguinte forma:
<name>:<nsets>:<bsize>:<assoc>:<repl>
O significado de cada um destes parâmetros é apresentado na Tabela 8. O parâmetro de
tamanho da cache não é especificado diretamente, mas pode ser obtido através do produto
dos parâmetros <nsets>, <bsize>, <assoc>.
Tabela 8. Parâmetros de configuração de uma cache
Parâmetro Descrição
<name>
Nome da cache que está sendo definida. O nome da cache deve ser iln ou dln, onde o n representa o nível da cache que está sendo definida.
<nsets> Número de conjuntos da cache.
<bsize> Tamanho da linha da cache em bytes.
<assoc> Associatividade da cache.
<repl> Política de substituição de uma linha, 'l'=LRU, 'f'=FIFO, 'r'=random.
Para cada uma das caches presente na hierarquia de memória a ser simulada deve-se
repetir estes parâmetros de configuração, <config>. A definição de cada nível da hierarquia
deve ser feita da seguinte forma:
-cache:il1 il1: <config> → configura uma cache de instruções de nível um.
-cache:dl1 dl1: <config> → configura uma cache de dados de nível um.
-cache:il2 dl2 -cache:dl2 ul2: <config> → configura uma cache unificada de nível dois.
-cache:il3 dl3 -cache:dl3 ul3: <config> → configura uma cache unificada de nível três.
Após a palavra “cache” é definido o tipo da memória cache que se deseja configurar. No
caso de uma cache unificada, antes de se escrever a configuração é preciso passar um
parâmetro que especifique que a cache de instruções estará junta com a cache de dados. Caso
não seja necessário usar os três níveis de configuração a palavra “none” deve ser passada após
a definição do tipo da cache.
57
A seguir, é descrito um exemplo de linha de comando para simulação de uma
arquitetura no sim-cache, considerando uma hierarquia de três níveis com segundo e terceiro
níveis unificados. As configurações da cache de dados e de instruções de primeiro nível são
dadas por: 4kbytes=64nsets*32bsize*2assoc, 32 bytes de tamanho de linha e política de
substituição LRU. As configurações de cache unificada de segundo nível são dadas por:
256kbytes=1024nsets*32bsize*8assoc, 32 bytes de tamanho de linha e política de substituição
LRU. Por fim, as configurações de cache unificada de terceiro nível são dadas por:
4Mbytes=8192nsets*32bsize*16assoc, 32 bytes de tamanho de linha e política de substituição
LRU. A linha de comando fornecida para o sim-cache para simular essa configuração de
arquitetura, para uma aplicação qualquer seria:
./sim-cache -redir:sim ./output.txt -cache:dl1 dl1:64:32:2:l -cache:il1 il1:64:32:2:l -cache:il2 dl2 -
cache:dl2 ul2:1024:32:2:l -cache:il3 dl3 -cache:dl3 ul3:8192:32:16:l ./<nome_da_aplicacao>
<parametros_da_aplicacao>
Cada aplicação tem um formato dos seus parâmetros de entrada diferente e, portanto,
também deve ser especificado na mesma linha de comando utilizada para executar o sim-
cache. A diretiva “-redir:sim” é responsável por gerar resultados estatísticos da simulação para
um arquivo de saída, o que no exemplo acima foi direcionado para o arquivo output.txt. Por
padrão, os resultados são gerados na tela do computador. Desta forma, ao final de cada
simulação têm-se as informações estatísticas sobre cada componente da hierarquia de
memória cache. A partir dos dados estatísticos, são extraídas as informações de faltas e
acertos, acessos e write-backs que são utilizadas na etapa seguinte de cálculo de energia.
5.4.4 Extração dos Parâmetros do Modelo de Energia
Para extrair os parâmetros de energia total consumida por uma hierarquia de memória
cache foi utilizado o simulador CACTI juntamente com o simulador de memória principal da
Micron, o Power Calc DDR3L. No entanto, ambos os simuladores precisam das informações
extraídas na etapa de simulação da hierarquia para conseguir estimar os valores de energia de
cada componente de memória da arquitetura. O fluxo de extração destes parâmetros é
apresentado na Figura 18.
58
Figura 18. Fluxo para extração dos parâmetros de energia
Inicialmente, a ferramenta de simulação de memórias cache, CACTI, recebe como
entrada um arquivo de configuração chamado “cache.cfg”, que permite definir os seguintes
parâmetros relacionados com a cache: tamanho da cache; tamanho da linha; associatividade;
tecnologia do transistor; nível da cache. Todos os parâmetros são alterados de acordo com a
cache a ser simulada. No entanto, para este trabalho, o valor de 32nm foi utilizado como valor
padrão para tecnologia do transistor. Uma vez configurado o arquivo, é possível iniciar a
simulação através da seguinte linha de comando:
./cacti –infile cache.cfg > cacti.txt
Segundo a linha de comando, os dados são direcionados para o arquivo cacti.txt. A partir
desse arquivo são extraídos os valores de energia dinâmica por acesso e a potência dissipada
pela cache relacionada à componente estática da energia.
O simulador da Micron é utilizado para extrair a informação da potência consumida pela
memória principal. Ele recebe como entrada a especificação completa da memória que será
CACTI
Parâmetros da cache
Arquivo com os resultados
Interpretação dos resultados
Potência dissipada da cache Potência dissipada pela memória principal
Energia consumida/acesso
Extração dos parâmetros de
energia
Parâmetros da memória principal
Simulador Micron
Planilha com resultados
59
simulada e a configuração do sistema no qual a memória será utilizada. A especificação da
memória pode ser obtida através do datasheet disponibilizado pelo fabricante. Deste
documento será necessário extrair os valores presentes na Tabela 9.
Tabela 9. Parâmetros de especificação da memória principal
Parâmetro Descrição Valor Unidade
Maximum VCC 1,435 V
Minimum VCC 1,283 V
Number of DQ strobes (DQS) per DRAM 4
Number of data mask (DM) per DRAM 2
IDD0 Maximum active precharge current 90 mA
IDD2P Maximum precharge power-down standby current 35 mA
IDD2N Maximum precharge standby current 47 mA
IDD3P Maximum active power-down standby current 55 mA
IDD3N Maximum active standby current 70 mA
IDD4R Maximum read burst current 270 mA
IDD4W Maximum write burst current 215 mA
IDD5A Maximum burst refresh current 215 mA
tCK used for current measurements 1,25 ns tRRD Minimum activate-to-activate timing (different bank) 7,5 ns tRC Minimum activate-to-activate timing (same bank) 48,75 ns tRAS tRAS used for IDD0 calculation 35 ns tRFC (MIN) Minimum refresh-to-refresh cycle time 340 ns tREFI Average periodic refresh cycle time 7,8 µs tCK (MIN) Minimum tCK cycle rate 1,25 ns tCK (MAX) Maximum tCK cycle rate 3,3 ns
Os valores preenchidos na Tabela 9 correspondem aos valores da especificação de uma
memória DDR3L de 1GB da Micron, a qual foi adotada como padrão para este trabalho por ser
o modelo mais simples da linha de memórias DDR3L fabricadas pela Micron.
Os parâmetros das condições de uso da memória no sistema são: a tensão de entrada, a
frequência do relógio, o percentual de ciclos de relógio em que a memória ficou lendo dados e
o percentual de ciclos de relógio em que a memória ficou escrevendo dados. Os dois primeiros
receberam valores padrões de 1,35V e 800MHZ respectivamente. Os outros dois parâmetros
são calculados de acordo com o número de faltas e de write-backs do último de nível de
memória cache.
Uma vez configurado, o simulador da Micron gera como saída uma planilha com o valor
estimado da potência dissipada pela memória principal. Este valor, junto com valores extraídos
do CACTI, será utilizado para o cálculo de energia total apresentado na próxima seção.
60
5.4.5 Mecanismo de Cálculo de Energia e Ciclos Total
O mecanismo de cálculo de energia e ciclos total visa juntar a extração dos parâmetros
de desempenho com a extração dos parâmetros de energia e aplicar estes valores nas
equações definidas nas seções 5.2.1 e 5.2.2 a fim de obter o valor da energia e ciclos total. O
processo utilizado pelo mecanismo para obter estes valores está ilustrado na Figura 19.
Figura 19. Processo do mecanismo de cálculo de energia e ciclos total
O processo é iniciado através de uma configuração de uma arquitetura para ser
avaliada. Uma aplicação é então selecionada para ser submetida à configuração da arquitetura
especificada. Estas duas entradas são enviadas para o modelo de extração de parâmetros de
energia, baseado nos simuladores vistos na seção 5.4.4, e para o modelo de extração de
parâmetros de desempenho, baseado no simulador apresentado na seção 5.4.3. Finalmente, a
partir dos resultados gerados pelos simuladores são aplicadas as fórmulas 21 e 27 para realizar
o cálculo dos valores de ciclos e de energia total.
Extração dos parâmetros de desempenho
Configuração da arquitetura
Aplicação
Extração dos parâmetros de
energia
Potência dissipada da cache Potência dissipada pela memória principal
Energia consumida/acesso
Faltas/cache Acertos/cache Acessos/cache
Write-backs/cache
Cálculo de Energia e Ciclos Total
Valor Total de Energia Valor Total de Ciclos
61
5.5 Mecanismo de exploração
O mecanismo de exploração de arquiteturas utilizado neste trabalho é capaz de gerar
informações detalhadas sobre desempenho e consumo de energia para diferentes
configurações de hierarquias de memória, conforme ilustrado na Figura 20 que apresenta todas
as etapas deste mecanismo.
Figura 20. Fluxo do mecanismo de exploração
Quando o objetivo é explorar todo o espaço de busca, o mecanismo utiliza um processo
de simulação exaustiva, onde todas as configurações são avaliadas. Entretanto, como o espaço
de busca pode ser muito grande, o que requer muito tempo para simular exaustivamente, um
heurística de busca pode ser aplicada para encontrar, de forma mais rápida, um conjunto de
soluções ótimas quanto aos objetivos de redução de energia e de ciclos para executar uma
determinada aplicação. No capítulo 6 será apresentado um algoritmo de busca baseado em
evolução diferencial que explica detalhadamente o processo de exploração de arquiteturas de
memória visando redução de energia e desempenho.
Aplicação Configurações de
arquiteturas
Tipo de Exploração
Simula Configuração
Calcula Ciclos e Energia Total
Última Configuração?
Seleciona Próxima Configuração
Seleciona uma ou mais Configurações
Avalia Resultados da Heurística
Calcula Ciclos e Energia Total
Terminou
Resultados
sim sim
não
não
Exaustiva
Heurística
62
5.6 Integração de Ferramentas
Para automatizar o processo de exploração de arquiteturas de memória foi preciso
integrar todos os simuladores de arquitetura, juntamente com o mecanismo de exploração
proposto, em uma ferramenta capaz de explorar diferentes configurações de arquiteturas e
gerar os resultados com informações de desempenho e energia consumida de cada
configuração explorada.
A ferramenta selecionada para realizar esta integração foi uma ferramenta chamada
CAeTO, que foi desenvolvida pelo próprio grupo de pesquisa. Para entender melhor o
funcionamento desta ferramenta, sua estrutura foi dividida em três partes, conforme ilustrada
na Figura 21 a seguir.
Figura 21. Estrutura do CAeTO
IL1 DL1 L3 L2 MEM 𝝁𝑷
IL1 DL1 L3 L2 MEM 𝝁𝑷
IL1 DL1 L3 L2 MEM 𝝁𝑷
Aplicação
Mecanismo de Exploração
Resultados
Mapeamento
Apl. 1
Apl. 2
Apl. n
...
Arq. 1
Arq. 2
Arq. n ...
Map. n
Map. 2
Map. 1
Resultado Arq. n Resultado Arq. 2
Resultado Arq. 1
Especificação da Plataforma
Estratégia de Exploração de Arquiteturas
Análise de Resultados
63
A primeira etapa, referente à especificação da plataforma, consiste no mapeamento das
arquiteturas com as aplicações que serão utilizadas para estudo destas arquiteturas. Uma
arquitetura, no entanto, é definida pelos seguintes parâmetros: o número e o tipo das caches, a
tecnologia do transistor, e os parâmetros de projeto de cada uma das caches (tamanho da
linha, associatividade, tamanho da cache). A ferramenta permite que sejam mapeadas várias
arquiteturas e aplicações ao mesmo tempo. Dessa forma, será possível executar as demais
etapas do processo em paralelo.
Para este trabalho, portanto, foi preciso estender esta primeira etapa para suportar a
especificação de hierarquias de memória com três níveis, assim como estender os intervalos de
configuração dos parâmetros de projeto de uma cache.
A segunda etapa corresponde a estratégia de exploração de arquiteturas apresentada
na seção 5.5. Nesta etapa as arquiteturas mapeadas são submetidas ao mecanismo de
exploração para obter as informações de desempenho e consumo de energia. Neste trabalho,
foi preciso alterar o mecanismo de exploração para integrá-lo com as ferramentas de simulação
de arquiteturas adaptadas, o SimpleScalar, o CACTI e o simulador da Micron. Além disto, foi
preciso substituir o modelo de cálculo de energia e ciclos total pelo modelo apresentado na
seção 5.2. Adicionalmente, o mecanismo de exploração foi expandido para suportar uma nova
técnica de otimização multi-objetivo baseada no algoritmo de evolução diferencial. Por fim,
duas outras técnicas de otimização, NSGAII e SPEA2, já presentes na ferramenta, foram
expandidas para suportar simulações de arquiteturas com hierarquias de memória de três
níveis de cache.
A terceira e última etapa consiste na geração e visualização de resultados. Estes
resultados correspondem às informações de energia consumida e desempenho das
arquiteturas simuladas. Entretanto, quando a simulação é realizada através de heurísticas de
busca, indicadores sobre a qualidade da busca também podem ser adicionados a estes
resultados. Para este trabalho, no entanto, apenas a parte de geração de resultados foi
expandida para suportar as saídas relacionas a hierarquias de memória com três níveis. Logo, a
análise de resultado teve que ser feita de forma separada, utilizando os arquivos de saída
gerados pela ferramenta.
64
A integração com o CAeTO, portanto, foi importante para facilitar o processo de
configuração e simulação das arquiteturas de memória, permitindo realizar mais simulações em
menos tempo e com menor esforço.
5.7 Simulação dos Algoritmos de Otimização
A metodologia utilizada para realizar as simulações foi dividida em três etapas: (i)
simulações exaustivas; (ii) simulações com o algoritmo de otimização proposto neste trabalho;
(iii) simulações das técnicas de otimização adaptadas.
Na primeira etapa foram realizadas as simulações exaustivas para cada uma das nove
aplicações, dos benchmarks MiBench e MediaBenchII, definidas na seção 5.4.2. O processo de
simulação exaustiva está apresentado na Figura 22 a seguir.
Figura 22. Processo de simulação exaustiva
Inicialmente uma das nove aplicações é selecionada para ser simulada junto a uma
arquitetura. Depois, são geradas diferentes combinações de parâmetros de hierarquias de
memória com três níveis de cache. Em seguida são identificadas as combinações que resultam
em configurações válidas. Então, é feita a simulação de cada uma destas configurações geradas.
Por fim, é gerado um arquivo de saída com as informações detalhadas sobre cada cache
simulada, assim como é registrado o valor da energia total consumida e do número de ciclos
Gerar combinações de parâmetros
Salvar Resultado
Simular Todas Configurações
Selecionar Aplicação
INÍCIO
FIM Última
Aplicação? Validar Configurações
não
sim
65
total necessários para executar a aplicação. O processo, então, volta para etapa inicial
realizando a simulação para uma nova aplicação.
Na segunda etapa foram realizadas as simulações para permitir a realização da análise
do mecanismo de otimização apresentado no capítulo 6. Assim como o processo de simulação
exaustiva, este algoritmo foi aplicado para cada uma das nove aplicações selecionadas. No
entanto, a fim de reduzir o tempo de simulação da segunda etapa, os arquivos gerados pelas
simulações exaustivas foram utilizados como banco de dados para extrair as informações de
energia e ciclo de uma determinada configuração de arquitetura. Dessa forma, não foi preciso
submeter uma configuração gerada ao mecanismo de cálculo de energia e ciclos. O processo de
simulação desta etapa está apresentado na Figura 23.
Figura 23. Processo de simulação do algoritmo de otimização proposto
O processo inicia com a escolha de uma aplicação. Em seguida é realizada a
configuração dos parâmetros do mecanismo de otimização. A determinação desta configuração
Variar Mecanismo?
Configurar Mecanismo de Otimização
Simular Configurações
Selecionar Configurações
Terminou Otimização?
Salvar Resultados
sim
não
Selecionar Aplicação
sim
sim
INÍCIO
FIM Última Aplicação?
não
não
30x
Inicializar Algoritmo
não
sim
66
é fundamental para encontrar melhores soluções em um espaço de tempo menor. Portanto,
para a técnica proposta foram estudadas diversas configurações a fim de se obter o melhor
valor dos parâmetros de entrada. Uma vez configurado, o mecanismo de otimização é
inicializado e começa o seu ciclo de simulações. Nesta fase, ele seleciona um conjunto de
soluções para serem simuladas, executa a simulação e verifica se o critério de parada foi
satisfeito. Caso tenha terminado, os resultados são salvos em um arquivo. A execução do
algoritmo é, então, repetida trinta vezes, a fim de se obter um resultado mais concreto sobre o
desempenho do algoritmo. Em seguida é verificada se será simulada uma nova configuração do
mecanismo para a mesma aplicação. Finalmente, é verificado se será feita uma nova rodada de
simulações para uma nova aplicação. Caso todas as nove aplicações tenham sido simuladas, o
processo termina.
Na última etapa, foram realizadas simulações para as três técnicas de otimização
apresentadas neste trabalho, com o objetivo de medir o desempenho de cada uma destas
técnicas, para em seguida compará-las. As três técnicas são: NSGAII, SPEA2 e o algoritmo
proposto baseado em evolução diferencial. O processo de simulação desta etapa foi similar ao
da etapa anterior. No entanto, como os parâmetros de configuração dos algoritmos foram
fixados, o ciclo de variação do mecanismo foi desconsiderado, passando-se logo para
verificação do ciclo de aplicações. Dessa forma, cada algoritmo foi executado 30 vezes para
cada uma das aplicações dos benchmarks selecionados.
67
Capítulo
6 6 Evolução Diferencial Aplicada ao
Problema de Exploração
Este capítulo tem como propósito apresentar uma técnica de otimização
desenvolvida para exploração de arquiteturas de sistemas com hierarquias de memórias com
três níveis de cache. A técnica apresentada é baseada no algoritmo evolucionário chamado de
Evolução Diferencial.
68
6.1 Introdução
A técnica de otimização apresenta neste capítulo corresponde a um algoritmo
evolucionário baseado em evolução diferencial que foi adaptado ao problema de exploração de
arquiteturas de memória visando redução de energia e desempenho. Neste capítulo, portanto,
será apresentado o mapeamento do espaço de decisão em um espaço de objetivos, assim
como o mapeamento das soluções em parâmetros de uma hierarquia de memória. Por fim,
será apresentado o algoritmo de evolução diferencial baseado nestes mapeamentos.
6.2 Mapeamento das Soluções
O mapeamento das soluções visa descrever como cada solução do problema é
representada. Em algoritmos evolucionários cada solução é representada na forma de um
indivíduo, que pode definido de várias formas. Para o problema de exploração de arquiteturas
de memória, um indivíduo representa uma configuração de uma arquitetura. Para arquiteturas
com hierarquias de memória de três níveis de cache, um indivíduo é capaz de representar a
associatividade, o tamanho da linha e o tamanho de cada cache. A fim de representar estes
parâmetros, o mapeamento das soluções proposto é criar indivíduos que codificam estes
parâmetros da arquitetura do sistema em números inteiros. Logo, um indivíduo é representado
por um vetor de números inteiros, conforme ilustrado na Figura 24.
Figura 24. Representação de um indivíduo
4 32 2048
IC1 DC1 L2 L3
Tamanho da cache
Tamanho da linha
Associatividade
69
O vetor de solução é dividido em quatro seções, cada seção representa uma cache da
hierarquia. A cache de instruções do primeiro nível e a cache de dados do primeiro nível são
representadas por IC1 e DC1, respectivamente. A cache unificada do segundo nível corresponde
ao L2 e a cache unificada de terceiro nível corresponde ao L3. Cada uma destas caches possui
três números inteiros associados, onde cada inteiro representa um parâmetro de configuração
da cache. No exemplo da Figura 24, a cache L2 foi expandida para representar o vetor de
números inteiros associado a ela. Neste exemplo, portanto, o indivíduo representado possui
uma cache L2 com tamanho de 2048 bytes, um tamanho de linha de 32 bytes e uma
associatividade de valor 4. Logo, para o problema de exploração de arquiteturas com
hierarquias de memória com três níveis de cache, podemos representar uma configuração
através de um indivíduo que corresponde a um vetor de doze números inteiros.
6.3 Mapeamento do Espaço de Exploração
O mapeamento das soluções em indivíduos formados por vetores de doze números
inteiros permite definir o espaço de exploração, também chamado de espaço de busca ou de
decisão, como um espaço com doze dimensões que representa o conjunto das possíveis
soluções. Para este trabalho, o intervalo de variação de cada dimensão do espaço de
exploração foi definido na Tabela 5. Cada solução contida no espaço de busca é mapeada para
o espaço de objetivos, que representa os objetivos que serão otimizados. Portanto, para
avaliação de uma solução, representada por uma configuração de arquitetura, é preciso
mapeá-la no espaço de objetivos, que corresponde a energia consumida e ao número de ciclos.
Embora a busca seja realizada no espaço de decisão, a qualidade da solução é medida
através do espaço de objetivos. Para o problema de otimização de hierarquia de memória
cache os objetivos são minimizar os valores de energia e ciclos que uma configuração de
memória necessita para executar uma determinada aplicação.
Portanto, o mapeamento do espaço de exploração no espaço de objetivos será
fundamental para o processo de busca otimizada apresentado na sessão a seguir, haja vista que
dessa forma é possível qualificar as soluções e direcionar a busca para regiões mais
promissoras.
70
6.4 Evolução Diferencial Aplicada a Exploração de Arquiteturas
O algoritmo de evolução diferencial originalmente foi desenvolvido para problemas de
otimização de domínio contínuo, conforme visto na seção 3.2.4. No entanto, o algoritmo
evolucionário baseado em evolução diferencial apresentado nesta seção corresponde a uma
variação do algoritmo adaptado para o problema de otimização multi-objetivo de domínio
discreto. Portanto, o algoritmo proposto será chamado de evolução diferencial discreta multi-
objetivo (EDDM). O detalhamento da técnica será feito com base no pseudocódigo, desta
adaptação do algoritmo, apresentado no Quadro 7.
Quadro 7. Pseudocódigo da evolução diferencial para otimização discreta multi-objetivo.
1: Gere uma população inicial com indivíduos selecionados de forma aleatória
2: Calcule os objetivos para cada indivíduo da população
3: while o critério de para não for satisfeito do
4: for cada indivíduo de
5: Selecione três indivíduos
6: Geração do
7: for cada parâmetro de
8: Execute a operação de mutação discreta
9: Execute a operação de recombinação discreta
10: end for
11: Calcule os objetivos do novo indivíduo
12: if é melhor que o pai then
13: Coloque o novo indivíduo em uma população
14: end if
15: end for
16: Ordene segundo o critério de dominância
17: Faça a seleção baseada em crowding distance dos indivíduos pertencentes à
18: end while
A primeira etapa consiste na geração de uma população inicial (linha 1). A geração
dessa população é feita através da seleção de indivíduos escolhidos aleatoriamente dentro
do espaço de exploração definido pelo usuário. Cada um dos indivíduos da população gerada
corresponde a uma configuração de arquitetura representada por um vetor de doze números
inteiros definido no mapeamento de soluções apresentado na seção 6.2.
O segundo passo consiste em calcular os valores de energia e ciclos para cada um dos
indivíduos selecionados na etapa anterior (linha 2). O cálculo destes valores corresponde a
71
avaliação dos objetivos dos indivíduos e está relacionado com a configuração da arquitetura
juntamente com a aplicação que está sendo estudada.
A terceira etapa consiste na criação do loop principal do algoritmo (linha 3). Nesta
etapa, portanto, é definido o critério de parada do algoritmo. Para este trabalho, o critério de
parada escolhido foi baseado no indicador de cobertura visto na 3.4.3. O indicador de
cobertura é avaliado sobre a população atual e a população da última geração. Caso não haja
melhoria de uma geração para outra, ou seja, se o valor da cobertura for igual à zero, então o
critério de parada foi satisfeito e o algoritmo é finalizado. Dessa forma, os indivíduos da última
população gerada são considerados uma solução do problema.
Na próxima etapa é criado um loop que irá iterar sobre cada um dos indivíduos alvo
da população atual (linha 4). Dentro deste loop ocorrerão as principais etapas do algoritmo:
mutação, recombinação e seleção. O primeiro passo antes aplicar estes operadores, é escolher
os indivíduos que irão gerar o valor do vetor de mutação diferencial (linha 5). Para tanto, três
indivíduos , diferentes entre si e diferente do indivíduo alvo , são selecionados da
população . O primeiro indivíduo selecionado ( ) corresponde a um indivíduo que representa
uma solução não dominada. Os outros dois indivíduos são selecionados de forma aleatória. O
segundo passo é gerar um valor que será utilizado para o cruzamento (linha 6). Este valor
corresponde a um índice escolhido aleatoriamente entre , onde é o número de
dimensões do problema.
Uma vez que todos os parâmetros para execução dos operadores de mutação, de
recombinação são selecionados, inicia-se as aplicações destes operadores para cada uma das
dimensões do indivíduo alvo , onde corresponde ao contador das dimensões sobre o
qual será iterada (linha 7). No caso do problema de exploração de arquiteturas com
hierarquias de cache com três níveis, foi visto que o vetor que representa o indivíduo é
composto por doze números inteiros. Neste caso este problema é tratado como um problema
de doze dimensões, onde cada dimensão representa um parâmetro de uma cache da
hierarquia. Dessa forma, o índice pode assumir qualquer valor no intervalo de 1 a 12.
O operador de mutação discreta é aplicado sobre cada parâmetro do indivíduo ,
gerando um novo indivíduo (linha 8). O valor da mutação para cada parâmetro é calculado
com base na diferença entre os parâmetros e dos indivíduos e . A forma de
calcular esta diferença será explicada na próxima seção. Depois, este valor de mutação é
72
utilizado para produzir uma perturbação diferencial no parâmetro Então, uma vez que esta
mutação é aplicada para cada valor de , o novo indivíduo é produzido. Os parâmetros deste
novo indivíduo precisam ser truncados dentro do espaço de exploração a fim de se obter um
indivíduo com parâmetros válidos, uma vez que o espaço de exploração é discreto. Este
truncamento é feito pela escolha do parâmetro válido com valor mais próximo ao valor que foi
calculado. Então, é possível representar este novo indivíduo através da seguinte equação:
( − ), (32)
onde o fator assume o valor de 1 para produzir soluções válidas no domínio discreto.
Na próxima fase, o operador de recombinação é aplicado (linha 9) segundo a equação
apresentada a seguir.
{
(33)
onde é a probabilidade de recombinação, e é o valor gerado para cada dimensão, a fim de
testar a probabilidade . Portanto, assim como o operador de mutação, a recombinação é
aplicada para cada um dos parâmetros que compõem um indivíduo. Para garantir a ocorrência
da recombinação, sempre que a iteração assumir o valor de gerado da linha 6, então o
valor do parâmetro será utilizado para compor o novo indivíduo .
Quando os processos de mutação e recombinação são finalizados, a nova configuração
de arquitetura, representada pelo indivíduo é avaliada quanto a energia consumida e ciclos
total (linha 11) segundo o mecanismo apresentado na seção 5.4.5. O processo de seleção vai,
então, avaliar se este novo indivíduo é melhor que o indivíduo alvo baseado no critério de
dominância (linha 12). Caso o indivíduo alvo seja dominado pelo indivíduo , então este
último é colocado em uma população (linha 13). Depois que todos os indivíduos de uma
geração são criados, o conjunto formado pela união de com é ordenado em diferentes
Fronts segundo critério de dominância (linha 16). Finalmente, o operador de seleção é aplicado
ao conjunto resultante de e seleciona os melhores indivíduos baseados no critério
de crowding distance (linha 17) conforme apresentado no Quadro 4. Esta seleção de indivíduos
baseada em crowding distance visa minimizar o problema dos algoritmos de evolução
diferencial relacionado com a concentração rápida das soluções para uma parte do espaço de
busca, o que permite, dessa forma, aumentar a diversidade da solução encontrada.
73
6.5 Exemplo de Execução do Mecanismo de Otimização Proposto
A fim de ilustrar melhor o funcionamento da evolução diferencial aplicada ao problema
de exploração de arquiteturas com hierarquias de memória com três níveis de cache, será
apresentado nesta seção um exemplo de execução deste algoritmo evolucionário. As etapas de
execução do mecanismo estão apresentadas na Figura 25. Cada uma destas etapas será
detalhada nas seções a seguir.
Figura 25. Etapas de um ciclo do mecanismo de otimização proposto
6.5.1 Inicialização
A etapa de inicialização consiste na geração da população inicial e na avaliação dos
indivíduos. Então, para este exemplo, será considerada a população inicial composta por cinco
indivíduos apresentada na Figura 26, assim como os valores dos objetivos, de cada um destes
indivíduos, exibidos na Tabela 10. Além disto, na etapa de inicialização são definidos o critério
de parada e a constante de probabilidade de recombinação . Para este exemplo o critério de
parada será considerado o número máximo de gerações igual a 1, ou seja, o ciclo será
executado apenas uma vez, e a constante assumirá o valor de 0.3 ou 30%.
Seleciona Primeiro Indivíduo
Último Indivíduo?
sim
não
Mutação
Recombinação
Avaliação
Inicialização
Seleção de Sobreviventes
Seleciona Próximo Indivíduo
Terminou?
Resultado
sim
não
Seleção de Pais
74
Figura 26. População inicial
Tabela 10. Avaliação da população inicial
Nº do Indivíduo Total de Ciclos Energia Total
1 6,88E+08 0,40473
2 6,56E+08 0,47955
3 6,71E+08 0,48768
4 6,48E+08 0,39901
5 6,51E+08 0,30276
6.5.2 Seleção de Primeiro Indivíduo
Esta etapa consiste de um procedimento bastante simples de seleção do primeiro
indivíduo da população inicial (Figura 27). No caso deste exemplo o indivíduo abaixo será
selecionado como o indivíduo alvo. Além disto, nesta etapa também é gerado um valor para
. Neste exemplo assumirá o valor 4.
Figura 27. Indivíduo selecionado
6.5.3 Seleção de Pais
Na etapa de seleção de pais são selecionados três indivíduos diferentes do indivíduo
alvo já selecionado na etapa anterior. O primeiro indivíduo, no entanto, é selecionado pelo
IC1 DC1 L2 L3
32KB 32B 2 32B 4 32 16 32B 64 16KB 4MB 1MB
8KB 64B 2 64B 2 64 16 64B 64 4KB 8MB 256KB
32KB 64B 2 64B 4 64 16 64B 16 64KB 4MB 2MB
32KB 32B 4 32B 8 64 16 64B 16 64KB 4MB 256KB
4KB 32B 2 32B 2 32 8 32B 16 4KB 4MB 256KB 1
2
3
4
5
4KB 32B 2 32B 2 32 8 32B 16 4KB 4MB 256KB 1
75
critério de não dominância. Para facilitar a escolha deste indivíduo, as soluções iniciais foram
mapeadas no espaço objetivo conforme ilustrado na Figura 28.
Figura 28. Espaço objetivo da população inicial
Dessa forma, a solução 5 é escolhida como a solução não dominada e as soluções 2 e 3
são escolhidas para completar a etapa de seleção de pais.
6.5.4 Mutação
Na etapa de mutação, cada parâmetro do indivíduo alvo será percorrido e sofrerá
mutação conforme a equação 32 apresentada na seção anterior. Primeiramente, a
representação dos indivíduos é alterada para expressar os valores dos parâmetros em potência
de dois. Depois, é calculado um novo vetor diferencial ( ) das soluções 2 e 3. O processo de
geração deste vetor é apresentado na Figura 29.
76
Figura 29. Vetor diferencial
Uma vez calculado o vetor diferencial, ele é combinado com o primeiro vetor
selecionado, para gerar o novo indivíduo mutado , conforme apresentado na Figura 30.
Figura 30. Vetor mutado
Os valores gerados para o novo indivíduo , no entanto, podem ultrapassar os valores
considerados no espaço de exploração. Neste caso, os valores limites são considerados,
conforme ilustrado na Figura 31, e o indivíduo ( ) resultante da mutação é finalmente gerado.
Figura 31. Indivíduo resultante da mutação
𝟐𝟏𝟓 𝟐𝟓 𝟐𝟏 𝟐𝟓 𝟐𝟐 𝟐𝟓 𝟐𝟒 𝟐𝟓 𝟐𝟔 𝟐𝟏𝟒 𝟐𝟐𝟐 𝟐𝟐𝟎 2
𝟐𝟏𝟑 𝟐𝟔 𝟐𝟏 𝟐𝟔 𝟐𝟏 𝟐𝟔 𝟐𝟒 𝟐𝟔 𝟐𝟔 𝟐𝟏𝟐 𝟐𝟐𝟑 𝟐𝟏𝟖 3
𝟐−𝟐 𝟐𝟏 𝟐𝟎 𝟐𝟏 𝟐−𝟏 𝟐𝟏 𝟐𝟎 𝟐𝟏 𝟐𝟎 𝟐−𝟐 𝟐𝟏 𝟐−𝟐 𝒗𝒅
5
𝟐𝟏𝟑 𝟐𝟔 𝟐𝟐 𝟐𝟔 𝟐𝟐 𝟐𝟕 𝟐𝟒 𝟐𝟕 𝟐𝟒 𝟐𝟏𝟒 𝟐𝟐𝟑 𝟐𝟏𝟔 𝒗
𝟐−𝟐 𝟐𝟏 𝟐𝟎 𝟐𝟏 𝟐−𝟏 𝟐𝟏 𝟐𝟎 𝟐𝟏 𝟐𝟎 𝟐−𝟐 𝟐𝟏 𝟐−𝟐 𝒗𝒅
𝟐𝟏𝟓 𝟐𝟓 𝟐𝟐 𝟐𝟓 𝟐𝟑 𝟐𝟔 𝟐𝟒 𝟐𝟔 𝟐𝟒 𝟐𝟏𝟔 𝟐𝟐𝟐 𝟐𝟏𝟖
8KB 64B 4 64B 4 128
B 16
128B
16 16KB 8MB 64KB 𝒗
8KB 64B 4 64B 4 64B 16 64B 16 16KB 8MB 256KB 𝒗
77
6.5.5 Recombinação
O operador de recombinação é aplicado sobre o indivíduo mutado da etapa anterior
junto com o indivíduo alvo conforme a equação 32. Para tanto, ele aplica a probabilidade de
recombinação ( ) em cada parâmetro do indivíduo alvo ou verifica se o número do parâmetro
corresponde ao número gerado na etapa de seleção do indivíduo alvo, . Caso a
recombinação do parâmetro ocorra, então, o parâmetro do indivíduo mutado substituirá o
parâmetro do indivíduo alvo, conforme ilustrado na Figura 32. Neste exemplo, será gerado um
novo indivíduo composto por parte do indivíduo alvo (indivíduo 1) e por parte do indivíduo
mutado .
Figura 32. Indivíduo gerado pela recombinação
No caso do exemplo apresentado na Figura 32, um valor foi gerado para cada
parâmetro e então comparado com o valor de . O indivíduo , portanto, corresponde
ao resultado da etapa de recombinação.
6.5.6 Avaliação
Na etapa de avaliação, os objetivos do indivíduo gerado na etapa de recombinação
são calculados. Estes objetivos, então, são comparados com os objetivos do indivíduo alvo.
Caso a solução domine a solução representada pelo indivíduo alvo, ele será adicionado a
população .
Para o exemplo tratado nesta seção os objetivos calculados para , junto com os
objetivos do indivíduo alvo, estão ilustrados na Tabela 11.
4KB 32B 2 32B 2 32B 8 32 16 4KB 4MB 256KB 𝟏
8KB 64B 4 64B 4 64B 16 64B 16 16KB 8MB 256KB 𝒗
8KB 32B 4 32B 2 32B 8 64B 16 16KB 8MB 256KB 𝒖𝟏
0.15 0.76 0.27 0.73 0.51 0.89 0.42 0.28 0.67 𝒋𝒓𝒂𝒏𝒅
𝟒 0.05 0.62 𝑟𝑗
78
Tabela 11. Valores de energia e ciclos para o indivíduo gerado e o indivíduo alvo
Indivíduo Total de Ciclos Energia Total
1 6,88E+08 0,40473
6,68E+08 0,40061
A Figura 33 abaixo apresenta o mapeamento do novo indivíduo gerado no espaço de
objetivos, o que permite comparar a solução com as demais soluções. Outra solução
também foi adicionada para ilustrar melhor o funcionamento das próximas etapas.
Figura 33. Comparação da solução gerada com outros indivíduos
Neste exemplo, as soluções geradas e não são dominadas por suas respectivas
soluções alvo e, portanto, serão adicionadas a população . Os ciclos dos demais indivíduos da
população foram omitidos, pois seguem o mesmo comportamento do primeiro ciclo. Então,
será apresentada na próxima seção a última etapa que corresponde a seleção de sobreviventes.
79
6.5.7 Seleção de Sobreviventes
A seleção de sobreviventes é realizada com base no critério de crowding distance,
conforme explicado na seção 6.4, e é aplicada sobre o conjunto formado pela população inicial
junto com a população gerada . Primeiramente o conjunto é ordenado segundo o
critério de dominância para encontrar os diferentes Fronts. Neste exemplo vamos considerar
apenas um Front formado pelas cinco soluções iniciais mais as duas soluções geradas. Então o
processo de seleção por crowding distance é aplicado. O cálculo do crowding distance inicia
através da ordenação dos elementos, em ordem crescente, com respeito a cada um dos seus
objetivos, conforme a ilustrado na Figura 34.
Figura 34. Ordenação dos indivíduos baseado nos valores dos objetivos
Para os elementos que possuem os valores extremos, máximo e mínimo, o valor do
crowding distance é considerado infinito. Para os demais elementos ele é calculado conforme a
equação 15 apresenta na seção 3.3.1.
( [ ]) ( [ ])− ( [ ])
−
, (34)
onde é o número do objetivo, é o índice da lista e representa o valor do objetivo de um
elemento .
80
Então, para lista ordenada pelo valor do total de ciclos (objetivo 1), o cálculo do
valor de crowding distance ( ) do segundo elemento da lista é feito da seguinte forma:
( [ ]) ( [ ]) − ( [ − ])
−
( ) − ( )
( ) − ( )
Os demais elementos seguem os mesmo critérios. Dessa forma, é possível obter as duas
listas apresentadas na Figura 35.
Figura 35. Valor de crowding distance para cada objetivo
Finalmente, para calcular o crowding distance de uma solução, basta somar os para
cada valor de . Dessa forma, podemos ordenar as soluções deste exemplo segundo o valor de
crowding distance conforme ilustrado na Figura 36.
Figura 36. Front ordenado por valor de crowding distance
Como o tamanho da população de uma geração para outra se mantém constante,
apenas os indivíduos apresentados nas cinco primeiras posições seriam selecionados, pois
obtiveram um valor maior para o indicador de crowding distance.
81
Capítulo
7
7 Resultados
Este capítulo tem como propósito apresentar os resultados alcançados com a
utilização do mecanismo de exploração desenvolvido, associado ao algoritmo de otimização
baseado em evolução diferencial, para redução de energia e ciclos de arquiteturas com
hierarquias de memória com três níveis de cache. Por fim, os resultados serão comparados com
outros algoritmos de otimização.
82
7.1 Introdução
Neste capítulo, serão apresentados os resultados da aplicação do mecanismo de
exploração de hierarquias de memória com três níveis de cache, junto com diferentes técnicas
de otimização para o problema de exploração de arquiteturas visando à redução de energia e
ciclos. Os algoritmos de otimização escolhidos para este trabalho correspondem ao NSGAII,
SPEA2 e o EDDM. Os dois primeiros são algoritmos que já foram utilizados com sucesso no
problema de exploração de hierarquias de memória, e que servirão como referencia para
comparação dos resultados obtidos com o último algoritmo (EDDM) desenvolvido neste
trabalho. Por se tratar de técnicas de otimização não determinísticas, a execução de cada
técnica foi repetida 30 vezes conforme o processo de simulação definido na seção 5.7.
7.2 Ambiente de Simulação
O ambiente de simulação utilizado para gerar os resultados deste trabalho é formado
por cinco componentes: aplicações, ferramenta de simulação, algoritmos de otimização, espaço
de exploração e máquina utilizada para realizar as simulações. O primeiro componente
necessário para realizar as simulações foi a definição das aplicações simuladas. Para este
componente foram escolhidos dois benchmarks, MiBench e MediaBenchII, formados pelas
aplicações bitcount, CRC, dijkstra, SHA, susan, djpeg, mpeg2enc, mpeg2dec e h263enc. O
segundo componente corresponde a ferramenta de simulação. Neste caso foi adotada a
ferramenta desenvolvida pelo grupo de pesquisa chamada CAeTO, que precisou ser integrada
com o novo mecanismo de exploração proposto neste trabalho. Esta integração foi descrita na
seção 5.6. O terceiro componente é representado pelos algoritmos de otimização que foram
adaptados para o problema de exploração de hierarquias de memória cache com três níveis.
Para realizar as simulações foram utilizadas as técnicas de otimização NSGAII, SPEA2, assim
como o algoritmo baseado em evolução diferencial, desenvolvido neste trabalho, apresentado
no capítulo 6. O quarto componente do ambiente de simulação corresponde ao espaço de
exploração definido na seção 5.4.1. O quinto e último componente, corresponde a definição da
máquina utilizada para realizar as simulações. O computador escolhido para executar as
simulações foi um Intel Core i7-2600k 3.4GHz com 8GB de memória RAM com sistema
operacional Ubuntu 10.04 64 bits.
83
7.3 Análise de Abordagem Proposta
Nesta seção, serão apresentadas algumas análises que permitiram a definição da
população inicial do algoritmo, entender o comportamento da convergência do algoritmo
evolucionário proposto, assim como avaliar o desempenho deste algoritmo.
7.3.1 Impacto do Tamanho da População Inicial
O gráfico da Figura 37 apresenta o número de simulações necessário, em cada geração,
para cinco valores diferentes de população inicial (10, 20, 30, 40 e 50 indivíduos). O gráfico
indica que o número de simulações requeridas aumenta proporcionalmente com o tamanho da
população inicial. O espaço de exploração considerado neste trabalho é formado por 28.800
diferentes configurações de hierarquias de memória válidas, então, a fim de reduzir o tempo de
processamento e manter o número de simulações compatível com as heurísticas de otimização,
foi considerado um tamanho da população inicial com 20 elementos. Adicionalmente, trabalhar
com um número alto para população inicial acarreta em ter que realizar um número excessivo
de simulações, conforme ilustrado na Figura 37.
Figura 37. Número de simulações x Gerações, considerando diferentes populações iniciais (10, 20, 30, 40, 50 indivíduos) e aplicação h263enc
84
A Figura 38 apresenta o valor da menor energia consumida por um indivíduo da
população em cada geração. Considerando que o valor inicial da população afeta a qualidade
da solução final, seu impacto foi avaliado com respeito à energia consumida e ao número de
gerações máximo de 50, mesmo que não seja necessário, uma vez que a convergência ocorre
antes deste valor máximo. O gráfico ilustra cinco casos para as populações iniciais: 10, 20, 30,
40 e 50 indivíduos. É importante salientar que a escolha dos indivíduos que compõem a
população inicial é feita de forma aleatória.
Figura 38. Evolução do menor valor da energia consumida por uma população em relação ao número da geração para a aplicação h263enc
A simulação Ilustrada na Figura 38 permite extrair as seguintes conclusões: (a) em um
primeiro nível, que inclui somente a população inicial de 10 indivíduos, o mecanismo de
otimização foi incapaz de encontrar um indivíduo com baixo consumo de energia, mesmo
sendo executado em 50 gerações; (b) no secundo nível, que inclui as populações iniciais de 20,
30, 40 e 50 indivíduos, o mecanismo encontrou configurações perto do Pareto Ótimo e a
convergência ficou em torno de 10 gerações; (c) uma pequena diferença entre os níveis de
85
convergência foi observada no segundo nível, entretanto, a população inicial de 40 indivíduos e
a de 50 indivíduos obtiveram melhores resultados.
Baseado nesta análise de consumo de energia por geração, embora o melhor valor para
população inicial seja algo entre 40 e 50 indivíduos, é recomentada a utilização de 20 indivíduos
como padrão para população inicial, conforme definido na análise da Figura 37, uma vez que o
número de simulações requeridas aumenta bastante com relação ao aumento deste
parâmetro, e os resultados obtidos ficaram próximos aos resultados ótimos.
De forma similar a análise realizada para o consumo de energia, as conclusões para os
experimentos realizados para o número de ciclos em função do número de gerações (Figura 39)
foram idênticas, considerando a mesma aplicação e os mesmos valores para população inicial.
Figura 39. Evolução do menor valor total de ciclos de uma população em relação ao número da geração para a aplicação h263enc
86
7.3.2 Convergência das Soluções
A técnica de otimização proposta neste trabalho (EDDM) foi aplicada para exploração de
hierarquias considerando três níveis cache conforme descrito no ambiente de simulação da
seção 7.2. Cada ponto exibido na Figura 40 corresponde a uma configuração obtida por esta
técnica e é representado no espaço objetivo como um par (energia, ciclos). O gráfico apresenta
a energia consumida e o número total de ciclos, necessários para executar a aplicação h263enc,
para quatro diferentes gerações (1, 3, 5 e 10). No resultado da exploração para a primeira
geração (representada pelo quadrado azul), os pontos estão espalhados por todo o espaço de
busca, dificultando a definição dos Fronts. O resultado para a terceira geração (representado
pelo circulo verde) mostra uma baixa concentração dos pontos próximos de um Pareto. Na
quinta geração (representada pelo triangulo azul) é possível observar que o Front está quase
formado. Somente depois de dez gerações (representadas pelo losango preto) é possível ver
claramente que o Pareto está mais evidenciado. Portanto, foi possível observar que o algoritmo
de otimização EDDM converge muito rápido, pois entre 5 e 10 gerações já é possível observar a
formação de um Pareto.
Figura 40. Evolução do Pareto em função do número de gerações para a aplicação h263enc e população inicial de 20 indivíduos
87
7.3.3 Desempenho da Abordagem Proposta
O desempenho do algoritmo de otimização proposto foi avaliado quanto à qualidade
das soluções relacionada com a capacidade de encontrar soluções próximas ao Pareto Ótimo e
ao tempo de necessário para gerar este conjunto de soluções. Os resultados relacionados com
a qualidade das soluções encontradas pelo algoritmo apresentaram um bom desempenho, pois
o algoritmo foi capaz de encontrar soluções próximas ao Pareto Ótimo. Algumas simulações
foram realizadas considerando os resultados das análises das seções 7.3.1 e 7.3.2. O algoritmo
de evolução diferencial, portanto, foi simulado considerando uma população inicial de vinte
indivíduos, assim como foi estabelecido um critério de parada de dez gerações. O valor da
probabilidade de cruzamento foi fixado em 0.3, seguindo os artigos publicados com este tipo de
algoritmo aplicado a problemas de domínio discreto [20]. As simulações foram realizadas para
todas as nove aplicações definidas na seção 7.2. Os resultados apresentados para estas
simulações foram confrontados com o restante do espaço de busca, representando resultados
das simulações exaustivas de cada algoritmo, conforme ilustrado na Figura 41.
88
Figura 41. EDDE x Simulação Exaustiva para as aplicações dos benchmarks MediabenchII e MiBench. (a) Bitcount. (b) CRC. (c) Dijkstra. (d) DJPEG. (e) H263enc. (f) MPEG2dec. (g)
MPEG2enc. (h) SHA. (i) Susan.
Conforme mostrado na Figura 41, os valores de cada solução da simulação exaustiva
foram representados por quadrados azuis claros, enquanto os resultados do algoritmo de
otimização foram representados por círculos azuis escuros. Apesar dos valores encontrados
pelo mecanismo de otimização proposto estarem bastante próximos ao Pareto Ótimo, a
característica do algoritmo de concentração das soluções ainda se mostrou evidente em alguns
casos, mesmo com a introdução da seleção baseada em crowding distance. As métricas de
avaliação destes resultados serão apresentadas na próxima seção, onde um número grande de
89
simulações foi realizado e os resultados foram comparados aos de outros algoritmos que são
referências para o problema de otimização de hierarquias de memória.
Outro ponto importante avaliado sobre o mecanismo de otimização proposto foi a
velocidade com que ele consegue gerar o conjunto de soluções ótimas. Como o número de
simulações é fixo para cada tamanho de população inicial, conforme exibido no gráfico da
Figura 37, e para estes testes foi considerado o número máximo de gerações de 10, então, é
possível calcular o percentual do espaço de exploração que foi utilizado pelo algoritmo de
otimização. Este cálculo corresponde a multiplicação do número de indivíduos da população
inicial pelo número de gerações necessárias. Neste caso, foi preciso simular 200 soluções de um
espaço de busca composto por 28.800 soluções, ou seja, foi preciso explorar apenas 0,7% do
espaço total de exploração. Os tempos para encontrar o conjunto de soluções, apresentados na
Tabela 12, estão diretamente relacionados com este baixo percentual de exploração durante o
processo de simulação.
Tabela 12. Tempo de exploração exaustiva x Tempo de exploração otimizada
Aplicação % de exploração Tempo Otimizado Tempo Exaustivo
Djepg 0,7% 03h 06m 18d 16h
mpeg2dec 0,7% 02h 33m 15d 08h
mpeg2enc 0,7% 06h 30m 39d 08h
h263enc 0,7% 02h 13m 13d 08h
Bitcount 0,7% 00h 36m 03d 16h
Crc 0,7% 00h 33m 03d 08h
Dijkstra 0,7% 00h 43m 04d 08h
Sha 0,7% 00h 40m 04d 00h
Susan 0,7% 00h 10m 01d 00h
A utilização do algoritmo de evolução diferencial discreta multi-objetivo para o
problema de exploração de hierarquias de memórias permite ao projetista de hardware
economizar cerca de 99,3% do tempo necessário para decidir sobre a arquitetura ideal do
sistema. Entretanto, para estes testes foi considerado um critério de parada por número
máximo de gerações, baseado no pior caso apresentado no estudo da seção 7.3.2, uma vez que
o algoritmo pode convergir entre 5 a 10 gerações. Na próxima seção serão apresentados os
resultados deste algoritmo para outro critério de parada que permitiu reduzir ainda mais o
tempo de simulação do algoritmo.
90
7.4 Comparação com Outros Mecanismos de Otimização
O algoritmo de otimização EDDM foi comparado com outros dois algoritmos genéticos
utilizados para o problema de otimização de hierarquias de memória, o NSGAII e o SPEA2. O
processo de simulação adoptado para gerar os resultados desta seção foi definido na seção 5.7.
Conforme descrito neste processo, por se tratarem de técnicas de otimização não
determinísticas, a execução de cada uma delas foi repetida 30 vezes com o intuito de se coletar
a média dos resultados.
O critério de parada adotado por todos os três algoritmos foi baseado em cobertura.
Neste tipo de critério, a execução de cada algoritmo encerra quando as soluções da última
iteração não cobrem mais as soluções da iteração anterior. Dessa forma, o algoritmo executa
até o momento de convergência, o que evita que sejam realizadas simulações que influenciam
pouco na qualidade dos resultados. Este tipo de abordagem é interessante quando o custo de
cada simulação é alto e é importante que se tenha o menor número de simulações possível
para a obtenção do conjunto ótimo de soluções. Outra vantagem da escolha deste critério de
parada é que cada um dos algoritmos tem uma velocidade de convergência diferente. Logo, no
caso de um critério de parada por número máximo de gerações, a qualidade dos resultados de
um algoritmo poderia ficar comprometida, enquanto de outro, seriam realizadas simulações
extras que não trariam ganho na qualidade das soluções, apenas aumentariam o tempo de
simulação delas.
Todas as três técnicas de otimização analisadas nesta seção (NSGAII, SPEA2 e EDDM)
foram avaliadas quanto a sua capacidade de otimizar energia e ciclos para problema de
exploração de hierarquias de memória. Entretanto, avaliar a qualidade das soluções geradas e a
velocidade de geração destas soluções para cada algoritmo não é uma tarefa fácil. Para tanto,
foram escolhidas três formas de comparar os algoritmos de otimização. A primeira visa
comparar a velocidade de geração do conjunto de soluções ótimas. As outras duas formas são
aplicadas para medir a qualidade das soluções propostas por cada uma das técnicas.
A primeira forma de comparar as técnicas, portanto, permite avaliar cada algoritmo
quanto ao número de simulações necessárias para encontrar o conjunto ótimo de soluções.
Cada uma destas técnicas foi executada para as nove aplicações. O resultado desta comparação
está ilustrado na Figura 42. O valor que representa o número de simulações corresponde ao
91
valor médio calculado a partir do número total de simulações das trinta execuções de cada
algoritmo de otimização. Além disto, a figura apresenta a média do número de simulações para
cada aplicação.
Figura 42. Número de simulações necessárias para cada técnica, para cada aplicação
O número de simulações executado por uma técnica corresponde ao número de vezes
que foi necessário simular uma determinada configuração de cache para observar o
comportamento da arquitetura em relação aos valores de energia e ciclos. Como cada
simulação tem um custo de tempo e processamento, é desejável que as técnicas executem o
menor número de simulações possível.
Conforme apresentado na Figura 42 o algoritmo de otimização EDDM precisa simular
em média 118 soluções do espaço de exploração de 28.800, para encontrar um conjunto de
soluções ótimas. O algoritmo de otimização SPEA2 apresentou um resultado bastante similar ao
do EDDM, precisando em média de 143 simulações. O terceiro algoritmo, NSGAII, apresentou
resultados bem inferiores aos dos outros dois algoritmos, precisando em média de 768
simulações para conseguir gerar um conjunto de soluções ótimas. Apesar deste número de
simulações do último algoritmo parecer elevado, ele corresponde a apenas 2,6% do espaço de
exploração. Outro aspecto sobre o NSGAII é que o número médio de simulações apresentou
uma variação maior de aplicação para aplicação, o que o torna mais imprevisível quando se
quer estimar o número de simulações necessárias. Já os outros dois algoritmos, EDDM e SPEA2,
o número médio de simulações possui uma variação pequena para cada aplicação. Dessa
djpegmpeg2
encmpeg2
dech363enc
bitcount crc dijkstra sha susan Média
NSGAII 934 875 765 800 763 702 705 720 646 768
SPEA2 170 159 142 150 133 130 125 147 128 143
EDDM 142 135 125 116 111 108 112 115 102 118
0
100
200
300
400
500
600
700
800
900
1000
Nú
mer
o d
e Si
mu
laçõ
es
92
forma, é possível dizer que em média o EDDM precisa explorar 0,41% do espaço total de busca
para gerar o conjunto de soluções ótimas, enquanto o SPEA2 e o NSGAII precisam de 0,5% e
2,6% respectivamente.
A segunda forma de comparar as técnicas de otimização é através da utilização de uma
métrica chamada de hipervolume. A característica que difere esta métrica das demais é que ela
consegue medir a convergência das soluções encontradas em relação ao Pareto Ótimo, assim
como o espalhamento das soluções ao longo do Pareto. Quanto maior o valor do hipervolume
melhor, indicando que as soluções encontradas estão mais espalhadas e próximas ao Pareto
Ótimo. Essa é uma métrica bastante utilizada para comparação entre técnicas de otimização
multi-objetivo, assim como é utilizado em [21] [22]. A Tabela 13 apresenta os resultados do
valor médio do indicador de hipervolume calculado sobre as trinta simulações de cada uma das
técnicas de otimização, para cada uma das nove aplicações selecionadas.
Tabela 13. Resultados da métrica de hipervolume
Aplicação EDDM SPEA2 NSGAII Melhor
djpeg 4,44E+15 2,15E+14 1,04E+15 EDDM
h263enc 7,60E+09 3,94E+08 2,11E+09 EDDM
mpeg2enc 5,69E+14 2,82E+13 1,53E+14 EDDM
mpeg2dec 4,07E+10 1,75E+09 8,51E+09 EDDM
bitcount 3,05E+06 1,41E+05 6,54E+05 EDDM
crc 1,68E+07 6,98E+05 3,31E+06 EDDM
dijkstra 5,92E+08 2,36E+07 1,15E+08 EDDM
sha 4,53E+07 2,10E+06 9,37E+06 EDDM
susan 9,83E+02 3,77E+01 1,69E+02 EDDM
Conforme apresentado na Tabela 13, o algoritmo de otimização EDDM obteve os
melhores resultados para o indicador de hipervolume para todas as nove aplicações. O
algoritmo NSGAII também obteve bons resultados, ficando a frente do SPEA2 para os valores
calculados para todas as aplicações.
A terceira forma de comparar os três algoritmos analisados é através do indicador de
distância generacional. Este indicador, assim como o indicador de hipervolume, visa comparar a
qualidade do conjunto de soluções ótimas gerado por cada técnica. Essa métrica mede o quão
próximas estão as soluções encontradas por cada técnica em relação às soluções do Pareto
Ótimo. No entanto, para aplicar esta métrica é preciso saber qual é o Pareto Ótimo, portanto,
foi preciso realizar uma simulação exaustiva para cada aplicação, para então, extrair o conjunto
93
das melhores soluções que serão utilizadas como referência do cálculo da distância
generacional. Este trabalho de simulação exaustiva, no entanto, já havia sido realizado para
validação do algoritmo de otimização EDDM e, portanto, não precisou ser refeito. No entanto
para casos onde o Pareto Ótimo não possa ser encontrado facilmente, pode-se utilizar um
Pareto Front como referência para o cálculo da métrica. Quanto menor o valor da métrica de
distância generacional, melhor o conjunto de resultados, pois indicam que as soluções
encontradas estão mais próximas do conjunto ótimo de soluções.
A Tabela 14 apresenta os resultados do valor médio do indicador de distância
generacional calculado sobre as trinta simulações de cada uma das técnicas de otimização, para
cada uma das nove aplicações selecionadas.
Tabela 14. Resultados da métrica de distância generacional Aplicação EDDM SPEA2 NSGAII Melhor
djpeg 4,58E+05 3,45E+09 8,46E+09 EDDM
h263enc 1,40E+05 2,22E+05 1,46E+05 EDDM
mpeg2enc 2,37E+04 9,25E+04 2,44E+05 EDDM
mpeg2dec 2,80E+04 5,00E+04 1,94E+05 EDDM
bitcount 1,30E+03 1,24E+02 1,40E+03 SPEA2
crc 5,11E+02 1,91E+03 4,68E+02 NSGAII
dijkstra 7,69E+03 8,65E+03 4,63E+04 EDDM
sha 7,77E+02 2,50E+03 6,65E+03 EDDM
susan 8,83E+00 5,03E+01 3,00E+01 EDDM
Conforme apresentado na Tabela 14 a técnica de otimização EDDM obteve melhores
resultados para sete das nove aplicações simuladas, ou seja, a técnica foi melhor em 78% dos
casos analisados. Dessa forma, é possível afirmar que o conjunto de soluções encontrado pelo
algoritmo evolucionário proposto neste trabalho é capaz de encontrar soluções mais próximas
às soluções do Pareto Ótimo quando comparado aos algoritmos NSGAII e SPEA2, apesar de em
alguns casos o algoritmo EDDM ter obtido resultados bastante próximos aos dois outros
algoritmos, haja vista que o NSGAII e o SPEA2 são técnicas que apresentam bons resultados
para esta métrica de distância generacional.
Finalmente, considerando o desempenho apresentado pelo EDDM para número de
simulações, para os indicadores de hipervolume e distância generacional é possível afirmar que
o EDDM é capaz de gerar soluções ótimas mais rapidamente e com uma qualidade superior a
das técnicas NSGAII e SPEA2, quando aplicado ao problema de exploração de hierarquias de
memória com três níveis de cache visando redução de energia e ciclos.
94
Capítulo
8
8 Conclusões e Trabalhos Futuros
Este capítulo tem como objetivo apresentar algumas considerações finais sobre os
principais tópicos abordados nesta dissertação, incluindo as contribuições alcançadas e
indicações para trabalhos futuros.
95
8.1 Considerações Finais e Contribuições
Neste trabalho foi proposto um novo modelo para estimativa de consumo de energia e
desempenho em arquiteturas de sistemas com hierarquias de memória com três níveis de
cache, considerando uma tecnologia de transistores de 32 nanômetros. Para tanto, foi
necessário expandir a ferramenta de simulação de arquiteturas SimpleScalar, a fim de simular o
terceiro nível de memória cache, assim como foi preciso adaptar duas ferramentas de
estimativa de energia de memória cache e memória principal. Por fim, todas as ferramentas
foram integradas em um mecanismo de cálculo de ciclos e energia total que recebe como
entrada aplicações e configurações de hierarquias de memória.
Além disto, um novo algoritmo de otimização baseado em evolução diferencial foi
proposto, visando reduzir o tempo de exploração de hierarquias de memória. Para validação
deste algoritmo, ele foi submetido a nove aplicações de dois benchmarks diferentes (MiBench e
MediaBenchII), e os resultados foram analisados segundo dois indicadores de qualidade
(hipervolume e distância generacional) e um de velocidade (tempo de simulação). Ao analisar
os resultados de velocidade da busca realizada pelo algoritmo, foi concluído que a técnica de
otimização proposta é capaz de gerar um conjunto de soluções ótimas explorando em média
0,41% do espaço de busca, ou seja, reduzindo cerca de 99,6% do tempo de exploração. Quanto
aos indicadores de qualidade, os resultados mostraram que o algoritmo proposto (EDDM) foi
melhor em 100% dos casos estudados para a métrica de hipervolume e 78% dos casos para a
métrica de distância generacional, quando comparados a outros dois algoritmos (NSGAII e
SPEA2) bastante utilizados para o mesmo tipo de problema de exploração de configurações de
hierarquias de memória. Portanto, assim como o trabalho proposto em [20], a evolução
diferencial aplicada a problemas de otimização no domínio discreto obteve bons resultados
quando comparada a outros algoritmos evolucionários.
Finalmente, o novo mecanismo de cálculo de energia e ciclos, junto com o algoritmo de
otimização desenvolvido, foi integrado a um ambiente gráfico de simulação de arquiteturas
capaz de proporcionar ao projetista de hardware a realização de estudos de diversas
arquiteturas em paralelo, o que permite reduzir ainda mais o tempo de projeto de um sistema.
96
8.2 Trabalhos Futuros
Os principais trabalhos que podem ser realizados a partir deste trabalho são:
1. Expandir o módulo de comparação de resultados disponível no CAeTO para
comparar os resultados das técnicas de otimização aplicadas a hierarquias com três
níveis de cache;
2. Expandir o ambiente gráfico de simulação para suportar vários modelos de
memórias principais;
3. Aumentar o número de aplicações simuladas, visando à simulação de aplicações
cada vez mais complexa e que permitam explorar mais o potencial do terceiro nível
de memória cache;
4. Expandir o modelo de estimativa de energia e ciclos para arquiteturas de sistemas
baseados em NOC (Network-on-Chip).
97
Referências Bibliográficas
Este capítulo tem como objetivo apresentar as referências bibliográficas detalhadas
utilizadas no processo de elaboração desta Dissertação de Mestrado.
98
[1] Burger, D.; Austin, T.M.; “The SimpleScalar Tool Set, Version 2.0”; Computer Architecture
News; Vol 25(3). June 1997. pp.13-25.
[2] Sugumar, R.A. and Abraham, S.G.; “Efficient simulation of multiple cache configurations
using binomial trees”, Technical Report CSE-TR-111-91, CSE Division, Univ. of Michigan,
1991.
[3] N. Muralimanohar, R. Balasubramonian, and N. P. Jouppi, “CACTI 6.0: A tool to model large
caches,” 2009. Disponível em: http://www.hpl.hp.com/techreports/2009/HPL-2009-
85.html. Acessado em: 10 de abril de 2013.
[4] M.Ehrgott. Multicriteria Optimization. Springer, Berlin, segunda edição, 2005. ISBN 3-540-
21398-8.
[5] V. Pareto. Cours D’Economie Politique, volume I e II. F. Rouge, Lausanne, 1896.
[6] HORN, J.; NAFPLIOTIS, N.; GOLDBERG, D.E. A Niched Pareto genetic algorithm for
multiobjective optimization. 1st IEEE Conference Of Evolutionary Computation. 1994. vol. 1,
p. 67-72.
[7] SRINIVAS, N; DEB, K. Multiobjective Function Otimization Using Nondominated Sorting
Genetic Algorithms, Evolutionary Computation. 1995. v. 2, p. 221-248.
[8] DEB, K.; AGRAWAL, S.; MEYARIVAN, T. A Fast Elitist Nondominated Sorting Genetic
Algorithm for Multi-objective Optimization: NSGA-II. Parallel Problem Solving from Nature,
2000, p. 849-858.
[9] ZITZLER, E.; LAUMMANS, M.; THIELE, L. SPEA2: Improving the Strength of Pareto
Evolutionary Algorithm for Multiobjective Optimization. Technical Report 103, Computer
Engineering and Networks Laboratory (TIK), Swiss Federal Institute of Technology (ETH),
Switzerland, 2001.
[10] Storn, R. e Price, K., “Differential Evolution - a Simple and Efficient Adaptive Scheme for
Global Optimization over Continuous Spaces” , Technical Report TR-95-012, ICSI, 1995.
[11] Quan-Ke Pan, Mehmet Fatih Tasgetiren, Yun-Chia Liang, A discrete differential evolution
algorithm for the permutation flowshop scheduling problem, Computers & Industrial
Engineering, Volume 55, Issue 4, November 2008, Pages 795-816, ISSN 0360-8352,
http://dx.doi.org/10.1016/j.cie.2008.03.003.
[12] Mingming Zhang; Shuguang Zhao; Xu Wang, "Multi-objective evolutionary algorithm
based on adaptive discrete Differential Evolution," Evolutionary Computation, 2009. CEC
'09. IEEE Congress on , vol., no., pp.614,621, 18-21 May 2009
doi: 10.1109/CEC.2009.4983002.
99
[13] FONSECA, C. M.; et al. A Tutorial on the Performance Assessment of Stochastic
Multiobjective Optimizers. Third International Conference on Evolutionary Multi-Criterion
Optimization, 2005.
[14] VELDHUIZEN, D. A. V.; LAMONT, G. B. Multiobjective Evolutionary Algorithm Research: A
History and Analysis. Technical Report: TR-98-03, 1998.
[15] ZITZLER, E.; THIELE, L. Multiobjective Optimization Using Evolutionary Algorithms – A
Comparative Case Study. Parallell Problem Solving from Nature, 1998. p. 292-301.
[16] Micron. DDR3L Memory Power Calculator. 2011. Disponível em:
http://www.micron.com/~/media/Documents/Products/Power%20Calculator/DDR3L_Pow
er_Calc.XLSM. Acesso em abril de 2013.
[17] M. R. Guthaus, J. S. Ringenberg, D. Ernst, T. M. Austin, T. Mudge,R. B. Brown, Mibench: A
free, commercially representative embedded benchmark suite. In Proceedings of the
Workload Characterization, 2001. WWC-4. IEEE International Workshop, 2001, pp.3–14.
[18] Jason E. Fritts, Frederick W. Steiling,Joseph A. Tucek. MediaBench II video: expediting
the next generation of video systems research. Proc. SPIE 5683, Embedded Processors for
Multimedia and Communications II, 79 Mar. 2005.
[19] ZITZLER, E.; THIELE, L. Multiobjective Optimization Using Evolutionary Algorithms – A
Comparative Case Study. Parallell Problem Solving from Nature, 1998. p. 292-301.
[20] ROBIE, T.; FILIPIE ,B. Differential Evolution Versus Genetic Algorithms in Multiobjective
Optimization. EMO 2007. LINCS., vol 4403, pp. 257-271. Springer, Heidelberg (2007).
[21] ASCIA, G.; CATANIA, V.; PALESI, M. A GA-Based Design Space Exploration Framework for
Parameterized System-On-A-chip Platforms. IEEE Transactions On Evolutionary
Computation, 2004. v. 8, n. 4.
[22] Perez-Perez, R., et al. Multiobjective Algorithms to Optimize Broadcasting Parameters in
Mobile Ad-hoc Networks, Evolutionary Computation. CEC 2007, 2007. p. 3142 - 3149.
[23] Zhang, C.,Vahid, F. A self-tuning cache architecture for embedded systems. In
Proceedings of the Design, Automation and Test (DATE) Conference in Europe, 2004.
[24] Givargis, T., Vahid, F. Platune: a tuning framework for system-ona- chip platforms. IEEE
Transactions on Computer Aided Design,Nov. 2002.
[25] Palesi, M., Givargis, T. Multi-objective design space exploration using genetic algorithms.
Internacional Wordshop on Hardware/Software Codesign, May 2002.
[26] A. Gordon-Ross, F. Vahid, N. Dutt. Automatic Tuning of Two-Level Caches to Embedded
Aplications. Design Automation & Test in Europe, Feb. 2004, pp.208-213.
100
[27] Zhang, C., Vahid, F., Cache configuration exploration on prototyping platforms. 14th IEEE
Interational Workshop on Rapid System Prototyping, Jun. 2003.
[28] A.G. Silva-Filho, M.E. Lima, P.S. Nascimento, R. Eskinazi. An Energy-Aware Exploration
Approach Based on Open Software Enviroment, IESS, July 2005, pp.97-102.
[29] A.G. Silva-Filho; F.R. Cordeiro; R.E. Sant’Anna; M.E. Lima. Heuristic for Two-Level Cache
Hierarchy Exploration Considering Energy Consumption and Performance, PATMOS, 2006,
pp.75-83.
[30] A.G. Silva-Filho, C.J.A. Bastos-Filho, R.M.F. Lima, D.M.A Falcão, F.R. Cordeiro and M.P.
Lima. An Intelligent Mechanism to Explore a Two-Level Cache Hierarchy Considering Energy
Consumption and Time Performance, SBAC-PAD, 2007, pp.177-184.
[31] Min Huang; Mehalel, M.; Arvapalli, R.; Songnian He. An energy efficient 32nm 20 MB L3
cache for Intel® Xeon® processor E5 family, Custom Integrated Circuits Conference (CICC),
2012 IEEE , Sept. 2012, pp.1,4, 9-12.
[32] Barth, J.; Plass, D.; Nelson, E.; Hwang, C.; Fredeman, G.; Sperling, M.; Mathews, A.;
Kirihata, T.; Reohr, W.R.; Nair, K.; Nianzheng Caon. A 45 nm SOI Embedded DRAM Macro for
the POWER™ Processor 32 MByte On-Chip L3 Cache, IEEE Journal of Solid-State Circuits,
Vol.46, No.1, Jan. 2011, pp.64, 75.
[33] S. Rusu, S. Tam, H. Muljono, J. Stinson, D. Ayers, J. Chang, R. Barada, M. Ratta, S.
Kottapalli, and S. Vora, “A 45 nm 8-core enterprise XEON processor,” IEEE J. Solid-State
Circuits, vol. 45, pp. 7–14, Jan. 2010.
[34] Jinuk Luke Shin; Golla, R., et al. The Next Generation 64b SPARC Core in a T4 SoC
Processor, IEEE Journal of Solid-State Circuits, Vol.48, No.1, Jan. 2013, pp.82, 90.
[35] Freescale Semiconductor. MPC7450 RISC Microprocessor Family Reference Manual,
MPC7450UM, Rev. 5, 2005.
[36] Freescale Semiconductor. Cache Latencies of the PowerPC MPC7451, Rev. 2, 2006.
[37] John L. Hennessy, David A. Patterson: Computer Architecture - A Quantitative Approach
(5. ed.). Morgan Kaufmann 2012, ISBN 978-0-12-383872-8.
