Klein FelipeVieira D

Tese apresentada ao Instituto de Computação,
unicamp, como requisito parcial para a ob-

tenção do tı́tulo de Doutor em Ciência da Com-
putação.
ii

!
∀ #∃ %&∋(∋
∋&) ∗ ∋
∋( !++∋ ,−./. ..0∀11.
2 34∋5%67−

589
#:;<+=%>∋ ?
∋ &).
≅.5Α ∋ .∀.−∋∋ ∋ .

Β. >∋% ∗ . Χ. ∆ ∋(∋ ∗ . ?. 5%
3 4∋ . ??. 589 7 − . ???. =%
>∋ .?∋ &).???.#Ε.
#Ε∋(∗ 5% ΦΑ3 Γ∋(Η ∋(Η∋.
/%+ Φ%∋(∗:ΗΓ< ≅.∋ Φ .∀.>∋ ∋ Η∋.Β./Γ

∋.Χ./Γ∋ ∋(.
Ι &) −∋∋ &)
#&) ;∋∗ ∋ &)
ϑ∋ /3.;.34∋5%:?+=Κ?5∆/<

/3.;.Λ
!−:?Κ>+=−<
/3.;.Λ(:?Κ+=7−<
/3.;.(∋ Φ:?+=Κ?5∆/<
/3.;.−(:?+=Κ?5∆/<
;3 ∀≅≅1∀11
/(∋/+7&) ;∋∗ ∋ &)

Instituto de Computação
Universidade Estadual de Campinas
Técnicas Avançadas de Modelagem, Análise e

Otimização de Potência em Sistemas Digitais
Felipe Vieira Klein1

Outubro de 2009
Banca Examinadora:
• Prof. Dr. Rodolfo Jardim de Azevedo (Orientador)
• Prof. Dr. Luiz Cláudio Villar dos Santos

Departamento de Informática e Estatı́stica – UFSC
• Prof. Dr. Luigi Carro

Instituto de Informática – UFRGS
• Prof. Dr. Reinaldo Bergamaschi

Instituto de Computação – UNICAMP
• Prof. Dr. Sandro Rigo

• Prof. Dr. Wang Jiang Chau (Suplente)

Laboratório de Microeletrônica – USP
• Prof. Dr. Mario Lúcio Côrtes (Suplente)

1
Suporte financeiro de: CNPq, FAPESP (processo 2005/02565-9) e CAPES (processo 0737/07-0).
vii

c Felipe Vieira Klein, 2009.
Todos os direitos reservados.
ix
Resumo
O crescente aumento da demanda por funcionalidades agregadas a um mesmo disposi-

tivo, aliado a rı́gidas restrições de desempenho colocam a dissipação de potência como um
dos requisitos mais importantes dentro do fluxo de projeto em CAD/EDA. A constante
evolução da tecnologia de semicondutores das últimas décadas tem garantido o aumento
da complexidade dos sistemas, que demandam cada vez mais recursos computacionais.
Contudo, esta crescente complexidade leva ao aumento do consumo de potência, que
tem uma série de efeitos colaterais indesejados, tais como, problemas térmicos e aumento
da densidade de potência, comprometendo a confiabilidade do circuito. Desta forma, é
necessário introduzir soluções para o resfriamento do chip, aumentando seu custo final
e seu time-to-market. Além disso, no que diz respeito aos dispositivos portáteis, estes
têm sua autonomia reduzida devido aos elevados montantes de energia requeridos para
seu funcionamento. As contribuições desta tese englobam dois temas distintos dentro
do chamado low-power design. O primeiro tema aborda as técnicas de macromodela-
gem de potência em RTL. Inicialmente, é mostrado que as técnicas convencionais de
modelo simples têm limitações intrı́nsecas que afetam a precisão de suas estimativas.
Uma análise quantitativa e qualitativa é conduzida, apontando as limitações de diversas
técnicas conhecidas, e demonstrando que o uso de uma única técnica pode comprome-
ter a qualidade geral das predições. Em seguida, são propostas duas novas técnicas de
macromodelagem baseadas em múltiplos modelos, a fim de explorar os pontos fortes de
cada modelo individual e otimizar a qualidade das estimativas. Os resultados obtidos
com a abordagem proposta revelaram melhorias significativas em relação a abordagem
convencional, alcançando resultados 7 vezes superiores para os erros médios, enquanto
que os erros máximos foram reduzidos em até 9 vezes. O segundo tema aborda uma
área que vem recebendo muita atenção com a chegada da era multi-core: o paradigma
de programação concorrente conhecido como memória transacional, cujo intuito é tornar
a tarefa de criar software concorrente mais simples. Embora esta seja uma área muito
ativa, os pesquisadores têm quase que invariavelmente se concentrado no desempenho das
xi
aplicações, negligenciando métricas tais como energia e potência. Este trabalho apresenta
uma análise pormenorizada do consumo de energia de uma implementação estado-da-arte
de STM (Software Transactional Memory), sendo a primeira do gênero neste contexto.
Além disso, uma nova estratégia de gerenciamento de contenção baseada em DVFS (Dy-
namic Voltage and Frequency Scaling) é proposta, com o intuito de reduzir o consumo de
energia de aplicações exibindo alta contenção no barramento.
xii
Abstract
The growing demand for features to be included into electronic devices, along with tight
performance constraints, make power consumption one of the most important design cons-
traints in the CAD/EDA design flow. The constant evolution of the semiconductor tech-
nology, observed in the last decades, has considerably increased the complexity of today’s
systems, which demand exorbitant computational resources. Unfortunately, the growing
complexity leads to a higher power consumption which, in turn, has a number of undesired
side effects, such as thermal issues and increased power density, thus compromising the
overall circuit reliability. Hence, elaborated cooling solutions are required, increasing its
final cost and compromising its time-to-market. Moreover, the large amounts of energy
needed by portable devices substantially reduce their battery lifetime. The contributions
of this thesis encompass two distinct topics within the so-called low-power design. The
first one is related to RTL power macromodeling techniques. It is shown that conventi-
onal single-model techniques have intrinsic limitations that affect their accuracy. Then,
a quantitative and qualitative analysis is conducted, pinpointing the limitations of se-
veral well-known techniques, followed by a demonstration that the adoption of a single
technique may compromise the overall quality of the estimates. Subsequently, two novel
multi-model power macromodeling techniques are proposed, which exploit the strengths
of each single-model technique in order to optimize the accuracy of power estimation. The
obtained results revealed substantial improvements in accuracy, which becomes 7 times
better for the average errors, while the overall maximum estimation error is divided by 9.
The second part of this thesis is related to a topic which is gaining much attention recently
in the multi-core era: the concurrent programming paradigm widely known as transac-
tional memory, which aims at making the task of creating concurrent software simpler.
Although this is a rather active area, researchers have invariably focused on performance,
leaving other metrics such as power and energy unattended. This work presents a detailed
power analysis of a state-of-the-art STM (Software Transactional Memory) implementa-
tion, being the first one in this context. Moreover, a novel DVFS-based (Dynamic Voltage
xiii
and Frequency Scaling) contention management strategy is proposed, which reduces the
energy consumption by exploiting the slack available in applications displaying high bus
contention.
xiv
Agradecimentos
Inicialmente, agradeço ao meu orientador, professor Rodolfo Avezedo que, em todos os

momentos desta longa jornada que é um doutorado, orientou-me de fato, criticando,
sugerindo, discutindo, e elogiando (quando era o caso). Ao meu co-orientador, professor
Guido Araújo, que também foi fundamental neste trabalho.
À FAPESP, CAPES e CNPq pelo suporte financeiro.
Ao Laboratório de Sistemas de Computação (LSC), que foi meu segundo lar, um
excelente ambiente de trabalho, onde pude, além de conduzir esta pesquisa, cultivar várias
amizades.
Aos meus amigos do LSC, da UNICAMP e outros, dentre os quais cito alguns: Eduardo
Billo, Patrick Brito, Roberto Leão, Javier Montoya, Alexandro Baldassin, Yang Yun Ju,
Felipe Portavales, Marcus Bartholomeu, Leonardo Piga, George Leandro.
Aos professores do LSC, Paulo Centoducatte e Sandro Rigo.
Ao Instituto de Computação da UNICAMP, professores, funcionários e colaboradores.
Ao professor Peter Marwedel, da Technische Universität Dortmund, que me acolheu
em seu grupo (LSXII) durante meu estágio na Alemanha. Aos colegas e amigos que fiz
por lá, entre eles René e Laura Streicher, Daniel Cordes, Olivera Jovanovic e Robert Pyka.
Aos meus pais, Vitor e Nires, meus incentivadores, meu porto seguro, e responsáveis
por quem sou hoje. Aos meus super-irmãos, Vitor Jr. e Adriana.
Last, but not least, à minha dignı́ssima esposa, Daniela Giongo, pelo apoio e pela
presença em todos estes anos.
xv
Sumário
Resumo xi
Abstract xiii
Agradecimentos xv
Sumário xvii
Lista de Tabelas xxi
Lista de Figuras xxiii
Lista de Acrônimos xxv
1 Introdução 1
1.1 Panorama dos Problemas Atacados . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Contribuições deste Trabalho . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Organização do Texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 Conceitos Fundamentais 7
2.1 Potência versus Energia . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Dissipação de Potência em CMOS . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.1 Potência Dinâmica e Estática . . . . . . . . . . . . . . . . . . . . . 10
2.3 Nı́veis de Abstração . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3 Trabalhos Relacionados 17
3.1 Nı́vel RTL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.1.1 Métodos Analı́ticos (top-down) . . . . . . . . . . . . . . . . . . . . . 18
3.1.2 Métodos Empı́ricos (bottom-up) . . . . . . . . . . . . . . . . . . . . 19
xvii
3.2 Nı́vel de Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2.1 Interconexão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2.2 ORINOCO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.3 Nı́vel de Instrução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.3.1 Otimizações de Software . . . . . . . . . . . . . . . . . . . . . . . . 33
3.4 Nı́vel de Sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.5 Modelagem de Baterias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.5.1 Equação de Peukert . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.5.2 Modelo Baseado em Cadeias de Markov . . . . . . . . . . . . . . . 40
3.5.3 Modelagem de Eficiência . . . . . . . . . . . . . . . . . . . . . . . . 41
3.5.4 Modelo Discreto para Nı́vel de Sistema . . . . . . . . . . . . . . . . 42
3.5.5 Sistemas com Múltiplas Baterias . . . . . . . . . . . . . . . . . . . 44
3.6 Memória Transacional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4 PowerSC: o Arcabouço para Análise de Potência 51

4.1 Caracterização de Potência no Nı́vel de Portas Lógicas . . . . . . . . . . . 53
4.2 Modelagem e Estimativa de Potência no nı́vel RT . . . . . . . . . . . . . . 61
5 A Abordagem de Múltiplos Modelos 65

5.1 Limitações da Abordagem de Modelo Único . . . . . . . . . . . . . . . . . 66
5.1.1 Técnicas de Macromodelagem Selecionadas . . . . . . . . . . . . . . 67
5.1.2 A Abordagem Convencional de Modelo Único . . . . . . . . . . . . 71
5.1.3 Análise Qualitativa das Limitações de Macromodelagem . . . . . . 77
5.2 A Abordagem Multimodelos Proposta . . . . . . . . . . . . . . . . . . . . . 79
5.2.1 Fase 1 (Criação de Macromodelos Individuais) . . . . . . . . . . . . 79
5.2.2 Fase 2 (Avaliação de Macromodelos Individuais) . . . . . . . . . . . 81
5.2.3 Fase 3 (Criação do Multimodelo) . . . . . . . . . . . . . . . . . . . 81
5.2.4 Fase 4 (Uso do Multimodelo) . . . . . . . . . . . . . . . . . . . . . 82
5.2.5 Discussão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
5.3 Experimentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
5.3.1 Configuração do Ambiente de Caracterização . . . . . . . . . . . . . 87
5.3.2 Resultados Experimentais . . . . . . . . . . . . . . . . . . . . . . . 87
5.3.3 Avaliação de Robustez . . . . . . . . . . . . . . . . . . . . . . . . . 91
xviii
6 Perfil de Consumo de Energia de Memória Transacional em Software 97
6.1 STM Adotada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
6.2 Plataforma de Simulação . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.3 Caracterização de Energia . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
6.3.1 A Ferramenta de Caracterização Parametrizável . . . . . . . . . . . 104
6.3.2 Resultados Preliminares . . . . . . . . . . . . . . . . . . . . . . . . 106
6.4 Perfilamento do STAMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
6.5 Estratégia de Gestão de Contenção Baseada em DVFS . . . . . . . . . . . 114
7 Conclusões 117
7.1 Produção Bibliográfica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.2 Tópicos em Aberto para Trabalhos Futuros . . . . . . . . . . . . . . . . . . 120
Referências Bibliográficas 123
xix
Lista de Tabelas
3.1 Caracterı́sticas das técnicas de macromodelagem . . . . . . . . . . . . . . . 24

3.2 Modelo spreadsheet-like . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.3 Sumário dos trabalhos revisados nas Seções 3.1–3.5 . . . . . . . . . . . . . 46
5.1 Circuitos selecionados como benchmarks . . . . . . . . . . . . . . . . . . . 87
6.1 Aplicações do STAMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
xxi
Lista de Figuras
2.1 Potência versus Energia . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.2 Análise de compromissos entre energia e potência . . . . . . . . . . . . . . 8
2.3 Um transistor na tecnologia CMOS . . . . . . . . . . . . . . . . . . . . . . 9
2.4 O inversor CMOS com seus dois transistores: PMOS (superior) e NMOS (in-
ferior) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.5 Potência de curto-circuito . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.6 Fontes de potência estática . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.7 Nı́veis de abstração versus domı́nios de descrição . . . . . . . . . . . . . . . 15
3.1 Relação entre probabilidade e densidade . . . . . . . . . . . . . . . . . . . 21

3.2 Fluxo de projeto do ORINOCO . . . . . . . . . . . . . . . . . . . . . . . . 29
3.3 Laço de caracterização . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.4 Exemplo de arquitetura em nı́vel de sistema . . . . . . . . . . . . . . . . . 35
3.5 Modelo baseado em cadeias de Markov . . . . . . . . . . . . . . . . . . . . 40
3.6 Modelos contı́nuos de bateria e conversor DC/DC . . . . . . . . . . . . . . 43
3.7 Código VHDL para o modelo da bateria . . . . . . . . . . . . . . . . . . . 44
4.1 Fluxo de projeto da PowerSC . . . . . . . . . . . . . . . . . . . . . . . . . 52

4.2 Modelo em SystemC habilitado para uso da PowerSC . . . . . . . . . . . . 54
4.3 Geração de código SystemC em gate-level . . . . . . . . . . . . . . . . . . . 55
4.4 Arquivo-exemplo de entrada para a psclib2sc mostrando a célula xor2v0x1
de uma bibioteca 0.13µm . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.5 Arquivo-exemplo de saı́da gerado pela psclib2sc para a porta lógica xor2v0x1 58
4.6 Arquivo-exemplo de entrada para a vlog2sc referente ao componente Add4 59
4.7 Arquivo-exemplo de saı́da gerado pela vlog2sc referente ao componente Add4 60
4.8 Suporte de macromodelagem da PowerSC . . . . . . . . . . . . . . . . . . 61
4.9 Esboço de uma possı́vel implementação de um multiplicador em SystemC . 62
xxiii
4.10 Esboço de um macromodelo para um multiplicador . . . . . . . . . . . . . 63
5.1 Distribuição de Erros (4DTab) . . . . . . . . . . . . . . . . . . . . . . . . . 73

5.2 Distribuição de Erros (EqTab) . . . . . . . . . . . . . . . . . . . . . . . . . 74
5.3 Distribuição de Erros (eHD) . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.4 Distribuição de Erros (Analytical) . . . . . . . . . . . . . . . . . . . . . . . 76
5.5 O fluxo do mecanismo multimodelos . . . . . . . . . . . . . . . . . . . . . 80
5.6 Função ζ para ambos os componentes . . . . . . . . . . . . . . . . . . . . . 83
5.7 Resultados obtidos com as técnicas de macromodelagem adotadas para os
circuitos selecionados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
5.8 Cobertura do espaço de entrada e distribuição de valores de potência de
referência para Add ECLA32 . . . . . . . . . . . . . . . . . . . . . . . . . 92
5.9 Robustez do modelo das técnicas adotadas (Add ECLA32) . . . . . . . . . 93
5.10 Distribuição dos valores de potência das técnicas adotadas (Add ECLA32) 94
6.1 Exemplo de um bloco atômico no paradigma de memória transacional . . . 98

6.2 MPARM: a plataforma de simulação . . . . . . . . . . . . . . . . . . . . . 102
6.3 Pseudocódigo da ferramenta de caracterização parametrizável . . . . . . . 105
6.4 Perfis energéticos das primitivas TxLoad e TxStore com a ferramenta de
caracterização . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
6.5 Perfis energéticos das primitivas TxCommit e TxAbort com a ferramenta
de caracterização . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
6.6 Overhead de energia das primitivas básicas . . . . . . . . . . . . . . . . . . 109
6.7 Energia vs. speedup para o STAMP . . . . . . . . . . . . . . . . . . . . . . 111
6.8 Decomposição do overhead de energia da STM para o caso com um único
core . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
6.9 Decomposição do overhead de energia da STM para o caso com 8 cores . . 113
6.10 Resultados da estratégia de gerenciamento de contenção baseado em DVFS
para o caso com 8 cores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
xxiv
Lista de Acrônimos
API Application Program Interface

ASIC Application-Specific Integrated Circuit
ASIP Application-Specific Instruction-Set Processor
BDD Binary Decision Diagram
CAD Computer-Aided Design
CAS Compare-And-Swap
CAFD Cycle-Accurate Functional Description
CDFG Control Data Flow Graph
CMM Correlated Multi-Modeling
CMOS Complementary Metal-Oxide Semiconductor
CPI Cycles Per Instruction
DRAM Dynamic Random Access Memory
DVS Dynamic Voltage Scaling
DVFS Dynamic Voltage and Frequency Scaling
DSP Digital Signal Processor
EDA Electronic Design Automation
EDP Energy-Delay Product
FSMD Finite State Machine with Datapath
HTM Hardware Transactional Memory
IP Intellectual Property
IPS Instructions Per Second
ISA Instruction-Set Architecture
ISS Instruction-Set Simulator
ITRS International Technology Roadmap for Semiconductors
LSC Laboratório de Sistemas de Computação
LUT Lookup Table
MPEG Moving Picture Experts Group
xxv
MPSoC Multi-Processor System-on-Chip
NASCUG North American SystemC User’s Group Meeting
PDE Partial Differential Equation
PFA Power Factor Approximation
PSM Power State Machine
RTL Register-Transfer level
SoC System-on-Chip/System-on-a-Chip
SMS Sampled Monitored Simulation
SPM ScratchPad Memory
SRAM Static Random Access Memory
STAMP Stanford Transactional Applications for Multi-Processing
STM Software Transactional Memory
TL2 Transactional Locking II
TLR Transactional Lock Removal
TM Transactional Memory
UMM Uncorrelated Multi-Modeling
VHDL VHSIC Hardware Description Language
VHSIC Very High Speed Integrated Circuits
VLSI Very Large Scale Integration
xxvi
Capı́tulo 1
Introdução
Num passado recente, o desenvolvimento de sistemas eletrônicos digitais era conduzido

focando-se, primordialmente, na redução de área, tempo e custo. O crescente aumento
da demanda por funcionalidades agregadas a um mesmo dispositivo, aliado a rı́gidas res-
trições de desempenho colocam a dissipação de potência como um dos requisitos mais
importantes dentro do fluxo de projeto em CAD (Computer-Aided Design)/EDA (Elec-
tronic Design Automation).
Desde os meros 2300 transistores do Intel 4004 aos impressionantes 2 bilhões de tran-
sistores num único chip anunciados recentemente [62], a evolução do projeto de semicon-
dutores tem seguido a conhecida predição feita por Gordon Moore em 1965, mantendo
um constante aumento da densidade de transistores por chip [2].
Esta evolução tem garantido o aumento da complexidade dos sistemas, que continuam
demandando cada vez mais recursos computacionais. Um exemplo tı́pico contemporâneo
são os conhecidos smartphones que, além de serem telefones, têm inúmeras funcionalida-
des, que incluem jogos eletrônicos, reprodução de arquivos de música e/ou vı́deo, acesso à
Internet, entre muitos outros. Porém, esta complexidade leva ao crescimento exponencial
da dissipação de potência destes dispositivos.
Esta tendência pode ser ilustrada representativamente pela linha de processadores da
Intel. Por exemplo, o modelo Celeron 266 (7,5 milhões de transistores) lançado em 1998
consome aproximadamente 16W, valor que alcançou a marca dos 150W no modelo Core
2 Extreme QX9775 (820 milhões de transistores), lançado em 2007.
O aumento do consumo de potência introduz uma série de efeitos colaterais indesejados
e nocivos.
Entre eles, estão o aumento da temperatura do chip e da densidade potência ( Wcmatt 2 )
que, como consequência, comprometem a confiabilidade do circuito. A fim de mitigar
1
2 Capı́tulo 1. Introdução
este problema são necessárias, então, soluções paliativas para o resfriamento do chip,
aumentando o custo final do produto e seu time-to-market. Logo, sua competitividade no
mercado é reduzida.
No que diz respeito aos dispositivos portáteis, que devem ser pequenos e possuir grande
autonomia, sabe-se que há um grande hiato entre a evolução da tecnologia de baterias e
da indústria de semicondutores [135]. Para manter a portabilidade, as baterias devem ser
pequenas. No entanto, as funcionalidades complexas implementadas por estes produtos
requerem altos montantes de energia, fazendo requisitos de portabilidade e autonomia
entrarem, inevitavelmente, em conflito.
Não é à toa que alguns colocam o problema do consumo de potência como um dos que-
sitos mais crı́ticos em Computação e no projeto de semicondutores [48]. Portanto, outras
abordagens devem ser adotadas no projeto de sistemas digitais e ferramentas adequadas
devem ser providas para que essa situação seja modificada.
Tudo isto deixa claro que o projeto de sistemas digitais visando a redução do consumo
de potência e energia é chave no fluxo de projeto, formando uma área denominada low
power design.
1.1 Panorama dos Problemas Atacados

Em essência, qualquer fluxo alicerça-se na interligação entre os seguintes elementos: (i)
modelagem; (ii) análise; e (iii) otimização. Sem modelagem não há análise. Sem análise
não há otimização. Sem otimização não há melhorias.
O ciclo de desenvolvimento de sistemas digitais é tipicamente conduzido em diversos
nı́veis de abstração (mais detalhes na Seção 2.3), de uma maneira top-down. Os nı́veis mais
altos são mais abstratos, têm alto desempenho de simulação mas, usualmente, exibem
menor precisão. Os nı́veis mais baixos, por sua vez, são mais próximos do hardware,
exibem uma maior precisão, mas têm baixo desempenho de simulação.
Esta tese de doutorado foca-se nos nı́veis mais altos de abstração, onde estão as maiores
oportunidades de otimização [103], atacando dois problemas distintos, o primeiro em
hardware e o outro em software.
O primeiro problema aborda as técnicas de macromodelagem de potência em
RTL (Register-Transfer Level ). Um macromodelo é um modelo empı́rico construı́do
a partir de medições (ou simulações) efetuadas em nı́veis de abstração inferiores. Estas
técnicas, embora sendo consideradas atualmente o estado-da-arte em RTL [91], padecem
de limitações que afetam a precisão de suas estimativas. A fim de otimizar as predições,
1.2. Contribuições deste Trabalho 3
este trabalho apresenta uma nova abordagem de modelagem de potência baseada em

múltiplos modelos.
Até recentemente, o aumento da frequência de operação dos processadores era uma
das maneiras utilizadas para melhorar o desempenho das aplicações. Esta era uma forma
natural de aumentar o desempenho, visto que, quanto maior é a frequência, maior é a
taxa de instruções executadas por segundo (IPS).
Contudo, restrições térmicas e de potência estabeleceram um limite superior para a
frequência de operação [122] e um limite inferior para o número médio de ciclos por
instrução (CPI)1 . Assim, atingiu-se um limite prático para a taxa de instruções por
segundo admissı́vel para um único processador, fazendo com que o paralelismo deva ser
acomodado em múltiplos processadores, dando inı́cio a era multi-core.
Com isso, introduziu-se um novo problema: como escrever aplicações concorrentes de
forma eficiente e com alta produtividade?
O segundo problema aborda um novo paradigma [58] de programação concorrente
conhecido como memória transacional, cujo intuito é responder à questão acima. As
pesquisas nesta área têm se concentrado, quase que invariavelmente, no desempenho das
aplicações, ignorando seus perfis de consumo de energia e potência. Este trabalho com-
plementa os trabalhos existentes na literatura, fazendo uma análise pormenorizada do
consumo de energia da abordagem de memória transacional em software.
1.2 Contribuições deste Trabalho

As contribuições desta tese de doutorado, para os dois problemas atacados, são sumari-
zadas abaixo:
• Diversas técnicas de macromodelagem foram submetidas à uma análise qualitativa

e quantitativa em relação aos seus méritos e deficiências na tarefa de capturar a
variação de potência. Esta análise evidencia as limitações existente nos métodos
convencionais de modelo único que, por sua vez, afetam a precisão das estimativas.
• São propostas duas novas técnicas de macromodelagem, baseadas na abordagem

de múltiplos modelos, a fim de otimizar a qualidade das estimativas. Para um
dado componente descrito em RTL, a primeira técnica cria uma função seletora que
usa propriedades dos estı́mulos aplicados às entradas do componente para determi-
nar, entre vários macromodelos, aquele que leva a melhores resultados. A segunda
1 f
Visto que IP S = CP I .
técnica cria uma função de predição que correlaciona as estimativas produzidas por
um conjunto de macromodelos, além das propriedades dos estı́mulos aplicados às
entradas. Esta função é construı́da com o auxı́lio de métodos de análise de regressão
não-linear.
• A infraestrutura de análise de potência em SystemC, que permite a modelagem

e análise de potência em diversos nı́veis de abstração. Os dois itens acima foram
realizados utilizando esta infraestrutura, denominada PowerSC.
• A análise pormenorizada do consumo de energia em uma implementação estado-da-

arte de memória transacional em software. Desconhece-se, da literatura, qualquer
outro trabalho que tenha realizado análise similar.
• Uma ferramenta de caracterização parametrizável foi proposta a fim de avaliar di-

ferentes cenários transacionais no que diz respeito ao consumo de energia.
• A proposição de uma nova estratégia de gerenciamento de contenção, baseada em

DVFS (Dynamic Voltage and Frequency Scaling), voltada a aplicações transacionais
com alta contenção no barramento. Esta estratégia explora os tempos de inatividade
da aplicação para colocar os processadores em modo de baixo consumo de potência.
Além disso, este trabalho gerou a seguinte produção bibliográfica: 2 artigos em
periódicos internacionais, 1 capı́tulo de livro, 5 artigos em anais de conferências inter-
nacionais e 2 relatórios técnicos.
1.3 Organização do Texto

O conteúdo desta tese de doutorado é o resultado da composição dos resultados parciais
publicados em diversos artigos, listados abaixo em ordem cronológica:
• “PowerSC: A SystemC-based Framework for Power Estimation”,
F. Klein, R. Leao, G. Araujo, L. Santos and R. Azevedo,
Instituto de Computação, UNICAMP, Relatório Técnico IC-07-02, Fevereiro de
2007.
• “On the Limitations of Power Macromodeling Techniques”,

Proceedings of the IEEE Computer Society Annual Symposium on VLSI (ISVLSI’07),
pp. 395–400, Maio de 2007.
1.3. Organização do Texto 5
• “An Efficient Framework for High-Level Power Exploration”,

Proceedings of the 50th IEEE International Midwest Symposium on Circuits &
Systems (MWSCAS’07), pp. 1046–1049, Agosto de 2007.
• “A Multi-Model Power Estimation Engine for Accuracy Optimization”,

Proceedings of the ACM/IEEE International Symposium on Low Power Electronics
and Design (ISLPED’07), pp. 280–285, Agosto de 2007.
• “A First Study on Characterizing the Energy Consumption of Software Transactio-

nal Memory”,
A. Baldassin, F. Klein, G. Araujo, R. Azevedo and P. Centoducatte,
Instituto de Computação, UNICAMP, Relatório Técnico IC-09-13, Abril de 2009.
• “A Multi-Model Engine for High-level Power Estimation Accuracy Optimization”,

IEEE Transactions on Very Large Scale Integration (VLSI) Systems, Volume 17,
Número 5, pp. 660–673, Maio de 2009.
• “On the Energy-Efficiency of Software Transactional Memory”,

F. Klein, A. Baldassin, P. Centoducatte, G. Araujo and R. Azevedo,
Proceedings of the 22nd Annual Symposium on Integrated Circuits and System
Design (SBCCI’09), Agosto/Setembro de 2009.
• “Characterizing the Energy Consumption of Software Transactional Memory”,

IEEE Computer Architecture Letters, 20 de agosto de 2009.
http://doi.ieeecomputersociety.org/10.1109/L-CA.2009.47
• “Improving Accuracy in Power Estimation by Exploiting Multi-Model Techniques”,

F. Klein, G. Araujo and R. Azevedo,
PhD Forum, IFIP/IEEE International Conference on Very Large Scale Integration
(VLSI-Soc 2009), Outubro de 2009.
• “SystemC-based Power Evaluation with PowerSC ”,

F. Klein, G. Araujo Luiz Santos e Rodolfo Azevedo,
capı́tulo do livro “Electronic System Level Design: an Open Source Approach”, a
ser publicado pela editora Springer (ainda sem data).
O restante deste documento organiza-se da seguinte forma: o Capı́tulo 2 conceitua

potência e energia dentro do contexto de EDA e introduz os diversos nı́veis de abstração
tipicamente considerados num fluxo de projeto. Os trabalhos relacionados mais relevan-
tes são apresentados no Capı́tulo 3. O Capı́tulo 4 descreve a infraestrutura desenvolvida
e utilizada para a modelagem e análise da abordagem de múltiplos modelos proposta.
No Capı́tulo 5, as limitações da abordagem convencional de modelo simples são revela-
das. Duas técnicas de macromodelagem distintas são, então, propostas com o intuito
de sobrepujar estas limitações. O Capı́tulo 6 faz uma análise pormenorizada do con-
sumo de energia em uma implementação estado-da-arte de STM (Software Transactional
Memory). As conclusões e contribuições desta tese são enumeradas e sumarizadas no
Capı́tulo 7, além de serem listados tópicos passı́veis de serem investigados futuramente.
Capı́tulo 2
Conceitos Fundamentais
Antes da revisão bibliográfica ser introduzida, este capı́tulo define alguns conceitos básicos
relacionados à dissipação de potência e elabora sobre os nı́veis de abstração e suas inter-
relações no projeto de circuitos integrados.
2.1 Potência versus Energia

Os termos potência e energia têm um alto grau de correlação mas, por muitas vezes,
são usados e/ou entendidos de forma errônea. Em Fı́sica, potência refere-se à quantidade
de trabalho (ou energia transferida) por unidade de tempo. No sistema internacional de
unidades (SI), a potência é medida em Watts, que é equivalente a J/s.
Figura 2.1: Potência versus Energia
A Figura 2.1 mostra, graficamente, a relação entre potência e energia no contexto deste
7
8 Capı́tulo 2. Conceitos Fundamentais
trabalho. O eixo horizontal apresenta o tempo de execução de uma determinada tarefa,

enquanto o eixo vertical mostra a potência em um dado tempo durante a realização da
mesma. Portanto, a potência instantânea de um circuito digital pode ser descrita pela
equação abaixo
P (t) = v(t) × i(t) (2.1)
onde v(t) e i(t) são, respectivamente, voltagem e corrente instantâneas, em função do

tempo t. A potência reflete a taxa na qual o trabalho é executado.
Diferentemente, a energia refere-se à quantidade de trabalho propriamente dita que,
na Figura 2.1, é representada pela área cinza sob a curva descrita pela potência. A
Equação 2.2 descreve a relação entre potência e energia:
Z t Z t
E= P (t)dt = v(t) × i(t)dt. (2.2)
0 0
Note que a Figura 2.1 exibe três métricas de grande importância dentro do chamado
low-power design, que são: potência média, potência de pico e energia.
A escolha da métrica mais relevante dependerá, entre outros, da aplicação e do tipo
de dispositivo sendo desenvolvido. Por exemplo, para um dispositivo contendo um de-
codificador de vı́deo, a potência instantânea variará expressivamente entre momentos da
decodificação do vı́deo em si e momentos em que o mesmo aguarda alguma entrada do
usuário (e.g., seleção do vı́deo a ser reproduzido). Se este mesmo dispositivo for operado
por baterias, a energia terá mais importância dentro do projeto, pois é o principal fator
que determina o tempo de vida de uma bateria.
Figura 2.2: Análise de compromissos entre energia e potência
De forma a ilustrar este tipo de análise, a Figura 2.2 apresenta os cenários observados
em dois circuitos distintos realizando uma mesma tarefa. No Cenário 1 (à esquerda),
o circuito executa a tarefa em τ1 = 30ns, com uma potência média de P1avg = 45mW .
2.2. Dissipação de Potência em CMOS 9
Logo, a energia consumida para a execução da tarefa sob estas condições será E1 =
τ1 ×P1avg = 1,35nJ. Analisando o Cenário 2 (à direita), pode-se notar que, em comparação
ao primeiro cenário, há uma dissipação de potência significativamente menor (P2avg =
15mW ), porém com uma duração maior (τ2 = 90ns). Fazendo os cálculos de forma
similar, tem-se E2 = τ2 × P2avg = 1,35nJ. Portanto, do ponto de vista de consumo de
energia, ambos os circuitos são equivalentes. A escolha entre um ou outro projeto será
definida pelas outras restrições impostas, que incluem o atraso máximo permitido e o
perfil de dissipação de potência esperado.
2.2 Dissipação de Potência em CMOS

Já que os termos potência e energia foram conceituados e correlacionados (Seção 2.1),
torna-se necessário definir como, de fato, ocorre a dissipação de potência em circuitos
digitais, bem como apresentar os seus principais componentes.
A tecnologia CMOS1 (Complementary Metal Oxide Semiconductor) foi escolhida pois
representa a grande maioria dos circuitos implementados dentro do contexto de projeto
de sistemas digitais [117].
Esta tecnologia possui diversos atributos desejáveis, tais como: efeitos parasitas mode-
rados, alta densidade de integração e processo de fabricação relativamente simples quando
comparado a outras tecnologias [117]. Tudo isto torna economicamente viável a produção
de circuitos grandes e complexos em larga escala.
Figura 2.3: Um transistor na tecnologia CMOS
A Figura 2.3 mostra o corte transversal de um transistor CMOS onde, sobre um

substrato de silı́cio, são fabricados o gate, o fonte (source) e o dreno (drain).
1
O termo CMOS é utilizado neste texto para referenciar unicamente a circuitos conhecidos por CMOS-
estático.
O transistor pode ser visto como uma chave. Quando uma voltagem maior que uma
dada voltagem de limiar (threshold VT ) é aplicada no gate, um canal condutivo é criado
sob o mesmo, de forma a habilitar a passagem de corrente elétrica entre fonte e dreno.
Quando isto ocorre, diz-se que a chave está fechada. Da mesma forma, quando a voltagem
aplicada é menor que VT , maior é a resistividade do canal e menor é a corrente. Se o canal
é inexistente (a corrente é nula), a chave é considerada aberta.
A tecnologia do processo de fabricação CMOS é definida em termos do comprimento
do canal de condução, que é ilustrado na Figura 2.3 sob o gate (e.g., 90nm, 45nm).
Dois tipos de transistores são encontrados em qualquer circuito CMOS, que são o
NMOS (substrato do tipo-P com fonte/dreno n+ ) e o PMOS (substrato do tipo-N com
fonte/dreno p+ ). De forma simplista, a diferença funcional entre ambos está na forma
como a chave é aberta e/ou fechada. No transistor NMOS, a chave fecha quando uma
voltagem equivalente ao valor lógico 1 é aplicada no gate . No PMOS ocorre o contrário,
isto é, uma voltagem equivalente ao valor lógico 0 fecha o canal de condução.
O estudo detalhado da tecnologia e dos circuitos CMOS está fora do escopo desta tese.
O leitor interessado encontrará em Rabaey et al [117] uma análise ampla e pormenorizada
desta tecnologia.
2.2.1 Potência Dinâmica e Estática

A dissipação de potência em CMOS pode ser dividida em duas componentes: potência
dinâmica e potência estática. A componente dinâmica engloba a potência dissipada
durante o chaveamento dos sinais do circuito entre os valores lógicos 0 e 1, responsável pela
carga e descarga das capacitâncias associadas ao mesmo. A componente estática, também
conhecida por leakage, engloba a potência dissipada quando o circuito está inativo, porém
alimentado, ou seja, quando os sinais não estão chaveando. De acordo com o roadmap
ITRS [43] (International Technology Roadmap for Semiconductors), a contribuição de
leakage no consumo total deve crescer nas próximas gerações da tecnologia de fabricação.
A Figura 2.4 apresenta o diagrama elétrico de um inversor CMOS, parte central de
qualquer projeto de sistema digital. Esta porta lógica é composta por dois transisto-
res, sendo um PMOS (superior) e outro NMOS (inferior), cujos gates compartilham o
mesmo sinal de entrada (in). O transistor PMOS está conectado a Vdd , que é a fonte de
alimentação, enquanto o NMOS conecta-se ao terra.
Esta figura ilustra como a potência dinâmica é dissipada durante o processo de carga
e descarga da capacitância de saı́da nesta porta . Ao se aplicar em in uma voltagem
equivalente ao valor lógico 0, o transistor NMOS abre, ao mesmo tempo em que o tran-
sistor PMOS fecha, conectando a saı́da out à Vdd e, desta forma, permitindo a carga
da capacitância CL associada à saı́da desta porta (Figura 2.4(a)). Complementarmente,
quando uma voltagem equivalente ao valor lógico 1 é aplicada, o oposto ocorre: o transis-
tor NMOS fecha, enquanto o transistor PMOS abre, fazendo com que esta mesma carga
CL seja descarregada através do terra (Figura 2.4(b)).
(a) Carga de capacitância (b) Descarga de capacitância
Figura 2.4: O inversor CMOS com seus dois transistores: PMOS (superior) e NMOS (in-
ferior)
Considerando-se que ambos os transistores nunca estão fechados ao mesmo tempo, a

energia dinâmica dissipada durante um ciclo de transição (0 → 1 e 1 → 0) é:
2
Edyn = CL Vdd . (2.3)
Por conseguinte, a potência dinâmica pode ser descrita por
Pdyn = Edyn fclock ptrans (2.4)
onde fclock é a frequência de operação do circuito, e ptrans representa a probabilidade

de transição do sinal de saı́da. Note que na Equação 2.4, a potência depende de forma
linear da atividade de transição, representado por ptrans . Portanto, a redução deste fator
é determinante para a redução da potência dinâmica. Observe também que há uma
dependência quadrática com relação à voltagem (Equação 2.3) e linear com relação à
frequência (Equação 2.4). Geralmente, a redução da voltagem implica na redução da
frequência, resultando num potencial teórico de redução cúbica da potência. No entanto,

a redução de fclock e Vdd tem impacto negativo no desempenho do circuito e, por isso,
deve ser avaliada cuidadosamente pelo projetista durante a otimização do projeto.
A suposição anterior, de que os transistores PMOS e NMOS nunca estão fechados ao
mesmo tempo, embora represente o caso ideal, não é real. Outro fator que contribui para
potência dinâmica é a chamada potência de curto-circuito, que ocorre justamente quando
ambos os transistores estão conduzindo simultaneamente.
Figura 2.5: Potência de curto-circuito
Este comportamento é ilustrado na Figura 2.5. Isto acontece pelo fato de existir um
atraso durante a transição entre os valores lógicos. Do lado esquerdo da figura é mostrada
a linha do tempo com os valores de voltagem dos sinais de entrada (in) e saı́da (out).
Note que, por um curto intervalo durante a transição do sinal de entrada, ambos os
transistores estão fechados e conectando Vdd ao terra, criando a corrente de curto-circuito
ISC . A potência de curto-circuito pode ser descrita pela equação abaixo:
PSC = tSC Vdd ISC fclock (2.5)
onde ISC e tSC denotam, respectivamente, a corrente de curto-circuito e o intervalo de

tempo da mesma. Desta forma, podemos reescrever a Equação 2.4 como:
Pdyn = Edyn fclock ptrans + tSC Vdd ISC fclock (2.6)
Embora relevante, a contribuição da potência de curto-circuito para o total dinâmico

é pequena, e tende a diminuir nas próximas gerações de processo de fabricação [43].
Com relação à potência estática, que é dissipada ao longo de perı́odos inativos do

circuito, há basicamente quatro fontes principais (Figura 2.6):
1. Isub (sub-threshold leakage): corrente existente do dreno para a fonte;
2. Igate (gate leakage): a corrente que flui diretamente do gate para o substrato;
3. Igidl (gate induced drain leakage): corrente que flui do dreno para o substrato;
4. Irev (reverse bias junction leakage): causado pela geração de buracos nas regiões de
depleção.
Figura 2.6: Fontes de potência estática
A potência estática tem se tornado cada vez mais importante ao longo das gerações
de tecnologia de processo. Espera-se que, a partir de 22nm, o componente estático passe
a contribuir em mais de 76% do total de potência dissipada [43].
Há diversas maneiras efetivas de gerenciar este tipo de dissipação, dentre as quais
podemos destacar: multi-VT e power gating [69]. Na primeira, o circuito é dividido em
diversas regiões, chamadas ilhas de voltagem, onde cada uma utiliza portas lógicas com
voltagem de threshold distintas, de forma a mitigar a dissipação estática. Saliente-se
que, quanto maior é VT , menor é Isub , o que contribui substancialmente para uma redução
da potência estática. Já na abordagem conhecida como power gating, há uma criteriosa
seleção de blocos lógicos cuja alimentação é cortada em perı́odos de inatividade.
Visto que os conceitos básicos de consumo de potência em CMOS foram introduzidos,

a próxima seção apresenta os diversos nı́veis de abstração, comumente utilizados dentro
de um fluxo de projeto de sistemas digitais.
2.3 Nı́veis de Abstração

A Figura 2.7 apresenta um modelo [147] que descreve as várias etapas e nı́veis de abstração
usualmente considerados no projeto de circuitos integrados digitais.
Os eixos na forma de um Y representam os três domı́nios de descrição, onde cada
domı́nio representa uma porção especı́fica da descrição total do projeto. Sobrepostos
aos domı́nios de descrição, os nı́veis de abstração estão representados como cı́rculos
concêntricos. Quanto mais distante do centro, maior é o nı́vel de abstração e, portanto,
menor é a informação a respeito da implementação real do circuito. Os domı́nios mostra-
dos são:
• comportamental (behavioral ): descreve o comportamento, que é a funcionalidade

do circuito. Possui elementos estáticos (operações), assim como dinâmicos (sequen-
ciamento e temporização).
• estrutural (structural ): descreve a estrutura lógica do circuito, geralmente através

de interconexões de um conjunto de blocos abstratos. É um meio-termo entre os
domı́nios comportamental e fı́sico.
• fı́sico (physical ): descreve a implementação fı́sica do circuito, ou também, o deta-

lhamento dos componentes do domı́nio estrutural com componentes fı́sicos reais.
Os nı́veis de abstração considerados são brevemente descritos a seguir:
• circuito (circuit): no domı́nio comportamental, este nı́vel é descrito como um con-

junto de equações diferenciais que representam corrente e potencial elétrico, en-
quanto no nı́vel estrutural, componentes como transistores e resistores são usados
em sua representação.
• lógico (logic): no domı́nio comportamental, o circuito é descrito através de equações

booleanas, enquanto no nı́vel estrutural, gates (AND, OR, NAND) e flip-flops são
usados para representá-lo.
2.3. Nı́veis de Abstração 15
Figura 2.7: Nı́veis de abstração versus domı́nios de descrição
• RTL (Register-Transfer Level): blocos como ALUs, MUXes e registradores, são

os componentes usados para representar o circuito no domı́nio estrutural, enquanto
transferências entre registradores (origem do nome) e operações lógicas e aritméticas
representam o domı́nio comportamental.
• algoritmo (algorithmic): este é um nı́vel onde o comportamento do circuito é des-

crito de maneira muito similar ao das linguagens de programação de alto nı́vel,
através de procedimentos e manipulação de estruturas de dados. A estrutura é des-
crita através de módulos de hardware utilizando, por exemplo, o tradicional modelo
FSMD (Finite State Machine with Datapath) [45].
• sistema (system): especificações de desempenho e caracterı́sticas operacionais sim-

plificadas definem o comportamento neste nı́vel de abstração. O domı́nio estrutural
engloba a escolha de componentes como processadores, memórias e barramentos,
como também o particionamento da aplicação entre componentes de hardware e
software.
Para os nı́veis mais baixos como, por exemplo, os nı́veis de circuito e lógico, estimar
potência já é uma área de pesquisa consolidada, havendo uma grande diversidade de
ferramentas de CAD (Computer-Aided Design) disponı́veis [102,139,140]. No entanto, no
nı́vel de circuitos reais esta pode ser uma tarefa excessivamente custosa, senão inviável,
em termos de tempo. O foco desta tese está nos nı́veis mais altos de abstração, onde
estão as maiores oportunidades de otimização de potência [103] e onde gargalos podem
ser detectados ainda em fases iniciais do ciclo de projeto.
O próximo capı́tulo apresenta uma seleção de trabalhos relacionados a esta tese, abran-
gendo vários nı́veis de abstração.
Capı́tulo 3
Trabalhos Relacionados
Neste capı́tulo serão revistos diversos trabalhos dentro do contexto de análise e otimização
de potência em altos nı́veis de abstração, conforme definidos na Seção 2.3.
A Seção 1.1 deu uma visão geral dos problemas estudados por esta tese de doutorado,
os quais são: (i) a modelagem de potência de sistemas digitais, no que diz respeito ao
seu componente de hardware; e (ii) o perfilamento energético de modelos de programação
concorrente modernos (memória transacional). Desta forma, este capı́tulo organiza-se
com o intuito de conglobar os trabalhos mais relevantes de ambos.
As Seções 3.1–3.4 concentram-se no primeiro problema, abordando os seguintes nı́veis

de abstração: RTL (mais baixo), de algoritmos, de instrução e de sistema (mais alto).
Numa abordagem bottom-up, os resultados obtidos com modelos de um nı́vel i são

usados para a elaboração de modelos em um nı́vel i + 1. Portanto, para possibilitar que
modelos de qualidade sejam gerados em altos nı́veis de abstração, como é o caso do nı́vel
de sistema, é necessário garantir que os modelos de potência de nı́veis subjacentes também
sejam de qualidade.
Além dos modelos de potência para os circuitos integrados, diversos modelos de bateria
serão apresentados na Seção 3.5, devido à grande importância dos dispositivos operados
por bateria no projeto de sistemas contemporâneos.
A Seção 3.6 concentra-se no segundo problema, descrevendo diversas abordagens de

memória transacional existentes. Tais abordagens podem ser categorizadas em: soluções
de hardware, soluções de software, ou ainda soluções hı́bridas.
17
18 Capı́tulo 3. Trabalhos Relacionados
3.1 Nı́vel RTL

As primitivas consideradas neste nı́vel são blocos funcionais, tais como somadores, regis-
tradores, SRAMs, controladores, etc. A grande dificuldade em se estimar potência no
nı́vel RT advém da falta de detalhes da implementação destas primitivas, pois um mesmo
bloco funcional pode ter implementações muito distintas, resultado de opções de sı́ntese
ou mesmo pelo uso de ferramentas diferentes. Outros detalhes, como floorplanning e
a interconexão entre os blocos também são desconhecidos neste nı́vel de abstração. As
técnicas de RTL podem ser divididas em duas categorias:
1. top-down (métodos analı́ticos) [28, 83, 92, 93, 99, 104, 151] e
2. bottom-up (métodos empı́ricos) [3,4,6,14,19–24,27,31,34,35,37,38,50–54,59,63–65,

76, 84–86, 95, 101, 110, 112, 121, 124–126, 148, 149, 152]
3.1.1 Métodos Analı́ticos (top-down)

Os métodos analı́ticos estimam potência de um circuito sem o conhecimento de detalhes in-
ternos de implementação e, por isso, são rotulados como top-down. Estas técnicas tentam
relacionar o consumo de potência de uma descrição RTL com quantidades fundamentais
que representem a capacitância fı́sica e a atividade do circuito.
Alguns modelos [83, 99] sustentam-se no fato de que a complexidade do circuito pode
ser descrita grosseiramente em termos de gates equivalentes. Em [99] a expressão básica
utilizada é a seguinte:
X
2
P = GEi (Etyp + CLi Vdd )f Aiint (3.1)
i ǫ {blocos}
onde GEi é o número gates equivalentes para cada bloco funcional i, Etyp é o consumo
médio de energia do gate de referência, CLi a capacitância, Vdd a voltagem de entrada, f
é a frequência de operação e Aiint é a porcentagem média dos gates que chaveiam a cada
ciclo. Um problema visı́vel é que apenas um gate é usado como referência para o consumo
de todo o circuito. Isso foi melhorado em [83], separando o circuito em várias entidades
(lógica, memória, interconexão e relógio), ajustando o cálculo de potência de acordo com
o tipo de entidade considerada.
Outras técnicas da abordagem top-down baseiam-se no conceito de entropia, da teoria
da informação, como medida de atividade do circuito. A meta é relacionar esforço compu-
tacional de cada bloco com sua dissipação de potência [92, 93, 104]. Em [104], os autores
3.1. Nı́vel RTL 19
observam que a potência é proporcional ao produto da capacitância fı́sica e a atividade,

usando área como medida de capacitância fı́sica e entropia como medida de atividade. Sua
metodologia consiste em simular o circuito medindo a entropia das entradas e saı́das dos
blocos funcionais e, após isso, utilizar esta informação para gerar estimativas de potência.
A expressão abaixo ilustra as relações exploradas neste trabalho:
P ∝ Capacitancia x Atividade ∝ Area x Entropia (3.2)
Há algumas visı́veis limitações nesta abordagem. Primeiro, existe uma suposição
implı́cita de que a capacitância é distribuı́da uniformemente pela área do circuito e, se-
gundo, informações de temporização não são levadas em conta no cômputo da entropia.
Todavia, uma notável vantagem das técnicas top-down é a necessidade de pouca in-
formação para a geração das estimativas. Em contrapartida, esta vantagem é um dos
fatores limitantes, pela fraca relação entre os modelos e o hardware real, o que acaba
afetando a precisão destas técnicas.
3.1.2 Métodos Empı́ricos (bottom-up)

Ao contrário do que é visto nos métodos analı́ticos, a relação entre os modelos e o hardware
é muito mais forte nos métodos empı́ricos. Ao invés de tentar relacionar o consumo dos
componentes RTL em parâmetros fundamentais, o que se faz é medir o consumo de imple-
mentações existentes e criar um modelo a partir destas medidas, gerando o que é chamado
de macromodelo. As técnicas de estimativa de potência baseadas em macromodelagem
são consideradas, atualmente, o estado da arte da área [91].
A primeira proposta dos métodos empı́ricos foi a PFA (Power Factor Approxima-
tion) [112]. Apesar de os autores discutirem sobre modelos de multiplicadores, memórias,
controladores de E/S, esta técnica pode ser vista como uma técnica geral para caracterizar
individualmente cada elemento de uma biblioteca de componentes. A potência é expressa
pela equação abaixo:
X
P = κi Gi fi (3.3)
i ǫ {blocos}
onde κi é uma constante de proporcionalidade, Gi é a medida de complexidade do bloco, e

f é a frequência de ativação do bloco. Como exemplo do uso destes parâmetros, considere
um multiplicador. Gi poderia ser definido como n2 , onde n é o tamanho da palavra de
entrada, definindo a complexidade do multiplicador em relação ao tamanho de palavra
de sua entrada. Já f seria definido como a frequência de ocorrência de multiplicações.
Finalmente, κi é um valor empı́rico presente na biblioteca, extraı́do de projetos de multi-

plicadores anteriores.
As técnicas de macromodelagem podem ainda ser divididas em duas categorias: (i)
baseadas em tabela e (ii) baseadas em equações.
Gupta et al [51] propuseram a primeira técnica baseada em tabela (chamada 3DTab),
onde uma LUT (lookup table) tridimensional é utilizada para armazenar valores de potência.
Os eixos desta tabela representam os parâmetros utilizados para estimar potência, que
são estatı́sticas dos sinais de entrada/saı́da do módulo:
• Pin : média das probabilidades dos sinais de entrada. A probabilidade de sinal é

definida como a probabilidade de uma entrada estar com valor lógico 1.
• Din , Dout : média das densidades de transição de entrada e saı́da, respectivamente.

Densidade de transições refere-se à quantidade de transições do tipo 1 → 0 e 0 → 1
por unidade de tempo.
Pin , Din e Dout são números reais no intervalo [0, 1], e seus valores referem-se à média
aritmética das probabilidades para todos os sinais de entrada e/ou saı́da. Logo, o macro-
modelo proposto pelos autores é uma expressão da forma
P ower = f (Pin , Din , Dout ) (3.4)
onde a potência é descrita em função dos parâmetros acima. Sejam Pi e Di , respectiva-

mente, a probabilidade de sinal e densidade de transição da i-ésima entrada. Dado que
um sinal de entrada xi faz no máximo uma transição por ciclo, há uma importante relação
entre probabilidade e densidade, dada pela equação:
Di Di
≤ Pi ≤ 1 − (3.5)
2 2
Esta propriedade implica que a tabela utilizada não será preenchida completamente, con-
forme é ilustrado na Figura 3.1. A região sombreada da figura representa a região das
combinações válidas no plano Pin × Din .
O processo de caracterização do macromodelo consiste, então, em duas etapas:
1. discretização do espaço de entradas e geração de sequências de vetores (streams);
2. simulação das sequências para obtenção de Dout .

D(in)
1
0 0.5 1 P(in)
Figura 3.1: Relação entre probabilidade e densidade
O processo de discretização dos parâmetros é importante para reduzir a quantidade de

memória necessária para o armazenamento da tabela gerada. Um valor tı́pico utilizado
é 0.1. Para cada par (Pin , Din ) no plano discretizado, são geradas diversas sequências
com estas caracterı́sticas, que são simuladas com ferramentas de baixo nı́vel (gates ou
circuito). Com isso, obtêm-se os valores de potência e o Dout . Este ultimo parâmetro é
de difı́cil controle, dado que o método desconhece o funcionamento do circuito, tornando
difı́cil induzir o valor de Dout para algum ponto especı́fico no espaço discretizado.
Outro detalhe com relação a geração de vetores é que os valores de Pin , Din , e Dout
dificilmente são gerados para os valores exatos desejados, pois há pertubações tanto na
criação das sequências de entrada, quanto no resultado de Dout , pelo problema descrito
acima. Portanto, os valores obtidos são usualmente arrendondados para o ponto mais
próximo do espaço discretizado.
Feito isso, a tupla (Pin , Din , Dout ) é usada como ı́ndice na tabela onde o valor de
potência obtido por simulação será armazenado. Como, normalmente, duas ou mais
sequências resultam numa mesma combinação de (Pin , Din , Dout ), as médias dos valores
são salvas na tabela.
Diversas sequências são usadas para cada ponto (Pin , Din ), com o intuito de cobrir o
máximo possı́vel do eixo Dout do modelo. Graficamente, um modelo para um componente
com uma cobertura adequada nos eixos Pin , Din e Dout tem o formato de uma pirâmide.
A forma de se estimar potência neste modelo é direta. Dada uma simulação de algum
componente em RTL, suas entradas e saı́das são monitoradas para capturar os valores
de densidade de transição e probabilidade de sinal. A tupla (Pin , Din , Dout ) resultante da
simulação é usada, sem discretização, buscando o valor mais próximo na tabela. Caso o
valor não corresponda exatamente a algum ponto na tabela, o que geralmente é o caso,
algum procedimento de interpolação é usado com os pontos vizinhos aos valores simulados.
Em [51], apesar de os autores sugerirem interpolação, nenhuma estratégia a ser seguida
é indicada. Em [6], algumas estratégias de interpolação são sugeridas para a técnica,
além de algumas melhorias, especialmente no que diz respeito à geração de sequências
de vetores. Posteriormente, Gupta et al [53] propuseram uma melhoria em sua técnica
original, adicionando um novo parâmetro ao modelo (i.e., um novo eixo), resultando numa
tabela quadridimensional.
Outra técnica, conhecida como EqTab [4], é uma mistura entre a abordagem baseada
em equações e a baseada em tabelas. Ela foi proposta originalmente para reduzir o
tempo de caracterização, reduzindo o número de sequências necessárias para a criação do
modelo. Porém, conforme já foi mostrado em [148], um conjunto adequado de sequências
é essencial para a elaboração de modelos de alta qualidade.
Nesta técnica, uma tabela de duas dimensões é utilizada, cujos eixos são os parâmetros
Pin e Din . Ao contrário do 3DTab, que usa a média da densidade de transição e proba-
bilidade entre todos os sinais de entrada e saı́da, esta técnica considera todos os sinais
individualmente. O modelo de potência é uma expressão da seguinte forma
P ower = c0 + c1 Din (0) + ... + cm Din (m) + cm+1 Dout (1) + ... + cm+n Dout (n) (3.6)
onde m e n são o número de entradas e saı́das, respectivamente, e ci são os coeficientes

da equação.
A seguir serão apresentadas a construção e avaliação desta expressão, com a descrição
do processo de caracterização e estimação. Para cada par (Pin , Din ), uma sequência de
K vetores de entradas é gerada, de forma a estimular o circuito sendo caracterizado para
potência.
Para cada par de vetores desta sequência, a potência dissipada pelo circuito é esti-
mada, e os valores de densidade de transição são anotados, individualmente, para cada
entrada/saı́da. Note que, como apenas um vetor está sendo considerado, os valores de
densidade correspondentes podem ser apenas 0 ou 1. Os valores de densidade de transição
e potência são armazenados nas matrizes SW e P que, ao final do procedimento, terão
K − 1 linhas. Então, monta-se o sistema de equações
SW × C = P (3.7)
onde C é um vetor-coluna correspondente aos ci ’s da Equação 3.6. A próxima etapa é

obter os fitting coefficients, o que é feito através de técnicas de regressão linear. Ao final
do processo de caracterização, cada ponto (Pin , Din ) da tabela terá, ao invés de valores
de potência, os coeficientes da Equação 3.6.
O processo de estimação consiste em selecionar a equação (os coeficientes) a ser usada,
escolhendo o ponto (Pin , Din ) mais próximo do resultado da simulação RTL. Os valores
dos coeficientes são, então, combinados com as densidades de transição individuais de cada
sinal na equação, seguindo-se a sua avaliação, cujo resultado é a estimativa de potência.
Em [27], os autores propõem uma técnica baseada em equações para estimar a potência
dos chamados operadores não-sintéticos. Operadores sintéticos são as macros consideradas
na maioria dos trabalhos propostos, como somadores, multiplicadores, etc. Neste trabalho,
os autores defendem que a visão estrutural do projeto em RTL como uma FSMD, onde o
projeto é visto como um conjunto de macros e uma máquina de estados, é ideal demais. O
resultado da elaboração do código em RTL consiste na instanciação de quatro primitivas
básicas: gates, macros, seletores (multiplexadores) e elementos de memória. Em sua
técnica, os autores apresentam modelos de potência para todas estas primitivas, nos quais
usa-se regressão linear para a criação das equações. São considerados parâmetros de
atividade e parâmetros de complexidade (quantidades visı́veis no nı́vel RTL).
Uma caracterı́stica aplicável a quase todas as abordagens de macromodelagem é o fato
de os modelos serem fortemente dependentes da biblioteca de tecnologia na qual os mesmos
foram gerados. Isto é, uma componente pode e deve ter implementações especı́ficas quando
sintetizada usando bibliotecas de tecnologia distintas. Como consequência, o perfil de
consumo de potência também será diferente. Uma solução interessante para este problema
foi proposta em [27], e é descrito a seguir.
Considere Lref como sendo a biblioteca de tecnologia de referência, utilizada durante
a fase de caracterização e Lnew a nova biblioteca, para qual o modelo de potência deve
ser portado. Os autores propõem, então, que o modelo de potência seja ajustado para a
nova biblioteca, de acordo com um fator de escala K. Na prática, tem-se
PLnew = K × PLref (3.8)
onde PLnew e PLref são os modelos de potência para as bibliotecas nova e de referência,
respectivamente. A tarefa então restringe-se na determinação do valor de K. Como a nova
biblioteca de tecnologia é especificada de antemão, o cálculo de K é baseado no processo
de escala de uma única instância G da biblioteca. Mais especificamente, uma instância
da biblioteca nova é selecionada e sintetizada para Lnew , e um modelo de potência PLGnew

é criado. Valores aleatórios são aplicados às entradas de G de forma a se obter um valor
de potência deste novo modelo. Após isso, o fator de escala é calculado fazendo-se
PLnew
K= (3.9)
PLref
As técnicas propostas neste trabalho [27] foram implementadas numa ferramenta comer-
cial chamada PowerChecker, da BullDAST [114].
Técn Tab Eq Ciclos Param Bib Técn Tab Eq Ciclos Param Bib
√ √ √ √ √ √
[21] [27]
√ √
[125] [121] • • • •
√ √ √ √ √
[54] [51]
√ √ √
[52] [53]
√ √ √
[126] [20]
√ √
[31] [6]
√ √ √ √
[64] [14]
√ √ √ √ √
[4] [22]
√ √ √
[85] [95]
√ √ √ √
[65] [34]
√ √ √
[3] [110]
√ √ √
[148] [50]
[84] • • [86] • •
√ √ √ √
[35] [152]
√ √ √ √
[24] [38]
√ √ √ √
[23] [149]
√ √ √
[59] [19]
√ √ √ √ √
[37] [63]
√ √
[124] [101]
Tabela 3.1: Caracterı́sticas das técnicas de macromodelagem
Diversas outras técnicas de macromodelagem foram propostas na literatura, com uma

grande variedade de parâmetros utilizados e de formas de armazenagem do modelo. A
Tabela 3.1 apresenta uma categorização de diversos trabalhos existentes na literatura, de
acordo com suas principais caracterı́sticas. Nesta tabela, as colunas 1 e 7 (rotuladas com
Técn) citam a referência bibliográfica, enquanto as colunas 2–6 e 8–12 indicam as carac-
terı́sticas consideradas da técnica: Tab (baseada em tabela); Eq (baseada em equação);
3.2. Nı́vel de Algoritmos 25
Ciclos (precisão de ciclos); Param (parametrizável) e Bib (suporte à ajustes de bibli-

√
oteca de tecnologia). As colunas marcadas com indicam a presença da caracterı́stica,
enquanto o sı́mbolo • é usado para indicar caracterı́sticas que não estão explı́citas no
artigo.
A coluna Param refere-se às técnicas que têm alguma solução para o modelo de
potência se ajustar de acordo com o tamanho de palavra do componente. Considere um
somador de 8 bits, por exemplo, que é então caracterizado, gerando assim um modelo de
potência. Técnicas parametrizáveis podem inferir um modelo de potência para somadores
com tamanhos de palavra diferentes, sem a necessidade de executar o procedimento de
caracterização novamente.
As técnicas bottom-up, que fazem parte do paradigma de macromodelagem, têm a
vantagem de ter uma relação forte com o hardware real e, portanto, conseguem obter
um grau de precisão absoluta superior às outras abordagens, sendo consideradas hoje,
o estado da arte no nı́vel RT [91]. Embora muitos trabalhos dentro deste paradigma
tenham sido reportados nos últimos anos, conforme foi apresentado nesta seção, esta
abordagem sofre de alguns problemas de robustez na modelagem de potência onde, em
casos extremos, erros bem superiores a 100% podem ser obtidos. Esta é uma das razões
pelas quais a macromodelagem é considerada como estando no limiar entre a Academia
e a Indústria [91], havendo ainda espaço para a pesquisa.
3.2 Nı́vel de Algoritmos

Dentro dos objetivos do nı́vel de algoritmos inclui-se a otimização de algoritmos que
serão implementados em software, em hardware, ou uma combinação de ambos. Diversas
métricas são utilizadas neste processo, tais como, desempenho, custo e potência. Selecio-
nar um algoritmo eficiente em termos de potência, a partir de um conjunto de algoritmos
funcionalmente equivalentes, exige esforço. Primeiro, os algoritmos sob análise devem
ser implementados (sintetizados para alguma tecnologia-alvo). Posteriormente, diversas
estimativas de potência devem ser geradas com estas implementações. Idealmente, esta
tarefa deveria ser conduzida sem, de fato, implementar os algoritmos.
Uma das dificuldades neste nı́vel é que o hardware não foi projetado ainda. Um
modelo de implementação comumente utilizado é o FSMD (ver a Seção 2.3) e, portanto,
uma descrição no nı́vel algorı́tmico deve, de alguma forma, mapear o algoritmo para esta
arquitetura, composta pelo datapath e o controlador. As descrições neste nı́vel podem
ser feitas através de linguagens de alto nı́vel (C, C++, SystemC) ou mesmo através de
CDFGs (Control Data Flow Graphs). O problema em se estimar potência aqui pode, de
maneira simplista, ser visto como: dada uma descrição comportamental, deve-se estimar
a potência dissipada pela implementação em hardware otimizado desta descrição.
Como pode ser visto, são necessárias predições da arquitetura, da ativação dos com-
ponentes da mesma, bem como da comunicação e armazenamento. Neste contexto, isto
se traduz em [94]:
2
P ower = Na Cavg Vdd fs (3.10)
onde Na é o número de ativações de determinado módulo, Cavg é a capacitância média

chaveada por ativação, Vdd é a voltagem de alimentação e fs é a freqüência de computação
(ou amostragem). O número de módulos e sua ativação dependem fortemente das etapas
de escalonamento, alocação e ligação1 , que não foram ainda executadas neste nı́vel. Por-
tanto, para avaliar a Equação 3.10, suposições devem ser feitas sobre a implementação
do hardware. E, além disso, modelos de potência devem existir. No caso de componentes
muito utilizados, como é o caso de somadores e multiplicadores, isto pode ser feito através
de técnicas similares às apresentados na Seção 3.1.
O método apresentado por Raghunathan e Jha [118] é considerado o primeiro método
de alocação low power, onde se tenta reduzir, simultaneamente, tanto a capacitância
quanto a atividade de transição. A técnica baseia-se no grafo de compatibilidade, onde
os pesos das arestas representam a capacitância e a atividade de transição (calculadas
como WC × WT ). Um método para a otimização do controlador também foi descrito:
os ciclos ociosos são explorados de forma a desativar os registradores nas entradas das
unidades funcionais, reduzindo a atividade de transição e, consequentemente, a potência.
As técnicas propostas pelos autores foram desenvolvidas estendendo-se a ferramenta de
sı́ntese comportamental Genesis-LP [8].
Uma abordagem diferente, baseada em entropia, foi proposta em [41]. A principal
suposição feita para se estimar a potência foi aproximar a capacitância e a atividade:
Pavg ∝ D × CT OT (3.11)
onde D é a densidade de transição e CT OT é a capacitância para um determinado compo-

nente. Note a similaridade desta expressão com a Equação 3.10. A variável D já engloba
2
os parâmetros fs e Na , e Vdd é uma constante. O ponto de entrada para a metodologia
proposta é uma rede de interconexão de módulos, descritos por BDDs (Binary Decision
Diagram). A capacitância interna de um módulo é aproximada a partir da descrição do
1
Do inglês, binding
3.2. Nı́vel de Algoritmos 27
BDD através da equação:

HO
CT OT = aNnodes +b (3.12)
m
onde Nnodes é o numero de nodos no BDD, HO é a entropia de saı́da do módulo e m é o
número de saı́das usada para normalizar a contribuição de HO . As constantes a e b são
obtidas através de análise de regressão (least mean squares). A atividade de transição é
estimada usando-se uma simples equação analı́tica baseada na entropia.
Os autores relatam ter obtido uma boa concordância para comparações relativas de
potência entre um modelo de referência e alternativas de projeto, comparadas aos resulta-
dos obtidos com o Design Power, da Synopsys. No artigo, não há comentários sobre valores
absolutos. Portanto, conclui-se que esta abordagem não é adequada para estimativa de
potência, quando o objetivo é obter números absolutos de potência.
Uma metodologia para estimativa de potência baseada em CAFDs (Cycle-Accurate
Functional Description) é introduzida em [154]. É feita a suposição de que, dado um
CAFD, há uma implementação em RTL desta descrição e associa-se as informações desta
implementação às variáveis do CAFD. Este CAFD anotado2 também faz a instanciação
do que é chamado pelos autores de componentes virtuais, que mapeiam os componentes
RTL para as variáveis no CAFD.
A atividade de transição destes componentes é capturada durante a simulação, e a
potência estimada a partir de modelos de potência de uma biblioteca de componentes pré-
caracterizada. Além disso, uma técnica denominada amostragem adaptativa 3 é proposta,
cujo intuito é melhorar o desempenho de simulação. O princı́pio básico do método é
manter informações de dissipação de potência para cada estado da unidade de controle e
parar a monitoração em determinados estados, de acordo com a contribuição de cada um
para a variação da potência total. Os resultados obtidos com esta técnica foram muito
similares aos resultados da simulação RTL pura, porém com ganhos de desempenho de
até 1000 vezes em projetos grandes.
3.2.1 Interconexão
Os elementos de comunicação são, por muitas vezes, ignorados durante a otimização do
hardware no nı́vel de algoritmos. Isto tende a acontecer pois são necessárias informações
fı́sicas sobre o placement dos componentes, de sua interconexão e também da rede de
relógio. Contudo, conforme mostrado em [132,153], reduções de mais de 20% na potência
2
Do inglês, back-annotated
3
Do inglês, adaptive sampling
total podem ser obtidas com técnicas de otimização de potência cientes da interconexão.
Em [153], os autores propõem uma técnica que, ao contrário de muitos trabalhos, não se
baseia na chamada regra de Rent [33] para estimar a potência da interconexão. Esta regra
é utilizada para derivar o comprimento médio dos fios dentro de chips. Um framework
que implementa suas heurı́sticas é introduzido, onde a descrição comportamental é feita
usando-se CDFGs, e os fios são representados pelas arestas. O fluxo deste framework
inicia-se com a simulação dos CDFGs, de forma a capturar estatı́sticas de atividade em
suas arestas, que são usadas durante o processo de sı́ntese. Uma técnica chamada signal
gating é aplicada para reduzir a atividade nos fios, onde for possı́vel, e heurı́sticas que
exploram o compartilhamento e ligação de recursos são aplicadas para reduzir a potência
de interconexão. Os resultados reportam reduções na potência total de aproximadamente
27% com um aumento de área de apenas 0.5%.
Uma outra abordagem para otimização de potência ciente de interconexão, que também
não usa a regra de Rent, é apresentada em [131, 132]. Os autores argumentam que a
potência de interconexão depende fundamentalmente do comprimento dos fios e apresen-
tam um modelo onde a capacitância do fio é derivada através de métodos de regressão
linear, usando como variáveis explanatórias o comprimento do fio, o número de pinos e o
número de branch points (pontos onde o fio se divide em dois ou mais caminhos). Uma
heurı́stica de floorplanning, baseada em simulated annealing (SA) é usada para estimar
o comprimento dos fios. O algoritmo de otimização consiste em dois algoritmos SA ani-
nhados, onde o SA mais interno executa o floorplanning e o SA externo executa a ligação
(note que as duas etapas são realizadas simultaneamente). Os resultados reportados são
similares aos da técnica anterior [153], com reduções de 22% na potência total e aumento
de 2% na área.
3.2.2 ORINOCO
Muitos trabalhos de pesquisa têm sido realizados no nı́vel algorı́tmico no âmbito acadêmico,
porém um número limitado de opções é encontrado na indústria [29, 44, 103]. Uma fer-
ramenta de análise e otimização de potência comercial neste nı́vel que deve ser menci-
onada é o ORINOCO (OFFIS Research INstitute pOwer Characterizer, estimator and
Optimizer) [103, 133]. O fluxo de projeto do ORINOCO é mostrado na Figura 3.2.
O ORINOCO aceita como entrada descrições comportamentais em C, C++ ou
SystemC, que são analisadas e instrumentadas automaticamente para capturar a ati-
vidade de transição. O resultado é um CDFG, utilizado durante a fase de otimização,
3.3. Nı́vel de Instrução 29
Figura 3.2: Fluxo de projeto do ORINOCO
que gera uma arquitetura otimizada para potência. Os modelos de potência utilizados são
gerados automaticamente por ferramentas de caracterização, que fazem parte do conjunto
de ferramentas do ORINOCO. Os relatórios de potência gerados auxiliam o projetista
a encontrar os pontos crı́ticos da arquitetura, facilitando a realização de modificações na
descrição algorı́tmica que gerem maior impacto na redução de potência.
3.3 Nı́vel de Instrução

Neste nı́vel, o objetivo é capturar o consumo de potência de arquiteturas dedicadas, tais
como DSPs (Digital Signal Processor) e processadores de uso-geral, através da execução de
suas instruções. O software per se não consome energia, porém as instruções executadas
estimulam as unidades dos processadores de forma distinta, gerando inúmeros padrões de
consumo de energia. Para capturar as variações destes padrões, um modelo de potência
é construı́do, cujo parâmetro de entrada é o trace de instruções executadas.
A vantagem deste paradigma é que o processador pode ser visto como uma caixa-
preta, facilitando a distribuição de modelos de potência, sem a necessidade de dar deta-
lhes sobre a microarquitetura, o que é, geralmente, considerado informação sigilosa para
os fabricantes. Além disso, mesmo que o projetista tenha acesso a uma descrição do
processador em RTL ou gate-level, estimar a potência nestes nı́veis de abstração é uma

tarefa excessivamente demorada para projetos do porte de um processador. Estes detalhes
são completamente abstraı́dos quando somente o fluxo de instruções é considerado. As
técnicas de análise de potência neste nı́vel podem ser divididas, em sua maioria, em:
i) técnicas de medição: medições reais [105] são feitas com o uso de amperı́metros
ii) técnicas de simulação: ferramentas de estimativa de potência (RTL, gate-level)

são usadas.
O primeiro modelo de potência em nı́vel de instrução foi proposto por Tiwari et

al [143], dentro da categoria dos modelos de medição. A metodologia para modelagem e
estimativa foi demonstrada em [143] para o processador Intel 486DX2, porém pode ser
considerada uma metodologia genérica, facilmente aplicável a outras arquiteturas. A es-
tratégia é a seguinte: para cada instrução do ISA (Instruction-Set Architecture), é criado
um laço com várias instâncias dela, como é mostrado na Figura 3.3, para a instrução
mov registrador, imediato. Este laço é, então, executado no processador-alvo e um
main:
mov bx, 0FF
mov bx, 0FA
...
mov bx, 0AC
...
jmp main
Figura 3.3: Laço de caracterização
amperı́metro, conectado ao pino de alimentação do processador, mede a corrente média

durante a execução deste programa. O número de instâncias de cada instrução deve ser
escolhido cuidadosamente, de forma a ser grande o suficiente para mitigar os efeitos do
branch no final do laço e pequeno o suficiente para não causar misses na cache. O valor
de corrente média obtido durante esta etapa é armazenado numa tabela de custos-base.
Além desta tabela, os autores também consideram o que eles chamam de efeitos inter-
instrução. O argumento é que usar somente a tabela de custos-base não é suficiente
para uma estimativa precisa, pois a potência consumida pelas instruções não é totalmente
independente. Estes efeitos são de três tipos:
• circuit-state overhead: considere uma instrução Ij qualquer de um programa. As

instruções Ij−1 e Ij+1 têm efeito sobre a dissipação de Ij , pois diferentes partes do
circuito serão ativadas, e haverá um padrão distinto de atividade de transição para
cada par de instruções.
• restrição de recursos: causando stalls no pipeline.
• cache misses: aumenta o número de ciclos executados, compulsoriamente penali-

zando com aumento de consumo de energia.
Cada um destes efeitos inter-instrução foi considerado pelos autores e o modelo de potência
resultante é: X X X
Eprog = (Bi Ni ) + (Oi,j Ni,j ) + Ek (3.13)
i i,j k
onde Eprog é a energia total do programa, Bi é o valor na tabela de custos-base para a

instrução i e Ni o número de ocorrências desta instrução; Oi,j é o circuit-state overhead
entre os pares consecutivos de instruções (i, j) e Ni,j o número de vezes que o par ocorre na
execução; finalmente, Ek é a contribuição para outros efeitos, como stalls e cache misses.
Uma proposta que se encaixa na categoria das técnicas baseadas em simulação é o
trabalho em [67], no âmbito da plataforma SEA. O processador utilizado para validar o
modelo proposto foi o MicroSparcIIep, que é um core em RTL sintetizável, disponı́vel em
domı́nio público. Os autores refinam a técnica de Tiwari et al [143] fazendo as seguintes
observações:
1. Independente do tipo de stall, vários módulos do core apresentam um comporta-

mento de potência muito similar. Portanto, seria benéfico diferenciar entre ciclos
de execução e ciclos de stall.
2. Variações nos dados tem uma contribuição significativa para a variação de potência
para uma dada instrução, ao contrário do que é afirmado em [143].
3. Efeitos inter-instrução são difı́ceis de modelar devido a grandes variações no contexto

de execução da instrução. Conforme é reportado em seus experimentos, estes efeitos
podem ser ignorados.
O modelo resultante é dado na Equação 3.14 abaixo:
Xn Xn
Eprog = (( Pavgi nai ) + ( nsi ) ∗ Pstall ) × T (3.14)
i=1 i=1
onde n é o número de instruções do trace, Pavgi é a potência média consumida pela

instrução i, Pstall é a potência média de stall, e T é o perı́odo do relógio. Um detalhe
importante é que, além de Pavgi , limites inferiores e superiores para o consumo da instrução
estão disponı́veis no modelo.
O modelo proposto pelos autores é utilizado dentro do SEA, uma plataforma para a
estimativa de potência de microarquiteturas. A entrada para o SEA é o código-objeto do
programa a ser analisado. Este binário é então executado em um simulador de conjunto
de instruções (ISS, Instruction Set Simulator) de forma a obter os traces de instruções da
execução. Um banco de dados contendo os modelos de potência é gerado previamente,
através da simulação do core RTL do processador em questão, em conjunto com uma
ferramenta comercial de estimativa de potência. O SEA acessa os modelos de potência
deste banco de dados, capturando sequências de instruções, dependências de dados e
efeitos de pipeline, gerando estimativas de consumo de potência para o programa.
Há ainda outras abordagens que se baseiam em métodos estatı́sticos para a modelagem
de potência de processadores, como o trabalho apresentado em [46]. Os autores criaram
modelos para dois DSPs, com um método que consiste em avaliar o acesso às unidades
funcionais dos processadores através de análise estática do código do programa. O modelo
é criado da seguinte forma: vários programas de um benchmark são executados inteira-
mente e um amperı́metro ligado à alimentação do processador captura a corrente média.
Estes valores são anotados para todos os programas e algumas variáveis que indicam o
acesso às unidades funcionais são automaticamente selecionados para serem usados num
processo de regressão linear. Exemplos de variáveis são: SU Bi (número de subtrações na
unidade i), M U Li (número de multiplicações na unidade i), LOADi (número de loads
na unidade i), onde i indica a unidade especı́fica do DSP.
Existem ainda métodos que diferem das abordagens anteriores, como a proposta
em [66], onde são usados contadores de performance4 (existentes na maioria dos pro-
cessadores) para derivar a atividade e o uso de diversas partes do processador. Através
desta informação e modelos de potência para as unidades do processador consideradas, a
potência é estimada. Dois processadores foram utilizados para validar o método em [66]:
Alpha e Pentium Pro. Para o Alpha, o simulador Wattch [26] foi utilizado, e para Pentium
Pro, os resultados foram comparados com medições reais. Para ambos os processadores,
os resultados reportados foram muito próximos aos valores de referência.
Outros métodos foram desenvolvidos usando conceitos similares aos das técnicas de
estimativa de potência apresentados nesta seção e estão disponı́veis na literatura [10, 11,
4
Do inglês, performance counter
25, 30, 47, 79, 89, 100, 115, 123, 134, 150].
3.3.1 Otimizações de Software

Modelos de potência em nı́vel de instrução, como os descritos acima, são de grande
importância no projeto de sistemas embarcados, pois habilitam o desenvolvimento de
técnicas de otimização de código visando a redução do consumo de energia. Uma das
vantagens em se otimizar software é que o custo associado é muito baixo e as peculia-
ridades de cada arquitetura podem ser exploradas pelo otimizador, considerando que os
modelos de potência estejam disponı́veis.
As primeiras técnicas de otimização de código com este intuito foram originadas no
trabalho de Tiwari et al [78, 142, 143]. Dentre as técnicas exploradas, estão o reescalona-
mento do código e a atribuição de operandos a diferentes bancos de memória.
Há ainda técnicas de otimização que se enquadram no gerenciamento dinâmico de
potência, como a apresentada em [60], onde é proposto um algoritmo de DVFS (Dynamic
Voltage and Frequency Scaling). O algoritmo proposto analisa o código-fonte e, com
o auxı́lio de informações de profiling, seletivamente instrumenta regiões do código com
pontos de entrada/saı́da de forma a reduzir/aumentar a frequência e voltagem de operação
do processador. Os autores reportam ganhos de até 28% no consumo de energia com
penalidades em desempenho na faixa de 0%–5%.
Embora vários esforços tenham sido feitos na área de gerenciamento dinâmico de
potência e energia, esta área de pesquisa é ainda considerada imatura [72].
Otimizações de código que explorem a hierarquia de memória quase sempre têm o efeito
colateral de redução de potência/energia, mesmo quando a função-objetivo centraliza-se
em desempenho. Isto ocorre, principalmente, porque memórias menores e mais próximas
de processadores geralmente possuem uma capacitância ordens de grandeza inferior a de
memórias off-chip. Portanto, otimizar o uso da memória, levando em conta sua hierarquia,
é um excelente ponto a ser atacado de forma a obter reduções significativas de potência
e/ou energia.
Os trabalhos em [144–146] visam a otimização de potência explorando estas carac-
terı́sticas da hierarquia de memória. O código é otimizado de forma a alocar as variáveis
mais utilizadas para as chamadas scratchpad memories, que são memórias extremamente
pequenas e, portanto, com um baixo consumo de energia. Os resultados reportados mos-
tram reduções significativas de até 30% do consumo total. O modelo de potência utilizado
como base para as estimativas é encontrado em [136].
Outras técnicas de otimização de código visando redução de consumo de potência e/ou

energia são encontradas na literatura [73, 127, 130, 155].
3.4 Nı́vel de Sistema

O nı́vel de abstração mais alto considerado nesta tese é o de sistema. Neste contexto, um
sistema é um conjunto de componentes de hardware e software que, juntos, executam uma
tarefa comum. Entre as etapas de desenvolvimento neste nı́vel, pode-se citar a alocação
de recursos de hardware e o particionamento das tarefas entre software e hardware, o que
definirá como a cooperação entre os vários componentes será realizada.
Usualmente, o projeto em nı́vel de sistema inicia-se com três entradas: (i) especificação,
(ii) requisitos e (iii) restrição de espaço de projeto.
O task graph [120] é um formalismo passı́vel de ser utilizado para a especificação de sis-
temas. Um task graph tem o valor semântico de uma tarefa, onde os vértices representam
as subtarefas (processos) e as arestas representam o fluxo e o controle de dados entre as
mesmas. Esta representação explicita o paralelismo e a concorrência existente, provendo
ao projetista informações iniciais que auxiliam no processo de alocação de recursos, bem
como no particionamento das subtarefas entre os recursos disponı́veis.
Os requisitos incluem informações tı́picas, tais como: requisitos mı́nimos de desempe-
nho, custo máximo, restrições de dissipação de potência, entre outros.
A restrição do espaço de projeto inclui a especificação que uma determinada famı́lia de
processadores deve ser usada, tipos de memória e barramentos disponı́veis, área máxima
utilizada. Todos estes elementos, juntamente com o componente de software definem uma
plataforma.
A Figura 3.4 mostra um exemplo de uma arquitetura descrita em nı́vel de sistema. Atu-
almente, é muito comum a implementação dos componentes de hardware de um sistema
como este serem feitos num único chip, sendo comumente chamados de SoCs (System-on-
Chip). Uma das tarefas do projetista é alocar os componentes e fazer o mapeamento dos
processos para os componentes do sistema, de forma a cumprir os requisitos especificados
previamente.
Uma forma de otimizar o sistema tanto para desempenho quanto para potência é
identificar os chamados kernels computacionais, que geralmente são os laços internos onde
há computação intensiva.
Em [56, 81], um framework chamado Avalanche é apresentado, onde o sistema é avali-
ado em sua totalidade. Este framework tem como principal objetivo permitir a exploração
3.4. Nı́vel de Sistema 35
I−cache
ASIP
core D−cache SRAM
Memória
IP principal IP
core (DRAM) core
IP
Processador de core
uso geral Cache
(ex. PowerPC)
Figura 3.4: Exemplo de arquitetura em nı́vel de sistema
do projeto com relação à potência e ao desempenho, aplicando variações nos parâmetros

de hardware (tamanho de memória e parâmetros de cache), além da realização de oti-
mizações no software.
Os componentes suportados pelo Avalanche são: o processador, ASICs (Application-
Specific Integrated Circuits), memória principal (DRAM) e caches (dados e instrução).
Neste trabalho especı́fico, os ASICs são considerados fixos e já sintetizados. Cada um dos
componentes tem associado a si um modelo de potência especı́fico.
Dados os modelos de potência, a entrada para o Avalanche é uma versão inicial do
programa, que é perfilado5 e analisado com relação ao seu consumo de energia e desem-
penho. O usuário tem a opção de escolher um objetivo de otimização: (1) energia, (2)
desempenho e (3) multi-objetivo. O software é analisado e então os melhores fragmentos
de programa candidatos são selecionados para sofrerem transformações (loop unrolling,
procedure inlining, ...) contanto que não excedam o tamanho da memória.
Os autores reportam reduções de até 94% no consumo de energia. Outro resultado
experimental interessante apresentado é que, para o benchmark utilizado (aplicações do-
minadas por dados, incluindo um codificador MPEG), cada aplicação exibiu um com-
portamento distinto para as variações nos parâmetros do sistema, demonstrando que a
melhoria global de consumo de energia com restrições não é uma tarefa previsı́vel. As
saı́das do fluxo do Avalanche são: o software otimizado e os melhores parâmetros, dado
5
Do inglês, profiled
o objetivo de otimização selecionado. Nada é mencionado sobre a estimativa de potência

dos ASICs.
Uma extensão deste trabalho [56,81] é apresentada pelos mesmos autores em [55], onde
é desenvolvida uma metodologia para o particionamento das aplicações entre hardware e
software de forma a reduzir o consumo de energia.
A entrada desta metodologia é a aplicação numa descrição comportamental. O al-
goritmo particionador, então, divide a aplicação em clusters, computando os possı́veis
ganhos em economia de energia e selecionando os clusters mais proeminentes para im-
plementação em hardware (i.e., kernels computacionais). Uma caracterı́stica importante
do algoritmo proposto é que a comunicação no barramento é levada em conta durante o
cálculo dos ganhos, o que torna a abordagem mais realista.
Os experimentos realizados com aplicações tı́picas de processamento de sinais apre-
sentaram reduções de 35% a 94% no consumo de energia, tendo como efeito colateral a
melhoria em desempenho (exceto para um caso).
Modelos de implementação são úteis no projeto em nı́vel de sistema, pois auxiliam
na rápida comparação de diferentes opções de implementação, dando noções, mesmo que
grosseiras, do impacto no consumo de energia. Um modelo relevante, conhecido por
spreadsheet-like, é tipicamente utilizado antes da prototipagem e sem o uso de modelos de
execução. Para estimar a potência do sistema, a informação sobre a dissipação de potência
de cada componente é geralmente extraı́da de datasheets e inserida numa planilha. A
potência total é obtida de forma bem direta, simplesmente somando-se a contribuição de
cada componente para a potência total. A ferramenta PowerPlay [82] usa estes conceitos,
onde uma biblioteca de modelos de potência está disponı́vel para diferentes tipos de
componentes.
Como exemplo ilustrativo, considere um sistema simples tal qual uma agenda eletrônica.
O sistema é composto por um microcontrolador com 1MB de memória RAM, 2MB de
memória FLASH para armazenar o firmware e 8MB adicionais de memória FLASH para
armazenar dados do usuário. Uma interface com o computador é disponibilizada através
de uma conexão por infravermelho (IR) e a interface com o usuário é feita através de
LCD, sensı́vel ao toque. O sistema também possui um relógio de tempo real (com um
oscilador de quartzo) e um conversor DC/DC para alimentar os componentes (em 3.3V).
O modelo spreadsheet-like para este sistema pode ser visto na Tabela 3.2 [17]. As duas
primeiras colunas mostram, respectivamente, a descrição do componente e o número de
componentes utilizados no sistema, e a terceira coluna indica a voltagem de alimentação
de cada um. As colunas 4 e 5 são os valores de corrente (em mA) informados para quando
3.4. Nı́vel de Sistema 37
Componente Quantidade Vdd Iidle ION % Idle % ON I (mA)

Processador 1 3.3 0.5 50 0.3 0.7 35.15
DRAM 1 3.3 0.1 12 0.3 0.7 8.43
FLASH 1 3.3 0.0 9 0.3 0.7 31.5
IR 1 3.3 0.0 64 0.95 0.05 3.2
RTC 1 3.3 0.0 0.1 0 1 0.1
DC/DC 1 3.3 0.1 5.5 0.01 0.99 5.44
Total 83.82
Tabela 3.2: Modelo spreadsheet-like
o componentes está ocioso e ativo, enquanto as colunas 6 e 7 indicam o percentual do

tempo no qual cada estado é utilizado. A última coluna indica a corrente média de cada
componente, calculada como
I = Ncomponentes × (Iidle × percentualidle + ION × percentualON ) (3.15)
A corrente total do sistema é apresentada no canto inferior direito da tabela. A partir

deste valor, obter a potência total é direta, multiplicando-se Vdd por I, resultando em
Pavg = 276.6mW.
Uma evidente limitação da abordagem spreadsheet-like é que a interação entre os
componentes não é modelada. Um trabalho desenvolvido para sobrepor esta limitação
é apresentado em [18], onde é proposto a chamada PSM (power state machine), que é
um modelo baseado em uma máquina de estados. Cada estado representa um modo de
operação (ocioso, ativo, desligado, etc) e é rotulado com a dissipação de potência. As
arestas entre os estados representam as mudanças válidas de modo de operação, e são
anotadas com o custo em termos de tempo e potência para mudança de um modo de
operação para outro. Se considerar o caso onde cada máquina de estados (uma para cada
componente) possui um único estado, o modelo PSM equivale ao modelo spreadsheet-like.
Um problema com esta abordagem é a necessidade de um esforço maior do projetista para
especificar a iteração dos componentes do sistema e a necessidade de modelos de potência
mais refinados que na abordagem spreadsheet-like.
Embora modelos de implementação sejam de grande valia numa fase inicial do projeto,
a funcionalidade do sistema não é tratada de forma adequada, dificultando a captura da
interação entre os componentes. Os chamados modelos funcionais executáveis resolvem
este quesito e permitem aos projetistas simular o sistema, capturando mais precisamente
a interação entre os componentes. Usualmente, estes modelos são descritos em linguagens

de descrição de hardware, tais como, Verilog, VHDL e SystemC [106], ou mesmo C ou
C++.
Um exemplo do uso de modelos de implementação deste tipo é apresentado em [128,
129]. Os autores apresentam uma metodologia para a estimativa de potência de sistemas
embarcados, compostos por um core de um processador ARM com caches L1 e L2, SRAM,
FLASH, off-chip DRAM, interconexão e um conversor DC/DC conectado a uma bateria.
O simulador ARMulator foi estendido, adicionando-se modelos de energia para cada um
dos componentes citados, com informações extraı́das de datasheets. Os modelos foram
validados comparando-se os resultados obtidos com medições reais de um protótipo, com
o auxı́lio de um osciloscópio. O erro médio obtido reportado foi de 5%. Os autores
também analisaram a eficiência das otimizações de código realizadas pelo compilador da
ARM com relação ao consumo de energia e observaram que quase nenhuma diferença era
obtida. Além disso, algumas otimizações em nı́vel de código-fonte foram desenvolvidas,
que obtiveram bons resultados para um decodificador de MPEG.
Embora no nı́vel de sistema a abstração seja alta, os sistemas atuais estão cada vez
mais complexos, degradando o desempenho de simulação para se estimar potência de
sistemas reais. Recentemente, Bansal et al [5] propuseram os chamados power monitors
para superar este problema.
Os autores inicialmente afirmam (e ilustram através de um exemplo) que, para SoCs
heterogêneos, a divisão do esforço computacional entre os vários componentes do sistema
tem uma grande discrepância em relação a contribuição de cada um para o consumo de
potência total. Baseado nestas afirmações, eles sugerem o uso de modelos de potência
mistos durante a simulação, através da chamada simulação baseada em monitores.
Para cada componente (ex., cache, processadores, barramentos, etc) diversos modelos
de potência são utilizados, cada um com um diferente nı́vel de eficiência e/ou precisão.
Durante a simulação, os modelos de potência são selecionados baseado em critérios como:
baixa contribuição para o consumo total de potência, baixa variação de atividade, etc,
com objetivo de relacionar o compromisso entre precisão e desempenho de simulação.
Os resultados apresentados para um caso de estudo de um SoC real foram muito
próximos aos resultados obtidos com uma simulação onde o modelo é mais preciso (por-
tanto, degradando o desempenho). Os erros obtidos ficaram abaixo de 4% para potência
média e com precisão de ciclos. O speedup de simulação obtido foi de aproximadamente
9,5 vezes.
3.5. Modelagem de Baterias 39
3.5 Modelagem de Baterias

Durante o desenvolvimento de sistemas digitais visando baixo consumo de potência, boa
parte da atenção do projetista está voltada para os circuitos e interfaces responsáveis pela
computação, armazenamento e comunicação. Embora haja uma vasta gama de modelos
de potência para estes circuitos, muito menos atenção tem sido dedicada aos modelos
de fonte de alimentação. Normalmente, é feita a suposição de que os sistemas estão
conectados à fontes de alimentação ideais, capazes de prover energia constantemente e
de forma infinita. Infelizmente, essa suposição não é válida para dispositivos alimentados
por bateria.
Em muitos trabalhos, baterias são vistas como reservatórios de carga ideais, o que não
é verdade. Entre as várias não-idealidades das baterias podemos citar:
• a voltagem de saı́da das baterias depende de forma não-linear de seu estado de carga
(state of charge). Por esta razão, existe a necessidade de conversores DC-DC para
estabilizar a voltagem de saı́da.
• a capacidade da bateria depende da corrente de carga.
• a taxa na qual ocorre a corrente de descarga afeta o montante de energia disponı́vel

na bateria.
• baterias têm, mesmo que limitada, a capacidade de recuperação de carga depen-

dendo de como a energia é extraı́da da mesma.
• células de baterias iguais exibem significativas diferenças fı́sico-quı́micas, que levam

a comportamentos diferentes. Por isso, não é considerado boa prática ligar baterias
em paralelo.
Modelos de simulação de baterias são desenvolvidos para se estimar o comportamento
real do circuito muito antes de se conectar a bateria real do protótipo. Os modelos
mais precisos são os que descrevem os fenômenos eletroquı́micos das células das baterias
através de equações diferencias parciais (PDE, Partial Differential Equation). Embora
estes modelos sejam precisos, eles são computacionalmente intensivos e dificultam o seu
uso na prática. Modelos em nı́vel mais alto que o eletroquı́mico foram elaborados, como
o proposto em [49], em PSPICE. O problema é que este modelo é descrito em nı́vel de
circuito e seu uso depende de que o projeto todo seja simulado em nı́vel de circuito, o que
é impraticável para projetos reais. Por esta dificuldade, modelos ainda mais abstratos
foram propostos, como mostrado a seguir.
3.5.1 Equação de Peukert

O modelo analı́tico de alto nı́vel mais simples leva em conta a relação não-linear entre
capacidade e corrente de uma bateria e leva o nome do autor, o cientista alemão W.
Peukert, que determinou esta equação no final do século XVII. Esta equação apresenta a
relação entre taxas de descarga variáveis e mostra como o tempo total de duração será
afetado por estas variações. A equação é mostrada abaixo:
K
C= (3.16)
Iα
onde C é a capacidade energética da bateria, K é uma constante referente às propriedades
quı́micas da bateria e I é a corrente de descarga. O valor de α também é determinado
empiricamente, de acordo com as propriedades quı́micas da bateria, onde α = 0 é usado
para o caso de baterias ideais. Para baterias reais, este valor fica em torno de 0.7.
Este modelo é útil como uma aproximação e exige pouco esforço computacional.
Porém, caracterı́sticas como a capacidade de recuperação não são levados em conta. Ou-
tra limitação deste modelo é que apenas taxas de descarga constantes são consideradas,
o que não é verdade para a maioria dos sistemas reais.
3.5.2 Modelo Baseado em Cadeias de Markov

Uma peculiaridade dos sistemas com algum tipo de gerenciamento de potência é a existência
de perı́odos de grande atividade seguidos por perı́odos de relaxação. O perfil de descarga
é pulsativo, de forma que, nos perı́odos de baixa atividade, a bateria consegue recupe-
rar parte de sua carga. Este efeito de recuperação das baterias é explorado no modelo
estocástico apresentado em [32, 107], onde é demonstrado que se a descarga da bateria
ocorrer de forma pulsativa, ganhos significativos em tempo de duração são obtidos. O
Figura 3.5: Modelo baseado em cadeias de Markov

modelo estocástico é mostrado na Figura 3.5, onde os estados de carga da bateria são
modelados como uma cadeia de Markov. O comportamento da célula de bateria é mode-
lado como um processo estocástico com tempo discreto. Cada estado da cadeia define o
atual estado de carga da bateria, onde N denota bateria cheia e 0 denota bateria vazia.
As transições entre os estados indicam descarga (forward transitions) e carga (backward
transitions), que representa a capacidade de recuperação da bateria. A cada unidade de
tempo, o estado de carga sai de i para i − n, onde n é o número de unidades de carga
requerido da bateria. Da mesma forma, quando nenhuma unidade de carga da bateria é
demandada, uma transição de i para i + 1 pode ocorrer.
Pelo fato deste modelo incluir a capacidade de recarga das baterias, um número de
unidades de carga maior que N pode ser utilizado, desta forma, melhorando o desempenho
da bateria. Este modelo foi validado comparando-se os resultados com os de um modelo
PDE e o erro máximo obtido foi de 3%.
Este modelo aproxima um comportamento contı́nuo através da discretização do pro-
cesso de descarga e carga (capacidade de recuperação). Isto é um problema no que diz
respeito ao processo de caracterização deste modelo, tornando difı́cil a sua utilização para
diferentes tipos de bateria com diferentes caracterı́sticas quı́micas.
3.5.3 Modelagem de Eficiência

O modelo em [109] apresenta uma abordagem mais simples que o processo estocástico
[32, 107], onde um fator de eficiência é introduzido. Os autores consideram sistemas
compostos pelo circuito VLSI conectado a um conversor DC/DC, que por sua vez é
conectado à célula de bateria. Este fator leva em conta as não-linearidades no processo de
descarga da bateria e alguma quantidade de energia é considerada desperdiçada de acordo
com o requerimento de energia imposto pelo circuito. O fator de eficiência é representado
por µ na expressão abaixo:
I
Iact = , 0 ≤ µ ≤ 1 (3.17)
µ
onde I é a corrente requisitada pelo circuito, enquanto a corrente real fluindo da bateria
é representada por Iact .
Definindo CAP0 como a quantidade de energia disponı́vel numa bateria nova e CAPact
como a quantidade de energia real que pode ser utilizada pelo circuito, a Equação 3.17 é
equivalente a:
CAPact = CAP0 × µ, 0 ≤ µ ≤ 1 (3.18)
O fator de eficiência µ é uma função da corrente de descarga I
µ = f (I) (3.19)
onde f é uma função monotonicamente decrescente. Ou seja, a capacidade real de uma

bateria diminui quando a corrente de descarga aumenta. A função f é aproximada através
de
µ=1−β×I (3.20)
ou
µ = 1 − γ × I2 (3.21)
onde β e γ são inteiros positivos determinados empiricamente, de acordo com o tipo de

bateria utilizada (Li-Ion, NiCd, etc).
Um dos resultados importantes apresentados em [109] foi que a duração de serviço
(Duration of Service) pode variar significativamente de acordo com o perfil de corrente
(também chamado de distribuição de corrente). Os autores demonstram que o melhor caso
(maior autonomia) é obtido quando o perfil segue uma função densidade de probabilidade
do tipo δ e o pior caso com uma distribuição uniforme, ocorrendo uma variação de até
20%–30% na duração de serviço.
3.5.4 Modelo Discreto para Nı́vel de Sistema

As células das baterias têm um comportamento intrinsecamente contı́nuo, cujos modelos
exigem um esforço computacional intensivo. Modelos descritos em nı́veis mais altos de
abstração são de extrema importância para que possam ser utilizadas na exploração de
projeto em nı́vel de sistema. No entanto, existe um compromisso entre desempenho de
simulação e precisão do modelo.
Os trabalhos em [12, 15] apresentam um modelo de tempo discreto para baterias e
conversores DC/DC que permite um alto desempenho de simulação com uma aproximação
precisa do comportamento contı́nuo. Este modelo pode ser facilmente implementado em
qualquer ambiente de simulação em nı́vel de sistema.
A Figura 3.6(a) apresenta um modelo contı́nuo de bateria. A dependência da voltagem
da bateria (Vin ) com relação ao seu estado de carga (Vbat ou VC ) é realizado armazenando-
se diversos pontos da curva numa lookup table (LUT), acessada pelo valor do estado de
carga (VC ). O modelo é preciso até uma voltagem mı́nima de corte, a partir da qual a
bateria é considerada totalmente descarregada.
(a) Modelo de bateria (b) Modelo de conversor DC/DC (buck conver-

ter)
Figura 3.6: Modelos contı́nuos de bateria e conversor DC/DC
A dependência na taxa de descarga é modelada com uma fonte de voltagem Vlost

em série com o capacitor de armazenamento de carga. A voltagem Vlost reduz a carga
aparente da bateria. O valor de Vlost é uma função não-linear da taxa de descarga, também
modelada através de uma LUT.
A dependência na frequência de descarga é modelada fazendo-se a média da taxa de
descarga usada para controlar Vlost através de um filtro passa-baixa (Rf ,Cf ).
De acordo com [49], este modelo tem erros dentro da faixa de 15%. Este erro é
perfeitamente aceitável, dado que a capacidade real de qualquer grupo de células de
bateria pode variar até 20% entre unidades idênticas, por causa de variações no processo
de fabricação.
A voltagem de saı́da de uma bateria depende de suas propriedades quı́micas e de seu
estado de carga e, durante a operação, não é bem controlada. Portanto, os circuitos não
podem ser conectados diretamente às células de bateria, necessitando assim, de conver-
sores DC/DC para ajustar e estabilizar a voltagem. Estes dispositivos foram levados em
conta pelos autores, que os modelaram como mostrado na Figura 3.6(b). O conversor
modelado é bem comum e conhecido como buck converter.
Baseado nos modelos contı́nuos apresentados na Figura 3.6, modelos discretizados no
tempo equivalentes foram implementados pelos autores em VHDL. A Figura 3.7 mostra
o código para o modelo da bateria. O modelo do conversor DC/DC é implementado de
forma semelhante.
A bateria é definida como uma entidade em VHDL com duas entradas: Ibatt , repre-
sentando a corrente fluindo para o conversor DC/DC; e update, um sinal utilizado para
atualizar os valores do modelo. A mesma entidade possui apenas uma saı́da, Vbatt , que
representa a voltagem fornecida pela célula ao conversor DC/DC.
Figura 3.7: Código VHDL para o modelo da bateria
A estrutura interna é baseada no modelo apresentado na Figura 3.6(a) e é composta

por dois processos concorrentes:
• Compute VC: calcula o valor do nodo VC da Figura 3.6(a) e o estado de carga

instantâneo da bateria levando em conta perdas devidas à alta taxa de descarga.
• Compute VLOST: calcula o valor de Vlost (implementa o filtro passa-baixa da Fi-

gura 3.6(a)).
Como pode ser notado, este modelo é de baixa complexidade de implementação e bom
desempenho de simulação, o que o torna adequado para uso em nı́vel de sistema. Os
autores reportam erros médios de 0.52% em seus experimentos.
3.5.5 Sistemas com Múltiplas Baterias

Os dispositivos portáteis contemporâneos geralmente provém ao usuários opções para a
adição de uma ou mais unidades de baterias (além da bateria original), de forma a estender
a autonomia do dispositivos.
Alguns trabalhos exploram as caracterı́sticas de sistemas com suporte à múltiplas

baterias [13, 16]. O trabalho em [13] propõe métodos para estender a duração de serviço
destes sistemas, introduzindo o conceito de escalonamento de bateria, que é a atribuição
de determinada unidade de bateria como fornecedor de corrente durante a execução.
Os autores observam que o tempo de vida garantido por uma bateria não escala
linearmente com sua capacidade e também que sistemas com múltiplas baterias nunca
têm uma maior autonomia que o sistema monolı́tico para uma mesma capacidade total.
São propostos três algoritmos de escalonamento para a seleção da bateria:
1. escalonamento serial: as baterias são descarregadas de forma sequencial, uma após

a outra.
2. escalonamento estático: um esquema round-robin é utilizado. A ordem na qual a

seleção ocorre é explorada bem como o time-slice de uso da bateria.
3. escalonamento dinâmico: informações fı́sicas (estado de carga, voltagem de saı́da)

são usadas para a seleção da bateria e para ajustar o perı́odo do time-slice de uso.
Os algoritmos foram experimentados com diferentes workloads de corrente, sendo al-

guns sintéticos e outros de um exemplo real. O número máximo de baterias utilizados foi
quatro, com diferentes configurações, como mesmas capacidades, capacidades diferentes,
etc.
A abordagem mais sensı́vel encontrada foi a do escalonamento serial, como já esperado.
O escalonamento serial é a abordagem tradicional utilizadas em dispositivos eletrônicos
comerciais. A redução no tempo de vida comparado com o caso monolı́tico ficou na faixa
de 6%–31%.
O escalonamento estático foi testado com um time-slice de 2s e 10s. A sensibilidade foi
significantemente reduzida, especialmente para o time-slice de 2s. Os autores observam
que quanto menor o time-slice, maior é a autonomia.
O escalonamento dinâmico utilizou uma abordagem baseada em threshold. Se a vol-
tagem de saı́da da bateria ativa caı́sse abaixo de um pré-definido threshold (95%), então
outra bateria seria selecionada. Os resultados foram similares ao escalonamento estático,
com uma pequena melhora.
De forma a sumarizar os trabalhos revisados nas Seções 3.1–3.5, os mesmos são orga-
nizados na Tabela 3.3. As duas primeiras colunas indicam, respectivamente, a categoria
e a seção no texto. A terceira coluna dá uma breve descrição sobre a categoria, enquanto
a quarta coluna lista diversas referências bibliográficas.
Categoria Seção Descrição Referências

RTL (top-down) 3.1.1 Métodos analı́ticos, cujos [28, 83, 92, 93, 99, 104, 151]
modelos não requerem de-
talhes internos da imple-
mentação
RTL (bottom-up) 3.1.2 Métodos empı́ricos, cujos [3, 4, 6, 14, 19–24, 27, 31, 34,
macromodelos são cons- 35, 37, 38, 50–54, 59, 63–65,
truı́dos através de medição 76, 84–86, 95, 101, 110, 112,
(ou simulação) da imple- 121, 124–126, 148, 149, 152]
mentação do hardware
Algoritmos 3.2 O hardware é descrito [8, 29, 41, 44, 94, 103, 118,
através de algoritmos 131–133, 153, 154]
usando-se, geralmente,
linguagens de alto nı́vel
Instrução 3.3 A granularidade dos mode- [10, 11, 25, 30, 46, 47, 66, 67,
los neste nı́vel são as ins- 79,89,100,105,115,123,134,
truções de processadores de 136, 143, 150]
uso-geral e DSPs
Otimiz. de código 3.3.1 Aqui, faz-se uso dos mo- [60, 72, 73, 78, 127, 130, 142–
delos do nı́vel de instrução 146, 155]
para produzir código efici-
ente em termos de energia/-
potência
Sistema 3.4 Componentes de hardware [5, 17, 18, 55, 56, 81, 82, 120,
e software são conside- 128, 129]
rados simultaneamente na
execução de uma tarefa co-
mum
Baterias 3.5 Modela a fonte de ali- [12,13,15,16,32,49,107,109]
mentação para os, em sua
grande maioria, dispositi-
vos portáteis. Inclui a mo-
delagem de fenômenos ele-
troquı́micos
Tabela 3.3: Sumário dos trabalhos revisados nas Seções 3.1–3.5

3.6. Memória Transacional 47
A próxima seção revisa alguns trabalhos relacionados à memória transacional, que

é um paradima de programação concorrente que vem ganhando notoriedade nos últimos
anos e cuja literatura é demasiadamente escassa no que diz respeito ao enfoque em análise
e otimização de potência. Logo, há várias lacunas a serem preenchidas neste contexto,
sendo algumas exploradas por esta tese no Capı́tulo 6.
3.6 Memória Transacional

Cada vez mais cores têm sido adicionados a um mesmo chip, aumentando enormemente
o potencial de desempenho das aplicações. Embora as arquiteturas multi-core tenham
se tornado dominantes em todos os nichos, programar para estas arquiteturas de forma
a explorar todo o potencial existente não é uma tarefa fácil, sendo propensa a erros.
Alguns [1] ponderam, inclusive, que o projeto de MPSoCs é um dos maiores desafios da
Computação dos últimos 30 anos.
A abordagem mais comumente utilizada para programação concorrente é através do
uso de locks, que é vista como sendo de excessivo baixo nı́vel para o programador, intro-
duzindo uma série de problemas [137], tais como os conhecidos deadlocks. Além disso, os
locks são sabidamente incomponı́veis6 , isto é, dois componentes de software baseados em
locks, mesmo que funcionalmente corretos quando considerados individualmente, não têm
garantias de corretude quando compostos.
Alternativamente, a abordagem de memória transacional [77] propõe um modelo de
programação promissor, cujo intuito é reduzir a complexidade do desenvolvimento de
aplicações concorrentes. Esta proposta inspira-se na teoria de banco de dados. Porém,
ao invés de efetivar operações em disco, as mesmas realizam-se em memória principal.
Tudo que o programador deve fazer neste modelo é delimitar um trecho de código como
sendo atômico (a transação) e toda a sincronização dos acessos à memória compartilhada
é gerenciada pelos mecanismos de memória transacional subjacentes.
Diversas e distintas abordagens de memória transacional são encontradas na litera-
tura [77], as quais podem ser categorizadas em: HTM (Hardware Transactional Memory),
STM (Software Transactional Memory) ou hı́bridas.
O foco de pesquisa em memória transacional tem se concentrado majoritariamente
no desempenho das aplicações. Embora potência e energia sejam métricas de grande
importância em sistemas contemporâneos, poucos trabalhos se ativeram em investigá-las
a fundo. No âmbito de STMs, até onde se saiba e durante a escrita desta tese, não há
6
Do inglês, not composable
publicações na literatura nesta direção. Em HTM, este cenário não é muito diferente,
com apenas alguns trabalhos [42, 97, 98] disponı́veis. Em [97, 98], os autores concluem
que, na ocorrência de poucos conflitos, a abordagem de HTM pode ser vantajosa tanto
em desempenho quanto em energia com relação à locks. Os autores em [42] avaliam uma
HTM implementada numa arquitetura embarcada e também propõem duas otimizações:
(i) um semáforo em hardware no qual os processadores executam os perı́odos de spin-lock
em memória scratchpad (mais eficiente em termos de energia); e (ii) uma estratégia para
desligar a cache transacional em caso de subutilização.
Herlihy e Moss [58] cunharam o termo memória transacional com sua proposta de
implementação em hardware das operações atômicas do tipo read-modify-write para um
número arbitrário (limitado) de posições de memória. Nesta abordagem, o processador
foi estendido com seis novas instruções para o gerenciamento de dados transacionais.
Uma cache transacional também foi adicionada, paralelamente à cache convencional, cuja
função é reter os dados transacionais criados com o uso das novas instruções. O protocolo
de coerência de cache foi modificado de forma a detectar conflitos nos acessos à memória
compartilhada entre os processadores.
Outra abordagem em hardware é a TLR [119] (Transactional Lock Removal), onde a
resolução de conflitos é suportada em hardware no protocolo de coerência e nos controlado-
res de cache. O mecanismo de resolução de conflitos baseia-se em timestamps e emprega
relógios lógicos de Lamport [75], além do algoritmo wound-wait, que garante que uma
transação de maior prioridade jamais espere por uma transação com menor prioridade,
forçando-a a esperar ou reiniciar em caso de existência de conflitos.
No contexto dos trabalhos em software, uma proposta proeminente é a DSTM [57],
que foi implementada como uma biblioteca. A granularidade das transações é definida
em termos de objetos (e.g. Java), que são clonados localmente dentro das transações. As
modificações são efetuadas diretamente na cópia privada (clone) e, eventualmente, o clone
irá substituir a versão original no caso de um commit. O programador utiliza a DSTM
fazendo uso das classes e métodos da biblioteca, encapsulando cada objeto envolvido numa
transação dentro de um contêiner.
No caso da TL2 [36], a granularidade é definida em termos de palavras. Nesta abor-
dagem, há um arranjo de locks versionados que controlam os acessos à memória com-
partilhada. Uma função de hash mapeia cada endereço de memória para uma posição
deste arranjo. Cada elemento deste arranjo ou contém um ponteiro para o descritor da
transação (caso o lock correspondente tenha sido adquirido), ou contém a versão atual
para esta posição de memória (baseada num número de versão global). O funcionamento
3.6. Memória Transacional 49
da TL2 pode ser resumido como segue: no inı́cio de cada transação, faz-se uma cópia
local do número de versão global. Durante sua execução, barreiras de leitura/escrita são
utilizados ao invés de chamadas diretas a loads/stores. Uma barreira de leitura garante a
consistência da execução através da comparação do número de versão global com a versão
do lock da palavra carregada. Uma barreira de escrita faz o valor sendo escrito ser armaze-
nado localmente num buffer de escrita. A etapa de commit inicia-se adquirindo os locks de
todas as entradas no buffer de escrita, seguido pelo incremento, efetuado atomicamente,
do número de versão global. Depois disso, o conjunto de leitura da transação é validado,
as modificações são confirmadas na memória principal e os locks são liberados. Se, em
algum dos passos anteriores, for encontrada alguma inconsistência, a transação é abortada
e re-executada. Esta abordagem de STM foi escolhida para a avaliação experimental feita
no Capı́tulo 6.
Outros trabalhos propuseram abordagens de memória transacional chamadas de
hı́bridas. Na proposta em [74], as transações podem ser executadas tanto em HTM (gra-
nularidade em termos de linhas de cache) quanto em STM (DSTM, com granularidade
em termos de objetos). O trabalho estende o conjunto de instruções do processador com
instruções para a execução de ambos os modos de operação (hardware e software). Um dos
requisitos desta abordagem é a necessidade de haver duas versões de cada transação, uma
para cada modo. Os autores descrevem o uso de heurı́sticas para determinar o modo de
execução: cada transação tenta executar em modo HTM por três vezes antes de alternar
para STM.
O próximo capı́tulo descreve a infraestrutura desenvolvida neste trabalho para análise
e modelagem de potência.
Capı́tulo 4
PowerSC: o Arcabouço para Análise

de Potência
Esta tese de doutorado é uma ampliação do trabalho de mestrado desenvolvido em [71]

pelo mesmo aluno, onde apresentou-se a PowerSC, que é uma extensão de SystemC de-
senvolvida com o intuito de ser uma infraestrutura de suporte à análise de potência em
sistemas descritos naquela linguagem1 .
A versão inicial da PowerSC já provia a captura automática de atividade de transição
durante a simulação, mais especificamente a densidade de transição e probabilidade de si-
nal, além de um algoritmo de predição de atividade de transição [70] que reduz o tempo de
monitoração da simulação. Embora estas estatı́sticas sejam essenciais para o cômputo de
potência, a biblioteca ainda não dispunha de uma interface para modelagem de potência
em diversos nı́veis de abstração, o que foi remediado dentro do contexto deste traba-
lho. Além disso, a PowerSC foi utilizada no trabalho de mestrado de Roberto Leão [80],
que contribuiu com a implementação de duas das técnicas de macromodelagem a serem
apresentadas no Capı́tulo 5, e também acrescentando à biblioteca a captura de outra
estatı́stica importante, a correlação espacial de sinais.
A metodologia da PowerSC é voltada para a análise/otimização de potência de
SoCs/MPSoCs, levando em conta os IPs individuais, embora seus outros componentes
possam ser incorporados. Esta metodologia suporta a modelagem de potência em di-
versos nı́veis de abstração, através de uma API bem definida. Um dos objetivos desta
metodologia é ser baseada somente na linguagem SystemC, de forma a ter uma repre-
sentação homogênea.
1
SystemC é, de fato, um conjunto de classes escritas em C++ combinadas com uma metodologia bem
definida para seu uso. Porém, o termo linguagem é comumente utilizado para referenciá-la.
51
52 Capı́tulo 4. PowerSC: o Arcabouço para Análise de Potência
Numa abordagem bottom-up, os nı́veis mais baixos de abstração são geralmente utiliza-
dos para a criação de modelos de potência para os imediatamente superiores. Há o suporte
à descrições em SystemC gate-level, para que o processo de modelagem de potência possa
ser realizado desde os nı́veis mais baixos, onde há uma precisão maior, até os mais altos,
onde o desempenho de simulação é superior.
A Figura 4.1 apresenta dois fluxos de projeto complementares e ortogonais. Do lado
direito, o fluxo SystemC puro é mostrado. Do lado esquerdo, o fluxo da PowerSC é
ilustrado com mais detalhes.
Design
Refinement
SystemC Config.
Design Files
PowerSC
Library SystemC
Library
C++ Compiler
PowerSC SystemC
Executable Specification Executable Specification
Simulation Usual
for Power Simulation
Reports Reports
PowerSC flow
Figura 4.1: Fluxo de projeto da PowerSC
Independente do fluxo escolhido, o ponto de entrada é uma descrição em SystemC. O

fluxo a ser seguido é determinado por alguns arquivos de configuração (e.g., Makefiles), que
4.1. Caracterização de Potência no Nı́vel de Portas Lógicas 53
instruem o compilador C++ a gerar uma especificação executável convencional (ligando2

somente a biblioteca SystemC) ou produzindo uma especificação executável incrementada
(ligando ambas as bibliotecas SystemC e PowerSC).
O primeiro passo nesta metodologia é compilar a especificação executável PowerSC,
que é instrumentada para capturar estatı́sticas de sinal durante a simulação. No próximo
passo, a simulação é disparada e, como consequência da devida instrumentação, os elemen-
tos do projeto são monitorados e a informação de potência é dinamicamente registrada.
Ao término da simulação, a informação resultante é sumarizada em relatórios de potência.
Os hotspots identificados podem, então, ser usados durante o processo de refinamento do
projeto, que pode passar pelo fluxo da PowerSC quantas iterações forem necessárias, até
atingir valores adequados de potência.
Note que o usuário pode facilmente trocar de um fluxo para o outro quantas vezes
forem necessárias para otimizar a potência e satisfazer as restrições de projeto.
Apenas duas modificações são necessárias na descrição SystemC para ativar o uso da
PowerSC. Uma modificação obrigatória é a inclusão do arquivo de cabeçalho principal da
PowerSC (powersc.h) dentro dos arquivos do modelo. Outra modificação compulsória é
a invocação de alguma macro pré-definida da PowerSC ao final da função principal do
simulador (sc main), de forma a ativar a geração de relatórios. Estas modificações são
mostradas na Figura 4.2, nas linhas 2 e 17, respectivamente.
Como pode ser visto, o esforço para a ativação do mecanismo de estimativa de potência
é mı́nimo, exigindo pequenas modificações na descrição original em SystemC. Também
deve ser observado que os tipos de dados de SystemC, sinais e módulos não precisam ser
modificados manualmente; a PowerSC as modifica automaticamente. Outra caracterı́stica
importante é o fato de não ser necessária nenhuma alteração no código da biblioteca
SystemC, o que facilita seu uso.
4.1 Caracterização de Potência no Nı́vel de Portas

Lógicas
Estimativas de potência com elevado grau de precisão obtidas no nı́vel de portas lógicas
(gate-level), são usualmente utilizadas na construção de modelos de potência em nı́veis
mais altos de abstração. De modo a permitir que tais estimativas sejam obtidas, um
mecanismo foi elaborado para a criação de uma biblioteca de componentes em gate-level
2
Do inglês, linking
1 #i n c l u d e <s y s t e m c . h>
2 #i n c l u d e <p o w e r s c . h> // <−− m o d i f i c a c a o o b r i g a t o r i a −−
3 #i n c l u d e ” muls32 . h”
4 .. ,
5 SC MODULE( r t l e x a m p l e ) {
6 sc in clk clk ;
7 ...
8 s c s i g n a l <s c u i n t <2> > s i g 1 , s i g 2 ; // s i n a i s
9 ...
10 MulS32 ∗ mult ;
11 ...
12 };
13 ...
14 i n t s c m a i n ( i n t a r g c , char ∗∗ a r g v ) {
15 . . . // i n s t a n c i a c a o de modulos
16 s c s t a r t ( /∗ tempo de s i m u l a c a o ∗/ ) ;
17 PSC REPORT POWER; // <−− i s t o tambem e ’ n e c e s s a r i o −−
18 return ( 0 ) ;
19 }
Figura 4.2: Modelo em SystemC habilitado para uso da PowerSC
para uma dada biblioteca de tecnologia. Os passos necessários para tal são mostrados na
Figura 4.3.
A biblioteca-base (contendo componentes, tais como, somadores e multiplicadores) é
construı́da a partir de uma biblioteca de tecnologia no formato Liberty [138] usando uma
ferramenta do pacote Cynthesizer [44]. Os componentes são descritos em SystemC no
nı́vel RT (SC RTL) e em Verilog em nı́vel de portas lógicas (V GATES).
Dado que, neste trabalho, o foco está numa representação unificada dentro do ar-
cabouço, foram implementados dois conversores, que realizam a tradução de formatos
externos para SystemC, como segue:
• a ferramenta vlog2sc traduz cada netlist3 encontrada em V GATES para uma des-
crição funcionalmente equivalente em SystemC;
• a ferramenta psclib2sc converte uma biblioteca de tecnologia do formato Liberty

para uma representação em C++.
As descrições gramaticais destes tradutores foram elaboradas com o auxı́lio do ANTLR [40,
3
netlist – lista de portas lógicas e suas interconexões que representam um circuito.
Technology C++
A B technology
Library (.lib) lib2psclib psclib2sc
library
Base Part Library C Part Library

vlog2sc D SystemC
SC RTL V GATES gate−level SC RTL SC GATES
parts
SystemC SystemC
RTL Design Gate−level Design
Figura 4.3: Geração de código SystemC em gate-level
108], que é uma ferramenta para reconhecimento de linguagens apta a gerar parsers em
uma grande diversidades de linguagens, tais como C++, que foi a linguagem-alvo seleci-
onada.
Os arquivos produzidos pelas ferramentas de conversão resultam na chamada biblioteca
de componentes em SystemC gate-level (SC GATES), que substitui a biblioteca Verilog.
O usuário pode, então, selecionar entre simulação no nı́vel RT ou de portas lógicas
através da seleção do componente da biblioteca apropriada: SC GATES ou SC RTL.
A estimativa de potência é feita da mesma forma como mostrado na Figura 4.2. Note
que, independente do nı́vel de abstração, os aspectos da PowerSC visı́veis ao usuário são
exatamente os mesmos.
O processo de conversão é ilustrado através de alguns exemplos de arquivos de en-
trada e saı́da. Inicialmente, considere as conversões representadas pelos pontos A e B
da Figura 4.3. Um trecho da descrição de uma biblioteca de tecnologia 0.13µm é exibido
na Figura 4.4 (ponto A da Figura 4.3) no formato PSCLib, que é uma versão simplifi-
cada de Liberty. Diversos atributos são definidos neste arquivo. Note que, no inicio do
código, as unidades adotadas são determinadas, seguidas pela descrição de uma das células
existentes na biblioteca (xor2v0x1). Estas informações habilitam o cálculo da potência
dissipada pelas células, bem como a geração automática de código em SystemC das mes-
mas. Como pode ser visto, os valores de potência estática (leakage power), dados sobre
capacitância nos pinos de entrada/saı́da (a, b, z), e potência dinâmica (obtida através da
tabela internal power) estão presentes. A semântica de cada célula é descrita pelo atri-
buto function que, neste exemplo, representa a porta lógica XOR (OU-exclusivo). Este
arquivo de entrada é convertido automaticamente para C++ (ponto B da Figura 4.3),
Figura 4.4: Arquivo-exemplo de entrada para a psclib2sc mostrando a célula xor2v0x1

de uma bibioteca 0.13µm
resultando em dois arquivos: techlibrary.h e techlibrary.cpp que, então, podem ser

utilizados no fluxo da PowerSC. Um excerto do último é mostrado na Figura 4.5, onde
pode ser vista parte da implementação da célula xor2v0x1.
Considere, agora, a conversão representada pelos pontos C e D da Figura 4.3. O
arquivo de entrada é um item da biblioteca de componentes V GATES, ou seja, o com-
ponente é descrito em Verilog gate-level. Um exemplo de somador de 4 bits neste nı́vel é
mostrado na Figura 4.6 (ponto C da Figura 4.3). Neste arquivo, diversas células da bibli-
oteca de tecnologia são instanciadas e interconectadas de forma a moldar o funcionamento
de um somador destas caracterı́sticas. Tomando como exemplo a célula identificada por
I22 (linha 5), esta representa uma instância de xor2v0x1, tal que seu pino de saı́da (z)
é conectado a um sinal rotulado como N74 e seus pinos de entrada (a, b) são conectados,
respectivamente, às segundas entradas dos sinais externos de 4 bits a e b. Este arquivo é
convertido em um modelo SystemC, conforme o esboço apresentado na Figura 4.7. Note
que, na primeira linha, a biblioteca de tecnologia gerada pela psclib2sc é incluı́da no mo-
delo. Observe que tal descrição simplesmente instancia e conecta as células da biblioteca
de tecnologia, além de definir entradas/saı́das, e declarar os sinais utilizados no modelo.
Este procedimento é conduzido de maneira muito similar ao que é feito num modelo
SystemC convencional.
A PowerSC habilita a modelagem em diversos nı́veis de abstração, dentre os quais
estão o nı́vel de portas lógicas e o nı́vel RT, conforme é apresentado na próxima seção.
1 const double L i b U n i t s : : v o l t a g e = 1 ;
2 const double L i b U n i t s : : c a p a c i t i v e = 1e −15;
3 const double L i b U n i t s : : t i m e = 1e −12;
4 const double L i b U n i t s : : l e a k a g e p o w e r = 1e −12;
5 const double L i b U n i t s : : d y n a m i c p o w e r = 0 . 0 0 1 ;
6 ...
7 void x o r 2 v 0 x 1 : : p r o c ( )
8 {
9 z . write ( a . read () ˆ b . read ( ) ) ;
10 }
11
12 xor2v0x1 : : ˜ xor2v0x1 ()
13 {
14 #i f d e f POWER SIM
15 sc interface ∗ if a = a. get interface ();
16 p s c o b j i n f o i f ∗ p a = dynamic cast<p s c o b j i n f o i f ∗>( i f a ) ;
17
18 sc interface ∗ if b = b. get interface ();
19 p s c o b j i n f o i f ∗ p b = dynamic cast<p s c o b j i n f o i f ∗>( i f b ) ;
20
21 sc interface ∗ if z = z . get interface ();
22 p s c o b j i n f o i f ∗ p z = dynamic cast<p s c o b j i n f o i f ∗>( i f z ) ;
23 ...
24 double E b z n = p s c g e o m e t r i c c e n t r o i d ( p t s b z n ,
25 p b −>g e t n e t d e l a y ( ) ,
26 p z −>g e t n e t l o a d ( ) ) ;
27
28 p s c c e l l p o w e r i n f o i n f o ( name ( ) , c e l l t y p e ) ;
29
30 i n f o . s e t l e v e l (PSC GATE LEVEL ) ;
31 info . set leak power ( leakage power ) ;
32 p s c p i n p o w e r i n f o p w r a z n ( p z −>g e t i d () , E a z n );
33 p w r a z n . s e t r e l p i n s ( 1 , p a −>g e t i d ( ) . c str ());
34 i n f o . add ( p w r a z n ) ;
35 p s c p i n p o w e r i n f o p w r b z n ( p z −>g e t i d () , E b z n );
36 p w r b z n . s e t r e l p i n s ( 1 , p b −>g e t i d ( ) . c str ());
37 i n f o . add ( p w r b z n ) ;
38 PSC INSERT CELL( i n f o ) ;
39 #e n d i f
40 }
Figura 4.5: Arquivo-exemplo de saı́da gerado pela psclib2sc para a porta lógica xor2v0x1
Figura 4.6: Arquivo-exemplo de entrada para a vlog2sc referente ao componente Add4

1 #i n c l u d e ” t e c h l i b r a r y . h”
2 ...
3 SC MODULE( Add4 )
4 {
5 s c i n <bool> a [ 4 ] ;
6 s c i n <bool> b [ 4 ] ;
7 sc out<bool> o u t 1 [ 4 ] ;
8
9 xor2v0x1 ∗ I22 ;
10 ...
11 p s c s i g n a l b o o l N74 ;
12 ...
13 SC CTOR( Add4 )
14 {
15 I 2 2 = new x o r 2 v 0 x 1 ( ” I 2 2 ” ) ;
16 I 2 2 −>z ( N74 ) ;
17 I 2 2 −>a ( a [ 1 ] ) ;
18 I 2 2 −>b ( b [ 1 ] ) ;
19 ...
20 PSC OBJ ALIAS( N74 , ”N74” ) ;
21 }
22 };
23
24 SC MODULE( A d d 4 w r a p p e r )
25 {
26 s c i n <s c u i n t <4> > a ;
27 s c i n <s c u i n t <4> > b ;
28 sc out<s c u i n t <4> > o u t 1 ;
29
30 Add4 ∗ a d d 4 0 ;
31 ...
32 }
33
34 #d e f i n e Add4 Add4 wrapper
Figura 4.7: Arquivo-exemplo de saı́da gerado pela vlog2sc referente ao componente Add4
4.2. Modelagem e Estimativa de Potência no nı́vel RT 61
4.2 Modelagem e Estimativa de Potência no nı́vel RT

Uma das principais caracterı́sticas do arcabouço da PowerSC é o seu suporte à modelagem
de potência em diferentes nı́veis de abstração. Este suporte existe através de sua API
de macromodelagem, que consiste em um conjunto de classes em C++ usadas para a
integração de distintas técnicas de modelagem.
Para adicionar um novo componente à biblioteca, duas classes devem ser derivadas:
psc_macromodel and psc_macromodel_parms. Os aspectos mais importantes da primeira
são ilustrados na Figura 4.8.
1 c l a s s psc macromodel {
2 ...
3 public :
4 v i r t u a l void i n i t p o w e r m a p ( ) ;
5 v i r t u a l double g e t p o w e r ( const psc macromodel parms & ) ;
6 ...
7 };
Figura 4.8: Suporte de macromodelagem da PowerSC
Os detalhes internos são omitidos do usuário, que deve apenas criar o código para
as seguintes funções virtuais, usadas internamente pela PowerSC para o cômputo da
potência:
• init_power_map: esta função inicializa as estruturas internas (definidas pelo usuário)

com a informação de potência advinda da fase de caracterização.
• get_power: esta função contém o comportamento a ser executado tendo como base
o seu parâmetro psc_macromodel_parms, que resultará na estimativa de potência.
Por exemplo, os atributos da classe psc_macromodel_parms derivada poderiam ser
as estatı́sticas de sinal. A PowerSC invoca esta função internamente de forma a
gerar os relatórios de potência de um modelo de potência especı́fico.
Um psc macromodel distinto é criado automaticamente para cada componente da

biblioteca, dado que as técnicas de macromodelagem geralmente requerem um compor-
tamento especı́fico para cada componente (tabelas inicializadas com diferentes valores,
equações de potência especı́ficas, etc). Estas distintas especializações de psc macromodel
também são úteis quando o projetista desejar utilizar diferentes metodologias para um
mesmo componente.
1 SC MODULE( MulS16 ) {
2 s c i n <s c i n t <16> > i n 1 ;
3 s c i n <s c i n t <16> > i n 2 ;
4 sc out<s c i n t <32> > o u t 1 ;
5 ...
6 void s o m e p r o c e s s ( ) ;
7 ...
8 PSC MACROMODEL MulS16 ;
9 ...
10 SC CTOR( MulS16 ) ;
11 } ;
Figura 4.9: Esboço de uma possı́vel implementação de um multiplicador em SystemC
Como exemplo ilustrativo deste suporte, considere um multiplicador com entradas de

16 bits. Uma possı́vel implementação para tal componente é exibida na Figura 4.9.
Este trecho de código mostra as principais partes do multiplicador, tais como suas
entradas/saı́das, além da assinatura de um processo responsável pelo cálculo da multi-
plicação das entradas in1 e in2. Também é mostrado como este componente poderia ser
instrumentado para o uso de um macromodelo disponı́vel (linha 8).
Esta macro deve, naturalmente, estar definida em algum outro ponto dentro do escopo
do arquivo, contendo os comandos apropriados de forma a converter este componente
especı́fico num multiplicador power-aware. A Figura 4.10 delineia uma possı́vel maneira
de alcançar este objetivo.
Como mencionado anteriormente, as duas classes psc macromodel e
psc macromodel parms devem ser derivadas de acordo com as especificidades de
cada técnica de macromodelagem. No caso deste exemplo, que ilustra o uso da técnica
EqTab [4], a classe psc macromodel MulS16 EqTab declara uma tabela (model coeffs),
que contém os valores dos coeficientes computados durante a fase de caracterização do
macromodelo (esta técnica é detalhada na Seção 5.1.1). Note que o modelo de potência é
instanciado condicionalmente, dependendo do valor da diretiva de compilação POWER SIM.
A eficácia do suporte à modelagem da PowerSC será demonstrada no próximo capı́tulo,
com a implementação de diversas técnicas de macromodelagem RTL através desta API.
4.2. Modelagem e Estimativa de Potência no nı́vel RT 63
1 ...
2 #i f d e f POWER SIM
3 #d e f i n e PSC MACROMODEL MulS16\
4 s t a t i c const char ∗ c e l l t y p e ; \
5 s t a t i c psc macromodel MulS16 EqTab p o w e r m o d e l ; \
6 ˜ MulS16 ( )
7 #e l s e
8 #d e f i n e PSC MACROMODEL MulS16
9 #e n d i f
10 ...
11 #d e f i n e TOTAL POINTS 59
12 ...
13 c l a s s psc macromodel parms MulS16 EqTab :
14 p u b l i c psc macromodel parms {
15 public :
16 psc macromodel parms MulS16 EqTab ( ) ;
17 ...
18 };
19
20 c l a s s psc macromodel MulS16 EqTab : p u b l i c psc macromodel {
21 private :
22 s t a t i c const double m o d e l c o e f f s [ TOTAL POINTS + 1 ] [ 6 4 + 1 ] ;
23
24 public :
25 void i n i t p o w e r m a p ( ) ;
26 double g e t p o w e r ( const psc macromodel parms & p ) ;
27 ...
28 };
Figura 4.10: Esboço de um macromodelo para um multiplicador

Capı́tulo 5
A Abordagem de Múltiplos Modelos
Tanto a Academia quanto a Indústria têm investido notáveis quantias de recursos e tempo
em pesquisa e desenvolvimento no contexto de projeto de circuitos integrados visando
baixo consumo de potência. Os nı́veis mais baixos de abstração, como o de circuito e o
de gates, foram os que receberam as maiores fatias deste investimento, atingindo elevados
patamares de solidez. Isto pode ser notado pelas diversas ferramentas industriais [61,102,
116, 139, 140] disponı́veis com ampla aceitação dos projetistas de hardware.
O crescente aumento de complexidade dos sistemas digitais contemporâneos tem forçado
os projetistas a conduzirem o desenvolvimento de seus projetos em nı́veis de abstração
cada vez mais altos. Ainda que diversos trabalhos sejam encontrados na literatura, con-
forme apresentado no Capı́tulo 3, o grau de consolidação da pesquisa nestes nı́veis ainda
está aquém dos padrões exigidos pela indústria.
Dentre os problemas encontrados, pode-se mencionar a precisão das estimativas gera-
das. Este problema é consequência, principalmente, da informação imprecisa do hardware
final nas descrições do sistema. Caracterı́sticas importantes, tais como, comprimento de
fios, roteamento, distribuição de relógio entre outros, encontram-se disponı́veis somente
nos últimos estágios de projeto.
Segundo Macii e Poncino, o nı́vel RT está atualmente no limiar entre a Academia
e a Indústria [91]. Uma caracterı́stica dos modelos de potência neste nı́vel é que sua
precisão é extremamente sensı́vel ao conjunto de treinamento utilizado, bem como às
variáveis selecionadas para sua criação. Um dos fatores responsáveis pelas técnicas de
macromodelagem RTL ainda não terem se tornado um padrão de facto, é o conjunto de
suposições feitas por cada técnica. Tais suposições distintas causam, fatalmente, algum
tipo de limitação intrı́nseca no modelo que, por sua vez, afetam a precisão das predições.
A maioria das abordagens existentes se baseia numa única técnica de macromode-
65
66 Capı́tulo 5. A Abordagem de Múltiplos Modelos
lagem. Todavia, dados um componente do sistema e um certo conjunto de estı́mulos,

pode existir uma técnica alternativa que resulte numa estimativa mais precisa para esta
configuração. Portanto, a exploração de múltiplas técnicas de macromodelagem a partir
de um kit de macromodelos pode ser uma maneira eficaz de se otimizar a estimativa de
potência.
Embora trabalhos relacionados [5, 9] aludam a combinações de macromodelos como
forma de melhorar o desempenho, poucas abordagens [111] propuseram o uso extensivo
de múltiplos modelos como forma de melhorar a precisão das estimativas de potência.
Ainda que escassas, há algumas opções de ferramentas industriais para RTL, mais
notavelmente [39,113,114,139]. Um dos problemas existentes é a dificuldade em se mapear
um componente descrito em RTL para sua implementação real. Além disso, componentes
funcionalmente equivalentes podem ter implementações muito distintas. Por exemplo,
um somador poderia ser implementado como ripple-carry, carry lookahead ou carry save,
tendo os três uma dissipação de potência muito diferente para um mesmo conjunto de
valores de entrada.
Um outro problema é a necessidade da geração de modelos de potência através de
um processo de caracterização para cada tipo de componente, o que pode ser uma tarefa
demorada e deve ser feita a cada mudança de tecnologia de implementação.
O remanescente deste capı́tulo organiza-se como segue: a Seção 5.1 faz uma dis-
cussão sobre as limitações existentes na abordagem de modelo único, demonstrando tais
limitações através de evidências empı́ricas. Na Seção 5.2, duas abordagens multimode-
los são propostas, com o intuito de explorar as qualidades de cada modelo, resultando
numa maior qualidade das estimativas. A Seção 5.3 apresenta os resultados experimentais
obtidos com as abordagens propostas, encerrando o capı́tulo.
5.1 Limitações da Abordagem de Modelo Único

A qualidade de um macromodelo é fortemente dependente do conjunto de treinamento.
Por exemplo, dado que o macromodelo em [51] supõe que as estatı́sticas de sinal são uni-
formemente distribuı́das entre entradas e saı́das, desbalanceamentos nos sinais de entrada
podem resultar em erros significativos, conforme mostrado em [86]. No macromodelo pro-
posto em [4], o conjunto de treinamento é restringido em apenas uma stream1 por ponto
caracterizado. No entanto, a escolha de um conjunto apropriado é crucial para a obtenção
1
Uma stream é um bloco de N vetores, tal que o comprimento dos vetores é igual à largura de bits de
entrada do componente.
5.1. Limitações da Abordagem de Modelo Único 67
de modelos de alta qualidade. Conforme mostrado em [148], enquanto alguns conjuntos

de entrada levam a modelos de alta qualidade (erros médios de ∼6%), outros resultam
em modelos de qualidade inaceitável (erros médios de ∼660%).
A sensibilidade ao conjunto de treinamento aliada às inerentes suposições de macro-
modelagem (e.g. distribuição uniforme de probabilidade [51], inexistência de modelagem
das propriedades do sinal de saı́da [64]) levam a limitações intrı́nsecas que degradam a
precisão das estimativas.
Esta seção provê ao leitor algumas evidências que mostram que a estimativa baseada
em macromodelagem pode resultar em erros excessivamente altos, identificando as origens
de imprecisão através de alguns exemplos, de forma a justificar a asserção de que nenhum
macromodelo é robusto o suficiente para ser utilizado sozinho. Portanto, esta seção fun-
damenta a Seção 5.2, onde é mostrado como nosso mecanismo manipula automaticamente
múltiplos modelos para melhorar, de forma geral, a precisão das estimativas.
5.1.1 Técnicas de Macromodelagem Selecionadas

Foram selecionadas quatro técnicas conhecidas de macromodelagem como candidatas
à análise experimental. A partir deste ponto, elas serão referenciadas no texto como
4DTab [53], EqTab [4], eHD [64] e Analytical [50].
Há três principais razões por trás desta seleção:
1. Estas técnicas modelam potência de formas bem distintas, fazendo diferentes su-
posições, especı́ficas a cada uma delas (i.e., elas se complementam).
2. Os resultados publicados na literatura demonstram que elas possuem, em geral, boa

precisão.
3. A complexidade de implementação faz com que a integração das técnicas a um fluxo

automatizado seja factı́vel.
Cabe mencionar que a técnica 3DTab [51] foi utilizada durante o inı́cio dos experi-
mentos, mas foi, posteriormente, suplantada pela 4DTab devido a sua maior precisão.
Esta seção sumariza alguns fundamentos das técnicas selecionadas, tais como, conceitos-
chave e passos de caracterização, como base para a discussão feita na Seção 5.2.
Modelo 1: Tabela Tetradimensional (4DTab)
O modelo 4DTab baseia-se nas seguintes propriedades de sinal: (i) a média da probabili-
dade de sinal de entrada Pin ; (ii) a média da densidade de transição de entrada Din ; (iii)
a média da correlação espacial de entrada SCin ; e (iv) a média da densidade de transição

de saı́da Dout . O modelo é representado por uma LUT (lookup table) de quatro dimensões
de forma que há um valor de potência correspondente para cada posição (Pin , Din , SCin ,
Dout ) da tabela.
Com o intuito de esclarecimento e conveniência, as definições destas propriedades são
informalmente recapituladas. Probabilidade de sinal é a fração de tempo em que um
determinado sinal tem o estado lógico alto (ou verdadeiro). Densidade de transição é
o número de transições lógicas (alto-para-baixo, baixo-para-alto) por unidade de tempo.
Correlação espacial é a probabilidade de dois sinais distintos possuı́rem o estado lógico
alto simultaneamente. Portanto, Pin , Din e Dout são definidas como médias de todas
posições bit-a-bit de entrada/saı́da, e SCin é a média de todos os possı́veis pares de
distintas posições de entrada bit-a-bit.
A estimação de potência consiste em, primeiramente, executar uma simulação RTL
para coletar as estatı́sticas de sinal Pin , Din , SCin e Dout e, então, procurar na tabela pelo
valor de potência correspondente. Quando as estatı́sticas de sinal não corresponderem
diretamente a uma posição da tabela, técnicas de interpolação serão usadas para retornar
o valor mais próximo.
O processo de caracterização de potência para um dado componente consiste na se-
guinte sequência de passos. Primeiro, para cada tupla (Pin , Din , SCin ) válida, são geradas
várias streams de entrada. Em seguida, cada stream distinta é aplicada às entradas do
componente, descrito num menor nı́vel de abstração (e.g., nı́vel de portas lógicas). O Dout
resultante desta injeção de estı́mulos é avaliado e o consumo de potência determinado.
Depois disso, a média de todos os valores de potência obtidos para um mesmo (Pin , Din ,
SCin , Dout ) é armazenada na posição adequada da tabela.
Modelo 2: Tabela de Coeficientes de Equação (EqTab)
Ao invés de basear-se na média geral das densidades de transição de entrada/saı́da (como é

feito no 4DTab), o modelo EqTab leva em consideração a contribuição individual de cada
posição bit-a-bit de entrada e saı́da. Sejam Din (x) e Dout (x) as transições de entrada
medidas na x-ésima posição bit-a-bit para uma stream de vetores de entrada e saı́da,
respectivamente. Sejam n e m, respectivamente, as larguras dos vetores de entrada e
saı́da. Dado um componente, seu consumo de potência é modelado pela seguinte equação,
onde ci denota um coeficiente:
P ower = c0 + c1 ∗ Din (0) + c2 ∗ Din (1) + ... + cn+m−1 ∗ Dout (m − 2) + cn+m ∗ Dout (m − 1)
A técnica EqTab baseia-se numa LUT que é indexada por (Pin , Din ). Para cada entrada
desta tabela, ao invés de diretamente armazenar um valor de potência, a entrada cor-
respondente, na verdade, armazena os coeficientes da equação acima. Como resultado, a
estimativa consiste em três passos:
1. Uma simulação RTL é executada e as densidades de transição bit-a-bit são coletadas,

juntamente com as propriedades Pin , Din e Dout .
2. Os coeficientes armazenados na entrada (Pin , Din ) são retornados. Se (Pin , Din )

não representarem uma entrada válida, o ponto mais próximo, de acordo com a
distância Euclidiana, é utilizado.
3. Finalmente, os coeficientes retornados e as estatı́sticas coletadas são combinadas de

acordo com a equação acima.
Ao contrário do que ocorre com o 4DTab, o processo de caracterização com o EqTab

emprega apenas uma stream de vetores de entrada para cada par (Pin , Din ) e consiste em
determinar o respectivo conjunto de coeficientes. Para encontrar o devido conjunto de
coeficientes, um sistema de equações é construı́do como segue.
Seja SW uma matriz com um número de linhas igual ao número de pares sucessivos de
vetores na stream (S pares) e com um número de colunas equivalente à largura composta
do vetor (n + m). Uma linha da matriz SW armazena as densidades de transição bit-
a-bit obtidas entre um par de vetores sucessivos. Uma coluna armazena a densidade de
transição de uma dada posição de bit ao longo da stream de entrada. Seja P uma matriz
S × 1, onde cada entrada pi armazena a potência consumida pelo i-ésimo par de vetores
de entrada.
A caracterização consiste em primeiro calcular as densidades de transição bit-a-bit
para cada par sucessivo de vetores de entrada (armazenando-os numa linha da matriz
SW ) e medindo seu respectivo consumo de potência (armazenando-o numa entrada da
matriz P ). Então, o conjunto de coeficientes2 C é obtido resolvendo-se o sistema de
equações SW ×C = P com técnicas de regressão convencionais (ex., mı́nimos quadrados).
Finalmente, tais coeficientes são armazenados na entrada (Pin , Din ).
Modelo 3: Distância de Hamming Aperfeiçoada (eHD)
Basicamente, o macromodelo eHD é uma equação que expressa potência como uma função
de duas propriedades de sinal distintas: (i) a distância de Hamming e (ii) o número de
2
fitting coefficients
bits estáveis entre dois vetores de entrada sucessivos (a técnica não emprega sinais de
saı́da). Dados dois vetores de entrada u e v com n bits cada, a distância de Hamming (h)
e o número de bits estáveis (s) com valor ‘1’ são definidos, respectivamente, como:
h(u, v) = |{i|(ui 6= vi )}|, para 1 ≤ i ≤ n; e
s(u, v) = |{i|(ui = vi = 1)}|, para 1 ≤ i ≤ n.
De forma oposta às técnicas anteriores, o macromodelo eHD calcula a potência por
ciclo, como segue.
Seja Eh,s uma classe de evento de chaveamento representando as propriedades de um
par de vetores, onde h é sua distância de Hamming e s é seu número de bits estáveis em
1. Sejam P ower(c) o consumo de potência no c-ésimo ciclo de simulação e n o número de
bits de entrada. A equação do macromodelo eHD é definida como segue, onde ph,s denota
a contribuição do evento de chaveamento Eh,s para o consumo de potência e δh,s denota
se tal evento ocorreu ou não no ciclo c.
 
δ1,n−1
 .. 
h i
P ower(c) = p1,n−1 · · · pn,0  .  (5.1)
δn,0
Em [64], δh,s é chamado de ativador e é definido como:

(
1, se Eh,s ocorrer no ciclo c;
δh,s =
0, se Eh,s não ocorrer no ciclo c.
Dada uma stream de entrada, a estimativa começa calculando-se h(u, v) e s(u, v) para
cada par (u, v) de vetores sucessivos. Então, os ativadores associados com eventos ocor-
rendo num dado ciclo c são determinados e a Equação 5.1 retorna o consumo de potência
para aquele ciclo. O consumo de potência total é obtido agregando-se a contribuição de
todos os ciclos.
A caracterização de componentes começa com a geração de streams de entrada criadas
aleatoriamente. Então, para todas as streams, cada par (u, v) de seus sucessivos vetores
é injetada nas entradas do componente e as funções h(u, v) e s(u, v) são avaliadas. O
consumo de potência resultante é determinado com um modelo de potência pré-existente
do componente, descrito em um nı́vel de abstração inferior. Finalmente, para todas as
streams com um mesmo (h, s), a potência média ph,s é calculada.
Modelo 4: Analı́tico (Analytical)
Comparando ao 4DTab, o macromodelo Analytical baseia-se nas mesmas propriedades de

sinal: (i) a correlação espacial de entrada SCin ; (ii) a probabilidade de sinal de entrada
Pin ; (iii) a densidade de transição de entrada Din ; e (iv) a densidade de transição de saı́da
Dout . O modelo é representado por uma equação que combina estes sinais da seguinte
forma:
P ower = c0 + c1 ∗ Pin + c2 ∗ Din + c3 ∗ SCin + c4 ∗ Dout + c5 ∗ Pin ∗ Din + c6 ∗ Pin ∗ SCin

2
+c7 ∗ Pin ∗ Dout + c8 ∗ Din ∗ SCin + c9 ∗ Din ∗ Dout + c10 ∗ SCin ∗ Dout + c11 ∗ Pin
2 2 2
+c12 ∗ Din + c13 ∗ SCin + c14 ∗ Dout
A estimativa de potência nesta técnica consiste em se executar uma simulação RTL

para coletar as estatı́sticas de sinal (Pin , SCin , Din , Dout ), seguida pela avaliação da
equação acima. Nenhum outro mecanismo é necessário (e.g., interpolação), dado que a
equação usa somente as estatı́sticas coletadas e os coeficientes obtidos durante a fase de
caracterização de potência.
A etapa de caracterização de componentes é efetuada em três passos:
1. Para cada tupla válida (Pin , SCin , Din ), diversas streams são geradas, tentando-se
cobrir ao máximo o espaço de entrada.
2. Cada stream distinta é aplicada às entradas do componente e o Dout e consumo de

potência resultantes são determinados.
3. Os valores resultantes (Pin , SCin , Din , Dout , P ower) são usados, de acordo com a
equação acima, num método de análise de regressão de forma a obter-se os coefici-
entes (c0 , c1 , ..., c14 ) da equação do macromodelo.
5.1.2 A Abordagem Convencional de Modelo Único

Para ilustrar como a precisão das estimativas pode variar enormemente entre os modelos
de potência, adotamos dois componentes reais como exemplos (somador do tipo carry
look-ahead de 32 bits Add ECLA32 e multiplicador de 16 bits com sinal MulS16). Ambos
os exemplos foram caracterizados pelas quatro técnicas de macromodelagem sumarizadas
na Seção 5.1.1 (4DTab, EqTab, eHD and Analytical).
Uma série de experimentos foi conduzida para obter os erros médios de cada ma-
cromodelo como uma função de dois parâmetros da stream de entrada (Pin e Din ) [86],
usando-se 0.1 como passo de discretização. Um conjunto de 5000 streams foi gerado de
forma a cobrir o espaço Pin x Din adequadamente. Então, as estimativas obtidas com
os macromodelos em RTL foram comparadas às estimativas em gate-level, para cada par
(Pin , Din ).
Os resultados obtidos com estes experimentos são mostrados nas Figuras 5.1, 5.2, 5.3
e 5.4, onde a distribuição de erros no espaço Pin × Din é revelada para ambos os exemplos,
e para as quatro técnicas adotadas.
Note que, para um dado componente, os distintos macromodelos levam a erros médios
bem diferentes. Por exemplo, independente do componente escolhido, o macromodelo eHD
leva aos maiores erros médios para as streams de entrada cuja densidade de transição está
dentro do intervalo [0.0,0.1]. Isto significa que 4DTab, EqTab ou Analytical poderiam ser
uma melhor escolha para tais streams. No entanto, para as streams cuja densidade de
transição é maior que 0.6, eHD exibe uma melhor precisão, competitiva em relação às
outras técnicas.
1.0 0%-10%
10%-20%
20%-40%
40%-100%
0.8 >100%
0.6
Din
0.4
0.2
0.0
0.0 0.2 0.4 0.6 0.8 1.0

Pin
(a) Add ECLA32
1.0 0%-10%
10%-20%
20%-40%
40%-100%
0.8 >100%
0.6
Din
0.4
0.2
0.0
0.0 0.2 0.4 0.6 0.8 1.0

Pin
(b) MulS16
Figura 5.1: Distribuição de Erros (4DTab)

1.0 0%-10%
10%-20%
20%-40%
40%-100%
0.8 >100%
0.6
Din
0.4
0.2
0.0
0.0 0.2 0.4 0.6 0.8 1.0

Pin
(a) Add ECLA32
1.0 0%-10%
10%-20%
20%-40%
40%-100%
0.8 >100%
0.6
Din
0.4
0.2
0.0
0.0 0.2 0.4 0.6 0.8 1.0

Pin
(b) MulS16
Figura 5.2: Distribuição de Erros (EqTab)

1.0 0%-10%
10%-20%
20%-40%
40%-100%
0.8 >100%
0.6
Din
0.4
0.2
0.0
0.0 0.2 0.4 0.6 0.8 1.0

Pin
(a) Add ECLA32
1.0 0%-10%
10%-20%
20%-40%
40%-100%
0.8 >100%
0.6
Din
0.4
0.2
0.0
0.0 0.2 0.4 0.6 0.8 1.0

Pin
(b) MulS16
Figura 5.3: Distribuição de Erros (eHD)

1.0 0%-10%
10%-20%
20%-40%
40%-100%
0.8 >100%
0.6
Din
0.4
0.2
0.0
0.0 0.2 0.4 0.6 0.8 1.0

Pin
(a) Add ECLA32
1.0 0%-10%
10%-20%
20%-40%
40%-100%
0.8 >100%
0.6
Din
0.4
0.2
0.0
0.0 0.2 0.4 0.6 0.8 1.0

Pin
(b) MulS16
Figura 5.4: Distribuição de Erros (Analytical)

5.1.3 Análise Qualitativa das Limitações de Macromodelagem
Cada macromodelo tem seus méritos na tarefa de capturar a variação de potência. No

entanto, cada técnica implica em um diferente uso de parâmetros que, eventualmente,
oculta alguma suposição. Esta seção mostra que tais suposições implı́citas são as fontes
de limitações e que elas são dificilmente sobrepujadas dentro do escopo de uma única
técnica de macromodelagem.
Em [53], Gupta e Najm descrevem uma relação matemática entre Pin , Din e SCin .
Neste ponto, esta relação é usada para ilustrar os problemas dos macromodelos mas,
por simplicidade, e sem perda de generalidade, restringimo-nos à densidade de transição
(Din ).
Inicialmente, considere a técnica 4DTab. Ela supõe que Pin , Din , SCin e Dout são
uniformemente distribuı́das ao longo de todos os sinais de entrada/saı́da, embora alguns
sinais possam ter um maior impacto no consumo de potência do que outros. Tal suposição
é claramente inadequada para circuitos com estruturas irregulares ou quando sinais de
controle são considerados, dado que eles podem modificar completamente o modo opera-
cional do circuito [34].
Para ilustrar isso, considere novamente o exemplo MulS16 (um multiplicador de 16 bits
usado como um componente do circuito de cruzamento de áudio estéreo a ser discutido na
Seção 5.3). Uma de suas implementações foi simulada usando-se 100 streams de entrada
distintas, monitorando-se um de seus operandos (16 entradas). Para a maioria das streams,
observou-se que apenas quatro das entradas monitoradas exibiam densidades de transição
maiores que zero.
Considere agora uma destas instâncias de simulação, cuja densidade de transição é
Din = 0.11 e cujas densidades de transição bit-a-bit são:
(D0 , D1 , ..., D15 ) = (0.49, 0.44, 0.50, 0, 0, ..., 0, 0.33).
Note que apenas a última (D15 ) e as três primeiras entradas (D0,1,2 ), de fato, chaveiam
para esta stream. Isto significa que parte do circuito MulS16 não é estimulado, ao contrário
da distribuição uniforme suposta pela 4DTab, o que implicaria nas seguintes densidades
de transição:
(D0 , D1 , ..., D15 ) = (0.006875, 0.006875, ..., 0.006875).
Pode-se, portanto, concluir que, apesar de terem um mesmo valor de Din , padrões
de estı́mulo completamente distintos como estes provavelmente levarão a estimativas de
potência completamente diferentes.

A técnica EqTab supera esta limitação levando em consideração cada entrada indivi-
dualmente, o que, a princı́pio, pode levar a uma melhor precisão. No entanto, ao contrário
da 4DTab, uma única stream é utilizada para cada entrada da tabela durante o processo
de caracterização. Dado que o número de possı́veis streams cresce exponencialmente com
relação à largura de entrada para alguma estatı́stica selecionada, tal suposição representa
um sério fator limitante, conforme é mostrado no próximo exemplo.
Sejam A e B operandos de entrada de 4 bits de um multiplicador de Booth. Considere
uma stream de caracterização candidata cuja densidade de transição é Din = 0.25 e cujas
densidades de transição bit-a-bit são:
(A0 , ..., A3 , B0 , ..., B3 ) = (0.5, 0.5, 0.5, 0.0, 0.0, 0.5, 0.0, 0.0),
onde os quatro primeiros elementos se referem ao A e os últimos quatro ao B. Agora,

considere uma stream de caracterização alternativa obtida trocando-se os operandos A
e B. Embora a densidade de transição continue a mesma, as resultantes densidades de
transição bit-a-bit agora são:
(A0 , ..., A3 , B0 , ..., B3 ) = (0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.5, 0.0).
Dado que o algoritmo de multiplicação citado requer esforço computacional drasticamente

diferente, dependendo se o operando é o multiplicando (o valor a ser somado) ou o mul-
tiplicador (o número de vezes que o multiplicando deve ser somado), é evidente que o
comportamento em termos de potência para estas duas streams de caracterização serão
bem diferentes, embora apenas um deles seria capturado pelo macromodelo.
Para a técnica eHD, ainda que dois pares de vetores distintos com as mesmas es-
tatı́sticas de sinal de entrada irão, provavelmente, resultar em estatı́sticas de sinal de
saı́da distintas, a modelagem é feita exatamente da mesma forma, que é baseada apenas
na informação de entrada.
O impacto de tal suposição é ilustrado através do seguinte exemplo. A caracterização
do componente Add ECLA32 foi conduzida, monitorando-se cada par (u, v) de vetores
sucessivos dentro das streams de caracterização (62 streams com 2000 vetores cada).
Observou-se que uma coleção de 505 pares tinha rigorosamente as mesmas estatı́sticas
de entrada: h(u, v) = 15 e s(u, v) = 49. Para tal coleção, as estimativas de potência fica-
ram dentro da faixa [100µW, 1000µW] com um valor médio de 482.2µW e desvio-padrão
de σ = 213.2µW. Comparadas aos valores de referência em gate-level disponı́veis para
5.2. A Abordagem Multimodelos Proposta 79
este componente, o erro fica no intervalo [-52%, 300%]. Isto implica que a técnica eHD
pode resultar em altos erros de estimativa, pois diferentes comportamentos do circuito
não podem ser distinguidos pelas mesmas estatı́sticas de sinal de entrada. Se estatı́sticas
de saı́da fossem incluı́das no modelo, tais comportamentos distintos poderiam ser melhor
capturados.
Considere agora a técnica Analytical. Este método utiliza os mesmos parâmetros
usados pela 4DTab. Novamente, há uma suposição implı́cita de que os parâmetros são
uniformemente distribuı́dos ao longo de todos os sinais de entrada/saı́da. Portanto, este
método está fadado a possuir as mesmas limitações da 4DTab.
Dado que as limitações de cada método foram identificadas quantitativamente e quali-
tativamente, a próxima seção propõe um mecanismo de múltiplos modelos como solução.
5.2 A Abordagem Multimodelos Proposta

A abordagem de múltiplos modelos consiste em quatro fases principais, conforme mostrado
na Figura 5.5:
1. criação de macromodelos individuais;
2. avaliação individual de macromodelos;
3. geração do multimodelo; e
4. uso do multimodelo.
As três primeiras fases são executadas apenas uma vez para uma dada biblioteca de tec-
nologia, durante a etapa de caracterização da biblioteca. No lado esquerdo da figura está
o gerador de sequências (streams), que produz dois tipos de streams: conjuntos de trei-
namento, usados durante o processo de caracterização (Fase 1) e conjuntos de avaliação,
usados durante a avaliação de robustez do modelo (Fase 2). Se um único conjunto fosse
usado durante ambas as Fases 1 e 2, somente os erros intrı́nsecos seriam capturados. Para
garantir um mecanismo de macromodelagem sem viés (Fase 3), conjuntos de treinamento
e avaliação são gerados de acordo com parâmetros distintos pré-especificados.
5.2.1 Fase 1 (Criação de Macromodelos Individuais)

O gerador de sequências produz um número de conjuntos de treinamento equivalente ao
número de componentes sob processo de caracterização, embora alguns possam ser com-
Character. Training ... Training

Parameters set n set 1
Library
RTL Part
Characterization GL Part
Engine
Power Power
Model 1 ... Model n
Phase 1
Sequence
Generator
Evaluation
Evaluation
Parameters
set
Evaluation
Engine
Model 1 Model n
...
Eval. Eval.
Phase 2
Multi−modeling
Engine
pi−function
Phase 3
RTL Part power aware

multi−model
RTL component
Phase 4
Figura 5.5: O fluxo do mecanismo multimodelos
patı́veis com mais de um componente e sejam reutilizados. A fase de criação de macromo-

delos individuais usa os conjuntos de treinamento na caracterização de cada componente
RTL da biblioteca, para cada técnica de macromodelagem suportada. Por exemplo, se a
biblioteca tiver 100 componentes RTL e 4 técnicas de macromodelagem forem adotadas,
esta fase resultará em 400 macromodelos diferentes (4 para cada componente).
Embora esta fase seja aparentemente muito custosa em termos de tempo, dado que di-
ferentes macromodelos precisam ser construı́dos para cada circuito, o tempo de construção
é, na verdade, determinado pela técnica que requer o maior esforço durante a simulação e
construção dos modelos. Dado que toda a informação necessária para se construir todos
os macromodelos está prontamente disponı́vel ao término da simulação, o tempo total

será levemente maior que o tempo exigido pela técnica mais complexa. Considerando
as quatro técnicas adotadas, a maioria dos parâmetros usados por elas podem ser com-
partilhados, bem como o passo de discretização. Logo, a técnica mais complexa requer
um conjunto de treinamento que pode ser visto como um superconjunto dos conjuntos de
treinamento de todas as técnicas de macromodelagem (no caso das técnicas selecionadas,
a eHD é a mais complexa).
5.2.2 Fase 2 (Avaliação de Macromodelos Individuais)

Uma vez que todos os macromodelos tenham sido gerados para um dado componente
RTL, eles são analisados pelo mecanismo de avaliação. Esta fase de avaliação individual de
macromodelos consiste em, primeiramente, disparar uma simulação RTL do componente,
que é estimulada pelo conjunto de avaliação. Como consequência, são obtidas estimativas
de potência distintas para cada macromodelo. Então, as estimativas são comparadas aos
valores de referência pré-existentes em gate-level e o erro é computado. Como resultado,
para cada macromodelo, um arquivo reportando sua robustez no espaço Pin × Din é
produzido. Esta informação é a entrada do mecanismo multimodelos, descrito a seguir.
Os resultados desta fase permitem gerar gráficos similares aos das Figuras 5.1–5.4
5.2.3 Fase 3 (Criação do Multimodelo)

Nesta fase, o mecanismo constrói um mapeamento π que representa uma estimativa de
potência como uma função de propriedades de sinal de entrada (Pin e Din ) e de estimativas
de potência associadas a cada macromodelo individualmente (uma estimativa pi distinta
para cada macromodelo i). A justificativa para se usar unicamente Pin e Din é que, como
foi demonstrado em [86], Din é o parâmetro que tem o maior impacto na variação de
potência, com uma relação aproximadamente linear. Ademais, os autores em [53] deriva-
ram uma propriedade que apresenta uma relação especial entre Pin e Din . Neste trabalho,
são propostas duas definições para a função π (a serem detalhadas na Seção 5.2.4):
(a) a primeira supõe que, dadas as propriedades do sinal de entrada, um dos macromo-
delos individuais leva a uma melhor precisão que os outros;
(b) enquanto a segunda captura possı́veis correlações entre estimativas de macromodelos

individuais, através do uso de métodos de análise de regressão.
5.2.4 Fase 4 (Uso do Multimodelo)

Uma vez que as funções π tenham sido construı́das para cada componente RTL na fase
anterior, esta fase consiste meramente na coleta das estatı́sticas de entrada e parâmetros
dos modelos durante a simulação.
Abordagem 1: Multimodelagem Não Correlacionada
Seja cada macromodelo individual i associado a um mapeamento pi : Pin × Din → R+

tal que, para um dado ponto do espaço de entrada, pi retorna a potência estimada pelo
macromodelo i.
Suponha que, para cada ponto no espaço de entrada, há um único macromodelo cuja
precisão seja máxima. Na chamada abordagem multimodelos não correlacionada ou sim-
plesmente UMM (Uncorrelated Multi-Modeling), é construı́da inicialmente uma função
seletora ζ para mapear cada ponto do espaço de entrada para o macromodelo que leva
ao menor erro, digamos i, e então é invocada a função pi para obter sua estimativa de
potência, como segue.
Seja M o conjunto de macromodelos e seja ei o erro computado para um dado i ∈ M .
A função de seleção ζ : Pin × Din → M representa o mapeamento de um par (Pin , Din )
para um macromodelo m ∈ M tal que em = min{ei }, ∀i ∈ M .
Considere um mapeamento π : Pin × Din × R+ × . . . × R+ → R+ tal que
π(Pin , Din , p1 , . . . , pi , . . . , p|M | ) representa a estimativa de potência multimodelo. Para a
abordagem UMM, definimos π como:
π(Pin , Din , p1 , . . . , pi , . . . , p|M | ) = pζ(Pin ,Din ) (5.2)
Dado que a função ζ é altamente dependente de uma escolha adequada de streams

de entrada, o conjunto de avaliação é projetado como uma grande coleção de streams de
entrada3 uniformemente distribuı́da sobre o espaço Pin × Din .
Em resumo, nosso mecanismo multimodelos associa uma função ζ distinta para cada
componente da biblioteca. Dada uma stream de entrada, suas propriedades (Pin , Din )
são empregadas para consultar a função ζ, que seleciona o macromodelo retornando a
estimativa de potência mais precisa, de acordo com a função seletora. Se um certo (Pin ,
Din ) não é membro do domı́nio de ζ, o membro mais próximo é escolhido de acordo com
a menor distância Euclidiana.
3
Aproximadamente 5000 na implementação atual
As Figuras 5.6(a) e 5.6(b) mostram as funções ζ geradas para os módulos Add ECLA32
e MulS16. Cada sı́mbolo representa o macromodelo mais preciso para um dado ponto no
espaço de entrada. Por exemplo, o sı́mbolo + associado à (Pin , Din ) = (0.8, 0.3) na
Figura 5.6(a) indica que o EqTab foi o modelo selecionado.
1 1
EqTab 4DTab
4DTab eHD
eHD Analytical
0.8 Analytical 0.8
Input Transition Density
Input Transition Density

0.6 0.6
0.4 0.4
0.2 0.2
0 0
0 0.2 0.4 0.6 0.8 1 0 0.2 0.4 0.6 0.8 1
Input Signal Probability Input Signal Probability
(a) Add ECLA32 (b) MulS16
Figura 5.6: Função ζ para ambos os componentes
Embora as funções ζ nas Figuras 5.6(a) e 5.6(b) sejam diferentes, um padrão comum
pode ser observado em ambos os exemplos. O macromodelo eHD é, em geral, mais preciso
que as outras técnicas para maiores densidades de transição, enquanto que o macromodelo
Analytical é mais preciso para menores densidades de transição. Como um exemplo, para
(Pin , Din ) = (0.5, 0.9), é melhor usar o modelo eHD para o componente Add ECLA32,
considerando que ele tem um erro médio esperado de 0% à 10%, enquanto que, para EqTab
e Analytical, este erro fica dentro das faixas de 10%–20% e 40%–100%, respectivamente.
Agora, considerando a região ao redor de (0.3, 0.3), o modelo 4DTab deveria ser usado
ao invés dos outros, dado que ele leva aos menores erros (10%–20%). Como um outro
exemplo, considere o componente MulS16. Como pode ser notado, o modelo Analytical é
selecionado para a maioria das regiões do espaço de entrada. Apesar disso, para as regiões
ao redor de (Pin , Din ) = (0.5, 0.6), os outros modelos deveriam ser usados, visto que eles
têm um erro esperado menor. Também observe que, para este componente, EqTab não é
selecionado para nenhuma região do espaço de entrada.
Abordagem 2: Multimodelagem Correlacionada
Para a obtenção de uma estimativa de potência, esta abordagem também se baseia nas es-
timativas computadas para cada macromodelo individual. Todavia, ao invés de selecionar
diretamente o macromodelo com precisão máxima e usá-lo para prover a estimativa de

potência, esta abordagem emprega uma função de estimativa de potência mais refinada,
que é construı́da através de análise de regressão, de forma a correlacionar as proprieda-
des da stream de entrada às estimativas individuais dos macromodelos, resultando numa
precisão ainda superior. Esta é a razão desta abordagem ser chamada de multimodelagem
correlacionada ou simplesmente CMM (Correlated Multi-Modeling).
Como supracitado, o mapeamento π : Pin × Din × R+ × . . . × R+ → R+ representa a
estimativa de potência do multimodelo. Para a abordagem CMM, definimos π como:
π(Pin , Din , p1 , . . . , pi , . . . , p|M | ) = X × C, (5.3)
onde C = [c0 c1 c2 . . . cn−1 ] é um vetor-linha cujos elementos são os coeficiente resul-

tantes de análise de regressão e onde X é um vetor-coluna cujos elementos representam
 
correlações, como mostrado abaixo: 1
Pin
 
 
 

 Din 

p
 
 1 
 

 . . . 


 p|M | 

 Pin ∗ Din ∗ pi 
 
 

 ... 

X =  Pin ∗ Din ∗ p|M |  (5.4)
 
 

 p1 ∗ p2 


 ... 

 
 p|M |−1 ∗ p|M | 
 
2

 P in


2
Din
 
 
 
2

 p1 

. . .
 
 
p2|M |
Na Equação 5.4, note que, de forma a efetivamente capturar a variação de potência,

primeiramente leva-se em consideração as contribuições individuais das propriedades da
stream de entrada e de cada estimativa individual dos macromodelos. Então, correlaciona-
se o par (Pin , Din ) de propriedades da stream de entrada com as estimativas individuais
dos macromodelos. O próximo passo é realizar a correlação cruzada de todas as esti-
mativas individuais dos macromodelos. Finalmente, captura-se as autocorrelações das

propriedades da stream de entrada e das estimativas individuais dos macromodelos.
Seja a o número de argumentos na função π e lembre-se que |M | é o número de

macromodelos individuais disponı́veis. O número total de correlações, denotado por n,
pode ser calculado da seguinte forma:

a−1
n=1+a+ +a (5.5)
2
Dado que a = |M | + 2, a Equação 5.5 pode ser reescrita como:

|M | + 1
n = 5 + 2|M | + (5.6)
2
Considerando que a relação entre os parâmetros é claramente não-linear, foram ado-

tados métodos de regressão não-linear tradicionais para obter os coeficientes contidos no
vetor-linha C.
Em resumo, o mecanismo de multimodelos constrói uma função π para cada compo-

nente da biblioteca. Dados uma stream de entrada e um ponto no espaço de entrada, as
estimativas de potência individuais são obtidas como um passo intermediário. Então, a
estimativa final de potência é computada avaliando-se a função π para o dado ponto no
espaço de entrada.
Para fechar esta seção, a formulação é ilustrada através de um exem-

plo. Considere o conjunto de macromodelos revisado neste trabalho: M =
{4DT ab, EqT ab, eHD, Analytical}. A função de estimativa de potência usando a abor-
dagem CMM é:
π = c0 + c1 ∗ Pin + c2 ∗ Din + c3 ∗ pEqT ab + c4 ∗ p4DT ab + c5 ∗ ppeHD

+c6 ∗ pAnalytical + c7 ∗ Pin ∗ Din ∗ pEqT ab + c8 ∗ Pin ∗ Din ∗ p4DT ab
+c9 ∗ Pin ∗ Din ∗ peHD + c10 ∗ Pin ∗ Din ∗ pAnalytical + c11 ∗ pEqT ab ∗ p4DT ab
+c12 ∗ pEqT ab ∗ peHD + c13 ∗ pEqT ab ∗ pAnalytical + c14 ∗ p4DT ab ∗ peHD
2 2
+c15 ∗ p4DT ab ∗ pAnalytical + c16 ∗ peHD ∗ pAnalytical + c17 ∗ Pin + c18 ∗ Din
+c19 ∗ p2EqT ab + c20 ∗ p24DT ab + c21 ∗ p2eHD + c22 ∗ p2Analytical
5.2.5 Discussão
Pode ser notado que, de forma geral, há uma grande interseção entre os conjuntos de
parâmetros requeridos para um dado pool de macromodelos suportados. Por exemplo,
sendo o macromodelo mais complexo, eHD contém os parâmetros requeridos por 4DTab,
EqTab e Analytical. Logo, o overhead de se usar a abordagem UMM é levemente maior que
o do macromodelo mais complexo. O pequeno incremento no overhead do macromodelo
dominante é devido ao tempo exigido para aplicar a função π, uma vez por componente.
Observe que, essencialmente, não há overhead extra na execução do macromodelo: apenas
uma função (possivelmente distinta) de macromodelo é invocada por componente, exata-
mente o mesmo número de execuções que um mecanismo de modelo simples convencional
requereria.
Para a abordagem CMM, dado que a estimativa de potência exige a computação
de pi , para todo i ∈ M , o overhead é composto de uma invocação de cada função de
macromodelo por componente durante a avaliação da função π.
5.3 Experimentos
Esta seção compara as técnicas convencionais de modelo simples com as abordagens mul-
timodelo propostas com relação à precisão das estimativas. As estimativas de referência
em gate-level foram obtidas com a ferramenta PrimePower, da Synopsys.
O conjunto de benchmarks consiste em seis circuitos, sintetizados para uma biblioteca
de tecnologia TSMC 0.25µm. Os nomes dos circuitos estão listados na primeira coluna
da Tabela 5.1, enquanto suas descrições e áreas estão mostradas nas colunas seguintes.
Dois deles são componentes simples de uma biblioteca de componentes (Add ECLA32 e
MulS16). Quatro são circuitos in-house complexos, extraı́dos de aplicações reais: uma
implementação de um algoritmo de equação diferencial (Diffeq) e várias implementações
de um algoritmo de cruzamento de áudio estéreo (Crossover1, Crossover2, Crossover3).
Estes circuitos complexos consistem de vários componentes diferentes, com diferentes
larguras de bit, tais como, somadores, multiplicadores e subtratores. Diversas estimativas
foram feitas para cada circuito e para várias streams de entrada diferentes. Os tempos
de simulação, que incluem o overhead imposto pelos macromodelos, ficou entre 56s e
126s para estes experimentos. As máquinas utilizadas foram Intel Pentium 4 2.8GHz
convencionais com o sistema operacional Linux.
5.3. Experimentos 87
Benchmark Descrição Área (µm2 )

Add ECLA32 somador de 32 bits (carry look-ahead) 19,351
MulS16 Multiplicador de entrada de 16 bits (com sinal) 115,190
Diffeq Equação diferencial 1,573,378
Crossover1 Cruzamento de áudio estéreo 370,343
Crossover2 Cruzamento de áudio estéreo 2,912,320
Crossover3 Cruzamento de áudio estéreo 3,658,289
Tabela 5.1: Circuitos selecionados como benchmarks
5.3.1 Configuração do Ambiente de Caracterização
Para poder avaliar as distintas técnicas de macromodelagem apropriadamente, o mesmo

procedimento de geração de vetores foi usado durante a caracterização. Adotamos o
procedimento descrito em [86], que habilita a geração de streams com alta precisão de
probabilidade de sinal, densidade de transição e correlação espacial. Como sugerido em
[86], ajustamos para 2000 o número de vetores das streams. O passo de discretização do
espaço de entrada adotado foi (0.00, 0.05, 0.15, ..., 0.95, 1.0) tanto para Pin quanto para
Din . Os tempos de caracterização exigidos para a construção dos modelos foram 92, 102,
232 e 246 minutos para 4DTab, EqTab, eHD e Analytical, respectivamente. Reiterando,
esta etapa é executada uma única vez para cada biblioteca de tecnologia.
5.3.2 Resultados Experimentais
As Figuras 5.7(a) e 5.7(b) mostram, respectivamente, os erros médios e máximos resul-

tantes para cada abordagem de macromodelagem. Os circuitos (listados na Tabela 5.1)
encontram-se no eixo horizontal, enquanto o eixo vertical apresenta os erros, expressos
como porcentagens. Para cada circuito, um agrupamento de barras é mostrado, cada barra
representando uma técnica de macromodelagem (da esquerda para a direita): 4DTab, Eq-
Tab, eHD, Analytical, UMM e CMM. Um agrupamento de barras adicional é acrescentado
ao lado direito destas figuras. Ela mostra a erro médio geral para todos os circuitos. Note
que as escalas utilizadas nestas figuras diferem uma da outra.
Estes resultados foram computados usando as equações abaixo:
n i i
1 X |Pest − Pref |
εAV G = i
× 100% (5.7)
n i=1 Pref
e ( )
i i
|Pest − Pref |
εM AX = max i
× 100% (5.8)
1≤i≤n Pref
i i
onde n é o número de componentes no circuito, Pest e Pref são, respectivamente, os valores
de potência estimados e de referência para o i-ésimo componente.
4DTab EqTab eHD Analytical UMM CMM

50
40
Average Error (%)
30
20
10
0
Add_ECLA32 MulS16 Crossover1 Crossover2 Crossover3 Diffeq AVERAGE
Design
(a) Erros médios
4DTab EqTab eHD Analytical UMM CMM
500
400
Maximum (%)
300
200
100
0
Add_ECLA32 MulS16 Crossover1 Crossover2 Crossover3 Diffeq AVERAGE
Design
(b) Erros máximos
Figura 5.7: Resultados obtidos com as técnicas de macromodelagem adotadas para os

circuitos selecionados
Três observações podem ser feitas a partir destas figuras. Primeiro, para todos os
circuitos, há uma grande variação nos erros entre cada uma das técnicas de modelo simples
(quatro primeiras barras). Para os erros médios, esta variação estende-se de 15% a 101%.
Valores ainda mais contrastantes podem ser vistos na Figura 5.7(b), na faixa de 83% a
1453%. Note que a abordagem de modelo simples pode levar a erros inaceitáveis. Erros
altos como estes podem comprometer a qualidade geral das estimativas o que, por sua
vez, pode levar a decisões de projeto equivocadas.
Para o conjunto de circuitos adotados, os maiores erros foram obtidos com a técnica
eHD. Isto indica que tal macromodelo não deve ser utilizado sozinho. Contudo, isto
não significa, necessariamente, que esta técnica deva ser descartada de antemão. Pelo
contrário, conclui-se que ela só não é adequada para algumas regiões no espaço Pin × Din .
De fato, conforme mostrado na Seção 5.1, há regiões onde eHD teve desempenho superior
com relação às outras técnicas.
A segunda observação é que as estimativas produzidas pelas abordagens multimodelo
propostas (duas últimas barras) são muito superiores se comparadas às produzidas pelas
técnicas de modelo único. Do ponto de vista de erros médios, CMM desempenhou melhor
que UMM na maioria dos casos. As únicas exceções foram para MulS16 e Crossover1,
onde UMM obteve erros menores. Isto é devido ao fato que, para o componente MulS16,
o macromodelo Analytical obteve resultados melhores se comparados às outras técnicas
(4DTab, EqTab e eHD) para uma grande parte do espaço de entrada (veja a Figura 5.6(b)).
Isto afetou a computação dos coeficientes do modelo durante a análise de regressão. Note,
todavia, que mesmo nestes casos as abordagens multimodelo superam o melhor modelo
único equivalente. Observe também que, em nenhum outro caso, uma técnica de modelo
único apresenta erros médios abaixo de ∼12%.
De forma a quantificar o benefı́cio obtido ao se usar as abordagens multimodelo pro-
postas ao invés das alternativas de modelo único convencionais, usamos a seguinte famı́lia
de razões como figuras de mérito:
x εsingle
AV Gx
RAV G = multi
, ∀x ∈ {min, avg, max}, (5.9)
εAV Gx
single multi
onde εAV G e εAV G são os erros médios para as técnicas de modelo único e multimodelo
(como computados na Equação 5.7) e onde x determina as faixas de benefı́cio quando com-
min
paradas às técnicas de modelo único. Em média, as razões obtidas foram: RAV G = 3.05,
avg max
RAV G = 7.75, e RAV G = 20.54.
Do ponto de vista de erros máximos (Figura 5.7(b)), resultados similares àqueles apre-
sentados na Figura 5.7(a) são percebidos, com os menores erros máximos sendo observados
para UMM e CMM. A única exceção é, MulS16, onde Analytical apresenta erros meno-
res que CMM. Note também que os erros máximos gerais de UMM são melhores que os
obtidos com CMM para estes experimentos.
Figuras de mérito similares àquelas da Equação 5.9 podem ser usadas com relação aos
erros máximos, como é mostrado abaixo:
x εsingle
M AXx
RM AX = multi , x ∈ {min, avg, max} (5.10)
εM AXx
single multi
A diferença da Equação 5.9 é basicamente na computação de εM AX e εM AX , que agora
min avg
usam a Equação 5.8. Na média, as razões resultantes foram: RM AX = 1.60, RM AX = 9.80,
max
e RM AX = 27.86.
A terceira observação, no que diz respeito às Figuras 5.7(a) e 5.7(b) é que cada técnica
de macromodelagem multimodelo exibe pequenas variações ao longo dos circuitos, ao
contrário das abordagens de modelo único convencionais. Para as abordagens multi-
modelo, encontrou-se um desvio padrão de σavg = 0.92% e σmax = 25.48% para os
erros médios e máximos, respectivamente. Em contraste, os valores σavg = 37.63% e
σmax = 609.62% foram encontrados para as abordagens de modelo único. Isto mostra
que as abordagens propostas produzem estimativas de potência de forma robusta, uma
propriedade desejável e importante que todo modelo de potência deveria possuir.
Para sumarizar as melhorias alcançadas num único número para os erros médios e
avg avg
máximos, fazemos uso das razões RAV G e RM AX , computadas com as Equações 5.9 e 5.10.
Note que a acurácia se torna 7 vezes melhor para os erros médios, se comparada às
abordagens convencionais, enquanto o erro máximo geral é divido por 9.
5.3.3 Avaliação de Robustez

De forma a correlacionar a precisão geral do sistema com os erros de estimação de um
componente, foquemo-nos nos circuitos mais complexos (Diffeq, Crossover1, Crossover2,
Crossover3). Estes circuitos empregam Add ECLA32 como um de seus vários componen-
tes e, portanto, foram selecionados para uma avaliação de robustez mais detalhada das
técnicas de macromodelagem adotadas.
Considera-se que um modelo é robusto quando este é capaz de produzir estimativas de
alta qualidade para uma ampla faixa de diferentes streams de entrada. De forma a fazer tal
avaliação, foram geradas streams de entrada suficientes, de forma a cobrir adequadamente
o espaço de entrada. A Figura 5.8(a) ilustra esta cobertura, onde os eixos horizontal e
vertical representam a probabilidade do sinal de entrada (Pin ) e a densidade de transição
(Din ), respectivamente. Cada ponto nesta figura representa a uma stream distinta.
1.0
100
0.8
80
Input Transtion Density
# of ocurrences
0.6
60
0.4
40
0.2
20
0.0 0
0.0 0.2 0.4 0.6 0.8 1.0 0 200 400 600 800
Input Signal Probability Actual Power (uW)
(a) Cobertura do espaço de entrada Pin × Din . (b) Distribuição dos valores de potência de re-
Cada ponto representa um stream distinta ferência
Figura 5.8: Cobertura do espaço de entrada e distribuição de valores de potência de

referência para Add ECLA32
Além disso, a distribuição dos valores de potência de referência para estas streams,
juntamente com a curva normal, é mostrada na Figura 5.8(b). Cada barra neste histo-
grama corresponde a um valor de potência distinto e sua altura corresponde ao número
de ocorrências deste valor especı́fico de potência.
O próximo passo da avaliação consistiu em gerar estimativas de potência com todas
as técnicas de modelo único e de múltiplos modelos, para todas as streams de entrada
da Figura 5.8(a). Então, estas estimativas foram comparadas aos valores de referência,
resultando na chamada robustez do modelo.
As Figuras 5.9(a)–5.9(f) apresentam a robustez das técnicas adotadas. Note que a
escala usada na Figura 5.9(d) é diferente da usada nas outras. Como pode ser visto nas
Figuras 5.9(a)–5.9(d), a afirmação de que técnicas convencionais de modelo único têm
limitações intrı́nsecas que afetam sua precisão é evidente. Note também que os erros
produzidos por estas técnicas não são aleatórios; uma tendência identificável é detectada
nas estimativas de cada um dos métodos, embora sejam bem distintas. Estes resultados
corroboram a análise qualitativa de limitações de macromodelagem feita na Seção 5.1.
A robustez das abordagens multimodelo propostas pode ser vista nas Figu-
ras 5.9(e) e 5.9(f). Observe que tanto a UMM quanto a CMM apresentam uma me-
800 800
600 600
Actual Power (uW)

Actual Power (uW)
400 400
200 200
0 0
0 200 400 600 800 0 200 400 600 800
4DTab (uW) EqTab (uW)
(a) Robustez da 4DTab (b) Robustez da EqTab

800
1200
1000
600
Actual Power (uW)
Actual Power (uW)

800
400
600
400
200
200
0 0
0 200 400 600 800 0 200 400 600 800 1000 1200
eHD (uW) Analytical (uW)
(c) Robustez da eHD (d) Robustez da Analytical

800 800
600 600
Actual Power (uW)
Actual Power (uW)
400 400
200 200
0 0
0 200 400 600 800 0 200 400 600 800
UMM (uW) CMM (uW)
(e) Robustez da UMM (f) Robustez da CMM
Figura 5.9: Robustez do modelo das técnicas adotadas (Add ECLA32)

140
120
150
100
# of ocurrences
# of ocurrences
80
100
60
40
50
20
0 0
0 200 400 600 800 0 200 400 600 800
4DTab (uW) EqTab (uW)
(a) Distribuição da 4DTab (b) Distribuição da EqTab
250 100
200 80
# of ocurrences
# of ocurrences
150 60
100 40
50 20
0 0
0 100 200 300 400 500 600 700 0 250 500 750 1000 1250 1500
eHD (uW) Analytical (uW)
(c) Distribuição da eHD (d) Distribuição da Analytical

125 120
100
100
80
# of ocurrences
# of ocurrences
75
60
50
40
25
20
0 0
0 200 400 600 800 0 200 400 600 800
UMM (uW) CMM (uW)
(e) Distribuição da UMM (f) Distribuição da CMM
Figura 5.10: Distribuição dos valores de potência das técnicas adotadas (Add ECLA32)
lhor robustez em relação às técnicas de modelo simples. Notavelmente, as estimativas

da técnica CMM ficaram muito mais próximas dos valores de referência do que todas as
outras técnicas.
Complementando os resultados de robustez, as distribuições dos valores de potência
para todas as técnicas são mostradas nas Figuras 5.10(a)–5.10(f). Note que há uma grande
discrepância entre as técnicas com relação ao número de ocorrências para cada faixa de
valores de potência. Observe que os histogramas nas Figuras 5.10(e) e 5.10(f) (UMM e
CMM) têm uma forma similar ao histograma de referência da Figura 5.8(b).
A grande variação nas estimativas e distribuições de valores de potência (Figu-
ras 5.9 e 5.10) é uma evidência da falta de robustez de um macromodelo simples. Por
um lado, devido a essa falta de robustez nas estimativas, um macromodelo simples está
fadado a comprometer a acurácia geral das predições. Por outro lado, as abordagens
multimodelo superam esta falta de robustez, como os resultados revelaram. Como um
comentário adicional, resultados similares foram observados para os outros circuitos.
O overhead imposto à simulação devido ao uso da abordagem multimodelo para esti-
mativa de potência é mı́nimo (∼1%). Uma vez que todos os modelos de potência tenham
sido construı́dos off-line e o componente da biblioteca apropriadamente instrumentado
com sua função π, a chamada a ela ou retorna somente o modelo a ser usado no mo-
mento (abordagem UMM) ou cada função dos macromodelos é invocada apenas uma vez
(abordagem CMM). Todo o overhead remanescente é exatamente o mesmo, como se uma
abordagem de modelo simples fosse utilizada. Logo, como pode ser notado, a melhoria na
robustez obtida através do uso das abordagens propostas compensa o pequeno overhead.
Este capı́tulo encerra as contribuições desta tese de doutorado com relação a um dos
problemas atacados (hardware), conforme foi mencionado no Capı́tulo 1. O próximo
capı́tulo detalha as contribuições feitas por este trabalho relativas a software, mais espe-
cificamente, uma análise pormenorizada do consumo de energia de uma implementação
de memória transacional em software (STM).
Capı́tulo 6
Perfil de Consumo de Energia de

Memória Transacional em Software
A era multi-core chegou e para ficar. Desde que se constatou que o ganho de desempenho
via o tradicional aumento de frequência alcançava seus limites fı́sicos, com grande impacto
no consumo de potência, pesquisadores têm concentrado seus esforços em investigar ar-
quiteturas alternativas a fim de conservar o crescente aumento de desempenho, conforme
observado nas últimas décadas.
Tal cenário é corroborado pela copiosa diversidade de arquiteturas multiprocessadas,
tanto acadêmicas quanto industriais, tornando a programação concorrente um importante,
senão essencial, paradigma para exploração destas arquiteturas.
Atualmente, a construção de software concorrente é usualmente feita com locks, que
exibem um desempenho excelente quando usados em aplicações de alta granularidade.
Contudo, programar nesta abordagem não é uma tarefa fácil, pois a mesma apresenta
vários problemas [137] (e.g. deadlocks), além de serem de difı́cil composição e depuração,
como mencionado na Seção 3.6.
Portanto, para que o paradigma de programação concorrente se torne ubı́quo, deve-se
buscar maneiras eficientes de simplificar a tarefa do programador.
Com este intuito, propôs-se memória transacional1 [58] (ver Seção 3.6, pág. 47). Neste
paradigma, o programador deve apenas marcar um trecho de código como transacional,
como ilustrado na Figura 6.1, deixando a cargo do sistema de memória transacional
subjacente a tarefa de detectar e resolver os conflitos de acesso à memória compartilhada.
Apesar de os requisitos de consumo de energia e/ou potência serem essenciais tanto
1
A partir daqui, o acrônimo TM será usado para se referenciar genericamente ao paradigma de memória
transacional.
97
98 Capı́tulo 6. Perfil de Consumo de Energia de Memória Transacional em Software
1 atomic {
2 statement 1;
3 statement 2;
4 ...
5 statement n ;
6 }
Figura 6.1: Exemplo de um bloco atômico no paradigma de memória transacional
em sistemas embarcados, servidores, ou mesmo em desktops [7], os pesquisadores de TM

têm focado predominantemente no desempenho das aplicações, deixando de lado estas
outras métricas.
Embora alguns trabalhos preliminares [42, 97, 98] tenham investigado alguns tópicos
em relação ao consumo de potência em HTM, nada foi publicado na literatura no que se
refere à STM. Em vista disso, os resultados reportados nesta tese são um primeiro passo
em busca do projeto de STMs cientes do consumo de energia.
Neste trabalho é apresentada uma análise pormenorizada do consumo de energia em
uma implementação estado-da-arte de STM. Além disso, uma metodologia de caracte-
rização de energia para STM é proposta com um algoritmo parametrizável, que tem o
objetivo de emular uma grande diversidade de cenários de aplicações baseadas em TM.
Em sua ampla maioria, as STMs são construı́das sobre os pilares de quatro primitivas
básicas:
• TxStart: cria um checkpoint marcando o inı́cio da transação.
• TxCommit: finaliza a transação e tenta confirmar, na memória principal, as mo-

dificações efetuadas dentro da transação (tornando-as visı́veis pelos outros proces-
sadores). Em caso de falha, a transação é abortada e as modificações descartadas.
• TxLoad: barreira de leitura de um dado transacional.
• TxStore: barreira de escrita de um dado transacional.
Duas primitivas extras são adicionadas por conveniência. A primeira (Rollback) su-
mariza os custos associados à reexecução de transações abortadas, enquanto a segunda
(Other) é utilizada para referenciar outras operações menos significativas dentro de uma
implementação de STM, tais como aquelas relacionadas à alocação/desalocação transaci-
onal de memória.
6.1. STM Adotada 99
Desta forma, a metodologia proposta é aplicável, sem perda de generalidade, a qual-

quer implementação de STM fundamentada nas mesmas primitivas. Após apresentar esta
metodologia, com alguns resultados preliminares, a análise é expandida, perfilando-se o
consumo de energia do STAMP [96], um conhecido benchmark de TM. Este perfilamento
originou uma otimização com um esquema de gerenciamento de contenção baseado em
DVFS, que explora o tempo ocioso para colocar o processador em modo de baixo consumo
de potência.
Os resultados reportados neste capı́tulo são fruto da forte colaboração feita com o co-
lega de doutorado do Laboratório de Sistemas de Computação (LSC), do IC-UNICAMP,
Alexandro Baldassin. Para viabilizar a infraestrutura necessária aos experimentos repor-
tados nesta tese, precisou-se adaptar a plataforma-alvo, estender e modificar ferramentas
e portar programas. Embora várias dessas adaptações e extensões tenham sido realizadas
em co-autoria, uma parte da construção da infraestrutura foi realizada exclusivamente
por Alexandro Baldassin (porte da implementação da STM adotada e das aplicações do
benchmark STAMP) e outra parte pelo autor desta tese (as modificações reportadas na
Seção 6.2, o artefato de caracterização descrito na Seção 6.3.1 e o mecanismo de gerenci-
amento de contenção baseado em DVFS descrito na Seção 6.5).
O restante deste capı́tulo organiza-se como segue: a Seção 6.1 descreve a STM ado-
tada, enquanto a Seção 6.2 apresenta a plataforma de simulação utilizada para os ex-
perimentos. A Seção 6.3 introduz a metodologia de caracterização de energia proposta.
Finalmente, na Seção 6.4, o consumo de energia do benchmark de TM é perfilado, seguido
pela apresentação da otimização voltada a aplicações com alta contenção no barramento
na Seção 6.5.
6.1 STM Adotada

A implementação de STM escolhida para análise experimental foi a TL2 [36], que é uma
solução baseada em relógio de versão global (i.e., as transações são time-stamped). Um
dos intentos do projeto da TL2 é prover alto desempenho para transações somente-leitura,
pelo fato de estas transações serem dominantes em muitas aplicações. Logo, transações
regulares (contendo pelo menos uma operação de escrita) e transações somente-leitura são
tratadas distintamente, como é descrito a seguir.
O substrato da TL2 controla os acessos à memória compartilhada na granularidade de
posições de memória. Isto é feito através do uso de um grande array, onde cada elemento
representa um lock de uma palavra da memória sendo versionada. Uma função de hash
mapeia os endereços de memória para um destes locks, que têm duas utilidades: (i) se
o lock do referido endereço de memória está liberado (o que é indicado pelo bit menos
significativo), então o elemento do array contém o número da versão baseado num relógio
global; (ii) caso contrário, o mesmo elemento armazena um ponteiro para o descritor da
transação ao qual o lock pertence.
As transações regulares e somente-leitura realizam os seguintes passos durante sua
execução, em ordem:
• Transações regulares
1. O valor do relógio de versão global é copiado para uma variável privada da

thread/processador.
2. O código da transação é executado especulativamente, garantindo-se a con-
sistência da memória. As leituras (na memória compartilhada) são substituı́das
por chamadas a TxLoad, que registram os endereços acessados em um read-set
(armazenado localmente). As escritas são substituı́das por chamadas à TxS-
tore, que registram em um write-set tanto o endereço acessado quanto o valor a
ser escrito. Quando uma leitura transacional é executada, o endereço é primei-
ramente buscado dentro do write-set local, de forma que o valor mais recente
seja retornado pela leitura. Uma operação de leitura (TxLoad ) também va-
lida o read-set, comparando o número de versão atual com o lock versionado
da palavra lida. Se esta validação falhar, a transação aborta, pois o valor foi
modificado por outra transação.
3. Os locks de todos os endereços no write-set são adquiridos, caso contrário a
transação falha e aborta.
4. O número de versão global é incrementado atomicamente, usando-se uma
operação do tipo CAS (compare-and-swap).
5. O read-set é validado comparando-se, para cada endereço do conjunto, o número
da versão atual com o relógio global, e verificando também se o lock do endereço
não foi adquirido por outro processador. Se esta validação falhar, a transação
aborta.
6. A transação é concluı́da com a operação TxCommit, confirmando as modi-
ficações do write-set na memória principal e liberando-se todos os locks adqui-
ridos.
• Transações somente-leitura
6.2. Plataforma de Simulação 101
1. O valor do relógio de versão global é copiado para uma variável privada da

thread/processador.
2. O código da transação é executado especulativamente. Cada operação de lei-
tura certifica-se de que o lock de escrita está livre e compara o número de
versão. Se a checagem falhar, a transação aborta, caso contrário ela se con-
firma (TxCommit).
A TL2 possui dois modos de versionamento: adiado (lazy) e imediato (eager ). O

primeiro (padrão) segue os passos conforme descrito anteriormente, onde as escritas são
armazenadas num buffer local, e os locks são adquiridos somente após a execução do código
da transação. Esta variação é denominada a partir daqui TL2-lazy. A outra variação,
denominada a partir daqui TL2-eager, obtém os locks e atualiza a memória no momento
da operação de escrita.
O gerenciamento de contenção é feito através de duas estratégias de backoff mutual-
mente exclusivas, disparadas após três abortos consecutivos. O princı́pio básico do backoff
é fazer o processador esperar por um tempo fixo, que pode aumentar de acordo com algum
critério pré-determinado. A primeira estratégia, que é o padrão, adota um critério linear,
enquanto a outra usa um exponencial.
A próxima seção introduz o ambiente de simulação para a qual a TL2 foi portada, e
onde os experimentos foram conduzidos.
6.2 Plataforma de Simulação

O ambiente utilizado para a coleta dos resultados de energia e desempenho foi o
MPARM [87], que é uma plataforma de simulação de MPSoCs baseada em SystemC com
precisão de ciclos. A arquitetura do MPARM é ilustrada na Figura 6.2, cujos principais
componentes são:
• um número variável de processadores ARMv7 (CORE), cada qual com uma ca-
che de instruções (I$) de 8KB e uma cache de dados (D$) de 4KB (ambas com
associatividade 4-way).
• memórias SPM (scratchpad memory) tanto para instrução (I-SPM) quanto para da-
dos (D-SPM). Estas memórias são geralmente bem pequenas e altamente acopladas
ao processador, o que garante acessos muito eficientes em termos de energia.
• um bloco de memória privada de 12MB para cada processador instanciado (Private

Memory).
• 16MB de memória compartilhada (Shared Memory), usada para comunicação inter-

processadores.
• semáforos em hardware (não mostrados na figura), dando suporte à sincronização

entre os processadores com operações do tipo test-and-set.
• um gerador de relógio programável que permite o escalamento da frequência de

operação de diversos dispositivos de hardware.
• um barramento AMBA AHB, interligando todos os componentes acima.
Figura 6.2: MPARM: a plataforma de simulação
Todos os modelos de potência existentes no MPARM (para os componentes acima)

foram caracterizados e validados para uma tecnologia 0.13µm da STMicroelectronics.
Três observações devem ser feitas sobre esta plataforma. Primeiro, a hierarquia de
memória é baseada em SRAM, que tem menor latência e maior eficiência energética
em relação a DRAM [90]. Segundo, a coerência de cache não é imposta por hardware,
sendo que acessos à memória privada são “cacheáveis”, ao passo que acessos à memória
compartilhada não. Embora esta caracterı́stica aparente ser um fator limitante, alguns
trabalhos [88] mostram que esta abordagem é competitiva em termos de desempenho e
6.3. Caracterização de Energia 103
consumo de energia em relação a soluções de coerência de cache baseadas em hardware.

Finalmente, o gerador de relógio programável é um módulo de hardware opcional que,
ao ser instanciado, introduz um baixo overhead no desempenho e consumo de energia da
aplicação. A frequência dos componentes é programada através de registradores conec-
tados ao barramento, que informam ao gerador de relógio o divisor de frequência a ser
utilizado. Quando a frequência é escalada, a voltagem também é variada.
Neste trabalho, teve-se acesso ao código-fonte do MPARM, o que possibilitou a im-
plementação de diversas modificações na plataforma, dentre as quais, podemos destacar
a adição de um gerenciador de memória eficiente e a melhoria dos mecanismos de tracing
da simulação.
O gerenciador de memória conhecido como dlmalloc [141] foi adaptado ao MPARM,
permitindo o uso de alocação dinâmica de memória (inclusive na memória compartilhada),
o que era ineficaz na versão original do simulador. O dlmalloc é extremamente eficiente e
é utilizado em diversas versões de Linux. Este suporte era necessário, pois as aplicações
a serem perfiladas na Seção 6.4 fazem uso massivo de memória dinâmica.
O mecanismo de tracing disponı́vel no MPARM era demasiadamente simples, tornando
difı́cil uma análise pormenorizada do substrato de STM. Portanto, esse mecanismo foi
melhorado de forma a possibilitar o perfilamento em granularidade fina, a ponto de quan-
tificar os custos de cada primitiva envolvida na execução de uma aplicação transacional
com a TL2.
A próxima seção apresenta alguns resultados preliminares de caracterização de energia
de STM.
6.3 Caracterização de Energia

A fim de proceder com o processo de caracterização, é necessário distinguir a energia
consumida pelo substrato de STM da energia consumida pela aplicação em si. O procedi-
mento de coleta de energia é efetuado numa única execução de acordo com três esquemas
distintos:
• Perfilamento da API: imediatamente ao iniciar a execução do código da STM,

através de uma chamada à sua API, a medição de energia é ativada. Durante este
perı́odo, a energia consumida por todos os componentes da plataforma (processa-
dores, caches, memórias, barramento) é coletada. Ao retornar para o código da
aplicação, a medição de energia é desativada e registrada para a primitiva.
• Perfilamento da aplicação: a aplicação inicia sua execução e a medição de ener-

gia é ativada. Antes de uma chamada à API da STM, a medição é desativada,
registrada, e então reativada ao retornar para o código da aplicação. Similarmente
ao que é feito com a API, todos os componentes são monitorados durante a medição
de energia.
• Perfilamento dos rollbacks: sempre que uma transação aborta, a energia regis-
trada de todas as primitivas executadas desde a última chamada a TxStart, incluindo
o código da aplicação, é agregada num único valor (Rollback). A única exceção é a
energia referente ao gerenciador de contenção, que é acumulada em backoff.
O procedimento descrito acima permite quantificar os custos de energia inerentes à
aplicação, bem como o overhead de cada uma das primitivas da API da STM. Com isso,
facilita-se a identificação de possı́veis gargalos, servindo de guia para a elaboração de
otimizações focadas na redução do consumo de energia devido à abordagem de STM.
É importante ressaltar que o impacto deste procedimento no consumo total de energia
foi relativamente baixo (∼2%).
Esta seção apresenta alguns resultados preliminares através do uso de uma aplicação
genérica, antes de introduzir o perfilamento das aplicações do benchmark de TM na
Seção 6.4.
6.3.1 A Ferramenta de Caracterização Parametrizável

Há uma grande diversidade de aplicações que poderiam se beneficiar do modelo de pro-
gramação de memória transacional. Logo, deve-se considerar isso durante a condução da
caracterização, de forma a abranger tais distintas aplicações evitando, assim, o enviesa-
mento dos resultados.
Dentre as caracterı́sticas contrastantes que devem ser levadas em conta estão: dife-
rentes tamanhos dos conjuntos de leitura/escrita (bem como a razão entre os mesmos),
taxa de abortos, tamanho de transação, etc. Devido à amplitude de possibilidades, o
procedimento de caracterização descrito nesta seção foi automatizado para cobrir uma
ampla faixa de tipos de aplicações dentro de uma janela de tempo factı́vel.
Para este propósito, uma ferramenta de caracterização parametrizável foi desenvolvida,
cujo pseudocódigo é mostrado na Figura 6.3. Esta ferramenta serve para um número ar-
bitrário de cores e executa uma séria de leituras e escritas transacionais em um array com-
partilhado (shrvar). Os principais parâmetros considerados, bem como as configurações
escolhidas, são sumarizados abaixo:
• VS: tamanho do vetor, define o número de elementos escalares do array comparti-

lhado (shrvar). Configuração: 32, 128, 512.
• IPC: iterações por core. Ajusta o número de transações a serem executadas por cada
core. Configuração: 2K, 8K.
• NRD: número de leituras feitas numa única transação. Configuração: 1, 2, 4, 8,

32, 64, 128.
• NWR: número de escritas feitas numa única transação. Configuração: 1, 2, 4, 8,

32.
• ITD: atraso intertransação (inter-transaction delay). Ajusta o número de operações

a serem inseridas entre duas transações consecutivas com o intuito de emular um
número variável de computações executadas fora das regiões atômicas. Confi-
guração: 0, 32, 1K.
1: for iter ← 1 to IterationsPerCore do

2: TxStart() {inı́cio da transação}
3: wdw ← GetWindowRange(iter)
4: for i ← 1 to NumberOfReads do
5: elem ← wdw[i]
6: x ← Consume(TxLoad(shrvar[elem]), x)
7: end for
8: for j ← 1 to NumberOfWrites do
9: offset ← Random(wdw.start, wdw.end)
10: elem ← wdw[offset]
11: y ← Produce(x + offset)
12: TxStore(shrvar[elem], y)
13: end for
14: TxCommit() {fim da transação}
15: InsertVariableDelay(ITD)
16: x ← 0 {limpa o valor para a próxima transação}
17: end for
Figura 6.3: Pseudocódigo da ferramenta de caracterização parametrizável
A ferramenta de caracterização funciona da seguinte forma: cada core é colocado

para executar IPC transações (linhas 2–14) e dentro de cada transação são executadas
NRD leituras transacionais seguidas por NWR escritas transacionais do array compartilhado
(shrvar).
Cada core é responsável pela leitura de uma janela deslizante, que muda a cada
transação. A função GetWindowRange (linha 3) retorna a fatia do array compartilhado
a ser considerada durante a iteração atual. Os elementos lidos desta janela são, então,
consumidos, resultando num valor distinto (x).
Depois que o valor é computado, a sequência de escritas é iniciada com o cômputo de
um deslocamento (offset) relativo ao começo da janela deslizante. Este deslocamento é
determinado aleatoriamente (linha 9) e confinado dentro dos limites da janela deslizante.
A seguir, um novo valor (y) é produzido baseado nos valores de deslocamento e de x
(previamente computado). Então, o valor resultante é armazenado de volta na janela
deslizante.
Assim que a sequência de leituras e escritas é concluı́da, a transação faz uma chamada
à operação TxCommit (linha 14). Subsequentemente, um atraso é requisitado fora do
escopo da transação e antes do inı́cio da próxima transação (determinado pelo parâmetro
ITD).
É importante observar que, embora o objetivo desta ferramenta parametrizável seja
emular o comportamento de diferentes aplicações, esta emulação não tem o propósito de
ser exaustiva.
6.3.2 Resultados Preliminares

Nesta seção é apresentada uma análise quantitativa do consumo de energia das primitivas
básicas da API, obtidos com as diversas configurações da ferramenta de caracterização.
Os resultados preliminares mostrados aqui foram obtidos com a TL2-lazy, que é o modo
de versionamento padrão desta STM.
Considere, inicialmente, a energia média consumida pelas primitivas TxLoad (Fi-
gura 6.4(a)) e TxStore (Figura 6.4(b)) para um sistema com 1, 2, 4 e 8 cores. O eixo
horizontal da Figura 6.4(a) representa o tamanho do read-set, enquanto o eixo vertical
representa a média de consumo de energia por operador para as diversas configurações
de write-set (variando de 1 a 32). Para a TxStore (Figura 6.4(b)), o eixo horizontal re-
presenta o tamanho do write-set e o eixo vertical a média de consumo de energia por
operador para as diversas configurações de read-set (variando de 1 a 128).
Cores
1
40 2
4
8
Mean Energy (nJ)/Load

30
20
10
1 2 4 8 16 32 64 128
Read Set Size
(a) TxLoad
Cores
50 1
2
4
8
Mean Energy (nJ)/Store
40
30
20
1 2 4 8 16 32
Write Set Size
(b) TxStore
Figura 6.4: Perfis energéticos das primitivas TxLoad e TxStore com a ferramenta de
caracterização
20000
Cores
18000 1
2
16000 4
8
Energy (nJ)/Commit
14000
128
12000
R=
10000
8000
6000
64
R=
4000
R=32
2000 R=4 R=8 R=16
R=1 R=2
0
1 4 16 1 4 16 1 4 16 1 4 16 1 4 16 1 4 16 1 4 16 1 4 16
2 8 32 2 8 32 2 8 32 2 8 32 2 8 32 2 8 32 2 8 32 2 8 32
Write Set Size
(a) TxCommit
160
Cores
2
140 4
8
R=16
120 R=2
Energy (nJ)/Abort
R=8 R=32 R=64
8
12
R=4
R=
100
80
60
40
1 4 16 1 4 16 1 4 16 1 4 16 1 4 16 1 4 16 1 4 16
2 8 32 2 8 32 2 8 32 2 8 32 2 8 32 2 8 32 2 8 32
Write Set Size
(b) TxAbort
Figura 6.5: Perfis energéticos das primitivas TxCommit e TxAbort com a ferramenta de
caracterização
Pode ser visto nestas figuras um comportamento similar para ambas as primitivas:
conforme os tamanhos dos conjuntos são aumentados, o consumo de energia diminui. Isto
é explicado por efeitos de misses observados na cache de instrução (13% para a TxLoad e
30% para a TxStore). Conforme os efeitos de cache são mitigados, a energia por operação
tende a estabilizar. Note também que as configurações com um número maior de cores
exibem maior consumo de energia, causado pela maior contenção gerada no barramento.
Os resultados para as primitivas TxCommit e TxAbort são mostradas nas Figu-
ras 6.5(a) e 6.5(b). As figuras apresentam o consumo de energia por operação variando-se
os tamanhos do write-set e read-set (R=valor indica a configuração do read-set).
Duas observações podem ser feitas para a TxCommit (Figura 6.5(a)). Primeiro,
fixando-se o tamanho de read-set, note que o custo energético aumenta com o tama-
nho do write-set. Isto ocorre pelo fato da TL2 iterar três vezes durante a execução desta
primitiva: (i) durante a aquisição dos locks; (ii) ao confirmar os valores na memória princi-
pal; e (iii) ao liberar os locks. Segundo, o custo de energia também aumenta com maiores
tamanhos de read-set, dado que o mesmo tem que ser validado com relação à consistência.
80
Cores
1
Mean STM Energy Overhead (%) 2
70 4
8
60
50
40
1.00
1.41
2.00
2.83
4.00
5.66
8.00
11.31
16.00
22.63
32.00
45.25
64.00
Geometric Mean (Reads and Writes)
Figura 6.6: Overhead de energia das primitivas básicas
Os resultados da primitiva TxAbort são mostrado na Figura 6.5(b) (o custo de backoff

foi omitido nesta figura). Como pode ser observado, o custo energético não varia consi-
deravelmente com o tamanho do read-set. Contudo, a variação no tamanho do write-set
tem maior impacto no custo por operação. Para entender este comportamento, lembre-se
que na TL2, um aborto pode ser gerado tanto por uma operação de leitura que falhou, ou
por um read-set inválido (caso mais comum). No último caso, os locks adquiridos na fase
de confirmação da transação devem ser liberados, resultando num maior custo energético.
Como última observação, note que a confirmação da transação (TxCommit) é a mais
custosa dentre as primitivas analisadas até aqui.
Além de caracterizar os custos energéticos de cada primitiva básica, uma estimativa
do overhead imposto à aplicação devido ao uso de STM é mostrado na Figura 6.6. O eixo
horizontal usa a média geométrica dos tamanhos do read-set e write-set para representar
configurações tı́picas destes parâmetros. Pode ser observado que para valores baixos (i.e.,
tamanhos pequenos do read-set e write-set), o overhead transacional é alto (variando de
Aplicação Transação R/W sets Tempo Contenção Descrição

bayes Longa Grande Alto Alta Aprende a estrutura de
uma rede Bayesiana
genome Média Médio Alto Baixa Faz sequenciamento de
genes
intruder Curta Médio Médio Alta Detecta intrusões à rede
kmeans Curta Pequeno Baixo Baixo Implementa agrupa-
mento K-means
labyrinth Longa Grande Alto Alta Faz roteamento dentro
de um labirinto
ssca2 Curta Pequeno Baixo Baixa Cria representações efi-
cientes de grafos
vacation Média Médio Alto Baixa/Média Emula um sistema de re-
servas de viagens
yada Longa Grande Alto Médio Refina uma malha de
Delaunay
Tabela 6.1: Aplicações do STAMP
∼40% no cenário com 1 core para ∼80% no cenário com 8 cores). Ao se aumentar os
tamanhos destes conjuntos, o overhead por operação é amortizado, reduzindo o overhead
total. Todavia, para maiores valores no eixo horizontal, o overhead tende a subir no-
vamente. Isto sugere a existência de configurações de read-sets e write-sets nas quais o
overhead tende a ser mı́nimo.
6.4 Perfilamento do STAMP

O STAMP [96] é um conhecido benchmark de TM, que consiste em oito aplicações carac-
terizando distintos cenários transacionais no que diz respeito a: tamanho de transação,
conjuntos de escrita e leitura, tempo de transação e nı́vel de contenção.
As aplicações são listadas na Tabela 6.1, juntamente com suas caracterı́sticas. O nome
de cada aplicação é dado na primeira coluna, enquanto as colunas 2–5 enumeram o cenário
transacional das mesmas. As colunas Transação e Tempo referem-se ao tamanho da
transação e o tempo despendido dentro de transações, respectivamente. A última coluna
descreve brevemente a funcionalidade da aplicação.
Todas as aplicações do benchmark foram portadas para a plataforma de simulação
descrita na Seção 6.2, totalizando dez variações nos experimentos. As aplicações são
referenciadas neste texto utilizando-se a nomenclatura em [96].
6.4. Perfilamento do STAMP 111
É necessário prover evidências da dissociação entre consumo de energia e desempenho,

corroborando a afirmação de que desempenho e energia devem ser ponderadas simultane-
amente. A Figura 6.7 apresenta tais evidências para o STAMP, utilizando a configuração
TL2-lazy com backoff linear. Os números desta figura são normalizados em relação ao
caso com um único core.
kmeans- kmeans- vacation- vacation-

bayes genome+ high low labyrinth+ ssca2 high low yada intruder+
5 5
Energy z Speedup z
Normalized Speedup
4 4
Normalized Energy
3 3
2 2
1 1
0 0
1 2 4 8 1 2 4 8 1 2 4 8 1 2 4 8 1 2 4 8 1 2 4 8 1 2 4 8 1 2 4 8 1 2 4 8 1 2 4 8
Figura 6.7: Energia vs. speedup para o STAMP
Como pode ser visto, aumentando o número de cores sempre causa um maior consumo
de energia, com exceção do bayes 4-core. No entanto, o desempenho não segue sempre
esta mesma tendência. Enquanto em algumas aplicações, tais como genome+ e kmeans,
o desempenho cresce monotonicamente com o número de cores, em outras o desempenho
não escala apropriadamente, obtendo, inclusive, degradação em alguns casos (mais nota-
velmente no intruder+). A explicação para a perda de desempenho é o excessivo número
de transações abortadas e o consequente tempo gasto durante o rollback das mesmas. O
mesmo comportamento foi observado para estas aplicações com a configuração TL2-eager.
O paradigma de memória transacional em software impõe um significativo overhead
nas aplicações. De forma a pormenorizar o impacto no consumo de energia, a Figura 6.8
decompõe o overhead de energia em seus constituintes para o caso com um único core. Os
números desta figura estão normalizados em relação à versão sequencial de cada aplicação.
Três observações são feitas sobre esta figura. Primeiro, algumas aplicações não exibem
overhead significativo. Mais especificamente, bayes, labyrinth+ e yada têm transações
longas e o overhead devido às primitivas transacionais é pequeno (no yada pode ser
notado um baixo overhead relativo a TxCommit). Contudo, o cenário é diferente para
o kmeans, pois esta aplicação faz uso extensivo de operações de ponto-flutuante que, na
plataforma utilizada, é emulada em software. Desta forma, estas operações contribuem
para esconder o overhead normalmente exibido pelas primitivas transacionais. Segundo,
o overhead do código da aplicação é significativo (∼2x) para o ssca2, o vacation e o

intruder+. A razão disto é que o compilador otimiza o código sequencial eficientemente,
o que não acontece na versão transacional devido à instrumentação do código com as
primitivas. Finalmente, pode ser notado que a primitiva TxStore é mais eficiente em
termos de energia na configuração TL2-lazy, ao passo que a primitiva TxCommit é mais
eficiente na configuração TL2-eager. Lembre-se que a aquisição dos locks é efetuada
durante a TxStore na TL2-eager e durante a TxCommit na TL2-lazy. Além disso, o
custo da operação TxLoad é menor na TL2-eager, dado que o valor lido não precisa ser
procurado no write-set (a TL2-lazy usa um filtro de Bloom2 para evitar a iteração no
write-set).
kmeans- kmeans- labyrinth vacation- vacation-

bayes genome+ high low + ssca2 high low yada intruder+
5
TXCOMMIT
TXSTORE
TXLOAD
Other
4 Application
Normalized Energy (w.r.t. Sequential)
0
lazy lazy lazy lazy lazy lazy lazy lazy lazy lazy
eager eager eager eager eager eager eager eager eager eager
Figura 6.8: Decomposição do overhead de energia da STM para o caso com um único core
Não obstante o entendimento dos pormenores do consumo de energia em STM provido

pela figura, ela não exibe o percentual da energia consumida com abortos e rollbacks (a
taxa de abortos é nula no caso com um único core). A fim de complementar esta situação, a
Figura 6.9 apresenta a decomposição do overhead de energia para a plataforma configurada
com 8 cores. Da mesma forma que na Figura 6.8, os números estão normalizados em
relação à versão sequencial das aplicações. Note que a escala utilizada para a aplicação
2
Filtros de Bloom são estruturas de dados probabilı́sticas, usadas para testar, de forma eficiente, se
um certo elemento é membro de um conjunto.
6.4. Perfilamento do STAMP 113
mais à direita (intruder+) difere das outras.

Observe que o overhead de energia do kmeans ainda é negligı́vel. Isto é devido ao
seu exı́guo tempo dentro de transações, transações curtas (ver Tabela 6.1) e também ao
bom balanceamento de carga entre os cores. Novamente, o uso extensivo de operações de
ponto-flutuante oculta o overhead produzido pelas primitivas transacionais.
A baixa taxa de abortos exibida pelas aplicações bayes (∼7.4%), genome+ (∼2.2%),
ssca2 (∼0.2%) e vacation-low (∼4.4%) impede quase que totalmente o surgimento de
overheads relacionados às primitivas de backoff e rollback.
Já na aplicação labyrinth+, embora seja observada uma alta taxa de abortos (∼30%),
não ocorrem perı́odos significativos de backoff, dado que suas transações longas incorrem
um consequente longo perı́odo para refazer as mesmas em caso de aborto (rollback ),
dando espaço suficiente para a resolução dos conflitos. Por conseguinte, o gerenciador
de contenção não ativa o mecanismo de backoff (lembre-se que ele só é ativado após três
abortos consecutivos).
As três aplicações restantes (vacation-high, yada e intruder+) exibem custos de
rollback e backoff em diferentes proporções, de acordo com suas taxas de abortos. Como
pode ser visto, o consumo de energia destas primitivas é notável no yada e no intruder+,
dominando o consumo total de energia destas aplicações. Note que, nos perı́odos de bac-
koff e rollback, nenhum trabalho útil é realizado. Estas duas primitivas usualmente se
correlacionam e dependem fortemente das polı́ticas adotadas pelo gerenciador de con-
tenção. Logo, como os resultados revelam, há um considerável espaço para melhorias,
que é explorado pela estratégia introduzida na próxima seção.
bayes genome+ kmeans-high kmeans-low labyrinth+ ssca2 vacation-high vacation-low yada intruder+
10 50
ROLLBACK
BACKOFF
8 TXCOMMIT 40
Normalized Energy
TXSTORE
TXLOAD
6 Other 30
Application
4 20
2 10
0 0
lazy/lin
eager/lin
lazy/exp
eager/exp
lazy/lin
eager/lin
lazy/exp
eager/exp
lazy/lin
eager/lin
lazy/exp
eager/exp
lazy/lin
eager/lin
lazy/exp
eager/exp
lazy/lin
eager/lin
lazy/exp
eager/exp
lazy/lin
eager/lin
lazy/exp
eager/exp
lazy/lin
eager/lin
lazy/exp
eager/exp
lazy/lin
eager/lin
lazy/exp
eager/exp
lazy/lin
eager/lin
lazy/exp
eager/exp
lazy/lin
eager/lin
lazy/exp
eager/exp
Figura 6.9: Decomposição do overhead de energia da STM para o caso com 8 cores
6.5 Estratégia de Gestão de Contenção Baseada em

DVFS
A estratégia proposta incrementa as polı́ticas de gerenciamento de contenção originais
da TL2, de forma a explorar os perı́odos de inatividade3 em aplicações exibindo alta
contenção no barramento. Com este intuito, adotou-se uma estratégia baseada em esca-
lamento dinâmico de voltagem e frequência (DVFS). Visto que a potência depende qua-
draticamente da voltagem e linearmente da frequência, a eficiência energética pode ser
melhorada, em teoria, cubicamente [68]. Qualquer gerenciador de contenção que pause
ou atrase a execução das transações é elegı́vel a usar esta técnica.
A estratégia, que é simples, porém efetiva, funciona da seguinte maneira: antes de
entrar no modo de backoff, o processador é colocado em modo de baixo consumo de
potência através da redução de sua frequência e voltagem. Então, o processador aguarda
por uma quantidade de tempo proporcional ao número de tentativas da transação ten-
tando confirmar-se (TxCommit). Consequentemente, o desperdı́cio de energia é reduzido
sem degradar o desempenho significativamente, dado que tais perı́odos são considerados
de inatividade, não efetuando nenhum trabalho útil. Ao concluir o perı́odo de backoff,
o processador tem sua voltagem e frequência reescalados para o modo de desempenho
máximo.
Levando em conta que o mecanismo de DVFS requer alternar o processador entre
diferentes estados, deve-se estar ciente deste overhead adicional ao se aplicar a estratégia,
de forma a não degradar o desempenho geral das aplicações (os resultados mostrados a
seguir incluem este overhead, que é de 2 ciclos no total para a plataforma utilizada).
A Figura 6.10 apresenta os resultados obtidos pela estratégia proposta para o STAMP,
com uma plataforma possuindo 8 cores, usando as configurações TL2-lazy e TL2-eager, e
adotando as polı́ticas de backoff linear e exponencial. O eixo vertical é dual, tendo no eixo
esquerdo o consumo de energia, enquanto o eixo direito mostra números de EDP (Energy-
Delay Product), usados para correlacionar o impacto tanto em energia quanto em desem-
penho. Os resultados desta figura estão normalizados em relação aos apresentados na
Figura 6.9.
Sobre esta figura são feitas quatro observações principais. Primeiro, para aque-
las aplicações exibindo contenção média e/ou alta, especificamente, intruder+, yada
e vacation-high, o esquema reduz o consumo de energia efetivamente. Em média, a
3
O termo inatividade é usado em referência aos perı́odos nos quais nenhuma computação útil está
sendo realizada. Neste contexto, tais perı́odos são: backoff e rollback.
6.5. Estratégia de Gestão de Contenção Baseada em DVFS 115
Figura 6.10: Resultados da estratégia de gerenciamento de contenção baseado em DVFS

para o caso com 8 cores
energia foi reduzida por um fator de ∼45%, alcançando reduções máximas de até 87%
para o intruder+. Como efeito colateral positivo desta otimização, a taxa de abortos
foi reduzida, dado que as transações abortadas permaneceram um maior tempo (devido a
redução da frequência) no modo de backoff, logo, evitando uma reexecução prematura que
estava fadada a falhar. Consequentemente, o desempenho aumentou em aproximadamente
13% (em média) e o resultante EDP foi diminuı́do substancialmente. Segundo, algumas
aplicações experienciaram resultados negativos com algumas configurações do backoff ex-
ponencial com DVFS. Nas aplicações genome+-lazy, ssca2-lazy e ssca2-eager, a con-
tenção observada foi baixa, o que implica em entrar no modo de backoff diminutas vezes.
Contudo, devido às baixas taxas de abortos (≤3%), o tempo despendido nos perı́odos de
backoff é aumentado mais do que o necessário, neutralizando os efeitos de executá-lo em
modo de baixo consumo de potência. Além disso, como não há perı́odos de inatividade
passı́veis de serem explorados, tanto a energia quanto o EDP são levemente, mas adversa-
mente, afetados por este comportamento. Uma explicação similar é válida para o aumento
do EDP nas aplicações vacation-low e vacation-high (ambos com backoff exponen-
cial). Porém, nestas aplicações, ao contrário do que ocorre com as aplicações anteriores,
há pequenos perı́odos de inatividade disponı́veis, que são apropriadamente explorados,
como pode ser observado pela diminuição no consumo total de energia. Note que as mes-
mas aplicações não são influenciadas pelo comportamento mencionado quando o esquema
de backoff linear é usado. Terceiro, para aquelas aplicações exibindo um baixo overhead
de energia de STM, especificamente, kmeans-high, kmeans-low e labyrinth+, os resul-
tados obtidos foram praticamente os mesmos. Isto acontece devido ao baixo número de
reexecuções por transação, o que impede o processador de entrar no modo de backoff.
Finalmente, para o bayes, mesmo havendo apenas uma estreita margem de rollback e
backoff disponı́vel, o esquema proposto praticamente reduziu pela metade seus montan-
tes, resultando numa melhoria média de ∼6% e ∼20%, no consumo total de energia e no
EDP, respectivamente.
O próximo capı́tulo conclui esta tese de doutorado, enumerando as contribuições e
resultados obtidos pela mesma.
Capı́tulo 7
Conclusões
Este trabalho abordou o chamado low-power design, um tema de crescente importância

dentro do âmbito do projeto de sistemas digitais. Como foi visto, há várias implicações
relacionadas ao aumento do consumo de potência, tais como problemas térmicos, redução
da confiabilidade dos circuitos, aumento do custo final dos produtos, além de reduzir o
tempo de vida dos dispositivos operados por baterias. Este capı́tulo conclui esta tese
de doutorado, sumarizando os principais resultados e contribuições deste trabalho, além
de enumerar as publicações e listar alguns tópicos passı́veis de serem investigados como
extensão deste trabalho.
Esta tese atacou dois problemas distintos: (i) as limitações das técnicas de macromode-
lagem e (ii) o perfilamento do consumo de energia do paradigma de memória transacional
em software.
O primeiro problema fundamenta-se na afirmação de que as técnicas convencionais
de modelo único têm sérias limitações que afetam a precisão de suas estimativas. Para
corroborar esta afirmação, quatro técnicas de macromodelagem distintas foram selecio-
nadas para análise experimental. Os critérios de seleção foram as caracterı́sticas de cada
método, além dos bons resultados reportados em seus artigos originais.
Efetuou-se, então, uma análise quantitativa e qualitativa, onde evidenciaram-se as
limitações intrı́nsecas de cada uma das técnicas de macromodelagem, deixando claro que
estas limitações poderiam comprometer a qualidade das estimativas. Esta análise mostrou
também que, mesmo com estas limitações, todas as técnicas têm pontos fortes na tarefa
de capturar a variação de potência.
Para que os experimentos envolvidos na análise supracitada pudessem ser conduzidos,
era necessário uma infraestrutura para modelagem e simulação. Para isto, foi desenvolvido
um arcabouço, denominado PowerSC, que provê uma API de modelagem suportando
117
118 Capı́tulo 7. Conclusões
diversos nı́veis de abstração. Este arcabouço foi apresentado no NASCUG VI1 (North
American SystemC User’s Group Meeting), um dos principais eventos de SystemC. O
trabalho foi apresentado em uma palestra, ocorrida no dia 21 de fevereiro de 2007, em
San Jose, Califórnia, EUA.
A fim de otimizar a precisão das estimativas, foram propostas duas novas técnicas de
macromodelagem baseadas em múltiplos modelos, cujo objetivo era explorar os pontos
fortes de cada método convencional de modelo simples, sobrepujando as limitações de
uma forma global.
Na primeira técnica, chamada UMM, uma função seletora é construı́da, em que a
escolha do macromodelo a ser utilizado para gerar a estimativa é feita com base nas
estatı́sticas da sequência (stream) de vetores sendo aplicados às entradas de um dado
componente.
Na segunda técnica, chamada CMM, uma função de predição é criada tal que, para um
dado conjunto de vetores utilizados como estı́mulos, as estimativas produzidas por cada
macromodelo são correlacionadas entre si e com as propriedades dos estı́mulos aplicados
às entradas para produzir uma estimativa de potência. Tal função é construı́da com o
auxı́lio de métodos de análise de regressão não-linear.
Os resultados obtidos com a abordagem de múltiplos modelos revelaram melhorias
significativas em comparação às técnicas convencionais de modelo único, otimizando a
precisão, em média, 7 vezes para os erros médios, e 9 vezes para os erros máximos. O
overhead de ∼1% imposto à simulação, devido ao uso da abordagem proposta, pode ser
considerado negligı́vel.
O segundo problema aborda um tópico relativamente distinto do primeiro. Como foi
mostrado, a chegada da era multi-core introduziu um nova dificuldade, que é a criação de
programas concorrentes que extraiam o máximo de paralelismo existente nas aplicações,
mas que, principalmente, sejam fáceis de programar e funcionalmente corretos. O para-
digma de programação concorrente conhecido como memória transacional tem esta pro-
posta.
Esta área de pesquisa é atualmente muito ativa, porém os pesquisadores têm se concen-
trado quase que invariavelmente no desempenho das aplicações, negligenciando métricas
importantes tais quais potência e energia.
Desta forma, esta tese efetuou uma análise pormenorizada do consumo de energia
em uma implementação estado-da-arte de STM. Inicialmente, uma ferramenta de ca-
racterização parametrizável foi proposta para emular diferentes cenários transacionais e
1
http://www.nascug.org
7.1. Produção Bibliográfica 119
capturar seus perfis de consumo de energia.

Depois, o principal benchmark de TM, denominado STAMP, foi perfilado com relação
a seu consumo de energia, para todas as suas aplicações. Esta análise deu origem a uma
nova estratégia de gerenciamento de contenção baseada em DVFS, que obteve reduções de
∼45% (média) e ∼87% (máxima) no consumo de energia em aplicações com alta contenção
no barramento. Desconhece-se, da literatura, outro trabalho focado no consumo de energia
de STMs.
7.1 Produção Bibliográfica

Periódicos internacionais:
• “A Multi-Model Engine for High-level Power Estimation Accuracy Optimization”,

IEEE Transactions on Very Large Scale Integration (VLSI) Systems, Volume 17,
Número 5, pp. 660–673, Maio de 2009.
• “Characterizing the Energy Consumption of Software Transactional Memory”,

IEEE Computer Architecture Letters, 20 de agosto de 2009.
http://doi.ieeecomputersociety.org/10.1109/L-CA.2009.47
Capı́tulos de livro:
• “SystemC-based Power Evaluation with PowerSC ”,

F. Klein, G. Araujo Luiz Santos e Rodolfo Azevedo,
capı́tulo do livro “Electronic System Level Design: an Open Source Approach”, a
ser publicado pela editora Springer (ainda sem data).
Conferências internacionais:
• “On the Limitations of Power Macromodeling Techniques”,

Proceedings of the IEEE Computer Society Annual Symposium on VLSI (ISVLSI’07),
pp. 395–400, Maio de 2007.
• “An Efficient Framework for High-Level Power Exploration”,

120 Capı́tulo 7. Conclusões
Proceedings of the 50th IEEE International Midwest Symposium on Circuits &

Systems (MWSCAS’07), pp. 1046–1049, Agosto de 2007.
• “A Multi-Model Power Estimation Engine for Accuracy Optimization”,

Proceedings of the ACM/IEEE International Symposium on Low Power Electronics
and Design (ISLPED’07), pp. 280–285, Agosto de 2007.
• “On the Energy-Efficiency of Software Transactional Memory”,

F. Klein, A. Baldassin, P. Centoducatte, G. Araujo and R. Azevedo,
Proceedings of the 22nd Annual Symposium on Integrated Circuits and System
Design (SBCCI’09), Agosto/Setembro de 2009.
• “Improving Accuracy in Power Estimation by Exploiting Multi-Model Techniques”,

F. Klein, G. Araujo and R. Azevedo,
PhD Forum, IFIP/IEEE International Conference on Very Large Scale Integration
(VLSI-Soc 2009), Outubro de 2009.
Relatórios Técnicos:
• “PowerSC: A SystemC-based Framework for Power Estimation”,

Instituto de Computação, UNICAMP, Relatório Técnico IC-07-02, Fevereiro de
2007.
• “A First Study on Characterizing the Energy Consumption of Software Transactio-

nal Memory”,
Instituto de Computação, UNICAMP, Relatório Técnico IC-09-13, Abril de 2009.
7.2 Tópicos em Aberto para Trabalhos Futuros

A abordagem de macromodelagem de potência baseada múltiplos modelos pode ainda ser
explorada em algumas vertentes.
O grau de saturação dos multimodelos poderia ser investigado mais a fundo. Por
exemplo, neste trabalho foram usadas quatro técnicas de macromodelagem distintas nos
experimentos. Seria benéfico poder determinar, empiricamente, o quanto se ganha em
precisão com a adição de mais técnicas ao multimodelo e encontrar o ponto de saturação
7.2. Tópicos em Aberto para Trabalhos Futuros 121
da abordagem. Isto é, determinar a cardinalidade do conjunto de modelos individuais que

maximizam a precisão.
Outra vertente interessante é relacionada ao gerador de sequências de vetores. Usu-
almente, a etapa de caracterização mais custosa em termos de tempo é a fase de treina-
mento, onde um grande número de sequências são geradas a fim de cobrir o espaço de
entrada dos componentes. Assim, pode-se investigar formas de melhorar o processo de
geração das mesmas, tentando reduzir o número de sequências necessárias para um dado
macromodelo.
Dentro de um fluxo de projeto, quanto maior é o nı́vel de abstração, maior é o desem-
penho de simulação e mais opções de projeto podem ser verificadas. Logo, a exploração de
múltiplos modelos em nı́veis superiores ao RTL com o objetivo de melhorar a qualidade
das estimativas pode ser realizada.
No contexto de TM, vista a escassez de trabalhos visando a redução do consumo de
potência e/ou energia, há muitos tópicos interessantes em aberto.
Um deles seria investigar o perfil de consumo de energia de outras implementações de
STM, de forma similar ao que foi feito neste trabalho. Isso daria uma visão abrangente
do atual estado da arte de STM, sendo possı́vel categorizar as implementações de acordo
com suas eficiências energéticas.
Outro tópico incluiria a elaboração de uma técnica de macromodelagem em alto nı́vel
para TM. Tal macromodelo teria como parâmetros apenas informações visı́veis no âmbito
da infraestrutura de TM, tais como: número de transações executadas, taxa de abortos,
números de leituras e escritas transacionais, etc. Com isto, seria, possı́vel obter esti-
mativas de potência/energia do sistema baseadas somente nas estatı́sticas do substrato
de memória transacional. Desta forma, simulações funcionais seriam suficientes para o
cômputo dos resultados, ao contrário das simulações com precisão de ciclos utilizadas
neste trabalho (reduzindo drasticamente o tempo de simulação). Este macromodelo po-
deria, ainda, ser usado para estudar mais detalhadamente o comportamento, em termos
de energia/potência, dos sistemas de TM, abrindo caminho para possı́veis otimizações.
Por fim, um estudo comparativo do consumo de energia e potência entre HTMs e
STMs seria outra contribuição significativa na área.
Referências Bibliográficas
[1] Demos On Demand Website, http://www.demosondemand.com/dod/proddemos/

vendors/pd_coware.aspx. Acessado em Janeiro de 2009.
[2] Sally Adee. 37 Years of Moore’s Law. IEEE Spectrum, May 2008.
[3] Crina Anton, Alessandro Bogliolo, Pierluigi Civera, Ionel Colonescu, Enrico Macii,
and Massimo Poncino. RTL Estimation of Steering Logic Power. In PATMOS
’00: Proceedings of the 10th International Workshop on Integrated Circuit Design.
Power and Timing Modeling, Optimization and Simulation, pages 36–46, London,
UK, 2000. Springer-Verlag.
[4] M. Anton, I. Colonescu, E. Macii, and M. Poncino. Fast Characterization of RTL

Power Macromodels. In ICECS’01: International Conference on Electronics, Cir-
cuits and Systems, pages 1591–1594, 2001.
[5] Nikhil Bansal, Kanishka Lahiri, Anand Raghunathan, and Srimat T. Chakradhar.
Power Monitors: A Framework for System-Level Power Estimation Using Hete-
rogeneous Power Models. In VLSID ’05: Proceedings of the 18th International
Conference on VLSI Design, pages 579–585, Los Alamitos, CA, USA, 2005.
[6] M. Barocci, L. Benini, A. Bogliolo, B. Ricco, and G. De Micheli. Lookup Table

Power Macro-models for Behavioral Library Components. In IEEE Alessandro Volta
Memorial Workshop on Low-Power Design, pages 173–181, March 1999.
[7] Luiz André Barroso and Urs Hözle. The Case for Energy-Proportional Computing.
IEEE Computer, 40(12):33–37, Dec 2007.
[8] S. Bathia and N. K. Jha. Genesis: A Behavioral Synthesis System for Hierarchical
Testability. In Proceedings of the European Design and Test Conference, pages
272–276. IEEE Press, 1994.
123
124 REFERÊNCIAS BIBLIOGRÁFICAS
[9] G. Beltrame, D. Sciuto, and C. Silvano. Multi-Accuracy Power and Performance

Transaction-Level Modeling. IEEE Transactions on Computer-Aided Design of In-
tegrated Circuits and Systems, 26(10):1830–1842, October 2007.
[10] L. Benini, D. Bruni, M. Chinosi, R. Zafalon, C. Silvano, and V. Zaccaria. A Power

Modeling and Estimation Framework for VLIW-based Embedded Systems. ST
journal of system research, 0(0):52–60, 2001.
[11] L. Benini, D. Bruni, M. Chinosi, R. Zafalon, C. Silvano, and V. Zaccaria. A Fra-

mework for Modeling and Estimating the Energy Dissipation of VLIW-Based Em-
bedded Systems. Design Automation for Embedded Systems, 7(3):183–203, 2002.
[12] L. Benini, G. Castelli, A. Macii, E. Macii, M. Poncino, and R. Scarsi. A Discrete-

Time Battery Model for High-Level Power Estimation. In DATE ’00: Proceedings of
the conference on Design, automation and test in Europe, pages 35–41, New York,
NY, USA, 2000. ACM Press.
[13] L. Benini, G. Castelli, A. Macii, E. Macii, M. Poncino, and R. Scarsi. Extending Li-
fetime of Portable Systems by Battery Scheduling. In DATE ’01: Proceedings of the
conference on Design, automation and test in Europe, pages 197–203, Piscataway,
NJ, USA, 2001. IEEE Press.
[14] Luca Benini, Alessandro Bogliolo, Enrico Macii, Massimo Poncino, and Mihai Sur-
mei. Regression-based RTL Power Models for Controllers. In GLSVLSI ’00: Proce-
edings of the 10th Great Lakes symposium on VLSI, pages 147–152, New York, NY,
USA, 2000. ACM Press.
[15] Luca Benini, Giuliano Castelli, Alberto Macii, Enrico Macii, Massimo Poncino, and
Riccardo Scarsi. Discrete-Time Battery Models for System-Level Low-Power Design.
IEEE Transactions on Very Large Scale Integration (VLSI) Systems, 9(5):630–640,
2001.
[16] Luca Benini, Giuliano Castelli, Alberto Macii, and Riccardo Scarsi. Battery-Driven
Dynamic Power Management. IEEE Design & Test of Computers, 18(2):53–60,
2001.
[17] Luca Benini and Giovanni de Micheli. System-Level Power Optimization: Techni-
ques and Tools. ACM Trans. Des. Autom. Electron. Syst., 5(2):115–192, 2000.
REFERÊNCIAS BIBLIOGRÁFICAS 125
[18] Luca Benini, Robin Hodgson, and Polly Siegel. System-Level Power Estimation and
Optimization. In ISLPED ’98: Proceedings of the 1998 International Symposium
on Low power Electronics and Design, pages 173–178, New York, NY, USA, 1998.
ACM Press.
[19] Giuseppe Bernacchia and Marios C. Papaefthymiou. Analytical Macromodeling for

High-Level Power Estimation. In ICCAD ’99: Proceedings of the 1999 IEEE/ACM
International Conference on Computer-Aided Design, pages 280–283, Piscataway,
NJ, USA, 1999. IEEE Press.
[20] A. Bogliolo and L. Benini. Robust RTL Power Macromodels. IEEE Transactions
on Very Large Scale Integration (VLSI) Systems, 6(4):578–581, December 1998.
[21] A. Bogliolo, I. Colonescu, R. Corgnati, E. Macii, and M. Poncino. An RTL Power

Estimation Tool with On-line Model Building Capabilities. In PATMOS-01: Inter-
national Workshop on Power And Timing Modeling, Optimization and Simulation,
pages 2.3.1–2.3.10, September 2001.
[22] A. Bogliolo, R. Corgnati, E. Macii, and M. Poncino. Parameterized RTL Power

Models for Soft Macros. IEEE Transactions on Very Large Scale Integration (VLSI)
Systems, 9(6):880–887, December 2001.
[23] Alessandro Bogliolo, Luca Benini, and Giovanni De Micheli. Regression-based RTL
Power Modeling. ACM Trans. Des. Autom. Electron. Syst., 5(3):337–372, 2000.
[24] Alessandro Bogliolo, Enrico Macii, Virgil Mihailovici, and Massimo Poncino.
Power Models for Semi-Autonomous RTL Macros. In PATMOS-00: International
Workshop on Power And Timing Modeling, Optimization and Simulation, 2000.
[25] C. Brandolese, W. Fornaciari, L. Pomante, F. Salice, and D. Sciuto. A Multi-

Level Strategy for Software Power Estimation. In ISSS ’00: Proceedings of the 13th
International Symposium on System Synthesis, pages 187–192, Washington, DC,
USA, 2000. IEEE Computer Society.
[26] David Brooks, Vivek Tiwari, and Margaret Martonosi. Wattch: A Framework for
Architectural-Level Power Analysis and Optimizations. In ISCA ’00: Proceedings of
the 27th Annual International Symposium on Computer Architecture, pages 83–94.
ACM Press, 2000.
[27] Maurizio Bruno, Alberto Macii, and Massimo Poncino. A Statistical Power Model
for Non-Synthetic RTL Operators. In PATMOS-03: International Workshop on
Power And Timing Modeling, Optimization and Simulation, pages 208–218, Sep-
tember 2003.
[28] K. M. Buyuksahin and F. N. Najm. Early Power Estimation for VLSI Circuits.
IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems,
24(7):1076–1088, July 2005.
[29] Mentor Graphics CatapultC Synthesis. http://www.mentor.com. Acessado em

agosto de 2009.
[30] Naehyuck Chang, Kwanho Kim, and Hyung Gyu Lee. Cycle-Accurate Energy Con-
sumption Measurement and Analysis: Case Study of ARM7TDMI. In ISLPED ’00:
Proceedings of the 2000 International Symposium on Low power Electronics and
Design, pages 185–190, 2000.
[31] Zhanping Chen and K. Roy. Estimation of Power Dissipation Using a Novel Power
Macromodeling Technique. IEEE Transactions on Computer-Aided Design of Inte-
grated Circuits and Systems, 19(11):1363–1369, November 2000.
[32] C. F. Chiasserini and R. R. Rao. Pulsed Battery Discharge in Communication

Devices. In MobiCom ’99: Proceedings of the 5th Annual ACM/IEEE International
Conference on Mobile Computing and Networking, pages 88–95, 1999.
[33] P. Christie and D. Stroobandt. The Interpretation and Application of Rent’s Rule.
IEEE Transactions on Very Large Scale Integration (VLSI) Systems, 8(6):639–648,
Dec 2000.
[34] R. Corgnati, E. Macii, and M. Poncino. Clustered Table-based Macromodels for

RTL Power Estimation. In GLSVLSI ’99: Proceedings of the 9th Great Lakes Sym-
posium on VLSI, pages 354–357, 1999.
[35] Imed Ben Dhaou and Hannu Tenhunen. Efficient Library Characterization for High-
Level Power Estimation. IEEE Transactions on Very Large Scale Integration (VLSI)
Systems, 12(6):657–661, June 2004.
[36] Dave Dice, Ori Shalev, and Nir Shavit. Transactional Locking II. In DISC ’06:
Proceedings of the 20th International Symposium on Distributed Computing, pages
194–208. Springer-Verlag, 2006.
[37] Michael Eiermann and Walter Stechele. Efficient Power Modeling Techniques for
Combinational and Sequential RTL Macroblocks. In 9th International Conference
on Electronics, Circuits and Systems, volume 2, pages 705–708, 2002.
[38] Michael Eiermann and Walter Stechele. Novel Modeling Techniques for RTL Power
Estimation. In ISLPED ’02: Proceedings of the 2002 International Symposium on
Low Power Electronics and Design, pages 323–328, 2002.
[39] Cadence Encounter RTL Compiler. http://www.cadence.com. Acessado em agosto

de 2009.
[40] Terence Parr et al. ANTLR – ANother Tool for Language Recognition. Disponı́vel
em http://www.antlr.org [consultado em agosto de 2009].
[41] F. Ferrandi, F. Fummi, E. Macii, M. Poncino, and D. Sciuto. Power Estimation of

Behavioral Descriptions. In DATE ’98: Proceedings of the Conference on Design,
Automation and Test in Europe, pages 762–766, 1998.
[42] Cesare Ferri, Amber Viescas, Tali Moreshet, R. Iris Bahar, and Maurice Herlihy.
Energy Efficient Synchronization Techniques for Embedded Architectures. In GLS-
VLSI ’08: Proceedings of the 18th ACM Great Lakes Symposium on VLSI, pages
435–440, 2008.
[43] International Technology Roadmap for Semiconductors. ITRS Update 2008. http:
//www.itrs.net/Links/2008ITRS/Home2008.htm [consultado em julho de 2009],
2008.
[44] FORTE Design Systems. Cynthesizer User’s Guide, v3.3 edition, May 2007.
http://www.forteds.com.
[45] D. Gajski, N. Dutt, A. Wu, and S. Lin. High-Level Synthesis: Introduction to Chip
and System Design. Kluwer Academic Publishers, 1992.
[46] C. Gebotys and R. Gebotys. Statistically Based Prediction of Power Dissipation

for Complex Embedded DSP Processors. Microprocessors and Microsystems, pages
135–144, 1999.
[47] C. Gebotys, R. Gebotys, and S. Wiratunga. Power Minimization Derived from

Architectural-Usage of VLIW Processors. In DAC ’00: Proceedings of the 37th
Conference on Design Automation, pages 308–311, 2000.
[48] Pat Gelsinger. Microprocessors for the New Millennium: Challenges, Opportunities,
and New Frontiers. In ISSCC ’01: Proceedings International Conference Solid-State
Circuits Conference, pages 22–25, San Francisco, CA, USA, 2001.
[49] Sean Gold. A PSPICE Macromodel for Lithium-Ion Batteries. In Annual Battery
Conference on Applications and Advances, pages 9–15. IEEE Press, 1997.
[50] Subodh Gupta and Farid Najm. Analytical Models for RTL Power Estimation of
Combinational and Sequential Circuits. IEEE Transactions on Computer-Aided
Design of Integrated Circuits and Systems, 19(7):808–814, July 2000.
[51] Subodh Gupta and Farid N. Najm. Power Macromodeling for High-Level Power
Estimation. In DAC ’97: Proceedings of the 34th Annual Conference on Design
Automation, pages 365–370, 1997.
[52] Subodh Gupta and Farid N. Najm. Energy-Per-Cycle Estimation at RTL. In ISL-
PED ’99: Proceedings of the 1999 International Symposium on Low Power Electro-
nics and Design, pages 121–126, 1999.
[53] Subodh Gupta and Farid N. Najm. Power Modeling for High-Level Power Es-
timation. IEEE Transactions on Very Large Scale Integration (VLSI) Systems,
8(1):18–29, February 2000.
[54] D. Helms, E. Schmidt, A. Schulz, A. Stammermann, and W. Nebel. An Improved

Power Macro-Model for Arithmetic Datapath Components. In PATMOS-02: Inter-
national Workshop on Power And Timing Modeling, Optimization and Simulation,
2002.
[55] Jörg Henkel. A Low Power Hardware/Software Partitioning Approach for Core-
based Embedded Systems. In DAC ’99: Proceedings of the 36th ACM/IEEE Con-
ference on Design Automation, pages 122–127, 1999.
[56] Jörg Henkel and Yanbing Li. Energy-Conscious HW/SW-Partitioning of Embedded

Systems: A Case Study on an MPEG-2 Encoder. In CODES ’98: Proceedings of the
6th International Workshop on Hardware/Software Co-Design, pages 23–27, 1998.
[57] Maurice Herlihy, Victor Luchangco, Mark Moir, and William N. Scherer, III. Soft-
ware Transactional Memory for Dynamic-Sized Data Structures. In PODC ’03:
Proceedings of the 22nd Annual Symposium on Principles of Distributed Compu-
ting, pages 92–101, 2003.
[58] Maurice Herlihy and J. Eliot B. Moss. Transactional Memory: Architectural Sup-
port for Lock-free Data Structures. In ISCA ’93: Proceedings of the 20th Annual
International Symposium on Computer Architecture, pages 289–300, San Diego, Ca-
lifornia, United States, 1993. ACM.
[59] Cheng-Ta Hsieh, Qing Wu, Chih-Shun Ding, and Massoud Pedram. Statistical
Sampling and Regression Analysis for RT-Level Power Evaluation. In ICCAD ’96:
Proceedings of the 1996 IEEE/ACM International Conference on Computer-Aided
Design, pages 583–588, 1996.
[60] Chung-Hsing Hsu and Ulrich Kremer. The Design, Implementation, and Evaluation
of a Compiler Algorithm for CPU Energy Reduction. SIGPLAN Not., 38(5):38–48,
2003.
[61] Cadence InCyte Chip Estimator. http://www.cadence.com. Acessado em agosto de

2009.
[62] Intel. World’s first 2-billion transistor microprocessor. http://www.intel.com/

technology/architecture-silicon/2billion.htm. Acessado em agosto de 2009.
[63] Yi-Min Jiang, Shi-Yu Huang, Kwang-Ting Cheng, Deborah C. Wang, and ChingYen
Ho. A Hybrid Power Model for RTL Power Estimation. In Asia and South Pacific
Design Automation Conference, pages 551–556, 1998.
[64] Gerd Jochens, Lars Kruse, Eike Schmidt, and Wolfgang Nebel. A new parameteri-
zable power macro-model for datapath components. In DATE ’99: Proceedings of
the conference on Design, automation and test in Europe, page 8, New York, NY,
USA, 1999. ACM Press.
[65] Gerd Jochens, Lars Kruse, Eike Schmidt, Ansgar Stammermann, and Wolfgang
Nebel. Power Macro-Modelling for Firm-Macro. In PATMOS-00: International
Workshop on Power And Timing Modeling, Optimization and Simulation, pages
24–35, September 2000.
[66] Russ Joseph and Margaret Martonosi. Run-Time Power Estimation in High Per-
formance Microprocessors. In ISLPED ’01: Proceedings of the 2001 International
Symposium on Low Power Electronics and Design, pages 135–140, 2001.
[67] Praveen Kalla, Jörg Henkel, and Xiaobo Sharon Hu. SEA: Fast Power Estimation
for Micro-Architectures. In ASPDAC: Proceedings of the 2003 Conference on Asia
South Pacific Design Automation, pages 600–605, 2003.
[68] Stefanos Kaxiras and Margaret Martonosi. Computer Architecture Techniques for
Power-Efficiency. Morgan & Claypool Publishers, 2008.
[69] Michael Keating, David Flynn, Robert Aitken, Alan Gibbons, and Kaijian Shi. Low
Power Methodology Manual for System-on-Chip Design. Springer, 2007.
[70] F. Klein, R. Azevedo, and G. Araujo. High-Level Switching Activity Prediction Th-
rough Sampled Monitored Simulation. In Proceedings of International Symposium
on System-on-Chip (SOC), pages 161–166, Tampere, Finland, November 2005.
[71] Felipe V. Klein. PowerSC: Uma Extensão de SystemC para a Captura de Atividade
de Transição. Master’s thesis, Instituto de Computação, Universidade Estadual de
Campinas (UNICAMP), 2005. Dissertação defendida em 15 de abril de 2005.
[72] Ulrich Kremer. Low-Power/Energy Compiler Optimizations. In Low-Power Elec-

tronics Design, chapter 35. CRC Press, 2005.
[73] Ulrich Kremer, Jamey Hicks, and James Rehg. A Compilation Framework for Power
and Energy Management on Mobile Computers. In 14th International Workshop
on Languages and Compilers for Parallel Computing (LCPC 2001), pages 115–131.
Springer-Verlag, 2001.
[74] Sanjeev Kumar, Michael Chu, Christopher J. Hughes, Partha Kundu, and Anthony
Nguyen. Hybrid Transactional Memory. In PPoPP ’06: Proceedings of the 11th
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming,
pages 209–220, 2006.
[75] Leslie Lamport. Time, Clocks, and the Ordering of Events in a Distributed System.
Communications of the ACM, 21(7):558–565, 1978.
[76] Paul E. Landman and Jan M. Rabaey. Activity-Sensitive Architectural Power

Analysis. In IEEE Transactions on Computer-Aided Design of Integrated Circuits,
pages 571–587. IEEE Computer Society Press, June 1996.
[77] James R. Larus and Ravi Rajwar. Transactional Memory. Morgan & Claypool
Publishers, 2007.
[78] Mike Tien-Chien Lee, Vivek Tiwari, Sharad Malik, and Masahiro Fujita. Power
Analysis and Minimization Techniques for Embedded DSP Software. IEEE Tran-
sactions on Very Large Scale Integration (VLSI) Systems, 5(1):123–135, 1997.
[79] Sheayun Lee, Andreas Ermedahl, and Sang Lyul Min. An Accurate Instruction-
Level Energy Consumption Model for Embedded RISC Processors. In LCTES ’01:
Proceedings of the ACM SIGPLAN Workshop on Languages, Compilers and Tools
for Embedded Systems, pages 1–10, 2001.
[80] Roberto Leão. Análise Experimental de Técnicas de Estimativa de Potência base-

adas em Macromodelagem em Nı́vel RT. Master’s thesis, Instituto de Informática
e Estatı́stica, Universidade Federal de Santa Catarina, 2008. Disponı́vel online:
http://www.laps.inf.ufsc.br/publications.htm.
[81] Yanbing Li and Jörg Henkel. A Framework for Estimation and Minimizing Energy
Dissipation of Embedded HW/SW Systems. In DAC ’98: Proceedings of the 35th
Annual Conference on Design Automation, pages 188–193, San Francisco, Califor-
nia, United States, 1998. ACM Press.
[82] David Lidsky and Jan M. Rabaey. Early Power Exploration: a World Wide Web
Application. In DAC ’96: Proceedings of the 33rd Annual Conference on Design
[83] D. Liu and C. Svensson. Power Consumption Estimation in CMOS VLSI Chips.
IEEE Journal of Solid-State Circuits, pages 663–670, June 1994.
[84] Xun Liu and Marios C. Papaefthymiou. A Markov Chain Sequence Generator
for Power Macromodeling. In ICCAD ’02: Proceedings of the 2002 IEEE/ACM
International Conference on Computer-Aided Design, pages 404–411, New York,
NY, USA, 2002. ACM Press.
[85] Xun Liu and Marios C. Papaefthymiou. HyPE: Hybrid Power Estimation for IP-
based Programmable Systems. In ASPDAC: Proceedings of the 2003 Conference on
Asia South Pacific Design Automation, pages 606–609, New York, NY, USA, 2003.
ACM Press.
[86] Xun Liu and Marios C. Papaefthymiou. A Markov Chain Sequence Generator for
Power Macromodeling. IEEE Transactions on Computer-Aided Design of Integrated
Circuits and Systems, 23(7):1048–1062, July 2004.
[87] Mirko Loghi, Massimo Poncino, and Luca Benini. Cycle-Accurate Power Analysis
for Multiprocessor Systems-on-a-Chip. In GLSVLSI ’04: Proceedings of the 14th
ACM Great Lakes Symposium on VLSI, pages 410–406, 2004.
[88] Mirko Loghi, Massimo Poncino, and Luca Benini. Cache Coherence Tradeoffs in
Shared-Memory MPSoCs. ACM Trans. Embed. Comput. Syst., 5(2):383–407, 2006.
[89] Josué Tzan Hsin Ma. Estimativa de Consumo de Energia em Nı́vel de Instrução
para Processadores Modelados em ArchC. Master’s thesis, Instituto de Computação,
Universidade Estadual de Campinas (UNICAMP), 2007. Dissertação defendida em
26 de outubro de 2007.
[90] Alberto Macii, Luca Benini, and Massimo Poncino. Memory Design Techniques for
Low Energy Embedded Systems. Springer, 2002.
[91] Enrico Macii and Massimo Poncino. Power Macro-Models for High-Level Power
Estimation. In Low-Power Electronics Design, chapter 39. CRC Press, 2005.
[92] D. Marculescu, R. Marculescu, and M. Pedram. Theoretical Bounds for Switching

Activity Analysis in Finite-State Machines. IEEE Transactions on Very Large Scale
Integration (VLSI) Systems, 8(3):335–339, June 2000.
[93] Diana Marculescu, Radu Marculescu, and Massoud Pedram. Information Theoretic
Measures of Energy Consumption at Register Transfer Level. In ISLPED ’95: Pro-
ceedings of the 1995 International Symposium on Low Power Design, pages 81–86.
ACM Press, 1995.
[94] Renu Mehra and Jan Rabaey. Behavioral Level Power Estimation and Exploration.
In Proceedings of the First International Workshop on Low Power Design, pages
197–202, 1994.
[95] Huzefa Mehta, Robert Michael Owens, and Mary Jane Irwin. Energy Characteriza-
tion Based on Clustering. In DAC ’96: Proceedings of the 33rd Annual Conference
on Design Automation, pages 702–707, 1996.
[96] Chi Cao Minh, JaeWoong Chung, C. Kozyrakis, and K. Olukotun. STAMP: Stan-
ford Transactional Applications for Multi-Processing. In IISWC 2008: Proceedings
of the IEEE International Symposium on Workload Characterization, pages 35–46,
Sep 2008.
[97] Tali Moreshet, R. Iris Bahar, and Maurice Herlihy. Energy Reduction in Multi-
processor Systems Using Transactional Memory. In ISLPED ’05: Proceedings of
the 2005 International Symposium on Low Power Electronics and Design, pages
331–334, 2005.
[98] Tali Moreshet, R. Iris Bahar, and Maurice Herlihy. Energy-Aware Microproces-
sor Synchronization: Transactional Memory vs. Locks. In Workshop on Memory
Performance Issues, 2006.
[99] K. D. Müller-Glaser, K. Hirsch, and K. Neusinger. Estimating Essential Design

Characteristics to Support Project Planning for ASIC Design Management. In
Proceedings of the IEEE International Conference on Computer-Aided Design, pages
148–151, Santa Clara, CA, November 1991. IEEE Computer Society Press.
[100] Radu Muresan and Catherine Gebotys. Instantaneous Current Modeling in a Com-
plex VLIW Processor Core. Trans. on Embedded Computing Sys., 4(2):415–451,
2005.
[101] Ashok K. Murugavel, N. Ranganathan, R. Chandramouli, and Srinath Chavali.

Average Power in Digital CMOS Circuits using Least Square Estimation. In IEEE
International Conference on VLSI Design, pages 215–220, January 2001.
[102] L. W. Nagel. SPICE2: A Computer Program to Simulate Semiconductor Circuits.

ERL-M520, Univ. California, Berkeley, 1975.
[103] Wolfgang Nebel and Domenik Helms. High-level Power Estimation and Analysis.
In Low-Power Electronics Design, chapter 38. CRC Press, 2005.
[104] Mahadevamurty Nemani and Farid Najm. Towards a High-Level Power Estimation
Capability. In IEEE Transactions on Computer-Aided Design of Integrated Circuits
and Systems, pages 588–598. IEEE Press, 1996.
[105] S. Nikolaidis, N. Kavvadias, P. Neofotistos, K. Kosmatopoulos, T. Laopoulos, and

L. Bisdounis. Instrumentation Set-Up for instruction Level Power Modeling. In
PATMOS ’02: Proceedings of the 12th International Workshop on Integrated Circuit
Design. Power and Timing Modeling, Optimization and Simulation, pages 71–80.
Springer-Verlag, 2002.
[106] Open SystemC Initiative. SystemC Language Reference Manual, revision 1.0 edition,
2003. See http://www.systemc.org.
[107] Debashis Panigrahi, Sujit Dey, Ramesh Rao, Kanishka Lahiri, Carla Chiasserini,
and Anand Raghunathan. Battery Life Estimation of Mobile Embedded Systems.
In International Conference on VLSI Design, volume 00, 2001.
[108] Terence J. Parr and Russell W. Quong. ANTLR: A Predicated-LL(k) Parser Gene-
rator. Software Practice and Experience, 25:789–810, 1994.
[109] Massoud Pedram and Qing Wu. Design Considerations for Battery-Powered Elec-
tronics. In DAC ’99: Proceedings of the 36th ACM/IEEE Conference on Design
[110] Nachiketh R. Potlapally, Michael S. Hsiao, Anand Raghunathan, Ganesh Lakshmi-

narayana, and Srimat T. Chakradhar. Accurate power macro-modeling techniques
for complex RTL circuits. vlsid, 00:235, 2001.
[111] Nachiketh R. Potlapally, Michael S. Hsiao, Anand Raghunathan, Ganesh Lakshmi-

narayana, and Srimat T. Chakradhar. Accurate Power Macro-modeling Techniques
for Complex RTL Circuits. In VLSID ’01: Proceedings of the 18th International
Conference on VLSI Design, pages 235–241. IEEE Computer Society, 2001.
[112] Scott R. Powell and Paul M. Chau. Estimating Power Dissipation of VLSI Signal
Processing Chips: The PFA Technique. VLSI Signal Processing IV, pages 250–259,
1990.
[113] Sequence Design Power Theater. http://www.sequencedesign.com. Acessado em

agosto de 2009.
[114] BullDAST PowerChecker. http://www.bulldast.com. Acessado em agosto de

2009.
[115] Gang Qu, Naoyuki Kawabe, Kimiyoshi Usami, and Miodrag Potkonjak. Function-
Level Power Estimation Methodology for Microprocessors. In DAC ’00: Proceedings
of the 37th Conference on Design Automation, pages 810–813, 2000.
[116] Magma Design Automation Quartz Rail. http://www.magma-da.com. Acessado

em agosto de 2009.
[117] Jan M. Rabaey, Anantha Chandrakasan, and Borivoje Nikolic. Digital Integrated
Circuits. Prentice Hall, 2nd edition, 2003.
[118] A. Raghunathan and N. K. Jha. Behavioral Synthesis for Low Power. In IEEE
International Conference on Computer Design, pages 318–322. IEEE Press, 1994.
[119] Ravi Rajwar and James R. Goodman. Transactional Lock-Free Execution of Lock-
based Programs. In ASPLOS-X: Proceedings of the 10th International Conference
on Architectural Support for Programming Languages and Operating Systems, pages
5–17, 2002.
[120] C. V. Ramamoorthy and M. J. Gonzalez. Recognition and Representation of Pa-

rallel Processable Streams in Computer Programs-II (Task/Process Parallelism). In
Proceedings of the 1969 24th National Conference, pages 387–397, 1969.
[121] Srivaths Ravi, Anand Raghunathan, and Srimat Chakradhar. Efficient RTL Power
Estimation for Large Designs. In IEEE International Conference on VLSI Design,
pages 431–439, January 2003.
[122] Philip E. Ross. Why CPU Frequency Stalled. IEEE Spectrum, Apr 2008.
[123] Jeffry T. Russel and Margarida F. Jacome. Software Power Estimation and Opti-
mization for High Performance, 32-bit Embedded Processors. In ICCD ’98: Proce-
edings of the International Conference on Computer Design, pages 328–333, 1998.
[124] E. Schmidt, G. Jochens, L. Kruse, F. Theeuwen, and W. Nebel. Automatic Non-

linear Memory Power Modelling. In DATE ’01: Proceedings of the Conference on
Design, Automation and Test in Europe, page 808, 2001.
[125] Eike Schmidt, Lars Kruse, Gerd Jochens, Ed Huijbregts, Wouter Nieuweboer, Eric
Seelen, and Wolfgang Nebel. Power Consumption of On-Chip ROMs: Analysis
and Modeling. In PATMOS-98: International Workshop on Power And Timing
Modeling, Optimization and Simulation, 1998.
[126] Eike Schmidt, Gerd von Cölln (Jochens), Lars Kruse, Frans Theeuwen, and Wolf-
gang Nebel. Memory Power Models for Multilevel Power Estimation and Opti-
mization. IEEE Transactions on Very Large Scale Integration (VLSI) Systems,
10(2):106–109, 2002.
[127] Joseph J. Sharkey, Dmitry V. Ponomarev, Kanad Ghose, and Oguz Ergin. Ins-
truction Packing: Reducing Power and Delay of the Dynamic Scheduling Logic.
In ISLPED ’05: Proceedings of the 2005 International Symposium on Low Power
Electronics and Design, pages 30–35, 2005.
[128] Tajana Simunic, Luca Benini, and Giovanni De Micheli. Cycle-Accurate Simulation
of Energy Consumption in Embedded Systems. In DAC ’99: Proceedings of the
36th ACM/IEEE Conference on Design Automation, pages 867–872, 1999.
[129] Tajana Simunic, Luca Benini, and Giovanni De Micheli. Energy-Efficient Design
of Battery-Powered Embedded Systems. In ISLPED ’99: Proceedings of the 1999
International Symposium on Low Power Electronics and Design, pages 212–217,
1999.
[130] Tajana Simunic, Luca Benini, Giovanni De Micheli, and Mat Hans. Source Code
Optimization and Profiling of Energy Consumption in Embedded Systems. In ISSS
’00: Proceedings of the 13th International Symposium on System Synthesis, pages
193–198, 2000.
[131] A. Stammermann, D. Helms, M. Schulte, A. Schulz, and W. Nebel. Binding, Al-

location and Floorplanning in Low Power High-Level Synthesis. In ICCAD ’03:
Design, page 544, 2003.
[132] A. Stammermann, D. Helms, M. Schulte, A. Schulz, and W. Nebel. Interconnect

Driven Low Power High-Level Synthesis. In PATMOS-03: International Workshop
on Power And Timing Modeling, Optimization and Simulation, pages 131–140, Sep-
tember 2003.
[133] Ansgar Stammermann, Lars Kruse, Wolfgang Nebel, Alexander Pratsch, Eike Sch-
midt, Milan Schulte, and Arne Schulz. System Level Optimization and Design Space
Exploration for Low Power. In ISSS ’01: Proceedings of the 14th International Sym-
posium on Systems Synthesis, pages 142–146, 2001.
[134] Phillip Stanley-Marbell and Michael Hsiao. Fast, Flexible, Cycle-Accurate Energy
Estimation. In ISLPED ’01: Proceedings of the 2001 International Symposium on
Low Power Electronics and Design, pages 141–146, 2001.
[135] Thad. E. Starner and Joseph A. Paradiso. Human-Generated Power for Mobile
Electronics. In Low-Power Electronics Design, chapter 45. CRC Press, 2005.
[136] S. Steinke, M. Knauer, L. Wehmeyer, and P. Marwedel. An Accurate and Fine Grain
Instruction-Level Energy Model Supporting Software Optimizations. In PATMOS-
01: International Workshop on Power And Timing Modeling, Optimization and

Simulation, September 2001.
[137] Herb Sutter and James R. Larus. Software and the Concurrency Revolution. Queue,
3(7):54–62, 2005.
[138] Synopsys. Liberty User Guide, 2003.12 edition, December 2003.
[139] Synopsys Inc. Power Compiler User Guide, x-2005.09 edition, December 2005.
[140] Synopsys Inc. Prime Power Manual, x-2005.06 edition, June 2005.
[141] Doug Lea et al. A Memory Allocator. Artigo e código-fonte disponı́veis no endereço
http://gee.cs.oswego.edu/dl/html/malloc.html. Acessado em agosto de 2009.
[142] V. Tiwari, S. Malik, A. Wolfe, and M. Lee. Instruction Level Power Analysis and
Optimization of Software. Journal of VLSI Signal Processing, 13(2–3):223–238,
August 1996.
[143] Vivek Tiwari, Sharad Malik, and Andrew Wolfe. Power Analysis of Embedded
Software: A First Step Towards Software Power Minimization. In ICCAD ’94:
Design, pages 384–390, San Jose, California, United States, 1994. IEEE Computer
Society Press.
[144] Manish Verma and Peter Marwedel. Overlay Techniques for Scratchpad Memo-
ries in Low Power Embedded Processors. IEEE Transactions on Very Large Scale
Integration (VLSI) Systems, 14(8):802–815, August 2006.
[145] Manish Verma, Lars Wehmeyer, and Peter Marwedel. Efficient Scratchpad Alloca-
tion Algorithms for Energy Constrained Embedded Systems. In PACS, pages 41–56,
2003.
[146] Manish Verma, Lars Wehmeyer, Robert Pyka, Peter Marwedel, and Luca Benini.
Compilation and Simulation Tool Chain for Memory Aware Energy Optimizati-
ons. In Workshop on Embedded Computer Systems: Architectures, Modeling, and
Simulation (SAMOS VI), 2006.
[147] Robert A. Walker and Donald E. Thomas. A Model of Design Representation and
Synthesis. In DAC ’85: Proceedings of the 22nd ACM/IEEE Conference on Design
Automation, pages 453–459, Las Vegas, Nevada, United States, 1985. ACM Press.
[148] Q. Wu, C. Ding, C. Hsieh, and M. Pedram. Statistical Design of Macro-Models for
RT-Level Power Evaluation. In ASP-DAC ’97: Proceedings of the Asia and South
Pacific Design Automation Conference, pages 523–528, 1997.
[149] Qing Wu, Qiu Qinru, Massoud Pedram, and Chih-Shun Ding. Cycle-Accurate
Macro-Models for RT-Level Power Analysis. IEEE Transactions on Very Large
Scale Integration (VLSI) Systems, 6(4):520–528, December 1998.
[150] Wei Wu, Lingling Jin, Jun Yang, Pu Liu, and Sheldon X.-D. Tan. A Systematic
Method for Functional Unit Power Estimation in Microprocessors. In DAC ’06:
Proceedings of the 43rd Annual Conference on Design Automation, pages 554–557,
2006.
[151] M. G. Xakellis and F. N. Najm. Statistical Estimation of the Switching Activity in

Digital Circuits. In Proceedings of DAC, pages 728–733, 1994.
[152] R. Zafalon, M. Rossello, E. Macii, and M. Poncino. Power Macromodeling for a

High Quality RT-Level Power Estimation. In ISQED’00: Proceedings of the First
International Symposium on Quality Electronic Design, pages 59–63. IEEE Press,
2000.
[153] Lin Zhong and Niraj K. Jha. Interconnect-Aware High-Level Synthesis for Low
Power. In ICCAD ’02: Proceedings of the 2002 IEEE/ACM International Confe-
rence on Computer-Aided Design, pages 110–117, 2002.
[154] Lin Zhong, S. Ravi, A. Raghunathan, and N. K. Jha. Power Estimation for Cycle-
Accurate Functional Descriptions of Hardware. In ICCAD ’04: Proceedings of the
2004 IEEE/ACM International Conference on Computer-Aided Design, pages 668–
675. IEEE Computer Society, 2004.
[155] Ahmad Zmily and Christos Kozyrakis. Energy-Efficient and High-Performance Ins-
truction Fetch Using a Block-Aware ISA. In ISLPED ’05: Proceedings of the 2005
International Symposium on Low Power Electronics and Design, pages 36–41, 2005.

Klein FelipeVieira D

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Klein FelipeVieira D

Enviado por

Direitos autorais:

Formatos disponíveis

Tese apresentada ao Instituto de Computação,

unicamp, como requisito parcial para a ob-

2    34 ∋5%67 − 

≅.5 Α  ∋   .∀.−∋ ∋ ∋   .

/  % + Φ %∋(∗:ΗΓ < ≅.∋  Φ  .∀.>∋ ∋  Η∋.Β./Γ

Ι     &) −∋ ∋  &)

# &) ; ∋∗  ∋  &)

 ϑ ∋  / 3.; .34 ∋5%:?+=Κ?5∆/<

/ ( ∋ /+7  &) ; ∋∗  ∋  &)

Técnicas Avançadas de Modelagem, Análise e

Felipe Vieira Klein1

• Prof. Dr. Rodolfo Jardim de Azevedo (Orientador)

• Prof. Dr. Luiz Cláudio Villar dos Santos

• Prof. Dr. Luigi Carro

• Prof. Dr. Reinaldo Bergamaschi

• Prof. Dr. Sandro Rigo

• Prof. Dr. Wang Jiang Chau (Suplente)

• Prof. Dr. Mario Lúcio Côrtes (Suplente)

O crescente aumento da demanda por funcionalidades agregadas a um mesmo disposi-

Inicialmente, agradeço ao meu orientador, professor Rodolfo Avezedo que, em todos os

Lista de Tabelas xxi

Lista de Figuras xxiii

Lista de Acrônimos xxv

4 PowerSC: o Arcabouço para Análise de Potência 51

5 A Abordagem de Múltiplos Modelos 65

Referências Bibliográficas 123

3.1 Caracterı́sticas das técnicas de macromodelagem . . . . . . . . . . . . . . . 24

5.1 Circuitos selecionados como benchmarks . . . . . . . . . . . . . . . . . . . 87

6.1 Aplicações do STAMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

2.1 Potência versus Energia . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3.1 Relação entre probabilidade e densidade . . . . . . . . . . . . . . . . . . . 21

4.1 Fluxo de projeto da PowerSC . . . . . . . . . . . . . . . . . . . . . . . . . 52

5.1 Distribuição de Erros (4DTab) . . . . . . . . . . . . . . . . . . . . . . . . . 73

6.1 Exemplo de um bloco atômico no paradigma de memória transacional . . . 98

API Application Program Interface

Num passado recente, o desenvolvimento de sistemas eletrônicos digitais era conduzido

que, como consequência, comprometem a confiabilidade do circuito. A fim de mitigar

1.1 Panorama dos Problemas Atacados

este trabalho apresenta uma nova abordagem de modelagem de potência baseada em

1.2 Contribuições deste Trabalho

• Diversas técnicas de macromodelagem foram submetidas à uma análise qualitativa

• São propostas duas novas técnicas de macromodelagem, baseadas na abordagem

• A infraestrutura de análise de potência em SystemC, que permite a modelagem

• A análise pormenorizada do consumo de energia em uma implementação estado-da-

• Uma ferramenta de caracterização parametrizável foi proposta a fim de avaliar di-

• A proposição de uma nova estratégia de gerenciamento de contenção, baseada em

1.3 Organização do Texto

• “On the Limitations of Power Macromodeling Techniques”,

• “An Efficient Framework for High-Level Power Exploration”,

• “A Multi-Model Power Estimation Engine for Accuracy Optimization”,

• “A First Study on Characterizing the Energy Consumption of Software Transactio-

• “A Multi-Model Engine for High-level Power Estimation Accuracy Optimization”,

• “On the Energy-Efficiency of Software Transactional Memory”,

• “Characterizing the Energy Consumption of Software Transactional Memory”,

• “Improving Accuracy in Power Estimation by Exploiting Multi-Model Techniques”,

• “SystemC-based Power Evaluation with PowerSC ”,

O restante deste documento organiza-se da seguinte forma: o Capı́tulo 2 conceitua

2.1 Potência versus Energia

Figura 2.1: Potência versus Energia

trabalho. O eixo horizontal apresenta o tempo de execução de uma determinada tarefa,

onde v(t) e i(t) são, respectivamente, voltagem e corrente instantâneas, em função do

Figura 2.2: Análise de compromissos entre energia e potência

2.2 Dissipação de Potência em CMOS

Figura 2.3: Um transistor na tecnologia CMOS

2 34∋5%67−

≅.5Α ∋ .∀.−∋∋ ∋ .

/%+ Φ%∋(∗:ΗΓ< ≅.∋ Φ .∀.>∋ ∋ Η∋.Β./Γ

Ι &) −∋∋ &)

#&) ;∋∗ ∋ &)

ϑ∋ /3.;.34∋5%:?+=Κ?5∆/<

/(∋/+7&) ;∋∗ ∋ &)